python学习笔记.docx

基本功
1. Python语言中没有采用花括号来分割代码块，而是使用了冒号和代码缩进来区分代码之间的层次。
Ex：
if __name__ == '__main__':
time = 12
if(time==12):
print '12'
else:
print '13'
2. 函数与函数之间或者类与类之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
Ex：
class Myclass:
def MyFirstClass(self):
print 'MyFirstClass'

def MySecondFun(self):
print 'MySecondFun'

if __name__ == '__main__':
myClass = Myclass()
myClass.MyFirstClass()
myClass.MySecondFun()

3. 函数命名规则：
函数名必须以下划线或字母开头，可以包含任意字母、数字或下划线的组合。
函数名是区分大小写的
函数名不能是保留字。（其他命名规则与java类似）
4. Java采用//或/*…*/作为注释标记，Python中
（1） 单行注释：#
（2） 行内注释：行内注释至少用两个空格和语句分开，以#和单个空格开始
（3） 注释块：也是用#
（4） 中文注释：如果需要在代码中加入中文注释，必须在文件最前端添加 #_*_ coding:utf-8 _*_,否则整的会报错。
（5） 跨平台注释：如果程序在windows以外的平台上运行，在文件最前端加!#/user/bin/python
5. Python一般用换行作为语句结束的标识，也可以像Java一样用分号，但是不推荐使用。如果一行中写多条语句，则用分号作为结束标识。（不赞成使用）
6. 数值类型：
（1） 整型：
1） 布尔型：TRUE为1，FALSE为0，为整型的子类，不能被继承。
2） 标准整数类型：
3） 长整型：从Python2.3开始，就不会出现整型溢出的错误，结果会被自动转换成长整型，即在数字后边加一个L。
（2） 双精度浮点型：类似于C语言中的double，可以用十进制或科学计数法表示。每个浮点数占8个字节，64比特。浮点数的表示方法通常使用一个小数点和一个可选的E(大小写都可以)，E和指数之间可以用+或-表示指数的正负。（+可以省略） 1.09E-12
（3） 复数：一个实数和一个虚数的组合构成一个复数
（4） 十进制浮点数：该类型不是内建类型，必须先导入decimal模块才可以使用这种数值类型。
Ex：
if __name__ == '__main__':
from decimal import Decimal
dec = Decimal(1.1)
print dec
print 1.1
7. 标识符的命名：
（1） 标识符的第一个字符必须是字母或者下划线
（2） 以下划线开头的标识符室友特殊意义的，其中：
1） 以单下划线开头的（_foo）代表不能直接访问的类的属性，需通过类提供的接口进行访问，也不能用from xxx import *导入
2） 以双下划线开头的（__foo）代表类的私有成员
3） 以双下划线开头和结尾的（__foo__）代表Python中特殊的方法专用的标识，例如__init__()代表类的构造方法。
（3） 标识符的其他部分也可以由字母、下划线、数字组成。
（4） 标识符的名称大小写敏感。
8. Python是动态类型的语言，不需要预先声明变量的类型。变量的类型和值在赋值的那一刻就被初始化了。且不支持i++，i--，++i，--i。支持i*=10，i= i*10。
9. Python创建的变量就是一个对象，Python会管理变量的生命周期。Python对变量的回收也是采用垃圾回收机制。
10. 在文件的开头定义全局变量，在函数中引用时，用global，否则会出现不正常的结果。
Ex
_num = 12
if __name__ == '__main__':
global _num
print _num
11. 单引号、双引号和三引号字符串
单引号：使用单引号表示普通的字符串，表示普通的字符串。（不带任何引号的字符串）
if __name__ == '__main__':
print '大家好，这是 HelloWorld！ '
大家好，这是 HelloWorld！
双引号：
1） 与单引号中使用方法相同
print "your name"
your name
2） 若字符串中使用了单引号，就不能使用单引号包围字符串
print "What's your name"
What's your name
3） 当字符串中要出现双引号时，可以在外边加上单引号。
print '"What is your name?" I say'
"What is your name?" I say
三引号：可以指示一个多行字符串，并且三引号中的字符串可以自由的使用单引号和双引号。
print '''"HelloWorld",
HiWord
'hi' '''
"HelloWorld",
HiWord
'hi'
12. str()：把值转换为合理的形式的字符串，以便用户理解
repr()：创建一个字符串，以合法的Python表达式的形式表达出来。
13. input()是把读入的用户输入默认为Python表达式。
name = input('what\'s your name?')
print 'my name is ' + name

