30.Python内置函数

A

abs()

返回一个数的绝对值。
如果参数是一个复数，则返回它的模。
参数可以是整数、浮点数或任何实现了 __abs__() 的对象。 

all()

 判断对象的值是否全为真.
 如果 iterable 的所有元素均为真值（或可迭代对象为空）则返回 True 。

# 等价于：
def all(iterable):
    for element in iterable:
        if not element:  # 所有的元素必须为真
            return False
    return True

any()

判断对象的值是否全为假.
如果 iterable 的任一元素为真值则返回 True。 如果可迭代对象为空，返回 False。

# 等价于:
def any(iterable):
    for element in iterable:
        if element:  # 所有的元素必须为假
            return True
    return False

ascii()

返回一个字符串，表示对象的可打印形式，
与 repr() 类似,但在 repr() 返回的字符串中，
非 ASCII 字符会用 \x、\u 和 \U 进行转义。
生成的字符串类似于 Python 2 中 repr() 的返回结果。

print(ascii('haha'))  # 'haha' 
print(ascii('哈哈'))  # '\u54c8\u54c8'

B

bin()

将整数转变为以“0b”前缀的二进制字符串。
结果是一个合法的 Python 表达式。
如果 x 不是 Python 的 int 对象，它必须定义 __index__() 方法，以便返回整数值。

print(bin(3))  # 0b11
print(bin(-10))  # -0b1010

# 若要控制是否显示前缀“0b”，可以采用以下两种方案：
print(format(3, '#b'), format(-3, 'b'))  # 0b11 -11
print(f'{3:#b}', f'{-3:b}')

bool()

返回参数的布尔值.
当参数 x 为真时返回 True，否则返回 False。
内置 True 和 False 是类 bool 的仅有的两个实例。
bool 类是 int 类的子类，不能被子类化。
# 在 3.7 版更改: x 现在只能作为位置参数。

print(bool('x'))  # True
print(bool())  # False

bytearray()

返回一个新字节数组。
这个数组里的元素是可变的，
并且每个元素的值范围: 0 <= x < 256。

语法:
class bytearray([source[, encoding[, errors]]])

参数:
如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素。

bytes()

函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。
它是 bytearray 的不可变版本。

语法:
class bytes([source[, encoding[, errors]]])

参数:
如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素。

# 与 bytearray的基本操作一样
a = bytes([1, 255])
print(a)  # b'\x01\xff'

# b = bytes([1, 256])
# print(b)  # b'\x01\xff' ValueError: bytes must be in range(0, 256)

c = bytes('sasasa', 'utf8')
print(c, type(c))  # b'sasasa' <class 'bytes'>

d = bytes('sasasa', 'ascii')
print(d, type(d))  # b'sasasa' <class 'bytes'>

e = bytes()
print(e)  # b''

C

callable()

检查一个对象是否是可调用的。
如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。
对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例, 它都返回 True。

print(callable(0))  # False

def add(a, b):
    return a + b

print(callable(add))  # True

class A(object):
    def method(self):
        return 0

print(callable(A))  # True

a = A()
print(callable(a))  # False, 类中没有实现 __call__ 方法

class B(object):
    def __call__(self):
        return 0

b = B()
print(callable(b))  # True

chr()

用一个整数作参数，返回一个对应的字符。
返回值是当前整数对应的 ASCII 字符。
参数可以是10进制或16进制的数字,数字范围为 0 到 1,114,111 (16 进制为0x10FFFF)

print(chr(65))  # A
print(chr(0x41))  # A

classmethod

使用@classmethod修饰符对应的函数不需要实例化，不需要 self 参数，
但第一个参数需要是表示自身类的 cls 参数，
可以来调用类的属性，类的方法，实例化对象等。

(类的方法是默认是绑定给给对象使用的,类想要使用方法则可以通过classmethod设置,
将方法绑定给类)

class A(object):
    value = 1

    def func1(self):
        print('func1')

    @classmethod
    def func2(cls):
        print('func2')
        print(cls.value)
        cls().func1()  # 实例化对象调用方法


A.func2()  # 类调用方法

测试结果:
func2
1
func1

cmp()

用于比较2个对象，如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。
Python 3.X 的版本中已经没有 cmp 函数.

语法:
cmp( x, y )

参数:
x -- 数值表达式。
y -- 数值表达式。

# python2.7 测试
print cmp(1, 2)  # -1
print cmp(1, 1)  # 0
print cmp(2, 1)  # 1

compile()

将一个字符串编译为字节代码。

语法:
compile(source, filename, mode[, flags[, dont_inherit]])

参数:
source -- 字符串或者AST（Abstract Syntax Trees）对象。。
filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
flags和dont_inherit是用来控制编译源码时的标志

str1 = 'for i in range(0, 10): print(i)'

# str1变量  ''文件名(不想写就写'') exec类型
code1 = compile(str1, '', 'exec')

print(code1)  # <code object <module> at 0x000002E029878270, file "", line 1>

exec(code1)

测试结果:
0
1
...
8
9

complex()

返回值为 real + imag*1j 的复数，或将字符串或数字转换为复数。

语法：
class complex([real[, imag]])

参数：
real -- int, long, float或字符串；
imag -- int, long, float；
如果第一个形参是字符串，则它被解释为一个复数，并且函数调用时必须没有第二个形参。
第二个形参不能是字符串。每个实参都可以是任意的数值类型（包括复数）。
如果省略了 imag，则默认值为零，构造函数会像 int 和 float 一样进行数值转换。
如果两个实参都省略，则返回 0j。

返回值:
返回一个复数。

对于一个普通 Python 对象 x，complex(x) 会委托给 x.__complex__()。
如果 __complex__() 未定义则将回退至 __float__()。
如果 __float__() 未定义则将回退至 __index__()。

注意点:当从字符串转换时，字符串在 + 或 - 的周围必须不能有空格。
例如 complex('1+2j') 是合法的，但 complex('1 + 2j') 会触发 ValueError 异常。

print(complex(1, 2))  # (1+2j)
print(complex('1'))  # (1+0j)
print(complex())  # 0j

print(complex('1+2j'))  # (1+2j)
# 注意点
print(complex('1 + 2j'))
# ValueError: complex() arg is a malformed string
# ValueError: complex() arg 是格式错误的字符串

