Python 练习, 常见功能查阅

#!/usr/bin/python#!/usr/bin/python3#!/usr/bin/env python

编码

如果遇到编码问题可以参考以代码:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

#!/usr/bin/python
# coding: UTF-8

python 命令

usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-b     : issue warnings about comparing bytearray with unicode(-bb: issue errors)
-B     : don't write .py[co] files on import; also PYTHONDONTWRITEBYTECODE=x
-c cmd : program passed in as string (terminates option list)
-d     : debug output from parser; also PYTHONDEBUG=x
-E     : ignore PYTHON* environment variables (such as PYTHONPATH)
-h     : print this help message and exit (also --help)
-i     : inspect interactively after running script; forces a prompt evenif stdin does not appear to be a terminal; also PYTHONINSPECT=x
-m mod : run library module as a script (terminates option list)
-O     : optimize generated bytecode slightly; also PYTHONOPTIMIZE=x
-OO    : remove doc-strings in addition to the -O optimizations
-R     : use a pseudo-random salt to make hash() values of various types beunpredictable between separate invocations of the interpreter, asa defense against denial-of-service attacks
-Q arg : division options: -Qold (default), -Qwarn, -Qwarnall, -Qnew
-s     : don't add user site directory to sys.path; also PYTHONNOUSERSITE
-S     : don't imply 'import site' on initialization
-t     : issue warnings about inconsistent tab usage (-tt: issue errors)
-u     : unbuffered binary stdout and stderr; also PYTHONUNBUFFERED=xsee man page for details on internal buffering relating to '-u'
-v     : verbose (trace import statements); also PYTHONVERBOSE=xcan be supplied multiple times to increase verbosity
-V     : print the Python version number and exit (also --version)
-W arg : warning control; arg is action:message:category:module:linenoalso PYTHONWARNINGS=arg
-x     : skip first line of source, allowing use of non-Unix forms of #!cmd
-3     : warn about Python 3.x incompatibilities that 2to3 cannot trivially fix
file   : program read from script file
-      : program read from stdin (default; interactive mode if a tty)
arg ...: arguments passed to program in sys.argv[1:]Other environment variables:
PYTHONSTARTUP: file executed on interactive startup (no default)
PYTHONPATH   : ':'-separated list of directories prefixed to thedefault module search path.  The result is sys.path.
PYTHONHOME   : alternate <prefix> directory (or <prefix>:<exec_prefix>).The default module search path uses <prefix>/pythonX.X.
PYTHONCASEOK : ignore case in 'import' statements (Windows).
PYTHONIOENCODING: Encoding[:errors] used for stdin/stdout/stderr.
PYTHONHASHSEED: if this variable is set to 'random', the effect is the sameas specifying the -R option: a random value is used to seed the hashes ofstr, bytes and datetime objects.  It can also be set to an integerin the range [0,4294967295] to get hash values with a predictable seed.

print

python2:

print("Hello, World!")print "Heello, World"print(123); print(456);print(123); print(456)a = 123
b = 456
print a, b

python3:

print("Hello, World!")

Python 保留字符

and        exec        not
assert     finally     or
break      for         pass
class      from        print
continue   global      raise
def        if          return
del        import      try
elif       in          while
else       is          with
except     lambda      yield

行和缩进

建议缩进层次使用 单个制表符 或 2个空格 或 4个空格, 但是不能混用

if True:print ("Answer")print ("True")
else:print("False")

if True:print ("Answer")print ("True")
else:print("False")

多行语句

多行连接符(\\)

a = 12
b = 34
c = 56
d = a + \\b + \\c

如果语句包含了 [], {} 或 () 可以不使用多行连接符

days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

引号

word = 'word'
sentence = "这是一个句子"
paragraph = '''这是一个段落.
包含了多个句子'''
paragraph = """这是一个段落.
包含了多个句子"""'''
也可以作为注释使用
1. xxx
2. yyy
'''"""
也可以作为注释使用
1. xxx
2. yyy
"""

等待用户输入

raw_input("按下 enter 键退出, 其他任意键显示...\\n")

变量类型

• Numbers（数字）
  • int（有符号整型）
  • long（长整型[也可以代表八进制和十六进制]）(123L)
  • float（浮点型）(3.1.4)
  • complex（复数） (3 + 4j 或 complex(3, 4))
• String（字符串）
• List（列表）
• Tuple（元组）
• Dictionary（字典）

counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串a = b = c = 1
a, b, c = 1, 2, "John"

删除对象引用

del a
del b, c

python的字串列表有2种取值顺序:

• 从左到右索引默认0开始的，最大范围是字符串长度少1
• 从右到左索引默认-1开始的，最大范围是字符串开头

Python 字符串

s[开始素引:结束索引不包含:步长]

s = 'abcdef'
s[1:5]   # 'bcde'
s[:3]    # 'abc'
s[3:]    # 'def'
s[:]     # 'abcdef'
s[1:-2]  # 'bcd'
s[1:4:2] # 'bc's[0]   # 'a'
s[1]   # 'b's[-1]  # 'f'
s[-2]  # 'e's * 2 # 'abcdefabcdef's + 'TEST' # 'abcdefTEST'a = ['1', 'a', 'b']
','.join(a)		# '1,a,b'a = ('1', 'a', 'b')
','.join(a)		# '1,a,b'a = {'1', 'a', 'b'}
','.join(a)		# 'b,1,a'a = {'1': '11', 'a': 'aa', 'b': 'bb'}
','.join(a)		# '1,a,b'

Python 列表

列表是有序的对象集合

list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
list[2]      # 2
list[2:]     # [2, 3, 4, 5, 6, 7, 8, 9]
list[:]      # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
list[1:3]    # [1, 2]
list[1:7]    # [1, 2, 3, 4, 5, 6]
list[1:7:2]  # [1, 3, 5]
list[1:7:3]  # [1, 4]
list[1:-1]   # [1, 2, 3, 4, 5, 6, 7, 8]
list[1:-1:3] # [1, 4, 7]list * 2 # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]other = [10, 11, 12]
list + other # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
list[0] = 2       # [2, 1, 2, 3, 4, 5, 6, 7, 8, 9]
list[0: 3] = [2]  # [2, 3, 4, 5, 6, 7, 8, 9]list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
list.append(10)		# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
del list[2]		# [0, 1, 3, 4, 5, 6, 7, 8, 9]
del list[1:5]	# [0, 6, 7, 8, 9]list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
list2 = [10, 11, 12]
list3 = list + list2
list3		# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
len(list3)	# 13

• cmp(list1, list2) 比较两个列表的元素. 0: 相等

• len(list) 列表元素个数

• max(list) 返回列表元素最大值

• min(list) 返回列表元素最小值

• list(seq) 将元组转换为列表

• list.append(obj) 在列表末尾添加新的对象

• list.count(obj) 统计某个元素在列表中出现的次数

• list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

• list.index(obj) 从列表中找出某个值第一个匹配项的索引位置

