Python开发Day3之函数
函数
一、背景
面向过程编程：根据业务逻辑从上到下实现功能，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，也就是将之前实现的代码块复制到现需功能处
函数式编程：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
面向对象编程：对函数进行分类和封装，让开发“更快更好更强...”
函数式编程最重要的是增强代码的重用性和可读性
二、定义和使用
def 函数名(参数):
...
函数体
...
返回值
函数的定义主要有如下要点：
- def：表示函数的关键字
- 函数名：函数的名称，日后根据函数名调用函数
- 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
- 参数：为函数体提供数据
- 返回值：当函数执行完毕后，可以给调用者返回数据。
三、参数
1.普通参数（位置参数）
# ######### 定义函数 #########
# name 叫做函数func的形式参数，简称：形参
def func(name):
print name
# ######### 执行函数 #########
# 'wupeiqi' 叫做函数func的实际参数，简称：实参
func('wupeiqi')
普通参数
2.默认参数
def func(name, age = 18):
print "%s:%s" %(name,age)
# 指定参数
func('wupeiqi', 19)
# 使用默认参数
func('alex')
注：默认参数需要放在参数列表最后
默认参数
3.动态参数
def func(*args):
print args
# 执行方式一
func(11,33,4,4454,5)
# 执行方式二
li = [11,2,2,3,3,4,54]
func(*li)
动态参数
4.关键字参数
def func(**kwargs):
print args
# 执行方式一
func(name＝'wupeiqi',age=18)
# 执行方式二
li = {'name':'wupeiqi', age:18, 'gender':'male'}
func(**li)
动态参数
5.*与**
如果是函数定义中参数前的*表示的是将调用时的多个参数放入元组中,**则表示将调用函数时的关键字参数放入一个字典中
如定义以下函数
def func(*args):print(args)
当用func(1,2,3)调用函数时,参数args就是元组(1,2,3)
定义以下函数
def func(**args):print(args)
当用func(a=1,b=2)调用函数时,参数args将会是字典{'a':1,'b':2}
如果是在函数调用中,*args表示将可迭代对象扩展为函数的参数列表
args=(1,2,3)
func=(*args)
等价于函数调用func(1,2,3)
函数调用的**表示将字典扩展为关键字参数
args={'a':1,'b':2}
func(**args)
等价于函数调用 func(a=1,b=2)
四、函数的返回值
函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。
def 发送短信():
发送短信的代码...
if 发送成功:
return True
else:
return False
while True:
# 每次执行发送短信函数，都会将返回值自动赋值给result
# 之后，可以根据result来写日志，或重发等操作
result = 发送短信()
if result == False:
记录日志，短信发送失败...
五、局部变量和全局变量
a = [00, 11, 22, 33]
def func():
b = [11,22,33,44]
print(a)
print(b)
六、函数内存机制
def func1():
return "func1"
def func2():
return "func2"
func1 =》函数
func1() =》执行
首先python解释器会将def func1和def func2加载到内存当中，然后创建两个函数func1和func2，当函数被执行时，加载函数内部的代码。
func1和func2是函数的引用，函数也可以当作参数进行传递。如filter(func, seq)中传的就是函数的引用
匿名函数
对于简单的 if else 语句，可以使用三元运算来表示，即
# 普通条件语句
if 1 == 1:
name = 'wupeiqi'
else:
name = 'alex'
# 三元运算
name = 'wupeiqi' if 1 == 1 else 'alex'
对于简单的函数，也存在一种简便的表示方式，即：lambda表达式（可配合filter()和map()使用
# ###################### 普通函数 ######################
# 定义函数（普通方式）
def func(arg):
return arg + 1
# 执行函数
result = func(123)
# ###################### lambda ######################
# 定义函数（lambda表达式）
my_lambda = lambda arg : arg + 1
# 执行函数
result = my_lambda(123)
递归
函数的自我调用被称为递归，一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。
典型的例子：
斐波那契数列:0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368...
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:wuyy
# depth = 1
# def func(x, y):
# global depth
# print(x, depth)
# if depth == 10:
# return x
# depth += 1
# z = x + y
# r = func(y, z)
# return r
#
# c = func(0, 1)
# print(c)
def func(x, y, depth):
print(x, depth)
# 边界条件
if depth == 10:
return x
z = x + y
r = func(y, z, depth+1)
return r
c = func(0, 1, 1)
print(c)
冒泡排序
冒泡排序是排序中经典排序之一，它利用相邻元素比较并进行位置的互换...
需求：请按照从小到大对列表 [13, 22, 6, 99, 11] 进行排序
思路：相邻两个值进行比较，将较大的值放在右侧，依次比较！
#第一步
li = [13, 22, 6, 99, 11]
for m in range(4): # 等价于 #for m in range(len(li)-1):
if li[m]> li[m+1]:
temp = li[m+1]
li[m+1] = li[m]
li[m] = temp
#第二步
li = [13, 22, 6, 99, 11]
for m in range(4): # 等价于 #for m in range(len(li)-1):
if li[m]> li[m+1]:
temp = li[m+1]
li[m+1] = li[m]
li[m] = temp
for m in range(3): # 等价于 #for m in range(len(li)-2):
if li[m]> li[m+1]:
temp = li[m+1]
li[m+1] = li[m]
li[m] = temp
for m in range(2): # 等价于 #for m in range(len(li)-3):
if li[m]> li[m+1]:
temp = li[m+1]
li[m+1] = li[m]
li[m] = temp
for m in range(1): # 等价于 #for m in range(len(li)-4):
if li[m]> li[m+1]:
temp = li[m+1]
li[m+1] = li[m]
li[m] = temp
print li
#第三步
li = [13, 22, 6, 99, 11]
for i in range(1,5):
for m in range(len(li)-i):
if li[m] > li[m+1]:
temp = li[m+1]
li[m+1] = li[m]
li[m] = temp
内置函数
abs(x)
返回一个数的绝对值。参数可以是普通的整数，长整数或者浮点数。如果参数是个复数，返回它的模。
all(iterable)
如果iterable的所有元素为真（或者iterable为空）， 返回True。
any(iterable)
如果iterable的任一元素为真，返回True。如果iterable为空，返回False。
bin(x)
将一个整数转化成一个二进制字符串。结果是一个合法的Python表达式。如果x不是一个Python int对象，它必须定义一个返回整数的__index__()方法。
bool([x])
将一个值转化成布尔值，使用标准的真值测试例程。如果x为假或者没有参数，它返回False；否则它返回True。bool也是一个类，它是int的子类。bool不能被继承。它唯一的实例就是False和True。
bytearray([source[, encoding[, errors]]])
返回一个新的字节数组。bytearray类型是一个可变的整数序列，整数范围为0 <= x < 256（即字节）。 它有可变序列的大多数方法，参见Mutable Sequence Types，同时它也有str类型的大多数方法，参见String Methods。
source参数可以以不同的方式来初始化数组，它是可选的：
如果是string，必须指明encoding（以及可选的errors）参数；bytearray()使用str.encode()将字符串转化为字节数组。
如果是integer，生成相应大小的数组，元素初始化为空字节。
如果是遵循buffer接口的对象，对象的只读buffer被用来初始化字节数组。
如果是iterable，它的元素必须是整数，其取值范围为0 <= x < 256，用以初始化字节数组。
如果没有参数，它创建一个大小为0的数组。
callable(object)
如果object参数可调用，返回True；否则返回False。如果返回真，对其调用仍有可能失败；但是如果返回假，对object的调用总是失败。注意类是可调用的（对类调用返回一个新实例）；如果类实例有__call__()方法，则它们也是可调用的。
chr(i)
返回一个单字符字符串，字符的ASCII码为整数i。例如，chr(97)返回字符串'a'。 它是ord()的逆运算。参数的取值范围为[0..255]的闭区间；如果i超出取值范围，抛出ValueError。参见unichr()。
classmethod(function)
将function包装成类方法。
类方法接受类作为隐式的第一个参数，就像实例方法接受实例作为隐式的第一个参数一样。声明一个类方法，使用这样的惯例：
compile(source, filename, mode[, flags[, dont_inherit]])
将source编译成代码对象，或者AST（Abstract Syntax Tree，抽象语法树）对象。代码对象可以经由exec语句执行，或者通过调用eval()演算。source可以是Unicode字符串，Latin-1编码的字符串或者AST对象。参考ast模块文档以了解如何和AST对象一起使用的信息。
filename参数指明一个文件，从该文件中读取（源）代码；如果代码不是从文件中读入，传递一个可识别的值（一般用'<string>'）。
mode参数指明了编译成哪一类的代码；它可以是'exec'，如果source包含一组语句；也可以是'eval'，如果是单一的表达式；或者是'single'，如果是单一的交互式语句（对于最后一种情况，如果表达式语句演算成非None，它的值会被打印）。
可选的参数flags和dont_inherit控制哪些future语句（见PEP 236）影响source的编译。如果没有这两个参数（或者都为0），使用调用compile的代码当前有效的future语句来编译source。如果给出了flags参数且没有给出dont_inherit参数（或者为0），除了本该使用的future语句之外，由flags参数指明的future语句也会影响编译。如果dont_inherit是非0整数，flags参数被忽略（调用compile周围的有效的future语句被忽略）。
future语句由bit位指明，这些bit可以做或运算，以指明多个语句。可以在__future__模块中，_Feature实例的compiler_flag属性找到指明功能的bit位。
如果被编译的源代码是不合法的，函数抛出SyntaxError；如果源代码包含空字节，函数抛出TypeError。
注意 当以'single'或者'eval'模式编译多行代码字符串的时候，输入至少以一个新行结尾。这主要是便于code模块检测语句是否结束。
complex([real[, imag]])
创建一个复数，它的值为real + imag*j；或者将一个字符串／数字转化成一个复数。如果第一个参数是个字符串，它将被解释成复数，同时函数不能有第二个参数。第二个参数不能是字符串。每个参数必须是数值类型（包括复数）。如果imag被忽略，它的默认值是0，这时该函数就像是int()，long()和float()这样的数值转换函数。如果两个参数都被忽略，返回0j。
注意 当从字符串转化成复数的时候，字符串中+或者-两边不能有空白。例如，complex('1+2j')是可行的，但complex('1 + 2j')会抛出ValueError异常。
在Numeric Types — int, float, long, complex中有对复数的描述。
delattr(object, name)
这个函数和setattr()有关。参数是一个对象和一个字符串。字符串必须是对象的某个属性的名字。只要对象允许，这个函数删除该名字对应的属性。例如，delattr(x, 'foobar')等同于del x.foobar。
dict(**kwarg)
dict(mapping, **kwarg)
dict(iterable, **kwarg)
创建一个新字典。dict对象就是字典类。。
dir([object])
如果没有参数，返回当前本地作用域内的名字列表。如果有参数，尝试返回参数所指明对象的合法属性的列表。
如果对象有__dir__()方法，该方法被调用且必须返回一个属性列表。这允许实现了定制化的__getattr__()或者__getattribute__()函数的对象定制dir()报告对象属性的方式。
如果对象没有提供__dir__()，同时如果对象有定义__dict__属性，dir()会先尝试从__dict__属性中收集信息，然后是对象的类型对象。结果列表没有必要是完整的，如果对象有定制化的__getattr__()，结果还有可能是不准确的。
对于不同类型的对象，默认的dir()行为也不同，因为它尝试产生相关的而不是完整的信息：
如果对象是模块对象，列表包含模块的属性名。
如果对象是类型或者类对象，列表包含类的属性名，及它的基类的属性名。
否则，列表包含对象的属性名，它的类的属性名和类的基类的属性名。
返回的列表按字母顺序排序。
divmod(a, b)
在长整数除法中，传入两个数字（非复数）作为参数，返回商和余数的二元组。对于混合的操作数类型，应用二元算术运算符的规则。对于普通整数或者长整数，结果等同于(a // b, a % b)。对于浮点数结果是(q, a % b)，q一般是math.floor(a / b)，但也可能比那小1。不管怎样，q * b + a % b非常接近于a，如果a % b非0，它和b符号相同且0 <= abs(a % b) < abs(b)。
enumerate(sequence, start=0)
返回一个枚举对象。sequence必须是个序列，迭代器iterator，或者支持迭代的对象。enumerate()返回的迭代器的next()方法返回一个元组，它包含一个计数（从start开始，默认为0）和从sequence中迭代得到的值：
eval(expression[, globals[, locals]])
参数是Unicode或者Latin-1编码的字符串，全局变量和局部变量可选。如果有全局变量，globals必须是个字典。如果有局部变量，locals可以是任何映射类型对象。
expression参数被当作Python表达式来解析并演算（技术上来说，是个条件列表），使用globals和locals字典作为全局和局部的命名空间。如果globals字典存在，且缺少‘__builtins__’，在expression被解析之前，当前的全局变量被拷贝进globals。这意味着一般来说expression能完全访问标准__builtin__模块，且受限的环境会传播。如果locals字典被忽略，默认是globals字典。如果都被忽略，表达式在eval()被调用的环境中执行。返回值是被演算的表达式的结果。语法错误报告成异常。例子：
>>>>>>
>>> x = 1
>>> print eval('x+1')
2
该函数也能执行任意的代码对象（如compile()返回的结果）。 在这种情况下，传递代码对象而不是字符串。如果代码对象编译时mode参数为'exec'，eval()返回None。
提示：exec语句支持动态的语句执行。execfile()函数支持执行文件中的语句。globals()和locals()函数返回当前的全局变量和局部变量的字典，可以传递给eval()或者execfile()。
参见ast.literal_eval()，该函数能安全演算只含字面量的表达式的字符串。
filter(function, iterable)
构造一个列表，列表的元素来自于iterable，对于这些元素function返回真。iterable可以是个序列，支持迭代的容器，或者一个迭代器。如果iterable是个字符串或者元组，则结果也是字符串或者元组；否则结果总是列表。如果function是None，使用特性函数，即为假的iterable被移除。
注意，在function不为None的情况下，filter(function, iterable)等同于[item for item in iterable if function(item)]；否则等同于[item for item in iterable if item]（function为None）。
参见itertools.ifilter()和itertools.ifilterfalse()，以得到该函数的迭代器版本，以及该函数的变体（过滤function返回假的元素）。
float([x])
将字符串或者数字转化成浮点数。如果参数是字符串，它必须包含小数或者浮点数（可以有符号），周围可以有空白。参数也可以是[+|-]nan或者[+|-]inf。其它情况下，参数可以是原始／长整数或者浮点数，（以Python的浮点数精度）返回具有相同值的浮点数。如果没有参数，返回0.0。
注意 当传递字符串时，依赖于底层的C库，可以返回NaN（Not a Number，不是一个数字）和Infinity（无穷大）这样的值。该函数接受字符串nan（NaN），inf（正无穷大）和-inf（负无穷大）。对于NaN，不区分大小写和+/-号。总是用nan，inf或者-inf来表示NaN和Infinity。
float类型描述于Numeric Types — int, float, long, complex。
format(value[, format_spec])
将value转化成“格式化”的表现形式，格式由format_spec控制。对format_spec的解释依赖于value参数的类型，大多数内置类型有标准的格式化语法：Format Specification Mini-Language。
注意 format(value, format_spec)仅仅调用value.__format__(format_spec)。
frozenset([iterable])
返回一个新的frozenset对象，如果可选参数iterable存在，frozenset的元素来自于iterable。frozenset是个内置类。参见frozenset和Set Types — set, frozenset。
关于其它容器，参见set，list，tuple，和dict类，以及collections模块。
getattr(object, name[, default])
返回object的属性值。name必须是个字符串。如果字符串是对象某个属性的名字，则返回该属性的值。例如，getattr(x, 'foobar')等同于x.foobar。如果名字指明的属性不存在，且有default参数，default被返回；否则抛出AttributeError。
globals()
返回表示当前全局符号表的字典。它总是当前模块的字典（在函数或者方法中，它指定义的模块而不是调用的模块）。
hasattr(object, name)
参数是一个对象和一个字符串。如果字符串是对象某个属性的名字，返回True；否则返回False。（实现方式为调用getattr(object, name)，看它是否抛出异常）。
hash(object)
返回对象的hash（哈希/散列）值（如果有的话）。hash值是整数。它被用于在字典查找时快速比较字典的键。相同的数值有相同的hash（尽管它们有不同的类型，比如1和1.0）。
help([object])
调用内置的帮助系统。（这个函数主要用于交互式使用。）如果没有参数，在解释器的控制台启动交互式帮助系统。如果参数是个字符串，该字符串被当作模块名，函数名，类名，方法名，关键字或者文档主题而被查询，在控制台上打印帮助页面。如果参数是其它某种对象，生成关于对象的帮助页面。
这个函数经由site模块加入内置的命名空间。
hex(x)
将任意大小的整数转化成以“0x”打头的小写的十六进制字符串，例如：
>>>>>>
>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
>>> hex(1L)
'0x1L'
如果x不是Python的int或者long对象，它必须定义__index__()方法以返回一个整数。
参见int()，它将十六进制字符串转化成一个整数。
注意 使用float.hex()方法得到浮点数的十六进制字符串表示。
id(object)
返回对象的“标识”。这是一个整数（或长整数），保证在对象的生命期内唯一且不变。生命期不重叠的两个对象可以有相同的id()值。
CPython实现细节： 这是对象的内存地址。
input([prompt])
该函数不会捕获用户错误。如果输入语法不合法，将抛出SyntaxError。如果演算中有错误，将抛出其它异常。
如果有装载readline，input()将会用它来提供复杂的行编辑和历史功能。
int(x=0)
int(x, base=10)
将数字或字符串x转化成一个整数，如果没有参数则返回0。如果x是个数字，它可以是普通整数／长整数，或者浮点数。如果x是浮点数，则向0截断。如果参数超出了整数的范围，则返回长整数对象。
如果x不是个数字，或者存在base参数，则x必须是个表示以base为基数的integer literal（整数字面量）的字符串或者Unicode对象。字面量的前面可以有+或者-（中间不能有空格），周围可以有空白。以n为基数的字面量包含数字0到n-1，用a到z（或者A到Z）来表示10到35。默认的base是10。允许的值为0和2-36。二进制，八进制和十六进制的字面量前面可以有0b/0B，0o/0O/0，或者0x/0X，就像代码中的整数字面量一样。基数0表示严格按整数字面量来解释字符串，所以实际的基数为2，8，10或者16。
整数类型描述于Numeric Types — int, float, long, complex。
isinstance(object, classinfo)
如果参数object 是参数classinfo 的一个实例；或者是其一个（直接的、间接的或者virtual）子类的实例，返回真。如果classinfo是类型对象（新式类）而object是该类型对象；或者是其子类（直接的，间接的，或者virtual），返回真。如果object不是给定类型的类实例或者对象，该函数总是返回假。如果classinfo既不是类对象，也不是类型对象，它可以是类／类型对象的元组，或者递归包含这样的元组（不接受其它的序列类型）。如果classinfo不是类，类型，类／类型的元组，抛出TypeError异常。
issubclass(class, classinfo)
如果class是classinfo的子类（直接的，间接的，或者virtual) ，返回真。一个类被认为是它自己的子类。classinfo可以是类对象的元组，这时classinfo中的每个类对象都会被检查。其它情况下，抛出TypeError异常。
iter(o[, sentinel])
返回一个iterator对象。根据有无第二个参数，对第一个参数的解释相差很大。如果没有第二个参数，o必须是个集合对象，要么支持迭代协议（即 __iter__()方法），要么支持序列协议（即__getitem__()方法，整数参数从0开始）。 如果这些协议都不支持，抛出TypeError。如果有第二个参数sentinel，o必须是个可调用对象。这种情况下返回的迭代，每当调用其next()方法时，将会调用o（不带参数）；如果返回值等于sentinel，抛出StopIteration，否则返回该值。
第二种形式的iter()的一个有用的应用就是读一个文件的行，直到读到特定行。下面的例子读一个文件，直到readline()方法返回一个空字符串：
with open('mydata.txt') as fp:
for line in iter(fp.readline, ''):
process_line(line)
len(s)
返回对象的长度（元素的个数）。参数可以是序列（如字符串，字节，元组，列表或者范围）或者集合（如字典，集合或者固定集合）。
list([iterable])
返回一个列表，其元素来自于iterable（保持相同的值和顺序）。iterable可以是个序列，支持迭代的容器，或者迭代器对象。如果iterable已经是个列表，返回其拷贝，类似于iterable[:]。例如，list('abc')返回['a', 'b', 'c']，list( (1, 2, 3) )返回[1, 2, 3]。如果没有参数，返回一个新的空的列表，[]。
list是可变序列类型，见文档Sequence Types — str, unicode, list, tuple, bytearray, buffer, xrange。关于其它容器参见内置dict，set，和tuple类，以及collections模块。
locals()
更新并返回表示当前局部符号表的字典。当locals在函数块中而不是类块中被调用时，locals()返回自由变量。
注意 不应该修改该字典的内容；所做的改变不一定会影响到解释器所用的局部和自由变量的值。
max(iterable[, key])
max(arg1, arg2, *args[, key])
返回可迭代的对象中的最大的元素，或者返回2个或多个参数中的最大的参数。
如果有一个位置参数，iterable必须是个非空的可迭代对象（如非空字符串，元组或者列表）。返回可迭代对象中最大的元素。如果有2个或更多的位置参数，返回最大位置参数。
可选的key参数指明了有一个参数的排序函数，如list.sort()中使用的排序函数。如果有key参数，它必须是关键字参数（例如，max(a,b,c,key=func)）。
memoryview(obj)
返回给定参数的“内存视图”。参见memoryview type。
min(iterable[, key])
min(arg1, arg2, *args[, key])
返回可迭代的对象中的最小的元素，或者返回2个或多个参数中的最小的参数。
如果有一个位置参数，iterable必须是个非空的可迭代对象（如非空字符串，元组或者列表）。返回可迭代对象中最小的元素。如果有2个或更多的位置参数，返回最小的位置参数。
可选的key参数指明了有一个参数的排序函数，如list.sort()中使用的排序函数。如果有key参数，它必须是关键字参数（例如，min(a,b,c,key=func)）。
next(iterator[, default])
通过调用iterator的next()方法，得到它的下一个元素。如果有default参数，在迭代器迭代完所有元素之后返回该参数；否则抛出StopIteration。
object()
返回一个新的无特征的对象。object是所有新式类的基类。它有对所有新式类的实例通用的方法。
oct(x)
将一个（任意尺寸）整数转化成一个八进制字符串。结果是一个合法的Python表达式。
open(name[, mode[, buffering]])
打开一个文件，返回一个file类型的对象，file类型描述于File Objects章节。如果文件不能打开，抛出IOError。当要打开一个文件，优先使用open()，而不是直接调用file构造函数。
头两个参数类似于stdio‘s fopen()的参数：name是要打开的文件的名字，mode是个指示如何打开文件的字符串。
mode的常用值包括：'r'读文件；'w'写文件（如果文件存在则截断之）；'a' 附加（在 某些Unix系统上意味着所有的写操作附加到文件的末尾，不管当前的写位置）。如果没有mode，默认是'r'。默认使用文本模式，它会在写文件时将'\n'字符转化成平台特定的字符，在读文件时又转回来。因此在打开二进制文件的时候，要以二进制模式打开文件，把'b'添加到mode值，这样可以增强可移植性。（在不区分二进制文件和文本文件的系统上，附加'b'仍然时有用的，它可以起到文档的目的。）参见下文以得到mode更多的可能的值。
可选的buffering参数指明了文件需要的缓冲大小：0意味着无缓冲；1意味着行缓冲；其它正值表示使用参数大小的缓冲（大概值，以字节为单位）。负的buffering意味着使用系统的默认值，一般来说，对于tty设备，它是行缓冲；对于其它文件，它是全缓冲。如果没有改参数，使用系统的默认值。[2]
模式'r+'，'w+'和'a+'打开文件以便更新（同时读写）。注意'w+'会截断文件。在区分文本文件和二进制文件的系统上，在模式中附加'b'会以二进制模式打开文件；在不区分的系统上，添加'b'没有效果。
除了标准的fopen()模式值，mode可以是'U'或者'rU'。构建Python时一般会添加universal newlines（统一新行）支持；'U'会以文本模式打开文件，但是行可以以以下字符结束：'\n'（Unix行结束符），'\r'（Macintosh惯例），或者'\r\n'（Windows惯例）。Python程序会认为它们都是'\n'。如果构建Python时没有添加统一新行的支持，mode 'U'和普通文本模式一样。注意，这样打开的文件对象有一个叫newlines的属性，它的值是None（没有发现新行），'\n'，'\r'，'\r\n'，或者是包含所有已发现的新行字符的元组。
Python要求模式字符串在去除'U'后以'r'，'w'或者'a'开头。
Python提供了许多文件处理模块，包括fileinput，os，os.path，tempfile和shutil。
ord(c)
给定一个长度为一的字符串，如果参数是unicode对象，则返回表示字符的代码点的整数；如果参数是八位字符串，返回字节值。例如，ord('a')返回整数97，ord(u'\u2020')返回8224。它是八位字符串chr()的反函数，也是unicode对象unichr()的反函数。如果参数是unicode且构建Python时添加了UCS2 Unicode支持，那么字符的码点必须在[0..65535]的闭区间；如果字符串的长度为2，则抛出TypeError。
pow(x, y[, z])
返回x 的 y次幂; 如果 z 提供的时候，, 返回 x 的 y 次幂，然后对 z 取模。(这样比 pow(x, y) % z) 更高效。两个参数的形式 pow(x, y) 与使用 操作符: x**y 是等价的。
参数必须是数字类型的。由于操作数是混合类型的，二进制计算的原因需要一些强制的规定。对于整型和长整型的操作数，计算结果和操作数（强制后的）是相同的类型。除非第二个 参数是负数。在这种情况下, 所有的参数都会被转化成浮点型，并且会返回一个浮点的结果。例如, 10**2 返回 100, 但 10**-2 返回0.01. (这个新特性被加入在Python2.2中在Python2.1和之前的版本中,如果两个参数是整型，并且第二个参数为负数的情况下，会抛出一个异常。）如果第二个参数为负数，那么第三个参数必须省略。如果提供参数 z , x and y 必须为整数，而且y要是非负整数。(这个限制是在Python2.2加入的。Python2.1以及之前的版本, 三个参数都是浮点型的pow() 版本，返回的结果依赖 平台 对于浮点数的取整情况。)
print(*objects, sep=' ', end='\n', file=sys.stdout)
以sep分割，end的值结尾，将对象打印到文件流中。sep, end 和 file，如果提供这三个参数的话，必须以键值的形式。
所有非键值形式提供的参数，都被转化为字符串，就像用str()转化那样。然后写到 文件流中，以 sep 分割， end 结尾。sep and end 都必须是字符串形式的; 也可以留成 None, 这样会使用默认值。如果没有打印 对象, print() 只打印一个 结束符号 end.
file 参数一定要是含有 write(string)方法的对象 ; 如果该参数为空，或为None, 默认使用sys.stdout 作为输出。输出缓冲方式由file决定。例如 ，使用file.flush() 来确保, 立即显示在屏幕上.
注意 这个函数一般不会被作为内置函数可用，因为print被识别为print语句。为了使得print语句失效，而使用 print() 函数, 可以在你的模块上面使用future 语句:
from __future__ import print_function
property([fget[, fset[, fdel[, doc]]]])
返回新式类（继承自object的类）的一个Property 性质的属性。
fget是用于获取属性值的函数，类似地fset用于设置属性，fdel用于删除属性。典型的用法是定义一个托管的属性x：
class C(object):
def __init__(self):
self._x = None
def getx(self):
return self._x
def setx(self, value):
self._x = value
def delx(self):
del self._x
x = property(getx, setx, delx, "I'm the 'x' property.")
假设c是C的一个实例，c.x将调用获取函数，c.x = value调用设置函数，del c.x调用删除函数。
如果给出doc，它将是该属性的文档字符串。否则，该属性将拷贝fget的文档字符串（如果存在）。这使得用property()作为装饰器创建一个只读属性非常容易：
class Parrot(object):
def __init__(self):
self._voltage = 100000
@property
def voltage(self):
"""Get the current voltage."""
return self._voltage
上面的例子将voltage() 方法转换为一个名称相同的只读属性。
Property 性质的属性具有getter、setter和deleter 方法，它们可以用做装饰器来创建该属性的拷贝，使得被修饰的函数为访问函数。最好的解释就是使用一个例子：
class C(object):
def __init__(self):
self._x = None
@property
def x(self):
"""I'm the 'x' property."""
return self._x
@x.setter
def x(self, value):
self._x = value
@x.deleter
def x(self):
del self._x
这段代码与第一个例子完全相等。请确保给额外的函数与原始的属性相同的名字（此例中为x。）
返回的属性同样有构造函数参数中的fget、fset和fdel。
range(stop)
range(start, stop[, step])
它返回一个range 对象而不是一个列表。这是一个惰性的序列类型，它生成与对应的列表相同的值但不会真正同时一起存储它们。
round(number[, ndigits])
返回一个浮点型 近似值，保留小数点后 ndigits 位。如果省略ndigits，它默认为零。结果是一个浮点数。该值将被圆整为距离10的负ndigits次方的最近的某个倍数; 如果有两个倍数离的一样近,结果取离0较远的（所以，例如，round(0.5)是1.0 且round(-0.5)是-1.0）。
Note 浮点数round()的行为可能让人惊讶，例如round(2.675, 2)给出的是2.67 而不是期望的2.68。这不是一个错误：大部分十进制小数不能用浮点数精确表示，它是因为这样的一个事实的结果。更多信息，请参阅Floating Point Arithmetic: Issues and Limitations。
set([iterable])
返回一个新的set 对象，其元素可以从可选的iterable获得。set是一个内建的类。关于该类的文档，请参阅set和集合类型 — set, frozenset。
关于其它容器请参阅内建的frozenset、list、tuple和dict类，还有collections模块。
setattr(object, name, value)
getattr()的相反操作。参数是一个对象、一个字符串和任何一个值。字符串可以是一个已存在属性的名字也可以是一个新属性的名字。该函数将值赋值给属性，只要对象允许。例如，setattr(x, 'foobar', 123)等同于x.foobar = 123。
slice(stop)
slice(start, stop[, step])
返回一个slice对象，表示由索引range(start, stop, step)指出的集合。start和step参数默认为None。切片对象具有只读属性start、stop和step，它们仅仅返回参数的值（或者它们的默认值）。它们没有其他显式的函数；它是它们用于Numerical Python和其它第三方扩展。在使用扩展的索引语法时同样会生成切片对象。例如：a[start:stop:step]或a[start:stop, i]。返回迭代器的另外一个版本可以参阅itertools.islice()。
sorted(iterable[, cmp[, key[, reverse]]])
依据iterable中的元素返回一个新的列表。
可选参数cmp、key和reverse与list.sort()方法的参数含义相同（在可变的序列类型一节描述）。
cmp指定一个自定义的带有两个参数的比较函数（可迭代的元素），它应该根据第一个参数是小于、等于还是大于第二个参数返回负数、零或者正数：cmp=lambda x,y: cmp(x.lower(), y.lower())。默认值是None。
key指定一个带有一个参数的函数，它用于从每个列表元素选择一个比较的关键字：key=str.lower。默认值是None（直接比较元素）。
reverse是一个布尔值。如果设置为True，那么列表元素以反向比较排序。
通常情况下，key和reverse转换处理比指定一个等同的cmp函数要快得多。这是因为cmp为每个元素调用多次但是key和reverse只会触摸每个元素一次。使用functools.cmp_to_key()来转换旧式的cmp函数为key函数。
关于排序的实例和排序的简明教程，请参阅Sorting HowTo。
staticmethod(function)
返回function的一个静态方法。
静态方法不接受隐式的第一个参数（也就是实例名称self）。要声明静态方法，请使用下面的习惯方式：
class C(object):
@staticmethod
def f(arg1, arg2, ...):
...
@staticmethod形式是一个函数装饰器 – 细节请参阅函数定义中函数定义的描述。
它既可以在类上调用（例如C.f()）也可以在实例上调用（例如C().f()）。除了它的类型，实例其他的内容都被忽略。
Python中的静态方法类似于Java或C++。关于创建类构造器的另外一种方法，请参阅classmethod()。
更多关于静态方法的信息，请查看标准类型层次中标准类型层次的文档。
str(object='')
返回一个字符串，包含对象的友好的可打印表示形式。对于字符串，它返回字符串本身。与repr(object)的区别是str(object)不会永远试图返回一个eval()可接受的字符串；它的目标是返回一个可打印的字符串。如果没有给出参数，则返回空字符串''。
关于字符串更多的信息请参阅序列类型 — str, unicode, list, tuple, bytearray, buffer, xrange，它描述序列的函数（字符串是序列的一种），以及在String Methods 一节中描述的字符串自己的方法。若要输出格式化的字符串，请使用模板字符串或在字符串格式化操作一节中描述的%操作符。另外可参阅字符串服务一节。另请参阅unicode()。
sum(iterable[, start])
将start以及iterable的元素从左向右相加并返回总和。start默认为0。iterable的元素通常是数字，start值不允许是一个字符串。
对于某些使用场景，有比sum()更好的选择。连接字符串序列的首选和快速的方式是调用''.join(sequence)。如要相加扩展精度的浮点数，请参阅math.fsum()。若要连接一系列的可迭代量，可以考虑使用itertools.chain()。
super(type[, object-or-type])
返回一个代理对象，这个对象指派方法给一个父类或者同类. 这对进入类中被覆盖的继承方法非常有用。搜索顺序和 getattr() 一样。而它自己的 类型 则被忽略。
type的__mro__属性罗列了用getattr()和super()来搜索排序的解决方法。它可以随着继承关系的变化，动态的更新。
如果没有第二个参数，则返回未绑定的super对象 If the second argument is an object, isinstance(obj, type) must be true. If the second argument is a type, issubclass(type2, type) must be true (this is useful for classmethods).
注意 super() 仅适用于 新式类。
tuple([iterable])
返回一个元组，其元素及顺序与iterable的元素相同。iterable可以是一个序列、支持迭代操作的容器或迭代器对象。如果iterable已经是一个元组，它将被原样返回。例如，tuple('abc')返回('a', 'b', 'c')，tuple([1, 2, 3])返回(1, 2, 3)。如果没有给出参数，则返回一个空的元组()。
tuple是一个不可变序列类型，其文档在序列类型 — str, unicode, list, tuple, bytearray, buffer, xrange。关于其它容器，请参阅内建的dict、list和set类以及collections模块。
type(object)
type(name, bases, dict)
只有一个参数时，返回object的类型。返回值是一个类型对象。建议使用内建函数isinstance()测试一个对象的类型。
带有三个参数时，返回一个新的类型对象。它本质上是class语句的动态形式。name字符串是类的名字且将成为__name__属性；bases元组逐条列举基类并成为__bases__属性；dict字典是包含类体定义的命名空间并成为__dict__属性。例如，下面的两条语句创建完全相同的type对象：
>>>>>>
>>> class X(object):
... a = 1
...
>>> X = type('X', (object,), dict(a=1))
vars([object])
返回模块、类、实例或其它任何具有__dict__属性的对象的__dict__属性。
模块和实例这样的对象具有可更新的__dict__属性；然而，其它对象可能对它们的__dict__属性具有写限制（例如，新式类使用dictproxy 来防止直接的字典更新）。
如果不带参数，则vars()的行为类似locals()。注意，局部字典只用于读取因为对局部字典的更新被忽略。
zip([iterable, ...])
该函数返回一个以元组为元素的列表，其中第 i 个元组包含每个参数序列的第 i 个元素。返回的列表长度被截断为最短的参数序列的长度。当多个参数都具有相同的长度时，zip()类似于带有一个初始参数为None的map()。只有一个序列参数时，它返回一个1元组的列表。没有参数时，它返回一个空的列表。
可以保证迭代按从左向右的计算顺序。这使得使用zip(*[iter(s)]*n)来将一系列数据分类归并为长度为n的组成为习惯用法。
zip() 与 * 操作符一起可以用来 unzip 一个列表：
>>>>>>
>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> zipped
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zipped)
>>> x == list(x2) and y == list(y2)
True
__import__(name[, globals[, locals[, fromlist[, level]]]])
注意 与 import lib.import_module() 不同，这是一个高级的函数，不会在日常的 Python 编程中用到。
如果你只是简单地想依据名字导入一个模块，请使用import lib.import_module()。
浙公网安备 33010602011771号