D

delattr()

删除属性。
delattr(x, 'foobar') 相等于 del x.foobar。

语法:
delattr(object, name)

参数:
object -- 对象。
name -- 必须是对象的属性。

返回值:
None

class A(object):
    x = 1
    y = 2
    z = 3

a = A()  # 实例化

print(a.x, a.y, a.z)  # 1 2 3

# 删除属性
delattr(A, 'z')

print(a.z)
# AttributeError: 'A' object has no attribute 'z'
# AttributeError：“A”对象没有属性“z”

dict()

用于创建一个字典。

语法:
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

参数:
**kwargs -- 关键字。
mapping -- 元素的容器，映射类型（Mapping Types）是一种关联式的容器类型，
	它存储了对象与对象之间的映射关系。
iterable -- 可迭代对象。

字典（dict）是Python中唯一的映射类型，映射字典 {'a': 1, 'b': 2}

print(dict())  # {}  空字典

# 关键字
print(dict(k1='v1', k2='v2'))  # {'k1': 'v1', 'k2': 'v2'}

# 映射函数方式构造字典 
print(dict(zip(['k1', 'k2'], ['v1', 'v2'])))  # {'k1': 'v1', 'k2': 'v2'}

# 可迭代对象方式来构造字典
print(dict([('k1', 'v1'), ('k2', 'v2')]))  # {'k1': 'v1', 'k2': 'v2'}

# 一个键对多个值
print(dict(k1=[1, 2]))
print(dict(zip(['k1'], [[1, 2], ])))
print(dict([('k1', [1, 2])]))
"""
{'k1': [1, 2]}
{'k1': [1, 2]}
{'k1': [1, 2]}
"""

dir()

函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；
带参数时，返回参数的属性、方法列表。
如果参数包含方法__dir__()，该方法将被调用。
如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

语法:
dir([object])

参数：
object -- 对象、变量、类型。

返回值:
返回模块的属性列表。

print(dir())
# ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']

print(dir([]))  # 查看列表的方法
"""
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
"""

divmod()

python divmod() 函数把除数和余数运算结果结合起来，
返回一个包含商和余数的元组(a // b 商, a % b 余数)。

在 python 2.3 版本之后不允许处理复数。
(3.6 不能用 2.7版本可以)

语法:
divmod(a, b)

参数：
a: 被除数
b: 除数

返回值:
返回一个元组(商,余数).

print(divmod(7, 2))  # (3, 1)
print(divmod(8, 2))  # (4, 0)

E

enumerate()

于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，
同时列出数据和数据下标，一般用在 for 循环当中。

Python 2.3. 以上版本可用，2.6 添加 start 参数。

语法:
enumerate(sequence, [start=0])

参数:
sequence -- 一个序列、迭代器或其他支持的迭代对象。
start -- 下标起始位置。start 默认为0

返回值:
返回 enumerate(枚举) 对象。
枚举:将对象可能存在的情况(可以说是可能的值)一一例举出来。

list1 = ['a', 'b', 'c']

print(list(enumerate(list1, start=1)))  # 返回的是一个enumerate(枚举) 对象 使用list转换处理才能显示值
# [(1, 'a'), (2, 'b'), (3, 'c')]

# 一般情况下搭配for 取值
for x,y in enumerate(list1, start=1):
    print(x, y)
"""
1 a
2 b
3 c
"""

eval()

执行一个字符串表达式，并返回表达式的值。

语法:
eval(expression[, globals[, locals]])

参数:
expression -- 表达式。
globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

优先顺序:
locals > locals > 全局
三个名称空间只有一个生效,其它两个的名称空间的名称不能被使用.

返回值:
返回表达式计算结果。

print(eval('2 + 2'))  # 4
print(eval('2  * 3'))  # 6
a = 10
print(eval('a  * 3'))  # 30

# 函数映射
my_len = eval('len("123")')
print(my_len)  # 3

# 实现int, list、dict、tuple与str之间的转化
list1 = eval('[1, 2, 3, 4,]')
dict1 = eval("{'k1': 'v1', 'k2': 'v2'}")
tuple1 = eval('(1, 2, 3)')

print(list1, type(list1))  # [1, 2, 3, 4] <class 'list'>
print(dict1, type(dict1))  # {'k1': 'v1', 'k2': 'v2'} <class 'dict'>
print(tuple1, type(tuple1))  # (1, 2, 3) <class 'tuple'>

# 优先顺序
a = 10
b = 20
c = 30

# 没有设置globals与locals的参数
print(eval('a + b + c'))  # 60

g = {'a': 1, 'b': 2, 'c': 3}  # globals参数出现 这里为主

print(eval('a + b + c', g))  # 6

g = {'a': 1, 'b': 2, 'c': 3}
l = {'a': 11, 'b': 22, 'c': 33}  # locals参数出现 这里为主

print(eval('a + b + c', g, l))  # 66

exec

执行储存在字符串或文件中的Python语句，
相比于 eval，exec可以执行更复杂的 Python 代码。

需要说明的是在 Python2 中exec不是函数，而是一个内置语句(statement)，
但是Python 2中有一个 execfile() 函数。
可以理解为 Python 3 把 exec 这个 statement 和 execfile() 函数的功能
整合到一个新的 exec() 函数中去了。

语法:
exec obj

参数:
obj -- 要执行的表达式。

返回值:
exec 返回值永远为 None。

# 单行语句字符串
exec('print("Hello World")')  # Hello World

# 多行语句字符串
exec("""for i in range(5):
    print(i)""")  # 0...5

x = 10
expr = """
z = 30
sum = x + y + z
print(sum)
"""

def func():
    y = 20
    exec(expr)  # 60
    exec(expr, {'x': 1, 'y': 2})  # 33
    exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})  # 34

func()

execfile()

语法:
execfile(filename[, globals[, locals]])

参数:
filename -- 文件名。
globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

返回值:
返回表达式执行结果。

# 1.py
print('hello word!')

# 2.py  在python2.7下测试
execfile('1.py')  # hello word!
# 同下
with open('1.py','r') as f:
    exec(f.read())  # hello word!

# python3 删去了 execfile()，代替方法如下：
    
