python笔记

第一章

模块

  • 载入:import math
  • 调用:math.floor
  • 去掉模块名字:from math import floor
  • 调用:floor
  • 换个名字:myfloor = math.floor
  • 调用:myfloor(2.2)

    为了避免名字冲突,应尽量使用普通的import

python环境

  • #!/usr/bin/env python

注释

  • ‘#’

输入

  • input输入合法表达式
  • raw_input输入都当字符串

换行

  • \

第二章 列表和元组

列表[]可以修改,元组()不可以

索引

  • >=0 正数,<=-1倒数
  • 分段,末尾留空str[-4:]
  • list 化为列表,’’.join 化为字符串,字符串不能直接修改
  • lst.append 增加一个列表元素;lst.count计算列表中某元素个数;lst.extend增加一个列表
  • lst.index找到元素第一次出现位置,lst.insert, lst.pop
  • lst.remove 删除第一个出现,lst.reverse
  • 复制列表用y=x[:],y=x使得y与x指向同一个列表
  • tuple将序列转换为元组
  • 元组主要用于当键,因其不可修改

第三章 字符串

1
2
3
4
format = '1.%s 2.%s'
values = ('first','second')
print format % values
str = 'my %d' % 10
  • str.find 找不到返回-1, 而lst中index找不到报错
  • str.lower
  • str.replace
  • str.split 是join的逆方法,可能会分出空
  • str.translate 字符映射 ,用maketrans制作映射表

字典{}

  • len(d),d[k],del d[k], k in d
  • 建立:d={}
  • d['wang']=1
  • 格式化:"wang :%(wang)s kang %(kang)s" % d
  • clear
    注意如下代码,xy指向同一个字典,x
1
2
3
4
5
6
7
8
9
10
11
x = {}
y = x
x['k']='v'
x = {}
#x {} y : k,v

x = {}
y = x
x['k']='v'
x.clear()
#x {} y : {}
  • copy
  • get(key,default_value) 访问没有的key不会报错,返回default_value
  • update

第五章 条件 循环

import特性

  • from m import func1, func2
  • from m import *
  • import m as x m的别名

赋值

  • x,y,z=1,2,3
  • x,y=y,x交换
  • x+=1,x-=2

条件

  • False,None,0,"",(),[],{}为假
  • 1<a<3

    语句块

  • begin with :

    1
    2
    3
    4
    5
    6
    #!/usr/bin/env python
    name = raw_input()
    if name.endswith('a'):
    print 'have a'
    else:
    print 'not a'
  • is表示统一性,必须指向同一个东西,并不止对比值相同

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    >>> x=[1,2,3]
    >>> y = x;
    >>> x is y
    True
    >>> z = x[:]
    >>> x
    [1, 2, 3]
    >>> z
    [1, 2, 3]
    >>> z is x
    False
    >>> z = y
    >>> z is x
    True

断言

  • assert成功没事,不成功报错程序结束

for while

  • range设定范围 xrange不一下创建整个范围序列
  • for i in s
  • while i <3
  • 迭代字典。for k in d; for k in d.keys(); for k,v in d.items()
  • zip 将两个序列合在一起for k,v in zip(a,b)
  • pass占位符,python中不允许空的代码块

列表推导式

  • [x*x for x in range(4)]

del,exec,eval

  • x=y, del y, x还存在。记住就行,只是删除了名字
  • exec 执行python代码,eval计算python表达式。

第六章 抽象

定义函数

1
2
3
4
5
6
7
8
9
def myadd(a,b):
return a+b
def f(x):
fn = [1,2]
for i in range(2,x):
fn.append(myadd(fn[i-2],fn[i-1]))
for i in range(x):
print(fn[i])
f(10)

关键字参数

1
2
3
4
5
6
7
def f(a,b):
print a,b
f(1,2)
f(b=1,a=2)
wangfan@Deballer-server:~/code/python$ ./p6.py
1 2
2 1

参数收集

  • f(*param)处理多个普通参数,保存为元组
  • f(**param)处理多个关键字参数,保存为字典

作用域

x=2实质为建立了x和1的字典
s = vars();返回的是当前作用域下的字典

1
2
>>> s
{'__builtins__': <module '__builtin__' (built-in)>, '__package__': None, 's': {...}, 'x': 2, '__name__': '__main__', '__doc__': None}

引用全局变量,global

第七章 类和继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#!/usr/bin/env python
__metaclass__ = type
class Person:
name = 'Yin'
def setName(pself,name):
pself.name = name

def getName(self):
return self.name

