python基础语法总结
参考：Python基础语法总结
参考：
1.Python标识符
在 Python 里，标识符有字母、数字、下划线组成。
在 Python 中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。
Python 中的标识符是区分大小写的。
以下划线开头的标识符是有特殊意义的。以单下划线开头_foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用from xxx import * 而导入；
以双下划线开头的__foo 代表类的私有成员；以双下划线开头和结尾的__foo__ 代表 Python 里特殊方法专用的标识，如__init__() 代表类的构造函数。
2.Python有五个标准的数据类型
Numbers（数字）
String（字符串）
List（列表）
Tuple（元组）
Dictionary（字典）
Python支持四种不同的数字类型：
int（有符号整型）
long（长整型[也可以代表八进制和十六进制]）
float（浮点型）
complex（复数）
python的字串列表有2种取值顺序:
从左到右索引默认0开始的，最大范围是字符串长度少1
从右到左索引默认-1开始的，最大范围是字符串开头
List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（即嵌套）。
列表用[ ] 标识，是 python 最通用的复合数据类型。
列表中值的切割也可以用到变量[头下标:尾下标] ，就可以截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标可以为空表示取到头或尾。
加号+ 是列表连接运算符，星号* 是重复操作。
元组是另一个数据类型，类似于List（列表）。
元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。
列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
3.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)将一个整数转换为一个八进制字符串
4.Python运算符
算术运算符
比较（关系）运算符
赋值运算符
逻辑运算符
位运算符
成员运算符
身份运算符
运算符优先级
python算术运算符
运算符描述实例
+加 - 两个对象相加a + b 输出结果 30
-减 - 得到负数或是一个数减去另一个数a - b 输出结果 -10
*乘 - 两个数相乘或是返回一个被重复若干次的字符串a * b 输出结果 200
/除 - x除以yb / a 输出结果 2
%取模 - 返回除法的余数b % a 输出结果 0
**幂 - 返回x的y次幂a**b 为10的20次方， 输出结果 100000000000000000000
//取整除 - 返回商的整数部分9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
①：python比较运算符
以下假设变量a为10，变量b为20：
运算符描述实例
==等于 - 比较对象是否相等(a == b) 返回 False。
!=不等于 - 比较两个对象是否不相等(a != b) 返回 true.
<>不等于 - 比较两个对象是否不相等(a <> b) 返回 true。这个运算符类似 != 。
>大于 - 返回x是否大于y(a > b) 返回 False。
<小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。(a < b) 返回 true。
>=大于等于 - 返回x是否大于等于y。(a >= b) 返回 False。
<=小于等于 - 返回x是否小于等于y。(a <= b) 返回 true。
②：Python赋值运算符
以下假设变量a为10，变量b为20：
运算符描述实例
=简单的赋值运算符c = a + b 将 a + b 的运算结果赋值为 c
+=加法赋值运算符c += a 等效于 c = c + a
-=减法赋值运算符c -= a 等效于 c = c - a
*=乘法赋值运算符c *= a 等效于 c = c * a
/=除法赋值运算符c /= a 等效于 c = c / a
%=取模赋值运算符c %= a 等效于 c = c % a
**=幂赋值运算符c **= a 等效于 c = c ** a
//=取整除赋值运算符c //= a 等效于 c = c // a
③：Python位运算符
下表中变量 a 为 60，b 为 13，二进制格式如下：
a=00111100b=00001101-----------------a&b=00001100a|b=00111101a^b=00110001~a=11000011
运算符描述实例
&按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0(a & b) 输出结果 12 ，二进制解释： 0000 1100
|按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。(a | b) 输出结果 61 ，二进制解释： 0011 1101
^按位异或运算符：当两对应的二进位相异时，结果为1(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<<左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。a << 2 输出结果 240 ，二进制解释： 1111 0000
>>右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数a >> 2 输出结果 15 ，二进制解释： 0000 1111
④：Python逻辑运算符
Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:
运算符逻辑表达式描述实例
andx and y布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。(a and b) 返回 20。
orx or y布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。(a or b) 返回 10。
notnot x布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。not(a and b) 返回 False
⑤：Python成员运算符
除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。
运算符描述实例
in如果在指定的序列中找到值返回 True，否则返回 False。x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in如果在指定的序列中没有找到值返回 True，否则返回 False。x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。
⑥：Python身份运算符
身份运算符用于比较两个对象的存储单元
运算符描述实例
isis 是判断两个标识符是不是引用自一个对象x is y, 类似id(x) == id(y), 如果引用的是同一个对象则返回 True，否则返回 False
is notis not 是判断两个标识符是不是引用自不同对象x is not y， 类似id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。
注：is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
5：Python循环语句
Python提供了for循环和while循环（在Python中没有do..while循环）:
循环类型描述
while 循环在给定的判断条件为 true 时执行循环体，否则退出循环体。
for 循环重复执行语句
嵌套循环你可以在while循环体中嵌套for循环
循环控制语句可以更改语句执行的顺序。Python支持以下循环控制语句：
控制语句描述
break 语句在语句块执行过程中终止循环，并且跳出整个循环
continue 语句在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。
pass 语句pass是空语句，是为了保持程序结构的完整性。
6：PythonNumber(数字)
Python 支持四种不同的数值类型：
整型(Int)- 通常被称为是整型或整数，是正或负整数，不带小数点。
长整型(long integers)- 无限大小的整数，整数最后是一个大写或小写的L。
浮点型(floating point real values)- 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102= 250）
复数(complex numbers)- 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
注：长整型也可以使用小写"L"，但是还是建议您使用大写"L"，避免与数字"1"混淆。Python使用"L"来显示长整型。
Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
Python Number类型转换：
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转换为一个列表chr(x)将一个整数转换为一个字符unichr(x)将一个整数转换为Unicode字符ord(x)将一个字符转换为它的整数值hex(x)将一个整数转换为一个十六进制字符串oct(x)将一个整数转换为一个八进制字符串
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的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j
Python随机函数：
随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
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三角函数：
Python包括以下三角函数：
函数描述
acos(x)返回x的反余弦弧度值。
asin(x)返回x的反正弦弧度值。
atan(x)返回x的反正切弧度值。
atan2(y, x)返回给定的 X 及 Y 坐标值的反正切值。
cos(x)返回x的弧度的余弦值。
hypot(x, y)返回欧几里德范数 sqrt(x*x + y*y)。
sin(x)返回的x弧度的正弦值。
tan(x)返回x弧度的正切值。
degrees(x)将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x)将角度转换为弧度
Python数学常量：
常量描述
pi数学常量 pi（圆周率，一般以π来表示）
e数学常量 e，e即自然常数（自然常数）。
7：Python字符串
Python转义字符：
在需要在字符中使用特殊字符时，python用反斜杠(\)转义字符。如下表：
转义字符描述
\(在行尾时)续行符
\\反斜杠符号
\'单引号
\"双引号
\a响铃
\b退格(Backspace)
\e转义
\000空
\n换行
\v纵向制表符
\t横向制表符
\r回车
\f换页
\oyy八进制数，yy代表的字符，例如：\o12代表换行
\xyy十六进制数，yy代表的字符，例如：\x0a代表换行
\other其它的字符以普通格式输出
Python字符串运算符：
下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"：
操作符描述实例
+字符串连接>>>a + b 'HelloPython'
*重复输出字符串>>>a * 2 'HelloHello'
[]通过索引获取字符串中字符>>>a[1] 'e'
[ : ]截取字符串中的一部分>>>a[1:4] 'ell'
in成员运算符 - 如果字符串中包含给定的字符返回 True>>>"H" in a True
not in成员运算符 - 如果字符串中不包含给定的字符返回 True>>>"M" not in a True
r/R原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。>>>print r'\n' \n >>> print R'\n'\n
%格式字符串请看下一章节
Python字符串格式化：
Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。
如下实例：
#!/usr/bin/pythonprint"My name is %s and weight is %d kg!"%('Zara',21)
以上实例输出结果：
MynameisZaraandweightis21kg!
python字符串格式化符号：
符 号描述
%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数（大写）
%f 格式化浮点数字，可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e，用科学计数法格式化浮点数
%g %f和%e的简写
%G %f 和 %E 的简写
%p 用十六进制数格式化变量的地址
8.Python列表：
Python包含以下函数:
序号函数
1cmp(list1, list2)
比较两个列表的元素
2len(list)
列表元素个数
3max(list)
返回列表元素最大值
4min(list)
返回列表元素最小值
5list(seq)
将元组转换为列表
Python包含以下方法:
序号方法
1list.append(obj)
在列表末尾添加新的对象
2list.count(obj)
统计某个元素在列表中出现的次数
3list.extend(seq)
在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4list.index(obj)
从列表中找出某个值第一个匹配项的索引位置
5list.insert(index, obj)
将对象插入列表
6list.pop(obj=list[-1])
移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7list.remove(obj)
移除列表中某个值的第一个匹配项
8list.reverse()
反向列表中元素
9list.sort([func])
对原列表进行排序
9.Python元组
Python的元组(tuple)与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组内置函数：
Python元组包含了以下内置函数
序号方法及描述
1cmp(tuple1, tuple2)
比较两个元组元素。
2len(tuple)
计算元组元素个数。
3max(tuple)
返回元组中元素最大值。
4min(tuple)
返回元组中元素最小值。
5tuple(seq)
将列表转换为元组。
10.Python字典（dictionary）
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中
字典内置函数及方法：
Python字典包含了以下内置函数：
序号函数及描述
1cmp(dict1, dict2)
比较两个字典元素。
2len(dict)
计算字典元素个数，即键的总数。
3str(dict)
输出字典可打印的字符串表示。
4type(variable)
返回输入的变量类型，如果变量是字典就返回字典类型。
Python字典包含了以下内置方法：
序号函数及描述
1dict.clear()
删除字典内所有元素
2dict.copy()
返回一个字典的浅复制
3dict.fromkeys(seq[, val]))
创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
4dict.get(key, default=None)
返回指定键的值，如果值不在字典中返回default值
5dict.has_key(key)
如果键在字典dict里返回true，否则返回false
6dict.items()
以列表返回可遍历的(键, 值) 元组数组
7dict.keys()
以列表返回一个字典所有的键
8dict.setdefault(key, default=None)
和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9dict.update(dict2)
把字典dict2的键/值对更新到dict里
10dict.values()
以列表返回字典中的所有值
11pop(key[,default])
删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
12popitem()
随机返回并删除字典中的一对键和值。
11.匿名函数lambda
python 使用 lambda 来创建匿名函数。
lambda只是一个表达式，函数体比def简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
如：
sum=lambdaarg1,arg2:arg1+arg2;print"相加后的值为 : ",sum(10,20) //输出30
12.python import语句
From...import语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中。语法如下：
frommodnameimportname1[,name2[,...nameN]]
例如，要导入模块 fib 的 fibonacci 函数，使用如下语句：
fromfibimport fibonacci
这个声明不会把整个 fib 模块导入到当前的命名空间中，它只会将 fib 里的 fibonacci 单个引入到执行这个声明的模块的全局符号表。
From...import*语句
把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：
frommodnameimport*
这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。
例如我们想一次性引入 math 模块中所有的东西，语句如下：
frommathimport*
13.Python文件操作
打开和关闭文件
现在，您已经可以向标准输入和输出进行读写。现在，来看看怎么读写实际的数据文件。
Python 提供了必要的函数和方法进行默认情况下的文件基本操作。你可以用file对象做大部分的文件操作。
open函数
你必须先用Python内置的open()函数打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。
语法：
fileobject=open(file_name[,access_mode][,buffering])
各个参数的细节如下：
file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。
access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。
不同模式打开文件的完全列表：
模式描述
r以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+打开一个文件用于读写。文件指针将会放在文件的开头。
rb+以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
w+打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
File对象的属性
一个文件被打开后，你有一个file对象，你可以得到有关该文件的各种信息。
以下是和file对象相关的所有属性的列表：
属性描述
file.closed返回true如果文件已被关闭，否则返回false。
file.mode返回被打开文件的访问模式。
file.name返回文件的名称。
file.softspace如果用print输出后，必须跟一个空格符，则返回false。否则返回true。
close()方法
File 对象的 close（）方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。
当一个文件对象的引用被重新指定给另一个文件时，Python 会关闭之前的文件。用 close（）方法关闭文件是一个很好的习惯。
语法：
fileObject.close();
write()方法
write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
write()方法不会在字符串的结尾添加换行符('\n')：
语法：
fileObject.write(string);
read()方法
read（）方法从一个打开的文件中读取一个字符串。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
语法：
fileObject.read([count]);
文件定位
tell()方法告诉你文件内的当前位置；换句话说，下一次的读写会发生在文件开头这么多字节之后。
seek（offset [,from]）方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。
如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。
重命名和删除文件
Python的os模块提供了帮你执行文件处理操作的方法，比如重命名和删除文件。
要使用这个模块，你必须先导入它，然后才可以调用相关的各种功能。
remove方法
你可以用remove()方法删除文件，需要提供要删除的文件名作为参数。
Python里的目录
所有文件都包含在各个不同的目录下，不过Python也能轻松处理。os模块有许多方法能帮你创建，删除和更改目录。
1.mkdir()方法
可以使用os模块的mkdir()方法在当前目录下创建新的目录们。你需要提供一个包含了要创建的目录名称的参数。
语法：
os.mkdir("newdir")
2.chdir()方法
可以用chdir()方法来改变当前的目录。chdir()方法需要的一个参数是你想设成当前目录的目录名称。
语法：
os.chdir("newdir")
3.rmdir()方法
rmdir()方法删除目录，目录名称以参数传递。
在删除这个目录之前，它的所有内容应该先被清除。
语法：
os.rmdir('dirname')
文件、目录相关方法
三个重要的方法来源能对Windows和Unix操作系统上的文件及目录进行一个广泛且实用的处理及操控，如下：
File 对象方法: file对象提供了操作文件的一系列方法。
OS 对象方法: 提供了处理文件及目录的一系列方法。
14.Python File(文件)方法
file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：
序号方法及描述
1file.close()
关闭文件。关闭后文件不能再进行读写操作。
2file.flush()
刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
3file.fileno()
返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
4file.isatty()
如果文件连接到一个终端设备返回 True，否则返回 False。
5file.next()
返回文件下一行。
6file.read([size])
从文件读取指定的字节数，如果未给定或为负则读取所有。
7file.readline([size])
读取整行，包括 "\n" 字符。
8file.readlines([sizehint])
读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比sizhint较大, 因为需要填充缓冲区。
9file.seek(offset[, whence])
设置文件当前位置
10file.tell()
返回文件当前位置。
11file.truncate([size])
截取文件，截取的字节通过size指定，默认为当前文件位置。
12file.write(str)
将字符串写入文件，没有返回值。
13file.writelines(sequence)
向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。
15.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()reversed()zip()
compile()hasattr()memoryview()round()__import__()
complex()hash()min()set()
delattr()help()next()setattr()
dict()hex()object()slice()
dir()id()oct()sorted()exec 内置表达式
python高级用法总结
列表推导（list comprehensions）
场景1：将一个三维列表中所有一维数据为a的元素合并，组成新的二维列表。
最简单的方法：新建列表，遍历原三维列表，判断一维数据是否为a，若为a,则将该元素append至新列表中。
缺点：代码太繁琐，对于Python而言，执行速度会变慢很多。
针对场景1，我们首先应该想到用列表解析式来解决处理，一行代码即可解决：
lista = [itemforiteminarrayifitem[0] =='a']
那么，何为列表解析式？
官方解释：列表解析式是Python内置的非常简单却强大的可以用来创建list的生成式。
强大具体如何体现？
可以看到，使用列表解析式的写法更加简短，除此之外，因为是Python内置的用法，底层使用C语言实现，相较于编写Python代码而言，运行速度更快。
场景2: 对于一个列表，既要遍历索引又要遍历元素。
这里可以使用Python内建函数enumerate，在循环中更好的获取获得索引。
array = ['I','love','Python']fori, element in enumerate(array): array[i] ='%d: %s'% (i, seq[i])
可以使用列表推导式对其进行重构：
def getitem(index, element): return'%d: %s'% (index, element)array= ['I','love','Python']arrayIndex = [getitem(index, element)forindex, elementinenumerate(array)]
据说这种写法更加的Pythonic。
总结：如果要对现有的可迭代对象做一些处理，然后生成新的列表，使用列表推导式将是最便捷的方法。
迭代器和生成器
迭代器（Iterator）
这里的迭代可以指for循环，在Python中，对于像list，dict和文件等而言，都可以使用for循环，但是它们并不是迭代器，它们属于可迭代对象。
什么可迭代对象
最简单的解释：可以使用for...in...语句进行循环的对象，就是可迭代对象（Iterable），可以使用isinstance()方法进行判断。
fromcollectionsimportIterabletype= isinstance('python',Iterable)printtype
什么是迭代器
迭代器指的是可以使用next()方法来回调的对象，可以对可迭代对象使用iter()方法，将其转换为迭代器。
temp = iter([1,2,3])printtype(temp)printnext(temp)
此时temp就是一个迭代器。所以说，迭代器基于两个方法：
next：返回下一个项目
iter 返回迭代器本身
可理解为可被next()函数调用并不断返回下一个值的对象就是迭代器，在定义一个装饰器时将需要同时定义这两个方法。
迭代器的优势
在构建迭代器时，不是将所有的元素一次性的加载，而是等调用next方法时返回元素，所以不需要考虑内存的问题。
迭代器应用场景
那么，具体在什么场景下可以使用迭代器呢？
数列的数据规模巨大
数列有规律，但是不能使用列表推导式描述。
生成器
生成器是一种高级迭代器，使得需要返回一系列元素的函数所需的代码更加的简单和高效（不像创建迭代器代码那般冗长）。
生成器函数
生成器函数基于yield指令，可以暂停一个函数并返回中间结果。当需要一个将返回一个序列或在循环中执行的函数时，就可以使用生成器，因为当这些元素被传递到另一个函数中进行后续处理时，一次返回一个元素可以有效的提升整体性能。
常见的应用场景是使用生成器的流数据缓冲区。
生成器表达式
生成式表达式是一种实现生成器的便捷方式，将列表推导式的中括号替换为圆括号。
和列表推导式的区别：列表生成式可以直接创建一个表，但是生成器表达式是一种边循环边计算，使得列表的元素可以在循环过程中一个个的推算出来，不需要创建完整的列表，从而节省了大量的空间。
g = (x * xforxinrange(10))
总结：生成器是一种高级迭代器。生成器的优点是延迟计算，一次返回一个结果，这样非常适用于大数据量的计算。但是，使用生成器必须要注意的一点是：生成器只能遍历一次。
lambda表达式（匿名函数）
lambda表达式纯粹是为了编写简单函数而设计，起到了一个函数速写的作用，使得简单函数可以更加简洁的表示。
lambda和def的区别
lambda表达式可以省去定义函数的过程，让代码更加的简洁，适用于简单函数，编写处理更大业务的函数需要使用def定义。
lambda表达式常搭配map(), reduce(), filter()函数使用
map(): map函数接受两个参数，一个是函数，一个是序列，其中，函数可以接收一个或者多个参数。map将传入的函数依次作用于序列中的每个元素，将结果作为新的列表返回。
#将一个列表中的数字转换为字符串map(str, [1,2,3,4,5,6])
reduce()：函数接收两个参数，一个是函数，另一个是序列，但是，函数必须接收两个参数reduce把结果继续和序列的下一个元素做累积计算，其效果就是reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)。
filter()：该函数用于筛选，将传入的函数，依次作用于每个元素，然后根据函数的返回值是True还是False，决定是留下还是丢弃该元素。
装饰器
装饰器本质是一个Python函数，它可以让其它函数在没有任何代码变动的情况下增加额外功能。有了装饰器，我们可以抽离出大量和函数功能本身无关的雷同代码并继续重用。经常用于具有切面需求的场景：包括插入日志、性能测试、事务处理、缓存和权限校验等。
那么为什么要引入装饰器呢？
场景：计算一个函数的执行时间。
一种方法就是定义一个函数，用来专门计算函数的运行时间，然后运行时间计算完成之后再处理真正的业务代码，代码如下：
importtime def get_time(func):startTime=time.time()func()endTime = time.time() processTime = (endTime - startTime) *1000print"The function timing is %f ms"%processTimedef myfunc():print"start func"time.sleep(0.8)print"end func"get_time(myfunc)myfunc()
但是这段代码的逻辑破坏了原有的代码逻辑，就是对所有func函数的调用都需要使用get_time(func)来实现。
那么，有没有更好的展示方式呢？当然有，那就是装饰器。
编写简单装饰器
结合上述实例，编写装饰器：
defget_time(func):defwrapper():startTime = time.time() func() endTime = time.time() processTime = (endTime - startTime) *1000print"The function timing is %f ms"%processTimereturnwrapperprint"myfunc is:", myfunc.__name__myfunc = get_time(myfunc)print"myfunc is: ", myfunc.__name__myfunc()
这样，一个简单的完整的装饰器就实现了，可以看到，装饰器并没有影响函数的执行逻辑和调用。
在Python中，可以使用"@"语法糖来精简装饰器的代码，将上例更改为：
@ get_timedefmyfunc():print"start func"time.sleep(0.8)print"end func"print"myfunc is: ", myfunc.__name__myfunc()
** 装饰器的调用顺序**
装饰器可以叠加使用，若多个装饰器同时装饰一个函数，那么装饰器的调用顺序和@语法糖的声明顺序相反，也就是：
@decorator1@decorator2def func(): pass
等效于：
func = decorator1(decorator2(func()))
被装饰的函数带参数
上述实例中，myfunc()是没有参数的，那如果添加参数的话，装饰器该如何编写呢？
#被装饰的函数带参数defget_time3(func):defwrapper(*args, **kwargs):startTime = time.time() func(*args, **kwargs) endTime = time.time() processTime = (endTime - startTime) *1000print"The function timing is %f ms"%processTimereturnwrapper@ get_time3defmyfunc2(a):print"start func"printa time.sleep(0.8)print"end func"a ="test"myfunc2(a)
带参数的装饰器
装饰器有很大的灵活性，它本身支持参数，例如在上述实例中，@get_time装饰器唯一的参数就是执行业务的函数，当然也可以在装饰器中添加参数，加以逻辑判断。
内置装饰器
Python中，常见的类装饰器包括：@staticmathod、@classmethod和@property
@staticmethod：类的静态方法，跟成员方法的区别是没有self参数，并且可以在类不进行实例化的情况下调用。
@classmethod：跟成员方法的区别是接收的第一个参数不是self，而是cls（当前类的具体类型）
@property：表示可以直接通过类实例直接访问的信息。