• list.insert(index, obj) 将对象插入列表

• list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

• list.remove(obj) 移除列表中某个值的第一个匹配项

• list.reverse() 反向列表中元素

• list.sort(cmp=None, key=None, reverse=False) 对原列表进行排序

list = [1, 3, 2,  8, 4, 2, 6, 0]
list.sort()
list		# [0, 1, 2, 2, 3, 4, 6, 8]list.sort(reverse=True)
list 		# [8, 6, 4, 3, 2, 2, 1, 0]def takeSecond(elem):return elem[1]random = [(2, 2), (3, 4), (4, 1), (1, 3)]random.sort(key=takeSecond)
random		# [(4, 1), (2, 2), (1, 3), (3, 4)]def cmpFirst(ele1, ele2):return ele1[0] - ele2[0]random.sort(cmp=cmpFirst)
random		# [(1, 3), (2, 2), (3, 4), (4, 1)]

Python 元组

元组是另一个数据类型，类似于 List（列表）。

元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')tuple[1]          # 786
tuple[:]          # ('runoob', 786, 2.23, 'john', 70.2)
tuple[1:]         # (786, 2.23, 'john', 70.2)
tuple[1:-1]       # (786, 2.23, 'john')
tuple * 2         # ('runoob', 786, 2.23, 'john', 70.2, 'runoob', 786, 2.23, 'john', 70.2)
tuple + tinytuple # ('runoob', 786, 2.23, 'john', 70.2, 123, 'john')# 只读, 不允许修改
# tuple[0] = 2# 删除整个元组
del tuple

• cmp(tuple1, tuple2) 比较两个元组元素。
• len(tuple) 计算元组元素个数。
• max(tuple) 返回元组中元素最大值。
• min(tuple) 返回元组中元素最小值。
• tuple(seq) 将列表转换为元组。

Python 字典

字典(dictionary) 是无序的对象集合。

字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

键必须不可变，所以可以用数字，字符串或元组充当

dict = {}                    # {}
dict['one'] = "This is one"  # {'one': 'This is one'}
dict[2] = "This is two"      # {2: 'This is two', 'one': 'This is one'}tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}dict['one']          # 'This is one'
dict[2]              # 'This is two'
tinydict             # {'dept': 'sales', 'code': 6734, 'name': 'runoob'}
tinydict.keys()      # ['dept', 'code', 'name']
tinydict.values()    # ['sales', 6734, 'runoob']

dict = {2: 'This is two', 'one': 'This is one'}
del dict[2]
dict 		# {'one': 'This is one'}dict.clear()
dict 		# {}

dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}
dict 		# {'Age': 7, 'Name': 'Manni'}

• cmp(dict1, dict2) 比较两个字典元素。

• len(dict) 计算字典元素个数，即键的总数。

• str(dict) 输出字典可打印的字符串表示。

• type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。

• dict.clear() 删除字典内所有元素

• dict.copy() 返回一个字典的浅复制

• dict.fromkeys(seq[, val]) 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值

• dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值

• dict.has_key(key) 如果键在字典dict里返回true，否则返回false

• dict.items() 以列表返回可遍历的(键, 值) 元组数组

• dict.keys() 以列表返回一个字典所有的键

• dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

• dict.update(dict2) 把字典dict2的键/值对更新到dict里

• dict.values() 以列表返回字典中的所有值

• pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

• popitem() 返回并删除字典中的最后一对键和值。

Python 数据类型转换

• int(x [,base]) 将x转换为一个整数
• long(x [,base] ) 将x转换为一个长整数
• float(x) 将x转换到一个浮点数
• complex(real [,imag]) 创建一个复数
• str(x) 将对象 x 转换为字符串
• repr(x) 将对象 x 转换为表达式字符串
• eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
• tuple(s) 将序列 s 转换为一个元组
• list(s) 将序列 s 转换为一个列表
• set(s) 转换为可变集合
• dict(d) 创建一个字典。d 必须是一个序列 (key,value)元组。
• frozenset(s) 转换为不可变集合
• chr(x) 将一个整数转换为一个字符
• unichr(x) 将一个整数转换为Unicode字符
• ord(x) 将一个字符转换为它的整数值
• hex(x) 将一个整数转换为一个十六进制字符串
• oct(x) 将一个整数转换为一个八进制字符串

幂

a**b # a 的 b 次方a**=b # a = a**b

2**10 # 1024

取整除, 向下取整

a//ba//=b # a = a//b

9//2  # 4
-9//2 # -5

Python 逻辑运算符

• and x and y
• or x or y
• not not x

Python 成员运算符

• in
• not in

list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]0 in list     # True
'0' in list   # False0 not in list     # False
'0' not in list   # True

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )'runoob' in tuple       # True
'runoob' not in tuple   # False

dict = {'name': 'runoob','code':6734, 'dept': 'sales'}'name' in dict 	    # True
'name' not in dict 	# Fals'runoob' in dict 	# False

Python 身份运算符

• is 判断两个标识符是不是引用自一个对象
• is not 判断两个标识符是不是引用自不同对象

a = 20
b = 20
a is b      # True
a is not b  # Falsea = [1, 2, 3]
b = [1, 2, 3]
a is b      # Falsea = (1, 2, 3)
b = (1, 2, 3)
a is b      # Falsea = {'name': 'ab'}
b = {'name': 'ab'}
a is b      # False

if

if 判断条件1 :执行语句1
elif 判断条件2 :执行语句2
else :执行语句3

if 判断条件1 :执行语句1if 判断条件2 :执行语句2执行语句1
else :执行语句3

while

while 判断条件1 :执行语句1执行语句1执行语句1
执行语句2

else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行

while 判断条件1 :执行语句1执行语句1执行语句1
else:执行语句2
执行语句3

for

for iterating_var in sequence:statements(s)

for index in range(10): # 0 到 10statements(s)

for index in range(5, 10): # 5 到 10statements(s)

for index in range(5, 10, 2): # 0 到 10, 步长为 2statements(s)

for index in range(len(sequence)):statements(s)

for iterating_var in sequence:执行语句1执行语句1
else :执行语句2

例子:

fruits = ['banana', 'apple',  'mango']
for fruit in fruits:        # 第二个实例print '当前水果 :', fruit

fruits = ['banana', 'apple',  'mango']
for index in range(len(fruits)):print '当前水果 :', index,  fruits[index]

break, continue

Python pass 语句

Python pass 是空语句，是为了保持程序结构的完整性。

pass 不做任何事情，一般用做占位语句。

if 判断条件1:pass
else :执行语句2

空函数

def function():pass

Python math 模块

>>> dir(math)
['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']

Python cmath 模块

>>> import cmath
>>> dir(cmath)
['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'isinf', 'isnan', 'log', 'log10', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']

Python 数学函数

