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' 

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

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)  #  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] 
print(dict1, type(dict1))  # {'k1': 'v1', 'k2': 'v2'} 
print(tuple1, type(tuple1))  # (1, 2, 3) 

# 优先顺序
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__': ,
'__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 

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..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)  # 

str1 = '1'
l1 = long(str1)

print long()  # 0
print l1  # 1
print type(l1)  # 

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)  # (, )

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

print v[0:5]  # 
print v[0:5].tobytes()  # hello

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

print(v, type(v))  #  
print(v[1])  # 101 h -->101
print(v[-1])  # 111 o -->111
print(v[0:5])  # 
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))  #