what's your name?'1'
my name is 1

raw_input()是把读入的数据转换为字符串。
name = raw_input('what\'s your name?')
print 'my name is ' name

what's your name?1
my name is 1
14. **，x**y求幂运算，2**3=8
15. if语句
name = 'Happy'
if name == 'Happy1':
print '111'
elif name == "Happy2":
print '222'
elif name == 'Happy3':
print '333'
else:
print 'Happy'
16. while循环，当while指定条件为true时，循环执行while块中的语句，否则执行else中的语句。

i = 1
while i < 5:
print '我是第' + str(i) + '次输出'
i = i + 1
else:
print '输出结果完毕'
17. for循环，
meinv = {
'赵飞燕':'水色萧前流玉霜，赵家飞燕待昭阳，掌中舞罢箫声绝，三十六宫秋夜长。',
'王昭君':'罗燕北飞情未消，折戟沉沙和两朝，可怜琵琶空对月，万般愁情镜中描。'
}
for key in meinv:
print key,'被形容的诗句是：',meinv[key]
18. 迭代器readline和next
Readline：一次从文件中读取一行文本，当调用readline方法是，就会前进到下一列，知道文件末尾，返回一个空字符串。
Next：当方法执行到文件末尾是，不是返回空字符串，而是印发内置的StopIteration异常。
iter()函数返回一个迭代器，然后使用迭代器的next方法降至输出。

19. 并行迭代，程序可以同时迭代两个程序。
names = ['A','B','C','D']
ages = ['21','22','23','24']
for i in range(len(names)):
print names[i],'的年龄是：',ages[i]

names = ['A''B','C','D']
ages = ['21','22','23','24']
for name,age in zip(names,ages):
print name,'的年龄是：',age

20. 编号迭代，我们使用了内建的enumerate函数来进行编号迭代，其主要作用是在提供索引的地方迭代索引值对。
strs = ['星桥鹊起','经年才见','想离情、','别恨难穷']
for index,s in enumerate(strs):
if '星桥鹊起' in s:
strs[index] = '金风玉露一相逢，便胜却人间无数'

for s in strs:
print s
2
fin = raw_input('请输入：')
flo = ['111','222','333','444','555','666']

for index,f in enumerate(flo):
if fin in f:
print 'find '+f
21. break语句在符合条件的情况下跳出整个循环，continue语句则是跳过符合条件的内容，然后转到循环的顶端继续执行循环。
在循环中可以使用else子句。
22. pass在程序中什么事情都不需要做，类似于一个占位符。
name = raw_input('输入用户名：')
if name == '111':
print 'you are manager:' + name
else:
pass

23. del,一般来说，Python会删除那些不再使用的对象，因为使用者不会再通过任何变量或者数据结果来引用他们。Del语句可以用来删除序列和字典元素，不仅会移除对一个对象的引用，还会移除这个名字本身。
name = 'HelloWorld'
del name
print name
（NameError: name 'name' is not defined）
24. Python程序其实是有包、模块和函数三者组成的。
包是由一系列模块组成的集合。模块是处理某一类问题的函数和类的集合。包中必须至少包含一个_init_.py文件，该文件的内容可以为空，用于标识当前文件夹是一个包。
25. Python可以在函数中默认参数值。
def login(username='haha',password = 'haha'):
if (username=='admin') and (password=='admin'):
print '登陆成功！'
else:
print '登陆失败！'

if __name__ == '__main__':
login()
login(username='admin',password='admin')

登陆失败！
登陆成功！
26. 函数的参数可以使变量，也可以是数组、列表等内置数据结构。
def login(usernames = [],password = 'haha'):
username = usernames[0]
if (username=='admin') and (password=='admin'):
print '登陆成功！'
else:
print '登陆失败'

if __name__ == '__main__':
login(['admin','123'],'admin')

登陆成功！
27. 可变长度的参数值。
在程序开发过程中，常常需要传递可变长度的参数。在函数的参数前使用标识符*，可以实现这个要求。*可以引用元祖，将多个参数组合在一个数组中。
def login(* userpwds):
username = userpwds[0]
password = userpwds[1]
if(username=='admin') and (password == 'admin'):
print '登陆成功！'
else:
print '登陆失败！'

if __name__ == '__main__':
login('admin','admin','123')

登陆成功！