with open('1.py','r', encoding='utf8') as f:  # windows 一定要指定解码的格式
    exec(f.read())  # hello word!

F

file()

创建一个 file 对象，它有一个别名叫 open()，更形象一些，它们是内置函数。
参数是以字符串的形式传递的。
Python 2.x 中使用.

语法:
file(name[, mode[, buffering]])

参数:
name -- 文件名
mode -- 打开模式
buffering -- 0 表示不缓冲,如果为 1 表示进行行缓冲，大于 1 为缓冲区大小。

返回值:
文件对象。

# 1.py
hello word!

# python 2.7中 使用
f = file('a.txt')
print f.read()  # hello word!

filter()

过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，
然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

语法:
filter(function, iterable)

参数:
function -- 判断函数。
iterable -- 可迭代对象。

返回值:
Python2.x 返回列表，Python3.x 返回迭代器对象.

iterable = filter(lambda n: n % 2 == 0, range(0, 10))
print(list(iterable))

float()

将整数和字符串转换成浮点数。

语法：
class float(x)

参数:
x -- 整数或纯数字的字符串

返回值:
返回浮点数。

print(float(1))  # 1.0
print(float('1'))  # 1.0

format()

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数，位置可以不按顺序。

# 不设置指定位置，按默认顺序
print("{} {}".format("hello", "world"))  # hello world

# 设置指定位置
print("{0} {1}".format("hello", "world"))  # hello world

# 设置指定位置
print("{1} {0} {1}".format("hello", "world"))  # world hello world

# {{}}取消转义
print ("{{0}}".format('hello'))  # 打印{0} 而不是hello 

 # 关键字参数
print("网站名：{name}, 地址 {url}".format(name="百度", url="www.baidu.com"))

# 通过字典设置参数
url = {"name": "百度", "url": "www.baidu.com"}
print("网站名：{name}, 地址 {url}".format(**url))  # ** 将字典 解压成 关键字参数形式