• abs(x) 返回数字的绝对值，如abs(-10) 返回 10
• ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5
• cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
• exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
• fabs(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0
• floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4
• log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0
• log10(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0
• max(x1, x2,…) 返回给定参数的最大值，参数可以为序列。
• min(x1, x2,…) 返回给定参数的最小值，参数可以为序列。
• modf(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
• pow(x, y) x**y 运算后的值。
• round(x [,n]) 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
• sqrt(x) 返回数字x的平方根

Python 随机数函数

• choice(seq) 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
• randrange ([start,] stop [,step]) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
• random() 随机生成下一个实数，它在[0,1)范围内。
• seed([x]) 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
• shuffle(lst) 将序列的所有元素随机排序
• uniform(x, y) 随机生成下一个实数，它在[x,y]范围内。

Python 三角函数

• acos(x) 返回x的反余弦弧度值。
• asin(x) 返回x的反正弦弧度值。
• atan(x) 返回x的反正切弧度值。
• atan2(y, x) 返回给定的 X 及 Y 坐标值的反正切值。
• cos(x) 返回x的弧度的余弦值。
• hypot(x, y) 返回欧几里德范数 sqrt(xx + yy)。
• sin(x) 返回的x弧度的正弦值。
• tan(x) 返回x弧度的正切值。
• degrees(x) 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
• radians(x) 将角度转换为弧度

Python 数学常量

• pi 数学常量 pi（圆周率，一般以π来表示） 3.141592653589793
• e 数学常量 e，e即自然常数（自然常数） 2.718281828459045

Python 转义字符

• \\ (在行尾时) 续行符
• \\\\ 反斜杠符号
• \\' 单引号
• \\" 双引号
• \\a 响铃
• \\b 退格(Backspace)
• \\e 转义
• \\000 空
• \\n 换行
• \\v 纵向制表符
• \\t 横向制表符
• \\r 回车
• \\f 换页
• \\oyy 八进制数，y 代表 0~7 的字符，例如：\\012 代表换行。
• \\xyy 十六进制数，以 \\x 开头，yy代表的字符，例如：\\x0a代表换行
• \\other 其它的字符以普通格式输出

Python 字符串运算符

• + 字符串连接
• * 重复输出字符串
• [] 通过索引获取字符串中字符
• [ : ] 截取字符串中的一部分
• in 成员运算符 - 如果字符串中包含给定的字符返回 True
• not in 成员运算符 - 如果字符串中不包含给定的字符返回 True
• r/R 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。
• % 格式字符串, 类似 其他语言的 Printf

print "My name is %s and weight is %d kg!" % ('Zara', 21) 

输出

My name is Zara and weight is 21 kg!

python 字符串格式化符号:

• %c 格式化字符及其ASCII码
• %s 格式化字符串
• %d 格式化整数
• %u 格式化无符号整型
• %o 格式化无符号八进制数
• %x 格式化无符号十六进制数
• %X 格式化无符号十六进制数（大写）
• %f 格式化浮点数字，可指定小数点后的精度
• %e 用科学计数法格式化浮点数
• %E 作用同%e，用科学计数法格式化浮点数
• %g %f和%e的简写
• %G %F 和 %E 的简写
• %p 用十六进制数格式化变量的地址

格式化操作符辅助指令:

• * 定义宽度或者小数点精度
• - 用做左对齐
• + 在正数前面显示加号( + )
• <sp> 在正数前面显示空格
• # 在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’)
• 0 显示的数字前面填充’0’而不是默认的空格
• % ‘%%‘输出一个单一的’%’
• (var) 映射变量(字典参数)
• m.n m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

>>> print 'pi %1.48f' % math.pi
pi 3.141592653589793115997963468544185161590576171875>>> print 'pi %2.48f' % math.pi
pi 3.141592653589793115997963468544185161590576171875

Unicode 字符串

>>> u'Hello World !'
u'Hello World !'

>>> u'Hello\\u0020World !'
u'Hello World !'

Python 字符串内建函数

• string.capitalize() 把字符串的第一个字符大写
• string.center(width) 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
• string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
• string.decode(encoding=‘UTF-8’, errors=‘strict’) 以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除非 errors 指 定 的 是 ‘ignore’ 或 者’replace’
• string.encode(encoding=‘UTF-8’, errors=‘strict’) 以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’
• string.endswith(obj, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
• string.expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。
• string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
• string.format() 格式化字符串
• string.index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在 string中会报一个异常.
• string.isalnum() 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
• string.isalpha() 如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
• string.isdecimal() 如果 string 只包含十进制数字则返回 True 否则返回 False.
• string.isdigit() 如果 string 只包含数字则返回 True 否则返回 False.
• string.islower() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
• string.isnumeric() 如果 string 中只包含数字字符，则返回 True，否则返回 False
• string.isspace() 如果 string 中只包含空格，则返回 True，否则返回 False.
• string.istitle() 如果 string 是标题化的(见 title())则返回 True，否则返回 False
• string.isupper() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
• string.join(seq) 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
• string.ljust(width) 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
• string.lower() 转换 string 中所有大写字符为小写.
• string.lstrip() 截掉 string 左边的空格
• string.maketrans(intab, outtab]) maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
• max(str) 返回字符串 str 中最大的字母。
• min(str) 返回字符串 str 中最小的字母。
• string.partition(str) 有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
• string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
• string.rfind(str, beg=0,end=len(string) ) 类似于 find() 函数，返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。
• string.rindex( str, beg=0,end=len(string)) 类似于 index()，不过是从右边开始.
• string.rjust(width) 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
• string.rpartition(str) 类似于 partition()函数,不过是从右边开始查找
• string.rstrip() 删除 string 字符串末尾的空格.
• string.split(str=“”, num=string.count(str)) 以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+1 个子字符串
• string.splitlines([keepends]) 按照行(‘\\r’, ‘\\r\\n’, \\n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
• string.startswith(obj, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
• string.strip([obj]) 在 string 上执行 lstrip()和 rstrip()
• string.swapcase() 翻转 string 中的大小写
• string.title() 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
• string.translate(str, del=“”) 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 del 参数中
• string.upper() 转换 string 中的小写字母为大写
• string.zfill(width) 返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0

Python 日期和时间

时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到2038年。

import timetime.time() # 当前时间戳, 单位 秒. 1627269172.099298time.localtime()	# time.struct_time(tm_year=2021, tm_mon=7, tm_mday=26, tm_hour=3, tm_min=26, tm_sec=19, tm_wday=0, tm_yday=207, tm_isdst=0)time.localtime(time.time())	# time.struct_time(tm_year=2021, tm_mon=7, tm_mday=26, tm_hour=3, tm_min=17, tm_sec=53, tm_wday=0, tm_yday=207, tm_isdst=0)time.asctime(time.localtime(time.time()))	# 'Mon Jul 26 03:25:34 2021'time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())	# '2021-07-26 03:27:12'time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())	# 'Mon Jul 26 03:28:32 2021'time.strptime("2021-07-26 03:27:12", "%Y-%m-%d %H:%M:%S")	# time.struct_time(tm_year=2021, tm_mon=7, tm_mday=26, tm_hour=3, tm_min=27, tm_sec=12, tm_wday=0, tm_yday=207, tm_isdst=-1)time.mktime(time.strptime("2021-07-26 03:27:12", "%Y-%m-%d %H:%M:%S"))	# 1627270032.0

python中时间日期格式化符号：

• %y 两位数的年份表示（00-99）

• %Y 四位数的年份表示（000-9999）

• %m 月份（01-12）

• %d 月内中的一天（0-31）

• %H 24小时制小时数（0-23）

• %I 12小时制小时数（01-12）

• %M 分钟数（00-59）

• %S 秒（00-59）

• %a 本地简化星期名称

• %A 本地完整星期名称

• %b 本地简化的月份名称

• %B 本地完整的月份名称

• %c 本地相应的日期表示和时间表示

• %j 年内的一天（001-366）

• %p 本地A.M.或P.M.的等价符

• %U 一年中的星期数（00-53）星期天为星期的开始

• %w 星期（0-6），星期天为星期的开始

• %W 一年中的星期数（00-53）星期一为星期的开始

• %x 本地相应的日期表示

• %X 本地相应的时间表示

• %Z 当前时区的名称

• %% %号本身

• time.altzone 返回格林威治西部的夏令时地区的偏移秒数。如果该地区在格林威治东部会返回负值（如西欧，包括英国）。对夏令时启用地区才能使用。

• time.asctime([tupletime]) 接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。

• time.clock() 用以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。

• time.ctime([secs]) 作用相当于asctime(localtime(secs))，未给参数相当于asctime()

• time.gmtime([secs]) 接收时间戳（1970纪元后经过的浮点秒数）并返回格林威治天文时间下的时间元组t。注：t.tm_isdst始终为0

• time.localtime([secs]) 接收时间戳（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。

• time.mktime(tupletime) 接受时间元组并返回时间戳（1970纪元后经过的浮点秒数）。

• time.sleep(secs) 推迟调用线程的运行，secs指秒数。

• time.strftime(fmt[,tupletime]) 接收以时间元组，并返回以可读字符串表示的当地时间，格式由fmt决定。

• time.strptime(str,fmt=‘%a %b %d %H:%M:%S %Y’) 根据fmt的格式把一个时间字符串解析为时间元组。

• time.time() 返回当前时间的时间戳（1970纪元后经过的浮点秒数）。

• time.tzset() 根据环境变量TZ重新初始化时间相关设置。

• time.timezone 属性 time.timezone 是当地时区（未启动夏令时）距离格林威治的偏移秒数（>0，美洲<=0大部分欧洲，亚洲，非洲）。

• time.tzname 属性time.tzname包含一对根据情况的不同而不同的字符串，分别是带夏令时的本地时区名称，和不带的。

import calendar
print calendar.month(2021, 07)'''July 2021
Mo Tu We Th Fr Sa Su1  2  3  45  6  7  8  9 10 11
12 13 14 15 16 17 18
19 20 21 22 23 24 25
26 27 28 29 30 31
'''

• calendar.calendar(year,w=2,l=1,c=6) 返回一个多行字符串格式的year年年历，3个月一行，间隔距离为c。 每日宽度间隔为w字符。每行长度为21* W+18+2* C。l是每星期行数。
• calendar.firstweekday( ) 返回当前每周起始日期的设置。默认情况下，首次载入 calendar 模块时返回 0，即星期一。
• calendar.isleap(year) 是闰年返回 True，否则为 False。
• calendar.leapdays(y1,y2) 返回在Y1，Y2两年之间的闰年总数。
• calendar.month(year,month,w=2,l=1) 返回一个多行字符串格式的year年month月日历，两行标题，一周一行。每日宽度间隔为w字符。每行的长度为7* w+6。l是每星期的行数。
• calendar.monthcalendar(year,month) 返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示，从1开始。
• calendar.monthrange(year,month) 返回两个整数。第一个是该月的星期几的日期码，第二个是该月的日期码。日从0（星期一）到6（星期日）;月从1到12。
• calendar.prcal(year,w=2,l=1,c=6) 相当于 print calendar.calendar(year,w=2,l=1,c=6)。
• calendar.prmonth(year,month,w=2,l=1) 相当于 print calendar.month(year,month,w=2,l=1) 。
• calendar.setfirstweekday(weekday) 设置每周的起始日期码。0（星期一）到6（星期日）。
• calendar.timegm(tupletime) 和time.gmtime相反：接受一个时间元组形式，返回该时刻的时间戳（1970纪元后经过的浮点秒数）。
• calendar.weekday(year,month,day) 返回给定日期的日期码。0（星期一）到6（星期日）。月份为 1（一月） 到 12（12月）。

Python 函数

def printinfo(name, age):print "name: ", nameprint "age: ", ageprintinfo('gz', 18)
printinfo(name='gz', age=18) # 关键字参数
printinfo(age=18, name='gz') # 关键字参数

# 默认参数
def printinfo(name, age = 15):print "name: ", nameprint "age: ", ageprintinfo('gz')
printinfo(name='gz')

# 不定长参数
def printinfo(arg1, arg2, *vartuple):print "arg1: ", arg1for var in vartuple:print varprintinfo(10, 20)
print(10, 20, 30, 40, 50, 60)

python 使用 lambda 来创建匿名函数。

• lambda只是一个表达式，函数体比def简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

lambda [arg1 [,arg2,.....argn]]:expression

# 匿名函数
sum = lambda arg1, arg2: arg1 + arg2
sum(10, 20)		# 30

Python 模块

Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。

support.py 模块：

def print_func( par ):print "Hello : ", parreturn

import 语句

test.py 文件代码：

import supportsupport.print_func("Runoob")

from…import 语句

from modname import name1[, name2[, ... nameN]]

from…import* 语句

from modname import *

搜索路径

当你导入一个模块，Python 解析器对模块位置的搜索顺序是：

1. 当前目录
2. 如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
3. 如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。

模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。

命名空间和作用域

变量是拥有匹配对象的名字（标识符）。命名空间是一个包含了变量名称们（键）和它们各自相应的对象们（值）的字典。

一个 Python 表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量。

每个函数都有自己的命名空间。类的方法的作用域规则和通常函数的一样。

Python 会智能地猜测一个变量是局部的还是全局的，它假设任何在函数内赋值的变量都是局部的。

因此，如果要给函数内的全局变量赋值，必须使用 global 语句。

global VarName 的表达式会告诉 Python， VarName 是一个全局变量，这样 Python 就不会在局部命名空间里寻找这个变量了。

例如，我们在全局命名空间里定义一个变量 Money。我们再在函数内给变量 Money 赋值，然后 Python 会假定 Money 是一个局部变量。然而，我们并没有在访问前声明一个局部变量 Money，结果就是会出现一个 UnboundLocalError 的错误。取消 global 语句前的注释符就能解决这个问题。

#!/usr/bin/python
# -*- coding: UTF-8 -*-Money = 2000
def AddMoney():# 想改正代码就取消以下注释:global MoneyMoney = Money + 1print(Money)
AddMoney()
print(Money)

dir()函数

dir() 函数一个排好序的字符串列表，内容是一个模块里定义过的名字。

返回的列表容纳了在一个模块里定义的所有模块，变量和函数。如下一个简单的实例：

import math
content = dir(math)
content	# ['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']

globals() 和 locals() 函数

根据调用地方的不同，globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字。

如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。

如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。

两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。

reload() 函数

当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。

因此，如果你想重新执行模块里顶层部分的代码，可以用 reload() 函数。该函数会重新导入之前导入过的模块。语法如下：

reload(module_name)

在这里，module_name要直接放模块的名字，而不是一个字符串形式。比如想重载 hello 模块，如下：

reload(hello)

Python中的包

包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。

简单来说，包就是文件夹，但该文件夹下必须存在 __init__.py 文件, 该文件的内容可以为空。__init__.py 用于标识当前文件夹是一个包。

Python 文件I/O

从标准输入读入一行文本

• raw_input([prompt]) 函数从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）
• input([prompt]) 函数可以接收一个Python表达式作为输入，并将运算结果返回

打开和关闭文件

open 函数

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

file object = open(file_name [, access_mode][, buffering])

• file_name 变量是一个包含了你要访问的文件名称的字符串值。

• access_mode 决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读®。

• buffering 如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。

• t 文本模式 (默认)。

• x 写模式，新建一个文件，如果该文件已存在则会报错。

• b 二进制模式。

• • 打开一个文件进行更新(可读可写)。
    

• U 通用换行模式（不推荐）。

• r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。

• rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。

• r+ 打开一个文件用于读写。文件指针将会放在文件的开头。

• rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。

• w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。

• wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。

• w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。

• wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。

• a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

• ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

• a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。

• ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

模式	r	r+	w	w+	a	a+
读	+	+		+		+
写		+	+	+	+	+
创建			+	+	+	+
覆盖			+	+
指针在开始	+	+	+	+
指针在结尾					+	+

File 对象的属性

• file.closed 返回true如果文件已被关闭，否则返回false。
• file.mode 返回被打开文件的访问模式。
• file.name 返回文件的名称。
• file.softspace 如果用print输出后，必须跟一个空格符，则返回false。否则返回true。

File 对象的方法

• file.close() 关闭文件。关闭后文件不能再进行读写操作。
• file.flush() 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
• file.fileno() 返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
• file.isatty() 如果文件连接到一个终端设备返回 True，否则返回 False。
• file.next() 返回文件下一行。
• file.read([size]) 从文件读取指定的字节数，如果未给定或为负则读取所有。
• file.readline([size]) 读取整行，包括 “\\n” 字符。
• file.readlines([sizeint]) 读取所有行并返回列表，若给定sizeint>0，则是设置一次读多少字节，这是为了减轻读取压力。
• file.seek(offset[, whence]) 设置文件当前位置
• file.tell() 返回文件当前位置。
• file.truncate([size]) 截取文件，截取的字节通过size指定，默认为当前文件位置。
• file.write(str) 将字符串写入文件，返回的是写入的字符长度。
• file.writelines(sequence) 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

seek（offset [,from]）:

方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。
如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。 

重命名文件/目录

os.rename(current_file_name, new_file_name)

删除文件

os.remove(file_name)

创建目录

os.mkdir(dir_name)

改变当前的目录

os.chdir(dir_name)

获取当前目录

os.getcwd()

删除目录

os.rmdir(dir_name)

Python OS 文件/目录方法

• os.access(path, mode) 检验权限模式
• os.chdir(path) 改变当前工作目录
• os.chflags(path, flags) 设置路径的标记为数字标记。
• os.chmod(path, mode) 更改权限
• os.chown(path, uid, gid) 更改文件所有者
• os.chroot(path) 改变当前进程的根目录
• os.close(fd) 关闭文件描述符 fd
• os.closerange(fd_low, fd_high) 关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略
• os.dup(fd) 复制文件描述符 fd
• os.dup2(fd, fd2) 将一个文件描述符 fd 复制到另一个 fd2
• os.fchdir(fd) 通过文件描述符改变当前工作目录
• os.fchmod(fd, mode) 改变一个文件的访问权限，该文件由参数fd指定，参数mode是Unix下的文件访问权限。
• os.fchown(fd, uid, gid) 修改一个文件的所有权，这个函数修改一个文件的用户ID和用户组ID，该文件由文件描述符fd指定。
• os.fdatasync(fd) 强制将文件写入磁盘，该文件由文件描述符fd指定，但是不强制更新文件的状态信息。
• os.fdopen(fd[, mode[, bufsize]]) 通过文件描述符 fd 创建一个文件对象，并返回这个文件对象
• os.fpathconf(fd, name) 返回一个打开的文件的系统配置信息。name为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。
• os.fstat(fd) 返回文件描述符fd的状态，像stat()。
• os.fstatvfs(fd) 返回包含文件描述符fd的文件的文件系统的信息，像 statvfs()
• os.fsync(fd) 强制将文件描述符为fd的文件写入硬盘。
• os.ftruncate(fd, length) 裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小。
• os.getcwd() 返回当前工作目录
• os.getcwdu() 返回一个当前工作目录的Unicode对象
• os.isatty(fd) 如果文件描述符fd是打开的，同时与tty(-like)设备相连，则返回true, 否则False。
• os.lchflags(path, flags) 设置路径的标记为数字标记，类似 chflags()，但是没有软链接
• os.lchmod(path, mode) 修改连接文件权限
• os.lchown(path, uid, gid) 更改文件所有者，类似 chown，但是不追踪链接。
• os.link(src, dst) 创建硬链接，名为参数 dst，指向参数 src
• os.listdir(path) 返回path指定的文件夹包含的文件或文件夹的名字的列表。
• os.lseek(fd, pos, how) 设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix，Windows中有效
• os.lstat(path) 像stat(),但是没有软链接
• os.major(device) 从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field)。
• os.makedev(major, minor) 以major和minor设备号组成一个原始设备号
• os.makedirs(path[, mode]) 递归文件夹创建函数。像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹。
• os.minor(device) 从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field )。
• os.mkdir(path[, mode]) 以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。
• os.mkfifo(path[, mode]) 创建命名管道，mode 为数字，默认为 0666 (八进制)
• os.mknod(filename[, mode=0600, device]) 创建一个名为filename文件系统节点（文件，设备特别文件或者命名pipe）。
• os.open(file, flags[, mode]) 打开一个文件，并且设置需要的打开选项，mode参数是可选的
• os.openpty() 打开一个新的伪终端对。返回 pty 和 tty的文件描述符。
• os.pathconf(path, name) 返回相关文件的系统配置信息。
• os.pipe() 创建一个管道. 返回一对文件描述符(r, w) 分别为读和写
• os.popen(command[, mode[, bufsize]]) 从一个 command 打开一个管道
• os.read(fd, n) 从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd对应文件已达到结尾, 返回一个空字符串。
• os.readlink(path) 返回软链接所指向的文件
• os.remove(path) 删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。
• os.removedirs(path) 递归删除目录。
• os.rename(src, dst) 重命名文件或目录，从 src 到 dst
• os.renames(old, new) 递归地对目录进行更名，也可以对文件进行更名。
• os.rmdir(path) 删除path指定的空目录，如果目录非空，则抛出一个OSError异常。
• os.stat(path) 获取path指定的路径的信息，功能等同于C API中的stat()系统调用。
• os.stat_float_times([newvalue]) 决定stat_result是否以float对象显示时间戳
• os.statvfs(path) 获取指定路径的文件系统统计信息
• os.symlink(src, dst) 创建一个软链接
• os.tcgetpgrp(fd) 返回与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组
• os.tcsetpgrp(fd, pg) 设置与终端fd（一个由os.open()返回的打开的文件描述符）关联的进程组为pg。
• os.tempnam([dir[, prefix]]) 返回唯一的路径名用于创建临时文件。
• os.tmpfile() 返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口，没有文件描述符，将会自动删除。
• os.tmpnam() 为创建一个临时文件返回一个唯一的路径
• os.ttyname(fd) 返回一个字符串，它表示与文件描述符fd 关联的终端设备。如果fd 没有与终端设备关联，则引发一个异常。
• os.unlink(path) 删除文件路径
• os.utime(path, times) 返回指定的path文件的访问和修改的时间。
• os.walk(top[, topdown=True[, οnerrοr=None[, followlinks=False]]]) 输出在文件夹中的文件名通过在树中游走，向上或者向下。
• os.write(fd, str) 写入字符串到文件描述符 fd中. 返回实际写入的字符串长度
• os.path 模块 获取文件的属性信息。

Python 标准异常

• BaseException 所有异常的基类
• SystemExit 解释器请求退出
• KeyboardInterrupt 用户中断执行(通常是输入^C)
• Exception 常规错误的基类
• StopIteration 迭代器没有更多的值
• GeneratorExit 生成器(generator)发生异常来通知退出
• StandardError 所有的内建标准异常的基类
• ArithmeticError 所有数值计算错误的基类
• FloatingPointError 浮点计算错误
• OverflowError 数值运算超出最大限制
• ZeroDivisionError 除(或取模)零 (所有数据类型)
• AssertionError 断言语句失败
• AttributeError 对象没有这个属性
• EOFError 没有内建输入,到达EOF 标记
• EnvironmentError 操作系统错误的基类
• IOError 输入/输出操作失败
• OSError 操作系统错误
• WindowsError 系统调用失败
• ImportError 导入模块/对象失败
• LookupError 无效数据查询的基类
• IndexError 序列中没有此索引(index)
• KeyError 映射中没有这个键
• MemoryError 内存溢出错误(对于Python 解释器不是致命的)
• NameError 未声明/初始化对象 (没有属性)
• UnboundLocalError 访问未初始化的本地变量
• ReferenceError 弱引用(Weak reference)试图访问已经垃圾回收了的对象
• RuntimeError 一般的运行时错误
• NotImplementedError 尚未实现的方法
• SyntaxError Python 语法错误
• IndentationError 缩进错误
• TabError Tab 和空格混用
• SystemError 一般的解释器系统错误
• TypeError 对类型无效的操作
• ValueError 传入无效的参数
• UnicodeError Unicode 相关的错误
• UnicodeDecodeError Unicode 解码时的错误
• UnicodeEncodeError Unicode 编码时错误
• UnicodeTranslateError Unicode 转换时错误
• Warning 警告的基类
• DeprecationWarning 关于被弃用的特征的警告
• FutureWarning 关于构造将来语义会有改变的警告
• OverflowWarning 旧的关于自动提升为长整型(long)的警告
• PendingDeprecationWarning 关于特性将会被废弃的警告
• RuntimeWarning 可疑的运行时行为(runtime behavior)的警告
• SyntaxWarning 可疑的语法的警告
• UserWarning 用户代码生成的警告

异常处理

try:<语句>        #运行别的代码
except <名字>：<语句>        #如果在try部份引发了'name'异常
except <名字>，<数据>:<语句>        #如果引发了'name'异常，获得附加的数据
else:<语句>        #如果没有异常发生

try:fh = open("testfile", "w")fh.write("这是一个测试文件，用于测试异常!!")
except IOError:print "Error: 没有找到文件或读取文件失败"
else:print "内容写入文件成功"fh.close()

使用except而不带任何异常类型, 捕获所有发生的异常:

try:# 正常的操作# ......................
except:# 发生异常，执行这块代码# ......................
else:# 如果没有异常执行这块代码

使用except而带多种异常类型:

try:# 正常的操作# ......................
except(Exception1[, Exception2[,...ExceptionN]]]):# 发生以上多个异常中的一个，执行这块代码# ......................
else:# 如果没有异常执行这块代码

try-finally 语句无论是否发生异常都将执行最后的代码:

try:# <语句>
finally:# <语句>    #退出try时总会执行
raise

异常的参数, 一个异常可以带上参数，可作为输出的异常信息参数:

try:# 正常的操作# ......................
except ExceptionType, Argument:# 你可以在这输出 Argument 的值...

def temp_convert(var):try:return int(var)except ValueError, Argument:print "参数没有包含数字\\n", Argumenttemp_convert("xyz");

触发异常

使用raise语句自己触发异常

raise [Exception [, args [, traceback]]]

def mye( level ):if level < 1:raise Exception,"Invalid level!"# 触发异常后，后面的代码就不会再执行
try:mye(0)            # 触发异常
except Exception,err:print 1,err
else:print 2

用户自定义异常

class Networkerror(RuntimeError):def __init__(self, arg):self.args = arg

try:raise Networkerror("Bad hostname")
except Networkerror,e:print e.args

Python 内置函数

abs()			divmod() 		input() 		open() 			staticmethod()
all() 			enumerate() 	int() 			ord() 			str()
any() 			eval() 			isinstance() 	pow() 			sum()
basestring() 	execfile() 		issubclass() 	print() 		super()
bin() 			file() 			iter() 			property()	 	tuple()
bool() 			filter() 		len() 			range() 		type()
bytearray() 	float() 		list() 			raw_input() 	unichr()
callable() 		format() 		locals() 		reduce() 		unicode()
chr() 			frozenset() 	long()		 	reload() 		vars()
classmethod() 	getattr() 		map() 			repr() 			xrange()
cmp() 			globals() 		max() 			reverse()	 	zip()
compile() 		hasattr() 		memoryview() 	round() 		__import__()
complex() 		hash()		 	min() 			set() 	
delattr() 		help()		 	next() 			setattr() 	
dict() 			hex() 			object()	 	slice() 	
dir() 			id() 			oct() 			sorted() 		exec 内置表达式

Python 面向对象

class Employee:'所有员工的基类'empCount = 0def __init__(self, name, salary):self.name = nameself.salary = salaryEmployee.empCount += 1def displayCount(self):print "Total Employee %d" % Employee.empCountdef displayEmployee(self):print "Name : ", self.name,  ", Salary: ", self.salary"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

• empCount 类变量, 所有的实例之间共享. 既可以通过类来调用, 也可以通过实例来调用
  *　init() 方法是类的构造函数. 创建实例的时候会被调用. 实例也可以直接调用.
• 方法的第一个参数代表实例本身, self并非关键字, 也可使用其他的变量名

也可以使用以下方式访问属性:

• getattr(obj, name[, default]) : 访问对象的属性。
• hasattr(obj,name) : 检查是否存在一个属性。
• setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
• delattr(obj, name) : 删除属性。

内置类属性:

• __dict__ : 类的属性（包含一个字典，由类的数据属性组成）
• __doc__ :类的文档字符串
• __name__: 类名
• __module__: 类定义所在的模块（类的全名是’main.className’，如果类位于一个导入模块mymod中，那么className.module 等于 mymod）
• __bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）

垃圾回收

Python 的垃圾收集器实际上是一个引用计数器和一个循环垃圾收集器。

循环引用指的是，两个对象相互引用，但是没有其他变量引用他们。

对象销毁的时候会调用 __del__ 方法

继承

class 派生类名(基类名)# ...

class A:        # 定义类 A# .....class B:         # 定义类 B# .....class C(A, B):   # 继承类 A 和 B# .....

基础重载方法

• __init__ ( self [,args...] ) 构造函数. 简单的调用方法: obj = className(args)
• __del__( self ) 析构方法, 删除一个对象. 简单的调用方法 : del obj
• __repr__( self ) 转化为供解释器读取的形式. 简单的调用方法 : repr(obj)
• __str__( self ) 用于将值转化为适于人阅读的形式. 简单的调用方法 : str(obj)
• __cmp__ ( self, x ) 对象比较. 简单的调用方法 : cmp(obj, x)
• __add__ ( self, x ) 对象相加. 简单的调用方法 : obj + x

类的私有属性/方法:　两个下划线开头. 实例不允许实例直接访问，但可以使用　object._className__attrName　访问.

class A:__name = "private attr"a = A()
print a._A__name

单下划线、双下划线、头尾双下划线说明：

• __foo__: 定义的是特殊方法，一般是系统定义名字 ，类似 init() 之类的。
• _foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
• __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

Python 正则表达式

re.match函数

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

re.match(pattern, string, flags=0)

• pattern 匹配的正则表达式
• string 要匹配的字符串。
• flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

可选标志:

• re.I 使匹配对大小写不敏感
• re.L 做本地化识别（locale-aware）匹配
• re.M 多行匹配，影响 ^ 和 $
• re.S 使 . 匹配包括换行在内的所有字符
• re.U 根据Unicode字符集解析字符。这个标志影响 \\w, \\W, \\b, \\B.
• re.X 该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

正则表达式模式:

• ^ 匹配字符串的开头

• $ 匹配字符串的末尾。

• . 匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。

• [...] 用来表示一组字符,单独列出：[amk] 匹配 ‘a’，‘m’或’k’

• [^...] 不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。

• re* 匹配0个或多个的表达式。

• re+ 匹配1个或多个的表达式。

• re? 匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式

• re{ n} 精确匹配 n 个前面表达式。例如， o{2} 不能匹配 “Bob” 中的 “o”，但是能匹配 “food” 中的两个 o。

• re{ n,} 匹配 n 个前面表达式。例如， o{2,} 不能匹配"Bob"中的"o"，但能匹配 "foooood"中的所有 o。“o{1,}” 等价于 “o+”。“o{0,}” 则等价于 "o*"。

• re{ n, m} 匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式

• a| b 匹配a或b

• (re) 对正则表达式分组并记住匹配的文本

• (?imx) 正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。

• (?-imx) 正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。

• (?: re) 类似 (…), 但是不表示一个组

• (?imx: re) 在括号中使用i, m, 或 x 可选标志

• (?-imx: re) 在括号中不使用i, m, 或 x 可选标志

• (?#...) 注释.

• (?= re) 前向肯定界定符。如果所含正则表达式，以 … 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。

• (?! re) 前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功

• (?> re) 匹配的独立模式，省去回溯。

• \\w 匹配字母数字及下划线

• \\W 匹配非字母数字及下划线

• \\s 匹配任意空白字符，等价于 [ \\t\\n\\r\\f]。

• \\S 匹配任意非空字符

• \\d 匹配任意数字，等价于 [0-9].

• \\D 匹配任意非数字

• \\A 匹配字符串开始

• \\Z 匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。

• \\z 匹配字符串结束

• \\G 匹配最后匹配完成的位置。

• \\b 匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\\b’ 可以匹配"never" 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’。

• \\B 匹配非单词边界。‘er\\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’。

• \\n, \\t, 等. 匹配一个换行符。匹配一个制表符。等

• \\1...\\9 匹配第n个分组的内容。

• \\10 匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

• . 匹配除 “\\n” 之外的任何单个字符。要匹配包括 ‘\\n’ 在内的任何字符，请使用象 ‘[.\\n]’ 的模式。

• \\d 匹配一个数字字符。等价于 [0-9]。

• \\D 匹配一个非数字字符。等价于 [^0-9]。

• \\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \\f\\n\\r\\t\\v]。

• \\S 匹配任何非空白字符。等价于 [^ \\f\\n\\r\\t\\v]。

• \\w 匹配包括下划线的任何单词字符。等价于’[A-Za-z0-9_]'。

• \\W 匹配任何非单词字符。等价于 ‘[^A-Za-z0-9_]’。

import re
print(re.match('www', 'www.runoob.com').span())  # 在起始位置匹配 (0, 3)
print(re.match('com', 'www.runoob.com'))         # 不在起始位置匹配 None

• group(num=0) 匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
• groups() 返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。

import reline = "Cats are smarter than dogs"matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)if matchObj:print matchObj.group() 	# Cats are smarter than dogsprint matchObj.group(0) 	# Cats are smarter than dogsprint matchObj.group(1)	# Catsprint matchObj.group(2)	# smarter
else:print "No match!!"

re.search方法

re.search 扫描整个字符串并返回第一个成功的匹配。

re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

re.search(pattern, string, flags=0)

替换

re.sub(pattern, repl, string, count=0, flags=0)

• pattern : 正则中的模式字符串。
• repl : 替换的字符串，也可为一个函数。
• string : 要被查找替换的原始字符串。
• count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

import rephone = "2004-959-559 # 这是一个国外电话号码"# 删除字符串中的 Python注释 
num = re.sub(r'#.*$', "", phone)
print num	# 2004-959-559# 删除非数字(-)的字符串 
num = re.sub(r'\\D', "", phone)
print num	# 2004959559

import re# 将匹配的数字乘以 2
def double(matched):value = int(matched.group('value'))return str(value * 2)s = 'A23G4HFD567'
print(re.sub('(?P<value>\\d+)', double, s))	# A46G8HFD1134

re.compile 函数

compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。

re.compile(pattern[, flags])

• pattern : 一个字符串形式的正则表达式
• flags : 可选，表示匹配模式，比如忽略大小写，多行模式等，具体参数为：
  • re.I 忽略大小写
  • re.L 表示特殊字符集 \\w, \\W, \\b, \\B, \\s, \\S 依赖于当前环境
  • re.M 多行模式
  • re.S 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）
  • re.U 表示特殊字符集 \\w, \\W, \\b, \\B, \\d, \\D, \\s, \\S 依赖于 Unicode 字符属性数据库
  • re.X 为了增加可读性，忽略空格和 # 后面的注释

import repattern = re.compile(r'\\d+')                    # 用于匹配至少一个数字
m = pattern.match('one12twothree34four')        # 查找头部，没有匹配
print m 	# None
m = pattern.match('one12twothree34four', 2, 10) # 从'e'的位置开始匹配，没有匹配
print m 	# None
m = pattern.match('one12twothree34four', 3, 10) # 从'1'的位置开始匹配，正好匹配
print m 	# 返回一个 Match 对象 <_sre.SRE_Match object at 0x10a42aac0>
m.group(0)  # '12'
m.start(0)  # 3
m.end(0)    # 5
m.span(0)   # (3, 5)

findall

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。

注意： match 和 search 是匹配一次, findall 匹配所有。

findall(string[, pos[, endpos]])

• string : 待匹配的字符串。
• pos : 可选参数，指定字符串的起始位置，默认为 0。
• endpos : 可选参数，指定字符串的结束位置，默认为字符串的长度。

import repattern = re.compile(r'\\d+')   # 查找数字
result1 = pattern.findall('runoob 123 google 456')
result2 = pattern.findall('run88oob123google456', 0, 10)print(result1)	# ['123', '456']
print(result2)	# ['88', '12']

re.finditer

和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。

re.finditer(pattern, string, flags=0)

import reit = re.finditer(r"\\d+","12a32bc43jf3") 
for match in it: print (match.group() )

re.split

split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：

re.split(pattern, string[, maxsplit=0, flags=0])

• maxsplit 分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。

import rere.split('\\W+', 'runoob, runoob, runoob.')		# ['runoob', 'runoob', 'runoob', '']
re.split('(\\W+)', ' runoob, runoob, runoob.')	# ['', ' ', 'runoob', ', ', 'runoob', ', ', 'runoob', '.', '']
re.split('\\W+', ' runoob, runoob, runoob.', 1)	# ['', 'runoob, runoob, runoob.']# 对于一个找不到匹配的字符串而言，split 不会对其作出分割
re.split('a*', 'hello world')		# ['hello world']

• [Pp]ython 匹配 “Python” 或 “python”

• rub[ye] 匹配 “ruby” 或 “rube”

• [aeiou] 匹配中括号内的任意一个字母

• [0-9] 匹配任何数字。类似于 [0123456789]

• [a-z] 匹配任何小写字母

• [A-Z] 匹配任何大写字母

• [a-zA-Z0-9] 匹配任何字母及数字

• [^aeiou] 除了aeiou字母以外的所有字符

• [^0-9] 匹配除了数字外的字符

• . 匹配除 “\\n” 之外的任何单个字符。要匹配包括 ‘\\n’ 在内的任何字符，请使用象 ‘[.\\n]’ 的模式。

• \\d 匹配一个数字字符。等价于 [0-9]。

• \\D 匹配一个非数字字符。等价于 [^0-9]。

• \\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \\f\\n\\r\\t\\v]。