28. 字典类型的参数值。
Python还提供了另一种标识符**，在形式参数前面添加**，可以引用夜歌字典作为参数。根据实际参数的赋值表达式生成字典。
def login(**userpwds):
keys=userpwds.keys()
username=''
password=''
for key in keys:
if 'username'==key:
username=userpwds[key]
if 'password'==key:
password=userpwds[key]
if(username=='admin') and (password=='admin'):
print '登陆成功！'
else:
print '登陆失败！'

if __name__ == '__main__':
login(username='admin',password='admin')

登陆成功！

29. 函数返回值，如果需要返回多个值
如果需要返回多个值，可以将需要返回的值全部打包到元组中。在调用时，对返回的元组解包即可。
def operat(x=1,y=1,z=1):
x = 1
y = 2
z = 3
oper=[x,y,z]
numbers = tuple(oper)
return numbers

if __name__ == '__main__':
x,yz=operat()
print x,y,z

30. Python中的from。。。import。。。语句可以将模块中的类或函数导入，从而不需要使用模块名作为前缀。
from module_name import function_name/class_name
但是不能直接引入某个类下的function
可能会产生代码可读性差的问题。
31. __name__属性
__name__属性用户判断当前模块是不是程序的入口，如果当前程序正在被使用，__name__的值为__main__。
If __name__ == ‘__main__’:
…
else:
…
32. __doc__属性
每个对象都会有__doc__属性，该属性值用于描述该对象的作用。
33. 33、apply()
可以实现调用可变参数列表的功能，把函数的参数存放到一个元组或序列中。
34. 列表（List）
添加元素：
append(value)
insert(index,value)
扩展元素：
extend()
a.extend(b),a和b为列表
元素赋值：
list[index] = value
删除元素：
List.remove(value)，删除的元素必须存在，否则报错
del list[index]，删除指定索引的元素
分片赋值：
List[m:n]=
list = [1,2,3]
list[2:2] = [4,5,6]
for a in list:
print a
1 2 4 5 6 3
列表的链接:
extend（） list1.estend(list2)
+ list3 = list1+list2
+= list1 += list2
* list2 = list1*2(将list1中的内容复制一次)
列表的查找、排序、反转：
list1.index(value) 返回值为value的序号
list1.sort()列表的排序，默认为升序，会改变原来的列表
list1.reverse()列表的反转，会改变原来的列表
pop()
list.pop()，移除最后一个元素，并返回
list.pop(0)，移除第一个元素，并返回
35. 元组
元组中的元素被包含在一对圆括号中，元素之间用逗号隔开。
如果元组只包含一个元素，那么该元素后面的逗号是不可忽略的。array = (a,)
创建元组后，其内部的值不能被修改，否则运行时将报错。
Tuple以一个序列作为参数，并把它转换为元组。
元组的遍历：
range()函数返回一个递增或递减的数字列表。
range(start,stop,step)
36. 字典
dictionary_name{key:value,key:value…}
其中key代表键值，value代表value值。字典由多个键值对组成，每个键和其对应的值用冒号：隔开，项与项之间用逗号隔开，整个字典用一对大括号括起来。
setdefault()方法可以用来想字典中添加元素。但是如果key已经存在，则其value为原有值。
userDic={'01':'xiaowan','02':'xiaoli'}
print userDic
userDic.setdefault('03','xiaopei')
print userDic
userDic.setdefault('03','xiaoma')
print userDic

{'02': 'xiaoli', '01': 'xiaowan'}
{'02': 'xiaoli', '03': 'xiaopei', '01': 'xiaowan'}
{'02': 'xiaoli', '03': 'xiaopei', '01': 'xiaowan'}
还可以用以下方式
userDic={'01':'xiaowan','02':'xiaoli'}
print userDic
userDic['03'] = 'xiaoma'
print userDic
userDic['03'] = 'xiaoli'
print userDic
这种方式可以修改已经存在key的value
37. 字典的删除元素
1、del(userDic['01']) 或 del userDic['02']
2、userDic.pop('01')
38. 38、字典的遍历
1、for…in
userDic={'01':'xiaowan','02':'xiaoli'}
userDic['03'] = 'xiaoma'
for key in userDic:
print 'userDic[%s]=' %key ,userDic[key]
2、items()
userDic={'01':'xiaowan','02':'xiaoli'}
userDic['03'] = 'xiaoma'
print userDic.items()
3、iteritems(),iterkeys(),itervalues()
iteritems()返回键值序列,相比items（），更加高效。
iterkey()返回所有key
itervalues()返回所有value
zip(userDic.iterkeys(),userDic.itervalues()) == iteritems()
39. 字典的其他方法
clear()清楚字典中的所有项
copy()返回值为一个具有相同键值对的新字典
fromkeys()使用给定的键来建立新的字典
userDic={'01':'xiaowan','02':'xiaoli'}
userDic['03'] = 'xiaoma'
userDic1 = userDic.fromkeys(['01','02'],['ma','li'])
print userDic1