# 通过列表索引设置参数
list1 = ['百度', 'www.baidu.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(list1))  # 0 是必须的,固定的格式
"""
网站名：百度, 地址 www.baidu.com
网站名：百度, 地址 www.baidu.com
网站名：百度, 地址 www.baidu.com
"""

class A(object):
    def __init__(self, age):
        self.age = age

a = A(18)
print('age: {0.age}'.format(a))

格式化

数字	格式	输出	描述
3.1415926	{:.2f}	3.14	保留小数点后两位
3.1415926	{:+.2f}	+3.14	带符号保留小数点后两位
-1	{:+.2f}	-1.00	带符号保留小数点后两位
2.71828	{:.0f}	3	不带小数
5	{:0>2d}	05	数字补零 (填充左边, 宽度为2)
5	{:x<4d}	5xxx	数字补x (填充右边, 宽度为4)
10	{:x<4d}	10xx	数字补x (填充右边, 宽度为4)
1000000	{:,}	1,000,000	以逗号分隔的数字格式
0.25	{:.2%}	25.00%	百分比格式
1000000000	{:.2e}	1.00e+09	指数记法
13	{:>10d}	13	右对齐 (默认, 宽度为10)
13	{:<10d}	13	左对齐 (宽度为10)
13	{:^10d}	13	中间对齐 (宽度为10)
11	{:b}.format(11)	1011	二进制
11	{:d}.format(11)	11	十进制
11	{😮}.format(11)	13	八进制
11	{:x}.format(11)	b	十六进制
11	{:#x}.format(11)	0xb	显示前缀
11	{:#X}.format(11)	0XB	大写

^, <, > 分别是居中、左对齐、右对齐，后面带宽度， 
: 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。

+ 表示在正数前显示 +，负数前显示 -；  （空格）表示在正数前加空格

b、d、o、x 分别是二进制、十进制、八进制、十六进制。

frozenset()

返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

语法：
class frozenset([iterable])

参数:
iterable -- 可迭代的对象，比如列表、字典、元组等等。

返回值:
返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合.

为什么需要冻结的集合（即不可变的集合）呢？
因为在集合的关系中，有集合的中的元素是另一个集合的情况，
但是普通集合（set）本身是可变的，
那么它的实例就不能放在另一个集合中（set中的元素必须是不可变类型）。

所以，frozenset提供了不可变的集合的功能，当集合不可变时，
它就满足了作为集合中的元素的要求，就可以放在另一个集合中了。

list1 = [1, 2]
set1 = {list1}  
# TypeError: unhashable type: 'list' 
# 类型错误：不可散列类型：“列表”

# 创建不可变集合

a = frozenset(range(10))
print(a)  # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})

b = frozenset('hello')  # 去重且无序的
print(b)  # frozenset({'l', 'e', 'o', 'h'})

print({a, b})
# {frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}), frozenset({'o', 'e', 'l', 'h'})}

G

getattr()

返回一个对象属性值。

语法：
getattr(object, name[, default])

参数:
object -- 对象。
name -- 字符串，对象属性。
default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。

返回值:
返回对象属性值。

class A(object):
    value = 1

a = A()

# 对象属性存在
print(getattr(a, 'value'))  # 1

# 对象属性不存在,设置返回值
print(getattr(a, 'value2', None))  # None

# 对象属性不存在,不设置返回值
print(getattr(a, 'value3'))
# AttributeError: 'A' object has no attribute 'value3'
# 属性错误：“A”对象没有属性“value3”

globals()

以字典类型返回当前位置的全部全局变量。

语法：
globals()

参数:
无

返回值:
返回全局变量的字典。

num = 1
print(globals())
"""
{'__name__': '__main__', '__doc__': None, '__package__': None, 
'__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000020DB8D8D4A8>,
'__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>,
'__file__': 'F:/synchro/Project/测试/2.py', '__cached__': None, 'num': 1}
"""

H

hasattr()

判断对象是否包含对应的属性。

语法：
hasattr(object, name)

参数:
object -- 对象。
name -- 字符串，属性名。

返回值:
如果对象有该属性返回 True，否则返回 False。

class A(object):
    value = 1

a = A()

print(hasattr(a, 'value'))  # True
print(hasattr(a, 'value2'))  # False

hash()

获取取一个对象（字符串或者数值等）的哈希值。

语法：
hash(object)

参数：
object -- 对象;

返回值:
返回对象的哈希值。

# 数字
print(hash(123))  # 123

# 字符串
str1 = '123'
print(hash(str1))  # 2565105887977682760  每一次都不一样

help()

查看函数或模块用途的详细说明。

语法：
help([object])

参数：
object -- 对象；

返回值:
返回对象帮助信息。

print(help(hash))
"""
hash的使用信息...
"""

hex()

将10进制整数转换成16进制，以字符串形式表示。

语法：
hex(x)

参数：
x -- 10进制整数

返回值:
返回16进制数，以字符串形式表示。

base = hex(255)
print(base, type(base))  # 0xff <class 'str'>

I

id()

返回对象的唯一标识符，标识符是一个整数。

CPython 中 id() 函数用于获取对象的内存地址。

语法：
id([object])

参数：
object -- 对象。

返回值:
返回对象的内存地址。

num = 1
print(id(num))  # 1960209152

input()

Python3.x 中:
	input() 函数接受一个标准输入数据，返回为 str 类型。
	注意：
	python3 里 input() 默认接收到的是 str 类型。

Python2.x 中:
	input() 相等于 eval(raw_input(prompt)) ，用来获取控制台的输入。
	raw_input() 将所有输入作为字符串看待，返回字符串类型。
	而 input() 在对待纯数字输入时具有自己的特性，它返回所输入的数字的类型（ int, float ）。
	
	注意：
	input() 和 raw_input() 这两个函数均能接收 字符串 ，
	但 raw_input() 直接读取控制台的输入（任何类型的输入它都可以接收）
	而对于 input() ，它希望能够读取一个合法的 python 表达式，	
	即你输入字符串的时候必须使用引号将它括起来，否则它会引发一个 SyntaxError 。
	除非对 input() 有特别需要，否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。
	
Python3.x 中 的input() 等于 Python2.x 中的 raw_input() 

语法:
input([prompt])

参数：
prompt: 提示信息

# python2 下的 input
a = input('input>>>:')
print(a, type(a))

b = input('input>>>:')
print(b, type(b))

c = input('input>>>:')
print(c, type(c))


f = input('input>>>:')
print(f, type(f))  

input>>>:1  # 输入数字1 绑定给变量a
(1, <type 'int'>)  
input>>>:'a'  # 输入字符a 绑定给变量b
('a', <type 'str'>)  
input>>>:a  # 没有带'' 被认为是变量名
(1, <type 'int'>)
input>>>:f  
Traceback (most recent call last):
....
NameError: name 'f' is not defined
名称错误：名称'f'未定义

int()

将一个字符串或数字转换为整型。

语法:
class int(x, base=10)

参数:
x -- 字符串或数字。float 类型不能转.
base -- 进制数，默认十进制。如果是带参数base的话,参数x必须是字符串.

返回值:
返回整型数据。

print(int())  # 不传入参数时，得到结果0
print(int('10'))  # 10
print(int('10', base=2))  # 二进制 '10'  --> 十进制 2
print(int('10', base=8))  # 八进制 '8'   --> 十进制 8
print(int('10', base=16))  # 十六进制 '10' --> 十进制 16

isinstance()

判断一个对象是否是一个已知的类型.

如果要判断两个类型是否相同推荐使用 isinstance()。

语法:
isinstance(object, classinfo)

参数:
object -- 实例对象。
classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。

返回值:
如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。

a = 0

print(isinstance(a, int))  # True

print(isinstance(a, str))  # False

print(isinstance(a, (int, float, str)))  # True

isinstance() 与 type() 区别：

type() 不会认为子类是一种父类类型，不考虑继承关系。

isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

class A(object):
    pass

a = A()
print(isinstance(a, A))  # True
print(type(a) == A)  # True

class B(A):
    pass

b = B()
print(isinstance(b, A))  # True
print(type(b) == A)  # False 不考虑继承

issubclass()

判断参数 class 是否是类型参数 classinfo 的子类。

语法:
issubclass(class, classinfo)

参数:
class -- 类。
classinfo -- 类。

返回值:
如果 class 是 classinfo 的子类返回 True，否则返回 False。

class A(object):
    pass

class B(A):
    pass

print(issubclass(B, A))  # True
print(issubclass(B, object))  # True

iter()

生成迭代器。

语法:
iter(object[, sentinel])

参数:
object -- 支持迭代的集合对象。
sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），
此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。

返回值:
迭代器对象。

iterator = iter([1, 2, 3])
print(iterator.__next__())  # 1

for i in iterator:
    print(i)  # 2 3

def a():
    return 123

callable_iterator = (iter(a, [1, 2]))  
print(callable_iterator.__next__())
print(callable_iterator.__next__())

# 可调用迭代器 不要使用for x in 可调用迭代器  会出现死循环

L

len()

返回对象（字符、列表、元组等）长度或项目个数。

语法:
len(s)

参数:
s -- 对象。

返回值:
返回对象长度。

str1 = "hello"
print(len(str1))  # 字符串长度

l1 = [1, 2, 3, 4, 5]
print(len(l1))  # 列表元素个数

list()

将可迭代对象转换为列表。
注意点:元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中.

语法：
list(tup)

参数:
tup -- 要转换为列表的可迭代对象。

返回值:
返回列表。

str1 = 'hello'
t1 = (1, 2, 3, 4, 5)

print(list(str1))  # ['h', 'e', 'l', 'l', 'o']
print(list(t1))  # [1, 2, 3, 4, 5]

locals()

以字典类型返回当前位置的全部局部变量。

对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。

语法：
locals():

参数:
无

返回值:
返回字典类型的局部变量。

def func():
    a = 1
    print(locals())  # {'a': 1}

    class A(object):
        a = 2
        print(locals()) 
        # {'__module__': '__main__', '__qualname__': 'func.<locals>.A', 'a': 2}

    A()

func()

long()

将数字或字符串转换为一个长整型。

Python3.x 版本已删除 long() 函数。

语法：
class long(x, base=10)

参数:
x -- 纯数字的字符串或数字。
base -- 可选，进制数，默认十进制。

返回值:
返回长整型数。

str1 = '1'
l1 = long(str1)
print l1  # 1
print type(l1)  # <type 'long'>

str1 = '1'
l1 = long(str1)

print long()  # 0
print l1  # 1
print type(l1)  # <type 'long'>

print long('0101', base=2)  # 5

M

map()

根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，
返回包含每次 function 函数返回值的新列表。

语法：
map(function, iterable, ...)

参数:
function -- 函数
iterable -- 一个或多个序列

返回值:
Python 2.x 返回列表。
Python 3.x 返回迭代器。

# 计算平方
def square(i):
    return i * i


# 一个函数 一个可迭代对象
iterable1 = map(square, range(0, 10))
print(list(iterable1))  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 一个匿名函数 一个可迭代对象
iterable2 = map(lambda i: i * i, range(0, 10))
print(list(iterable2))  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 一个匿名函数 两个可迭代对象
iterable3 = map(lambda x, y: x + y, range(0, 10), range(0, 10))
print(list(iterable3))  # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

memoryview()

返回给定参数的内存查看对象(memory view)。

所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。

语法：
memoryview(obj)

参数：
obj -- 对象

返回值:
返回元组列表。

# python 2.7
v = memoryview('hello')
print v, type(v)  # (<memory at 0x0000000002CC6048>, <type 'memoryview'>)

print v[0], v[1], v[-1]  # h e o

print v[0:5]  # <memory at 0x00000000033565E8>
print v[0:5].tobytes()  # hello

v = memoryview(bytearray('hello', 'utf8'))  # utf8 转 unicode

print(v, type(v))  # <memory at 0x000001898C09C888> <class 'memoryview'>
print(v[1])  # 101 h -->101
print(v[-1])  # 111 o -->111
print(v[0:5])  # <memory at 0x0000025E6048CAC8>
print(v[0:5].tobytes())  # b'hello'

min()

返回给定参数的最小值，参数可以为序列。

语法:
min( x, y, z, .... )

参数:
x -- 数值表达式。
y -- 数值表达式。
z -- 数值表达式。

返回值:
返回给定参数的最小值。

print(min(1, 2, 3))  # 1
print(min('a', 'b', 'c'))  # a  比较字符对应的ASCII表 十进制的大小

N

next()

返回迭代器的下一个项目。

next() 函数要和生成迭代器的 iter() 函数一起使用。

语法：
next(iterable[, default])

参数：
iterable -- 可迭代对象
default -- 可选，用于设置在没有下一个元素时返回该默认值，
如果不设置，又没有下一个元素则会触发 StopIteration 异常。

返回值:
返回下一个项目。

it = iter([1, 2])
print(next(it))  # 1
print(next(it))  # 2

# 设置默认值
print(next(it, 'no'))  # no
# 不设置默认值
print(next(it))  # StopIteration

O

object()

返回一个空对象。

您不能向这个对象添加新的属性或方法。

这个对象是所有类的基础，它拥有所有类默认的内置属性和方法。

语法:
object()

参数:
无参数.

返回值:

x = object()
print(x, type(x))  # <object object at 0x00000243C78DB0F0> <class 'object'>

oct()

将一个整数转换成 8 进制字符串。

Python2.x 版本的 8 进制以 0 作为前缀表示。
Python3.x 版本的 8 进制以 0o 作为前缀表示。

语法：
oct(x)

参数：
x -- 整数。

返回值:
返回 8 进制字符串。

print(oct(11))  # 0o13

open()

打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。

语法:
open(name[, mode[, buffering]])

参数：
name : 一个包含了你要访问的文件名称的字符串值。
mode : mode 决定了打开文件的模式：只读，写入，追加等。
所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。

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

模式	描述
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
U	通用换行模式（不推荐）。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

file 对象方法
file.read([size])：size 未指定则返回整个文件，如果文件大小 >2 倍内存则有问题，
f.read()读到文件尾时返回""(空字串)。

file.readline()：返回一行。

file.readlines([size]) ：返回包含size行的列表, size 未指定则返回全部行。

for line in f: print line ：通过迭代器访问。

f.write("hello\n")：如果要写入字符串以外的数据,先将他转换为字符串。

f.tell()：返回一个整数,表示当前文件指针的位置(就是到文件头的字节数)。

f.seek(偏移量,[起始位置])：用来移动文件指针。

偏移量: 单位为字节，可正可负
起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾
f.close() 关闭文件

# 1.txt
hello word!

f = open('1.txt')
print(f.read())  # hello word!
f.close() 

ord()

返回参数对应的 ASCII 数值，
或者 Unicode 数值，如果所给的 Unicode 字符超出了你的 Python 定义范围，则会引发一个 TypeError 的异常。

语法:
ord(c)

参数:
c -- 长度为1的字符。

返回值:
返回值是对应的十进制整数。

print(ord('你'))  # 20320
print(ord('好'))  # 22909

P

pow()

返回 xy（x 的 y 次方） 的值。
分:
内置的    pow() 方法
math 模块 pow() 方法

注意：pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float。

内置的 pow() 方法
语法:
pow(x, y[, z])
函数是计算 x 的 y 次方，如果 z 在存在，则再对结果进行取模，其结果等效于 pow(x,y) %z。
import math
语法:
math.pow( x, y )

参数:
x -- 数值表达式。
y -- 数值表达式。
z -- 数值表达式。

返回值:
返回 x的y次方的值。

import math

print(math.pow(2, 8))  # 256.0

print(pow(2, 8))  # 256

# 求模 256 % 5 
print(pow(2, 8, 5))  # 256...1

print()

用于打印输出，最常见的一个函数。

在 Python3.3 版增加了 flush 关键字参数。

print 在 Python3.x 是一个函数，但在 Python2.x 版本不是一个函数，只是一个关键字。

语法:
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

参数:
objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
sep -- 用来间隔多个对象，默认值是一个空格。
end -- 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
file -- 要写入的文件对象。
flush -- 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，就会被强制刷新。

返回值:
None

print('a''b')  # ab
print('a', 'b')  # a b
# 设置间隔符
print('a', 'b', sep='.')  # a.b
# 设置结束符
print('a', end='')  # ab
print('b')

# flush 参数生成一个  的效果：
import time

print('加载中', end='')
for i in range(10):
    print('.', end='', flush=True)  # 加载中.......... 一个点一个点的出现
    time.sleep(0.5)

property()

在新式类中返回属性值。

语法:
class property([fget[, fset[, fdel[, doc]]]])

参数:
fget -- 获取属性值的函数
fset -- 设置属性值的函数
fdel -- 删除属性值函数
doc -- 属性描述信息
返回值:
返回新式类属性。

class C(object):
    def __init__(self):
        self._x = 1

    # 查
    def getx(self):
        """
        帮助文档
        函数介绍:
        "I'm the 'x' property."
        return self._x
        """
        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()
print(c.x)  # c.x      将触发  getter  getx

c.x = 2  # c.x = value 将触发 setter  setx

print(c.x)  # 2

del c.x  # 触发 deleter delx

# 查看属性介绍
print(c.__class__.x.__doc__)  # I'm the 'x' property.

如果给定 doc 参数，其将成为这个属性值的 docstring，
否则 property 函数就会复制 fget 函数的 docstring（如果有的话）。
docstring --> 帮助文档

property 的 getter,setter 和 deleter 方法同样可以用作装饰器
这个代码和上个例子完全相同，但要注意这些额外函数的名字和 property 下的一样，例如这里的 x。

class C(object):
    def __init__(self):
        self._x = 1

    @property
    def x(self):
        """
        帮助文档
        函数介绍:
        "I'm the 'x' property."
        return self._x
        """
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x


c = C()
print(c.x)  # 显示 1   c.x将触发  getter

c.x = 2  # c.x = value 将触发 setter

print(c.x)  # 2

del c.x  # 触发 deleter

print(c.__class__.x.__doc__)  # 显示帮助文档的信息

R

range()

python2.x range() 函数可创建一个整数列表，一般用在 for 循环中。
Python3 range() 返回的是一个可迭代对象（类型是对象），而不是列表类型.

语法:
range(start, stop[, step])

参数：
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

返回值:
python2.x  整数列表
python3.x 可迭代对象

print(list(range(0, -10, -1)))
# [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

print(list(range(0)))  # []

print(list(range(10, 0)))  # []

print(list(range(10, 0, -1)))  
# [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

raw_input()

获取控制台的输入。

raw_input() 将所有输入作为字符串看待，返回字符串类型。

注意：input() 和 raw_input() 这两个函数均能接收 字符串 ，
但 raw_input() 直接读取控制台的输入（任何类型的输入它都可以接收）。
而对于 input() ，它希望能够读取一个合法的 python 表达式，
即你输入字符串的时候必须使用引号将它括起来，否则它会引发一个 SyntaxError 。
Python2.x
除非对 input() 有特别需要，否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。

注意：Python3 里 input() 默认接收到的是 str 类型。
Python2.x 的  raw_input() 等于  Python3 的 input() 

语法:
raw_input([prompt])

参数：
prompt: 可选，字符串，可作为一个提示语。

返回值:
字符串类型的输入信息.

a = raw_input("input:")
print a, type(a)
"""
input:1
1 <type 'str'>
"""

reduce()

对参数序列中元素进行累积。

函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：
用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，
得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

Python3.x reduce() 已经被移到 functools 模块里，
如果我们要使用，需要引入 functools 模块来调用 reduce() 函数：
from functools import reduce

语法:
reduce() 函数语法：
reduce(function, iterable[, initializer])

参数:
function -- 函数，有两个参数
iterable -- 可迭代对象
initializer -- 可选，初始参数

返回值:
返回函数计算结果。

# -*- coding: UTF-8 -*- Pytohn2.7
def add(x, y):  # 两数相加
    return x + y


sum1 = reduce(add, [1, 2, 3, 4, 5])  # 计算列表和：1+2+3+4+5
sum2 = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
print(sum1)  # 15
print(sum2)  # 15

# Python3
def add(x, y):  # 两数相加
    return x + y


sum1 = reduce(add, [1, 2, 3, 4, 5])  # 计算列表和：1+2+3+4+5
sum2 = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函数
print(sum1)  # 15
print(sum2)  # 15

reload()

重新载入之前载入的模块。
Pytohn2.7的函数.

语法:
reload(module)

参数:
module -- 模块对象。

返回值:
返回模块对象。

# -*- coding: UTF-8 -*- Pytohn2.7
import sys

# 获取python编辑器当前使用的编码
print sys.getdefaultencoding()  # ascii

reload(sys)
# 使用 reload重新载入模块, 执行这个代码后sys可以使用setdefaultencoding方法设置编码格式否则
# AttributeError: 'module' object has no attribute 'setdefaultencoding'
# 属性错误：“模块”对象没有属性“setdefaultencoding”


sys.setdefaultencoding('utf8')  # 设置编码
print sys.getdefaultencoding()  # utf8

repr()

将对象转化为供解释器读取的形式。

函数str() 用于将值转化为适于人阅读的形式，而repr() 转化为供解释器读取的形式。

语法:
repr(object)

参数:
object -- 对象。

返回值:
返回一个对象的 str 格式。

# 在python解释器执行
>>> s = 'hello word'
>>> repr(s)
"'hello word'"
>>> s = 123
>>> repr(s), type(repr(s))
('123', <type 'str'>)

repr()函数得到的字符串通常可以用来重新获得该对象，
repr()的输入对python比较友好。通常情况下obj==eval(repr(obj))这个等式是成立的。

>>> obj='I love Python'
>>> obj==eval(repr(obj))
True

>>> obj='I love Python'
>>> obj==eval(str(obj))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1
    I love Python
         ^
SyntaxError: invalid syntax

reverse()

语法：
list.reverse()

参数:
NA。

返回值:
该方法没有返回值，但是会对列表的元素进行反向排序。

l1 = [1, 2, 3, 4, 5]
l1.reverse()
print(l1)  # [5, 4, 3, 2, 1]

round()

返回浮点数x的四舍五入值。

语法:
round( x [, n]  )

参数:
x -- 数值表达式。
n -- 数值表达式，表示从小数点位数。

返回值:
返回浮点数x的四舍五入值。

print(round(3.1415926, 1))  # 3.1
print(round(3.1415926, 2))  # 3.14
print(round(3.1415926, 3))  # 3.142

S

set()

创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

 语法：
class set([iterable])

参数说明：
iterable -- 可迭代对象对象,不可以支持存放可变类型的数据,可以放可变类型的变量.

返回值:
返回新的集合对象。

# 1.可行
l1 = [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
set(l1) 

# 2.不可行
set([1, 2, 3, 4, 5, 1, 2, 3, 4, 5])

l1 = [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
l2 = [4, 5, 6, 7, 8, 9]

# 去重
s1 = set(l1)
print(s1)  # {1, 2, 3, 4, 5}

s2 = set(l2)

# 交集
print(s1 & s2)  # {4, 5}

# 并集
print(s1 | s2)  # {1, 2, 3, 4, 5, 6, 7, 8, 9}

# 差集
print(s1 - s2)  # {1, 2, 3}

setattr()

对应函数 getattr()，用于设置属性值，该属性不一定是存在的,
如果属性不存在会创建一个新的对象属性，并对属性赋值.

语法：
setattr(object, name, value)

参数:
object -- 对象。
name -- 字符串，对象属性。
value -- 属性值。

返回值:
None

class A(object):
    value = 1


a = A()
print(getattr(a, 'value'))  # 获取属性 value 值
setattr(a, 'value', 5)  # 设置属性 value 值

print(getattr(a, 'value'))  # 5

class A(object):
    value = 1


a = A()

setattr(a, 'age', 5)  # 设置属性 age 值
print(getattr(a, 'age'))  # 5
print(a.age)  # 5 飘黄是编辑器无法检测到该变量来源的问题,实际是有的.

slice()

实现切片对象，主要用在切片操作函数里的参数传递。

语法： 
class slice(start, stop[, step])
class slice(stop) 设置一个参数是默认是stop.

参数：
start -- 起始位置
stop -- 结束位置
step -- 间距

返回值:
返回一个切片对象。

my_slice = slice(5)  # 切片的数量

# 查看
print(my_slice, type(my_slice))  # slice(None, 5, None) <class 'slice'>

# 生成一个可迭代对象
arr = range(10)

# 切片操作
arr_slice = arr[my_slice]
print(arr_slice, type(arr_slice))  # range(0, 5) <class 'range'>

# 切片后还是一个迭代器,使用list转换下
print(list(arr_slice))  # [0, 1, 2, 3, 4]

sorted()

对所有可迭代的对象进行排序操作。

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，
而内置函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

语法：
sorted(iterable, cmp=None, key=None, reverse=False)

参数：
iterable -- 可迭代对象。
cmp -- 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，
	此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key -- 主要是用来进行比较的元素，只有一个参数，
	具体的函数的参数就是取自于可迭代对象中，
	指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则
	reverse = True 降序 ，
	reverse = False 升序（默认）。
	
返回值:
返回重新排序的列表。

a = [5, 7, 6, 3, 4, 1, 2]

# 升序
print(sorted(a))  # [1, 2, 3, 4, 5, 6, 7]

# 降序
print(sorted(a, reverse=True))
# [7, 6, 5, 4, 3, 2, 1]

# -*- coding: UTF-8 -*- Pytohn2.7

L = [{1: 5}, {1: 3}, {1: 1}, {1: 9}]

def f2(a, b):
    print(a, b)  # 两两比较, 大的值继续和后面的值继续比较大小,小的往前排
    print(a[1], b[1])
    return a[1] - b[1]

L.sort(cmp=f2)
print L

# 利用key
new_L = sorted(L, key=lambda x: x[1])  

print new_L  # [{1: 1}, {1: 3}, {1: 5}, {1: 9}]

# -*- coding: UTF-8 -*- Pytohn2.7

L = [(100, 1), (300, 3), (200, 2),  (400, 4)]
print sorted(L, cmp=lambda x, y: cmp(x[1], y[1]))  # 使用cap函数
# [(100, 1), (200, 2), (300, 3), (400, 4)] 按 1324 的大小顺序排序

# -*- coding: UTF-8 -*- Pytohn2.7

students = [('kid', 'A', 15), ('qz', 'B', 12), ('qq', 'C', 10)]

new_students1 = sorted(students, key=lambda s: s[1])  # 按等级排序
new_students2 = sorted(students, key=lambda s: s[2])  # 按年龄排序

print new_students1  # [('kid', 'A', 15), ('qz', 'B', 12), ('qq', 'C', 10)]
print new_students2  # [('qq', 'C', 10), ('qz', 'B', 12), ('kid', 'A', 15)]

staticmethod()

返回函数的静态方法。
该方法不强制要求传递参数.
使用装饰器@staticmethod。参数随意，没有“self”和“cls”参数，
但是方法体中不能使用类或实例的任何属性和方法.

语法:
staticmethod(function)

参数：
无

class A(object):
    @staticmethod
    def func(a, b, c):
        pass

# 以上实例声明了静态方法 func，从而可以实现实例化使用 A().func()，当然也可以不实例化调用该方法 A().func()

class A(object):
    @staticmethod
    def func():
        print('123')


# 以上实例声明了静态方法 func，从而可以实现实例化使用 A().func()，当然也可以不实例化调用该方法 A().func()

A.func()  # 123 静态方法无需实例化  

obj = A()
obj.func()  # 123 也可以实例化后调用

str()

将对象转化为适于人阅读的形式。

语法:
class str(object='')

参数:
object -- 对象。

返回值:
返回一个对象的str格式。

s = str(123)
print(s, type(s))  # 123 <class 'str'>

sum()

对序列进行求和计算。

语法:
sum(iterable[, start])

参数:
iterable -- 可迭代对象，如：列表、元组、集合。
start -- 指定相加的参数，如果没有设置这个值，默认为0。

返回值:
返回计算结果。

print(sum([0, 1, 2]))  # 3

# 元组计算总和后再加 1
print(sum((2, 3, 4), 1))  # 10

# 列表计算总和后再加 2
print(sum([0, 1, 2, 3, 4], 2))  # 12

super()

用于调用父类(超类)的一个方法。
是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，
但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（菱形继承）等种种问题。

MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

语法:
super(type[, object-or-type])

参数:
type -- 类。
object-or-type -- 类，一般是 self

返回值
无。

Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 
super().xxx 代替 super(Class, self).xxx 

class A:
    def add(self, x):
        y = x + 1
        print(y)

class B(A):
    def add(self, x):
        super().add(x)  # 这句在这个程序中等于执行A类中的add,把参数x=2传过去


b = B()
b.add(2)  # 3

# -*- coding: UTF-8 -*- Python2.7

class A(object):  # Python2.x 记得继承 object, Python3.x  默认继承object
    def add(self, x):
        y = x + 1
        print(y)

class B(A):
    def add(self, x):
        super(B, self).add(x)

b = B()
b.add(2)  # 3

# -*- coding: UTF-8 -*-

class FooParent(object):  # 父
    def __init__(self):
        self.parent = '5'
        print ('1')

    def bar(self, message):
        print (message)


class FooChild(FooParent):  # 子
    def __init__(self):
        # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类 FooChild 的对象转换为类 FooParent 的对象
        super(FooChild, self).__init__()
        print ('2')

    def bar(self, message):
        super(FooChild, self).bar(message)
        print ('4')
        print (self.parent)


fooChild = FooChild()  # 打印 1 2
fooChild.bar('3')  # 打印 3 4 5

T

tuple()

将列表转换为元组。

语法：
tuple( iterable )

参数:
iterable -- 要转换为元组的可迭代序列。

返回值:
返回元组。

print(tuple())  # () 空元组
print(tuple([1, 2, 3, 4]))  # (1, 2, 3, 4)
print(tuple({1: 2, 3: 4}))  # 针对字典 会返回字典的key组成的tuple

type()

只有第一个参数则返回对象的类型，三个参数返回新的类型对象.

isinstance() 与 type() 区别：

type() 不会认为子类是一种父类类型，不考虑继承关系。

isinstance() 会认为子类是一种父类类型，考虑继承关系。

如果要判断两个类型是否相同推荐使用 isinstance()。

语法:
type(object)
type(name, bases, dict)

参数:
name -- 类的名称。
bases -- 基类的元组。
dict -- 字典，类内定义的命名空间变量。

返回值:
一个参数返回对象类型, 三个参数，返回新的类型对象。

print(type(1))  # <class 'int'>

print(type('hello'))  # <class 'int'>

# 等同于
# class X(object):
#     a = 1


X = type('X', (object,), dict(a=1))  # 产生一个新的类型 X

print(X)  # <class '__main__.X'>

x = X()
print(x.a)  # 1

class A(object):
    pass

class B(A):
    pass

print(isinstance(A(), A))  # True
print(type(A()) == A)  # True
print(isinstance(B(), A))  # True
print(type(B()) == A)  # False

###U

unichr()

unichr() 函数 和 chr() 函数功能基本一样， 只不过是返回 unicode 的字符。

注意： Python3 不支持 unichr()，改用 chr() 函数。

语法:
unichr(i)

参数:
i -- 可以是10进制也可以是16进制的形式的数字。

返回值:
返回 unicode 的字符。

# Python 2.7
print unichr(97)  # a

unicode()

从给定的编码字符串创建一个新的 Unicode 对象.
默认序数范围内（128内）

语法:
unicode(string[, encoding[, errors]]) 

参数:
string -- 从给定的编码字符串创建一个新的 Unicode 对象。
encoding -- 默认为当前默认的字符串编码。
errors  -- 错误可以是“严格”、“替换”或“忽略”，默认为“严格”。
	'strict' 'replace'  'ignore'  'strict'.

返回值:
unicode 对象

# -*- coding: UTF-8 -*-
s1 = unicode('哈哈', encoding='utf8')
print s1, type(s1)  # <type 'unicode'>

V

vars()

返回对象object的属性和属性值的字典对象。

语法：
vars([object])

参数:
object -- 对象

返回值:
返回对象object的属性和属性值的字典对象，
如果没有参数，就打印当前调用位置的属性和属性值 类似 locals()。

print(vars())

"""
{'__name__': '__main__', '__doc__': None, '__package__': None,
 '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000024C788FD4A8>, 
 '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 
 '__file__': 'F:/synchro/Project/测试/2.py', '__cached__': None}
"""

class A(object):
    value = 1

print(vars(A))
"""
{'__module__': '__main__', 'value': 1, '__dict__': <attribute '__dict__' of 'A' objects>, 
'__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
"""

a = A()
print(vars(a))  # {}

X

xrange()

xrange() 函数用法与 range 完全相同，所不同的是生成的不是一个数组，而是一个生成器。

语法：
xrange(stop)
xrange(start, stop[, step])

参数：
start: 计数从 start 开始。默认是从 0 开始。例如 xrange(5) 等价于 xrange(0， 5)
stop: 计数到 stop 结束，但不包括 stop。例如：xrange(0， 5) 是 [0, 1, 2, 3, 4] 没有 5
step：步长，默认为1。例如：xrange(0， 5) 等价于 xrange(0, 5, 1)

返回值:
返回生成器。

l1 = xrange(10)
print l1, type(l1)  # xrange(10) <type 'xrange'>
print list(l1)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Z

zip()

将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，
然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，
利用 * 号操作符，可以将元组解压为列表。

zip 方法在 Python 2 和 Python 3 中的不同：在 Python 3.x 中为了减少内存，
zip() 返回的是一个对象。如需展示列表，需手动 list() 转换。

语法：
zip([iterable, ...])

参数：
iterabl -- 一个或多个迭代器;

返回值:
返回元组列表。

# -*- coding: UTF-8 -*-
a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]

# # 打包为元组的列表
zipped1 = zip(a, b)
print(list(zipped1))  # [(1, 4), (2, 5), (3, 6)]

# 元素个数与最短的列表一致
zipped2 = zip(a, c)
print(list(zipped2))  # [(1, 4), (2, 5), (3, 6)]

# 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
print(zip(*zipped1))  # [(1, 2, 3), (4, 5, 6)] Python 3 这句得到的结果是空 

-

__ import __()

 函数用于动态加载类和函数 。
 如果一个模块经常变化就可以使用 __import__() 来动态载入。

语法：
__import__(name[, globals[, locals[, fromlist[, level]]]])

参数：
name -- 模块名

返回值:
返回元组列表。

# 1.py
print('hello')

# 1.py
m1 = __import__('1') # 导入 1.py 模块 打印hello
print(m1, type(m1))
# <module '1' from 'F:\\synchro\\Project\\测试\\1.py'> <class 'module'>