• \\S 匹配任何非空白字符。等价于 [^ \\f\\n\\r\\t\\v]。

• \\w 匹配包括下划线的任何单词字符。等价于’[A-Za-z0-9_]'。

• \\W 匹配任何非单词字符。等价于 ‘[^A-Za-z0-9_]’。

Python 操作 MySQL 数据库

Python 网络变成

Python SMTP

Python 多线程

thread.start_new_thread ( function, args[, kwargs] )

• threading.currentThread(): 返回当前的线程变量。
• threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
• threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。

Thread类提供了以下方法:

• run(): 用以表示线程活动的方法。
• start():启动线程活动。
• join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
• isAlive(): 返回线程是否活动的。
• getName(): 返回线程名。
• setName(): 设置线程名。

使用Threading模块创建线程，直接从threading.Thread继承，然后重写__init__方法和run方法.

使用Thread对象的Lock和Rlock可以实现简单的线程同步，这两个对象都有acquire方法和release方法.

线程优先级队列（ Queue）

Python的Queue模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列PriorityQueue。这些队列都实现了锁原语，能够在多线程中直接使用。可以使用队列来实现线程间的同步。

Queue模块中的常用方法:

• Queue.qsize() 返回队列的大小
• Queue.empty() 如果队列为空，返回True,反之False
• Queue.full() 如果队列满了，返回True,反之False
• Queue.full 与 maxsize 大小对应
• Queue.get([block[, timeout]])获取队列，timeout等待时间
• Queue.get_nowait() 相当Queue.get(False)
• Queue.put(item) 写入队列，timeout等待时间
• Queue.put_nowait(item) 相当Queue.put(item, False)
• Queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号
• Queue.join() 实际上意味着等到队列为空，再执行别的操作

Python JSON

• json.dumps 将 Python 对象编码成 JSON 字符串
• json.loads 将已编码的 JSON 字符串解码为 Python 对象

import jsondata = [ { 'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5 } ]data2 = json.dumps(data)
print(data2)	＃　[{"a": 1, "c": 3, "b": 2, "e": 5, "d": 4}]

使用参数让 JSON 数据格式化输出：

import jsondata = [ { 'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5 } ]data2 = json.dumps({'a': 'Runoob', 'b': 7}, sort_keys=True, indent=4, separators=(',', ': '))
print(data2)

{"a": "Runoob","b": 7
}

编码: Python 原始类型 - JSON 类型 对照:

• dict - object
• list, tuple - array
• str, unicode - string
• int, long, float - number
• True - true
• False - false
• None - null

解码: JSON 类型 - Python 原始类型 对照:

• object - dict
• array - list
• string - unicode
• number (int) - int, long
• number (real) - float
• true - True
• false - False
• null - None

使用第三方库：Demjson

Demjson 是 python 的第三方模块库，可用于编码和解码 JSON 数据，包含了 JSONLint 的格式化及校验功能。

Github 地址：https://github.com/dmeranda/demjson

官方地址：http://deron.meranda.us/python/demjson/