{'02': ['ma', 'li'], '01': ['ma', 'li']}
get()用于返回字典中的某个元素，如果访问的元素不存在，则返回none
has_key()可以检查字典中是否含有指定的键，返回值为true或false
popitem()第一次调用会返回第一个元素，第二次调用会返回第二个元素。。。
update()
pop()参数为键，用于获取相应参数的值，然后将这个键值对从字典中删除。
formkeys（）用给定的键建立新的字典，每个键都对应一个默认的None，参数为列表[‘’,’’,’’,’’]

40. eval（）
运行一个包含Python表达式的字符串
num1 = '1'
num2 = '2'
print eval(num1+'+'+num2)
print eval('1+2')
41. ord() and chr()
Ord()将单个字符转换成ASCII数值
Chr将整数转换成对应的字符。
42. 42、在程序前加from __future__ import division ，可执行普通除法。用双斜线//可实现整除。
43. 43、字符串格式化
format = "Hello,%s %s enouth for ya?"
value=("world","Hot")
print format % value

Hello,world Hot enouth for ya?
只有元组和字典可以格式化一个以上的值。其他会被解释为一个值。
substitute()

44. 字符串常用方法
find(),查找字串，如果存在返回该子串最左端的索引，否则返回-1。可加入非别为起始点和结束点的参数。
join()用来链接序列中的元素，且要求序列元素都为字符串。
seq = ['1','2','3','4']
sep = '!'
print sep.join(seq)

1!2!3!4
表示用sep链接seq。
lower()返回字符串的小写字母
upper（）返回字符串的大写字母
replace（）查找并替换，将字符串中的第一个参数替换成第二个参数。
split（），是join的逆方法，用来将字符串分割为序列。如果不提供任何分隔符（参数），程序会把空格作为分隔符。
strip()返回出去两侧空格的字符串，不包括内部空格
translate（）可以替换字符中的某些部分，但只能处理单个字符。可以同时进行多行替换。
makestrans()函数接收两个参数，两个等长的字符串，表示第一个字符串中的每个字符都用第二个字符串中相同位置的字符替换。
table = maketrans('cs','kz')
print len(table)
print 'cscscscsascbbbbbc'.translate(table);

256
Kzkzkzkzazkbbbbbk
45. 赋值
序列解包
x,y,z = '1',2,'b'
print x,y,z
交换两个值
x,y,z = 'a',2,3
x,y = y,x
print x,y
2 a
序列
values=[12,3]
x,y,z = values
print x,y,z
46. 下面的值在作为布尔表达式时，会被解释器看做假（false）
False, none, 0, ””, (), [], {}
47. bool（）函数可以将其他值转换为布尔值。
48. cmp（x,y）用于比较两个对象是否相同，若相同则返回0，否则返回-1.
49. is运算符是判断同一性，而不是相等性，==用于判断相等性。
50. 字符串、序列可以按照字母顺序排列进行比较
print 'abcdef' < 'bacdef'

True
51. 列表推导式，利用其他列表创建新列表
print [x*x for x in range(10)]
print [x*x for x in range(10) if x%3==0]

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[0, 9, 36, 81]
52. 内建的callable函数可以用来判断函数是否可调用。
53. 收集参数
函数中的参数带*时，意思是手机其余的位置参数，
有**时，表示收集其余的关键字参数。
def story(**kwds):
print 'Once upon a time, there was a %(job)s called %(name)s' %kwds
def power(x,y,*others):
if others:
print 'Received redundant parameters:',others
return pow(x,y)
def interval(start,stop=None,step=1):
if stop is None:
start, stop = 0, start
re = []
i = start
while iep
print re

story(job='king',name='Pei')
params = {'job':'Co', 'name':'Pei'}
story(**params)
del params['job']
story(job='coco',**params)
power(3,3,'Hello,world')
interval(10)
interval(1,5)
Once upon a time, there was a Co called Pei
Once upon a time, there was a coco called Pei
Received redundant parameters: ('Hello,world',)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4]
54. Choice
From random import choice
X = choice([‘’,’’,’’,,])
X为choice参数（列表）中的某一项
55. Python不需要对类写get & set 方法，属性可以在外部直接访问
56. Python为了让方法或者特性（属性）变为私有，从外部不能访问，只要再它的名字前面加上双下划线__。
在累的内部定义中，所有以双下划线开始的名字都被翻译”成前面加上单下划线和类名的形式。所以可以这样继续访问，s=_ClassName__method()
__metaclass__=type