foo = Person()
print foo.getName()
def psetName(heihei,name):
heihei.name = name+'.net'
foo.setName = psetName
#foo.setName('wf') #error,绑定外部函数后不再有第一个隐含参数输入
#foo.setName(foo,'wf') #error, <bound method Person.getName of <__main__.Person object at 0x7f6342377f90>>
print foo.getName

内部默认是共有,私有需要加__

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/usr/bin/env python
__metaclass__ = type
class Person:
name = 'Yin'
def setName(pself,name):
Person.name = name

def getName(self):
return self.name
foo = Person();
print foo.getName();
Person.name='wf';
print foo.getName();
print Person.name;
foo.name = 'Ha'
print foo.getName();
print Person.name;
#Yin
#wf
#wf
#Ha
#wf

第八章 异常

raise Exception()

1
2
3
4
5
6
try:
x = input();
y = input();
print x/y
except Exception :
print 'zeor!!!!!'

捕获多个异常

1
exception (exceptionA,B,C)

保存异常对象

1
2
except Exception , e: #python2
except Exception as e : #pyton3

扑捉所有异常

1
2
3
4
try :
except :
else :
finally: #不管发不发生异常都会执行

第九章 类

构造函数

1
2
class A:
def __init__(self)

析构函数

__del__,在垃圾回收之前调用,但具体时间不可知,建议不要用

子类不会主动调用父类的构造函数,需要手动:

1
2
3
4
5
6
7
8
9
10
class A :
def __init__(this):
this.val = 6
def show(this):
print this.val

class B(A) :
def __init__(this):
A.__init__(this)#旧式
super(B,this).__init__()#新式,需要__metaclass__=type

属性

1
2
3
4
5
6
7
8
9
10
11
12
class A:
def __init__(this,start=0,step=1):
this.start = start
this.step = step
this.changed={}
def __getitem__(this,key):
return this.changed[key]
def __setitem__(this,key,value):
this.changed[key]=value
a = A(1,2);
a[4]=2;
print a[4]

重写计数

1
2
3
4
5
6
7
8
9
10
11
12
class plist(list):
def __init__(this,*args):
super(plist,this).__init__(*args)
this.count = 0
def __getitem__(this,index):
this.count +=1
return super(plist,this).__getitem__(index)
l = plist(range(10));
print l;
print l[1]
print l[2]
print l.count

property函数

有4个参数fget,fset,fdel,doc

1
2
3
4
5
6
7
8
9
10
11
12
class A:
def __init__(this):
this.num=0
def pget(this):
return this.num
def pset(this,i):
this.num = i
size = property(fget=pget,fset=pset)
a=A();
print a.size
a.size=4;
print a.size

静态方法和类成员方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class A:
@staticmethod
def sm():
print 'sm'
@classmethod
def cm(cls):
print 'cm',cls
def m(this):
print 'm'

A.sm();
A.cm();
a = A();
a.sm();
a.cm();
a.m();
A.m();

##ouput

sm
cm <class '__main__.A'>
sm
cm <class '__main__.A'>
m
Traceback (most recent call last):
File "./p9.py", line 20, in <module>
A.m();
TypeError: unbound method m() must be called with A instance as first argument (got nothing instead)

迭代器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class A:
def __init__(this):
this.a=0;
this.b=1;
def next(this):#关键
if this.a > 1000:
raise StopIteration
this.a=this.a+this.b;
this.a,this.b=this.b,this.a;
return this.b;
def __iter__(this):#关键
return this
a=A();
for i in a:
print i

生成器

1
2
3
4
5
6
def ft(nested):
for sublist in nested:
for element in sublist:
yield element
for num in ft([[1,2],[3,4]]):
print num

第十章 模块

设置模块搜索路径import sys and sys.path.append('')
模块可以是一个文件,包是一个目录,其中有__init__.py文件

1
2
3
4
5
import copy
copy.__all__ #列表
copy.__doc__ #文档
help(copy.copy)
print copy.__file__ #源码位置

第十一章 文件和流

r+ 以读写方式打开文件,文件可读可写,可写到文件的任何位置。通过seek来定位。

a+ 以追加方式读写文件,a+ 和r+不同的是,它只能写到文件末尾

w+ 和r+不同的是,它会先清空文件。

sys.stdin 标准读入 input 和 raw_input也是在stdin中
sys.stdout 标准输出
sys.stderr

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#!/usr/bin/env python
#!coding:utf8
f = open('a.txt','w')
f.write('Hello\nword!\n')
f.close()

f = open('a.txt','r')
#s = f.read()
#全部读出
s = f.readline()
#读取一行
print s

for line in open('')
f = fopen()
for line in f.readlines()
#按照行读