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()
#按照行读