class Person:

__name=''

def setName(self,name):
self.__name = name

def getName(self):
return self.__name

def greet(self):
print 'Hello, world, I am %s' %self.__name

foo = Person()
bar = Person()
foo.setName('Pei')
bar.setName('Wang')
print foo.getName()
print bar.getName()
foo.greet()
print foo._Person__name
print foo.__name

Pei
Wang
Hello, world, I am Pei
Pei
AttributeError: 'Person' object has no attribute '__name'

如果不需要使用这种方法，又想让其他对象不访问内部数据，那么可以使用单下划线。例如，前面有下划线的名字都不会被带星号的import语句（from module import *）导入。
57. 指定父类
子类可以扩展父类的定义。将其他类名写在class语句后的圆括号内可以指定父类。
Class subclass（superclass1，superclass2。。。）：
58. 检查继承
Issubclass(subclass,superclass)
如果向知道已知类的基类们，
可以Subclass.__bases__
59. 实例检查
Isinstance（）
60. 多个父类时，同名方法的顺序
如果一个方法从多个父类继承（父类们中有两个具有相同名字的不同方法），先继承的类中的方法会重写后继承的类中的方法。
61. hasattr(),getattr(),setattr()，callable（），type（）
hasattr(object，‘attr’)用于检查对象中是否含有属性（方法）attr
getattr(object,’attr’,None)如果object不含属性（方法）attr。
Callable（method）判断方法是否可用
Setattr(object,’name’,’value’) object.name=value
Type(object)返回对象的类型

62. dir（）
dir() 函数可能是 Python 自省机制中最著名的部分了。它返回传递给它的任何对象的属性名称经过排序的列表。如果不指定对象，则 dir() 返回当前作用域中的名称
63. python的一些常见异常

64. 创建自己的异常类
class UrExceptionName(Exception): …
65. Try/except捕获异常
try:
x = input('Enter a number')
y = input('Enter a number')
print x/y
except ZeroDivisionError:
print 'The second number can not be zero!'
66. 如果捕捉到异常，但又不想处理，而是启发它
可用raise
try:
x = input('Enter a number')
y = input('Enter a number')
print x/y
except ZeroDivisionError:
raise
67. 可以由多个except，一个except中也可以有多个异常，如果想获得异常对象：
Try:
…
Except (E1,E2…), e(2.0)
Except (E1,E2…) as e(3.0)
…
68. 如果想捕获所有异常，使没有漏掉的异常，可以在except子句中忽略所有异常类。
Except:
…
while TRUE:
try:
x = input('Enter a number')
y = input('Enter a number')
print x/y
except:
print 'Wrong,try again'
else:
break;
69. Finally
不管try中是否发生异常，finally中的内容肯定会被执行。
70. 构造函数
Python中只能有一个构造函数，def __init__(self, attr, attr, …):attr为参数，可以没有。实例化一个子类的时候，并不会调用他的父类构造方法，因此也得不到父类实例化时初始化的属性，例如hungr，因此在子类的构造房子法中，还要调用父类的构造方法。可用super函数。
class Bird():
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
self.hungry = False
print 'I am eating...'
else :
print 'I am not hungry, thanks...'
class SongBird(Bird):
# hungry = True
def __init__(self):
# Bird.__init__(self)
super(SongBird,self).__init__()
self.song = 'Hello...'
def sing(self):
print self.song

sb = SongBird()
sb.sing()
sb.eat()
sb.eat()
71. 迭代器
__iter__方法，返回一个迭代器，就是具有next方法（不需要任何参数）的对象。调用next方法时，迭代器会返回它的下一个值。如果next方法被调用，但是迭代器没有值可返回，就睡引发一个StopIteration异常。
class Fibs:
def __init__(self):
self.a = 0
self.b = 1
def next(self):
self.a,self.b = self.b,self.a + self.b
return self.a
def __iter__(self):
return self
fibs = Fibs()
for f in fibs:
print f
if f>1500:
break
一个实现了__inter__方法的对象是可迭代的，一个实现了next方法的对象是迭代器。

72. 从迭代器得到序列
class TestIterator:
value = 0