Python编码规范
类名首字母大写，对象名小写。
类的属性与方法名以对象作为前缀。
类的私有变量、私有方法以两个下划线作为前缀。
函数名通常采用小写，并用下划线或者单词首字母大写增强可读性。
Python的注释以 # 开头，后面的文字直到行尾都算注释
Python的编码通过缩进表示每行代码之间的层次关系。如下
x=1
if x == 1:
print"x=",x #代码缩进
else:
print"x=",x #代码缩进
x = x + 1 #代码缩进
print"x=",x
Python中语句可以用;结束语句，也可以省略
#下面两句语句等价
print"hello"
print"hello";
但是在同一行中有多条语句，就必须用分号隔离
#使用分号分隔语句
x = 1 ; y = 1 ; x= 1
对于一些一行代码比较长的语句。
Python支持多行写一条语句，
Python使用\作为多行语句连接符。
以下为两种写法
写法一只用了一对双引号，
写法二用了两对双引号，写法二比写法一的可读性强。
注：\用来链接字符串时，后不能有任何代码，包括注释
print"hello \
world"
print"hello "\
"world"
输出结果都为
hello world
Python有的编辑器是不支持中文字符的，
用到中文需要在最顶部添加
# -*- coding: utf-8 -*-
变量和数据类型
Python会根据变量的值自动判断变量的类型。
有如下类型。
一、整数
Python可以处理任意大小的整数。
二、浮点数
浮点数也就是小数。
三、字符串
字符串是以' '或" "或''' '''(三个单引号)括起来的任意文本
四、布尔值
Python中，可以直接用True、False表示布尔值(注意大小写)
五、空值
空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
运算符与表达式
算术运算符
算数运算符包括四则运算符、求模运算符和求幂运算符。
+：加法运算
-：减法运算
*：乘法运算
/：除法运算
%：求模运算
**：求幂运算
# -*- coding: utf-8 -*-
print"1 + 1 =",1+1 #结果为：1 + 1 = 2
print"2 - 1 =",2-1 #结果为：2 - 1 = 1
print"3 * 2 =",3*1 #结果为：3 * 2 = 3
print"4 / 2 =",4/2 #结果为：4 / 2 = 2
print"1 / 2 =",1/2 #结果为：1 / 2 = 0
print"1 / 2 =",1.0/2.0 #结果为：1 / 2 = 0.5
print"3 % 2 =",3%2 #结果为：3 % 2 = 1
print"2 ** 3 =",2**3 #结果为：2 ** 3 = 8
关系运算符
>：大于
>=：大于等于
<=：小于等于
==：等于
!=：不等于
# -*- coding: utf-8 -*-
print 2 > 1 #结果为：True
print 4 < 2 #结果为：False
print 3 >= 2 #结果为：True
print 2 <= 1 #结果为：False
print 4 == 2 #结果为：False
print 3 != 2 #结果为：True
逻辑运算符
在Python中采用 and ornot表示与、或、非
与运算：只有两个布尔值都为 True 时，计算结果才为 True。
print True and True # ==> True
print True and False # ==> False
print False and True # ==> False
print False and False # ==> False
或运算：只要有一个布尔值为 True，计算结果就是 True。
print True or True # ==> True
print True or False # ==> True
print False or True # ==> True
print False or False # ==> False
非运算：把True变为False，或者把False变为True。
print not True # ==> False
print not False # ==> True
在逻辑运算中，有一条重要法则：短路计算。
1. 在计算 a and b 时，
如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；
如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。
2. 在计算 a or b 时，
如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；
如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。
a = 'python'
print a or 'world' #==>python
b = ''
print b or 'world' #==>world
Python集合与元祖
Python内置的一种数据类型是列表：list。
list是一种有序的集合，可以随时添加和删除其中的元素。
下面演示集合的一系列操作
# -*- coding: utf-8 -*-
L=['A','B','C','D','E',1,2,3,4,5] #定义一个list集合
print L #==>['A', 'B', 'C', 'D', 'E', 1, 2, 3, 4, 5]
#list集合索引是从0开始的。
#读取集合时候不要越界，会报错。
print L[0] #==>A
print L[6] #==>2
#倒序读取
print L[-1] #==>5
print L[-6] #==>E
print L[-10] #==>A
L.append(6) #末尾追加一个元素
print L #==>['A', 'B', 'C', 'D', 'E', 1, 2, 3, 4, 5, 6]
L.insert(1,'in') #在索引为1的位置插入元素'in'
print L #==>['A', 'in', 'B', 'C', 'D', 'E', 1, 2, 3, 4, 5, 6]
L.pop() #删除list最后一个元素
print L #==>['A', 'in', 'B', 'C', 'D', 'E', 1, 2, 3, 4, 5]
#删除最后一个元素并打印出这个值
print L.pop() #==>5
print L #==>['A', 'in', 'B', 'C', 'D', 'E', 1, 2, 3, 4]
L.pop(1) #删除索引值为1的元素
print L #==>['A', 'B', 'C', 'D', 'E', 1, 2, 3, 4]
#替换数组中的值
L[1]='TB' #替换索引值为1的值为TB
L[-2]=33 #替换倒数第二个值为33
print L #==>['A', 'TB', 'C', 'D', 'E', 1, 2, 33, 4]
总结上面的测试代码，列表有几个常用的函数。
append(object)：在列表的尾部添加一个object
indert(index,object)：在指定的索引处插入一个object
pop([index])：删除索引index指定的值，如果index不指定则删除最后一个元素
还有不常用的一些。
remove(value)：删除列表中首次出现的value值
extend(iterable)：将iterable指定的元素复制到列表的尾部
index(value,[start,[stop]])：返回value出现在列表中的索引值，start、stop可省略
sort(cmp=None,key=None,reverse=False)：列表的排序
reverse()：列表的反排序
tuple是另一种有序的列表，中文翻译为“ 元组 ”。
tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修改了。
获取 tuple 元素的方式和 list 是一模一样的，
可以正常使用 t[0]，t[-1]等索引方式访问元素，
但是不能赋值也不能删除里面元素。
单元素元组需要在元素后面加上,
因为()既可以表示tuple，又可以作为括号表示运算时的优先级，
结果 (1) 被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。
正是因为用()定义单元素的tuple有歧义，
所以 Python 规定，单元素 tuple 要多加一个逗号“,”
T=(1)
print T #==>1
T = (1,)
print T #==>(1,)
元组的访问还有一种特殊方法，
分片(slice)是元组的一个子集，
在与之类似的数组也能使用
分片是从从第一个索引(包含第一个索引所指向的元素)
到第二个索引(不包含第二个索引所指向的元素)所指定的所有元素。
分片的表达式如下：
tuple[m:n]
# -*- coding: utf-8 -*-
T = (0,1,2,3,4,5)
#包含左边索引对应值，不包含右边索引对应值
print T[1:3] #==>(1, 2)
print T[1:-2] #==>(1, 2, 3)
print T[2:] #==>(2, 3, 4, 5)
print T[:3] #==>(0, 1, 2)
print T[:] #==>(0, 1, 2, 3, 4, 5)
print T[:10] #==>(0, 1, 2, 3, 4, 5)
print T[10:] #==>()
数组访问之打包解包
# -*- coding: utf-8 -*-
T = (00,10,20,30,40,50) #打包
a,b,c,d,e,f=T #解包，需要一一对应
print b #==>10
T = [00,10,20,30,40,50] #打包
a,b,c,d,e,f=T #解包，需要一一对应
print b #==>10
Python控制语句
Python中条判断语句：
if语句、if...else...语句、if...elif...else...语句
使用控制语句需要注意Python缩进规则，具有相同缩进的代码被视为代码块，
缩进请严格按照Python的习惯写法：
4个空格，不要使用Tab，因为有的编译器Tab不是四个空格，很容易造成因为缩进引起的语法错误。
通过缩进代码可以互相嵌套。
注意： 语句后接表达式，然后用:表示代码块开始。
# -*- coding: utf-8 -*-
age = 50
if age >= 18:
if age>=60:
print "老年人"
else:
print '成年人'
elif age >= 12:
print '青年'
elif age >= 3:
print '儿童'
else:
print '宝宝'
Python中循环语句：
for循环、while循环。
for 循环可以依次把list或tuple的每个元素迭代出来
while 循环不会迭代 list 或 tuple 的元素，而是根据表达式判断循环是否结束。
# -*- coding: utf-8 -*-
L = [1, 2, 3, 4, 5]
sum = 0
for i in L: #依次取出L中元素放入i中
sum+=i
print sum #==>15
i = 1
sum = 0
while i<=5:
sum=sum+i
i=i+1
print sum #==>15
break 与continue语句
break：退出循环语句
# -*- coding: utf-8 -*-
# -*- coding: utf-8 -*-
L = [1, 2, 3, 4, 5]
sum = 0
for i in L:
sum+=i
if i==3: #当取出元素等于3
break #退出循环体
print sum #==>6
continue：跳过本次循环
# -*- coding: utf-8 -*-
L = [1, 2, 3, 4, 5]
sum = 0
for i in L:
if i%2==0: #当取出元素是偶数
continue #跳过执行下面代码，
sum+=i
print sum #==>9
了解这两个控制语句后，来看看
for...else...、while...else...语句。
只有当循环执行结束才会运行循环后else代码块语句。
循环过程中途退出循环则不会运行循环后else代码块语句。
continue不会影响执行else语句
# -*- coding: utf-8 -*-
L = [1, 2, 3, 4, 5]
sum = 0
for i in L:
if i%2==0: #当取出元素是偶数
continue #跳过执行下面循环体内代码，
sum+=i
else: #循环语句执行完成，进入else
sum=0
print sum #==>0
break直接退出循环，包括else
# -*- coding: utf-8 -*-
L = [1, 2, 3, 4, 5]
sum = 0
for i in L:
sum+=i
if i==3: #当取出元素等于3
break #退出整个循环结构，包括后面的else
else:
sum=0
print sum #==>6
循环也是可以多重嵌套的，
for x in ['A', 'B', 'C']:
for y in ['1', '2', '3']:
print x + y
结果为：
A1
A2
A3
B1
B2
B3
C1
C2
C3
Python中Dict和Set类型
Dict与list 、 tuple 可以用来表示顺序集合，
但是Dict可以自定义索引，
所以Dict也叫字典，他是由一系列的 “键：值”(key:value)对组成.
对之间用逗号隔开。然后通过对应的索引值可以取得元素
注意：索引区分大小写
d = {
'A': 1,
'B': 2,
'C': 3
}
print d['A'] #==>1
由于“键：值”算一个，所以字典d的大小为3
在字典中通过 key 访问 字典 的值，只要 索引 存在，字典就返回对应的值。
如果如果不存在，会直接报错。
所以有以下解决方法。
# -*- coding: utf-8 -*-
d = {
'A': '我是A',
'B': '我是B',
'C': '我是C'
}
#方法一先判断
if 'A' in d: #判断A是否在字典中
print d['A']
#方法二直接读取，如果不存在返回空
print d.get("A") #==>我是A
print d.get("D") #==>None
dict的第一个特点是查找速度快，
无论dict有10个元素还是10万个元素，查找速度都一样。
而list的查找速度随着元素增加而逐渐下降。
不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，
还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。
由于dict是按 key 查找，所以，在一个dict中，key不能重复。
dict的第二个特点就是存储的key-value序对是没有顺序的
这和list不一样。
dict打印的顺序不一定是我们创建时的顺序，
而且，不同的机器打印的顺序都可能不同，这说明dict内部是无序的，不能用dict存储有序的集合。
dict的第三个特点是作为 key 的元素必须不可变
Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。
但是list是可变的，就不能作为 key。
字典的值是可变的，可以通过索引赋值。
# -*- coding: utf-8 -*-
d = {
'A': 'woshiA',
'B': 'woshiB',
'C': 'woshiC'
}
d['A']='tihuan'
print d #==>{'A': 'tihuan', 'C': 'woshiC', 'B': 'woshiB'}
字典遍历
d = {
'A': 111,
'B': 222,
'C': 333
}
for key in d:
print key,d[key]
结果为：
A 111
C 333
B 222
dict的作用是建立一组 key 和一组 value 的映射关系，dict的key是不能重复的。
有的时候，我们只想要 dict 的 key，不关心 key 对应的 value，
目的就是保证这个集合的元素不会重复，这时，set就派上用场了。
set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。
s = set(['A', 'B', 'C'])
print s #==>set(['A', 'C', 'B'])
set不能包含重复的元素，所以，当我们传入包含重复元素的 list ，set会自动去掉重复的元素
s = set(['A', 'B', 'C','C'])
print s #==>set(['A', 'C', 'B'])
由于set存储的是无序集合，所以我们没法通过索引来访问。
我们可以用 in 操作符判断：
s = set(['A', 'B', 'C'])
print 'A' in s #==>True
print 'D' in s #==>False
print 'b' in s #==>False
字典还能添加和删除元素
d = {
'A': 111,
'B': 222,
'C': 333
}
d.setdefault('D',444)
print d #==>{'A': 111, 'C': 333, 'B': 222, 'D': 444}
print d.pop('A') #==>111
print d #==>{'C': 333, 'B': 222, 'D': 444}
由于 set 也是一个集合，所以，遍历 set 和遍历 list 类似，都可以通过 for 循环实现。
s = set(['A', 'B', 'C'])
for key in s:
print key
结果为：
A
C
B
由于set存储的是一组不重复的无序元素，因此，更新set主要做两件事：
一是把新的元素添加到set中，二是把已有元素从set中删除。
注意：如果删除的元素不存在set中，remove()会报错，
所以在删除不确定的元素之前需要先做判断
s = set(['A', 'B', 'C'])
s.add('D')
s.remove('B')
if 'B' in s: #判断'B'对否在s内
s.remove('B')
print s #==>set(['A', 'C', 'D'])
170
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
