69 个内置函数，还是挺多的，呵呵，小意思
官方文档：https://docs.python.org/zh-cn/3/library/functions.html
一个个来吧：
-
abs(x)
返回一个数的绝对值。
参数可以是一个整数或浮点数。
如果参数是一个复数，则返回它的模。
如果 x 定义了 __abs__()，则 abs(x) 将返回 x.__abs__()
-
all(iterable)
如果 iterable 的所有元素为真（或迭代器为空），返回 True 。等价于(这个等价真的一语中的):
def all(iterable):
for element in iterable:
if not element:
return False
return True
-
any(iterable)
任一 ，和 all() 相反，只满足一个即可，相当于是 all() 的取反。
如果 iterable 的任一元素为真则返回 True。
如果迭代器为空，返回 False。 等价于:
def any(iterable):
for element in iterable:
if element:
return True
return False
-
ascii(object)
就像函数 repr()，返回一个对象可打印的字符串，但是 repr() 返回的字符串中非 ASCII 编码的字符，会使用 \x、\u 和 \U 来转义。生成的字符串和 Python 2 的 repr() 返回的结果相似。
-
bin(x)
bin 即：binary 二进制的缩写，转化为二进制的意思
将一个整数转变为一个前缀为“0b”的二进制字符串。结果是一个合法的 Python 表达式。如果 x 不是 Python 的 int 对象，那它需要定义 __index__() 方法返回一个整数。一些例子：
>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'
-
class bool([x])
返回一个布尔值，True 或者 False。 x 使用标准的 真值测试过程 来转换。如果 x 是假的或者被省略，返回 False；其他情况返回 True。bool 类是 int 的子类（参见 数字类型 --- int, float, complex）。其他类不能继承自它。它只有 False 和 True 两个实例（参见 布尔值）。
-
breakpoint(*args, **kws)
此函数会在调用时将你陷入调试器中，神马pdb啥的，感觉太难了，哈哈哈，以后有机会再看
-
class bytearray([source[, encoding[, errors]]])
返回一个新的 bytes 数组
-
class bytes([source[, encoding[, errors]]])
返回一个新的“bytes”对象， 是一个不可变序列，包含范围为 0 <= x < 256 的整数。bytes 是 bytearray 的不可变版本
-
callable(object)
如果参数 object 是可调用的就返回 True，否则返回 False。 如果返回 True，调用仍可能失败，但如果返回 False，则调用 object 将肯定不会成功。如果是类本身，肯定是callable 的（因为所有类都可以（ ） 初始化），所以一般判断的是类的实例，只要实例所在的类有 _ call _ 就是判True
这个函数一开始在 3.0 的时候被移除了，3.2 之后又重新引入
-
chr(i)
i 合法范围是 0 到 1,114,111（16 进制表示是 0x10FFFF），把整数转化为 Unicode 字符（所有的单个字符，所有国家的语言，比如中文就转化为 一个喊汉字，或者一个 中文标点符号等等。）表示（是ord 的逆函数）
中文真实博大精深50010 是什么汉字？？
有兴趣可以试试
-
@classmethod
装饰器，把一个方法封装成类方法，就像实例把自己传入给 第一个参数self 一样，类方法会把所属类 传给方法第一个参数
调用直接使用类，或者其实例都可以的，如果是继承的子类调用，则会把子类自己传入。
如果类方法在其所属类的派生类上调用，则该派生类对象会被作为隐含的第一个参数被传入 (派生类理解为子类)
-
compile (source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
这个函数内容还挺多的
简单来说和eval() 有点类似的感觉
参数：
source -- 字符串或者AST（Abstract Syntax Trees）对象。。
filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
指定编译代码的种类。可以指定为 exec, eval, single
compile（）方法返回一个Python代码对象
如果Python代码为字符串形式或是AST对象，并且您想将其更改为代码对象，则使用compile（）方法
稍后可以使用诸如exec（） 和 eval（）之类的方法来调用compile（）方法返回的代码对象，这些方法 将执行动态生成的Python代码
Python可执行对象——exec、eval、compile
compile 返回的是 可以被eval exec 或 single 可以调用的对象
简单来说：
compile语句是从type类型（包括’eval’: 配合eval使用，’single’: 配合单一语句的exec使用，’exec’: 配合多语句的exec使用）中将str里面的语句创建成代码对象。file是代码存放的地方，通常为""。
compile语句的目的是提供一次性的字节码编译，就不用在以后的每次调用中重新进行编译了
其实可直接使用eval 和exec 的，只不过compile 和re.compile 的目的是一样的，编译一次，加快执行速度。
关于eval 和exec的使用以及参数的不同，参见下面的 这两个内置函数的介绍
eval 只能执行单一语句，比如"a+1", "print(22)" ,不执行 "for i in range(5):print(21)",但是exec 却可以
-
class complex([real[, imag]])
把参数(数字或数字类字符串)转化复数表示；
例子：
complex(1, 2)
结果：(1 + 2j)
complex(1) # 数字 第二个参数默认为 0
(1 + 0j)
complex() # 不传参数默认都为 0
结果 （0j）
# 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1 + 2j)
如果参数是 Python 对象：
对于一个普通 Python 对象 x，complex(x) 会委托给 x.__complex__()。 如果 __complex__() 未定义则将回退至 __float__()。 如果 __float__() 未定义则将回退至 __index__()。
多讲一点，int() float() complex() index() 分别调用是对象的
__int__(), __float__() 和 __complex__()
__index__(self)
类似的内置函数 ，如果他们的参数是对象，而不是常规参数 。有很多都是调用的这些对应的内置魔法方法。（一般来说 就是内置函数前后加上 _ _）
比如 int("2") 结果是 2
传入对象如果没有 _ _ int_ _() 会报错，因为他既不是 明显的数字字符串，也不是带有 可以调用 的 _ int _() 对象：
-
delattr(object, name)
这个很熟悉了。 和setattr() getattr() hasattr()都是一起的
delattr(x, 'foobar') 等价于 del x.foobar
-
class dict(**kwarg)
穿件一个新字典的函数，这个很熟悉了
-
dir([object])
如果没有实参，则返回当前本地作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表
如果对象有 _ dir _ 那么久调用他（并且必须返回一个属性列表）
如果对象不提供
__dir__()，这个函数会尝试从对象已定义的 __dict__属性和类型对象收集信息。结果列表并不总是完整的，如果对象有自定义 __getattr__()那结果可能不准确。
如果对象是模块对象，则列表包含模块的属性名称。
如果对象是类型或类对象，则列表包含它们的属性名称，并且递归查找所有基类的属性。
否则，列表包含对象的属性名称，它的类属性名称，并且递归查找它的类的所有基类的属性
返回的列表按字母表排序。例如：
>>> import struct
>>> dir() # show the names in the module namespace # doctest: +SKIP
['__builtins__', '__name__', 'struct']
>>> dir(struct) # show the names in the struct module # doctest: +SKIP
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
'__initializing__', '__loader__', '__name__', '__package__',
'_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
'unpack', 'unpack_from']
>>> class Shape:
... def __dir__(self):
... return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']
-
divmod(a, b)
返回 一个结果元祖，第一个元素是商，第二个参数是余数
如：
>>>divmod(7, 2)
(3, 1)
>>> divmod(8, 2)
(4, 0)
>>> divmod(1+2j,1+0.5j)
((1+0j), 1.5j)
-
enumerate(iterable, start=0)
这个也很熟悉了，迭代列表元素的时候经常用，返回 （index,value） 元祖 的迭代器（带yield ,那就是一个迭代器了）
原理如下：
def enumerate(sequence, start=0):
n = start
for elem in sequence:
yield n, elem
n += 1
-
eval(expression[, globals[, locals]])
很熟悉了
-
exec(object[, globals[, locals]])
和eval 类似，但是支持动态执行语句，一大串的那种
可以是 compile 编译过的pythoN 对象
该函数返回值是 None 请注意
-
filter(function, iterable)
这个也用过，经常和map 函数一起使用的来着 ,map 是不判断，直接把后面的可迭代参数 ，传入前面的 func，结果也是一个可迭代对象
Python2.x 中返回的是过滤后的列表, 而 Python3 中返回到是一个 filter 类。
filter 类实现了 iter 和 next 方法, 可以看成是一个迭代器, 有惰性运算的特性, 相对 Python2.x 提升了性能, 可以节约内存。
function -- 判断函数。
iterable -- 可迭代对象。
下面说的就比较清晰了
filter(function, iterable) 相当于一个生成器表达式，当 function 不是 None 的时候为 (item for item in iterable if function(item))；function 是 None 的时候为 (item for item in iterable if item) 。
例子：
过滤出1~100中平方根是整数的数：
import math
def is_sqr(x):
return math.sqrt(x) % 1 == 0
newlist = filter(is_sqr, range(1, 101))
print(list(newlist))
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
-
class float([x])
返回从数字或字符串 x 生成的浮点数
如果实参是字符串，则它必须是包含十进制数字的字符串
普通Python对象 会交个 __float__() 如果没有float()，则将回退至 __index__()
如果没有实参，则返回 0.0
-
format(value[, format_spec])
这个比较熟悉，不单独详说
-
class frozenset([iterable])
-
getattr(object, name[, default])
这个很熟悉了，不多介绍
-
globals()
返回表示当前全局符号表的字典。这总是当前模块的字典
-
hasattr(object, name)
获取对象的属性，name是字符串
是调用 getattr(object, name) 看是否有 AttributeError 异常来实现的
如果字符串是对象的属性之一的名称，则返回 True，否则返回 False。
-
hash(object)
返回该对象的哈希值（如果它有的话）。哈希值是整数。它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值（即使它们类型不同，如 1 和 1.0）。
-
help([object])
-
hex(x)
整数转化为16 进制
将整数转换为以“0x”为前缀的小写十六进制字符串。如果 x 不是 Python int 对象，则必须定义返回整数的 __index__() 方法。一些例子：
hex(255)
'0xff'
hex(-42)
'-0x2a'
别忘了转化字符串要 也可以用 % 或者 format 实现:
'%#x' % 255, '%x' % 255, '%X' % 255
('0xff', 'ff', 'FF')
format(255, '#x'), format(255, 'x'), format(255, 'X')
('0xff', 'ff', 'FF')
f'{255:#x}', f'{255:x}', f'{255:X}'
('0xff', 'ff', 'FF')
格式化字符串文字: 就是常见的 f 或者 F 开头的 常简称为 f-字符串
将表达式写成 {expression} 来在字符串中包含 Python 表达式的值。
例子一：
import math
print(f'The value of pi is approximately {math.pi:.3f}.')
The value of pi is approximately 3.142
例子二：
在 ':' 后传递一个整数可以让该字段成为最小字符宽度。这在使列对齐时很有用
table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
for name, phone in table.items():
... print(f'{name:10} ==> {phone:10d}')
...
Sjoerd ==> 4127
Jack ==> 4098
Dcab ==> 7678
animals = 'eels'
print(f'My hovercraft is full of {animals}.')
My hovercraft is full of eels.`
从上面看出，这是 % fromat 的另一种 实现方式。{} 里面可以传变量，或者表达式，并且可以在 后面加 { varname :xx } 来格式化这个变量的值,总的来说，你如果使用了这个格式化字符串，你就是高大上了
最后弄一个，对齐的例子，回忆一下format 把
2d 表示 长度为 2 的十进制整数
for x in range(1, 11):
... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
-
id(object)
很熟悉了
返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的 id() 值
以下函数记录记录的比较快了，虽然比较熟悉，但是原理并不是太别的了解，需要经常看看
-
input([prompt])
当读取到 EOF 时，则触发 EOFError。
-
class int([x])
在 3.8 版更改: 如果 __int__() 未定义则回退至 __index__()
-
isinstance(object, classinfo)
如果 classinfo 既不是类型，也不是类型元组或类型元组的元组，则将引发 TypeError异常。
classinfo 可以是默认类，也可以是你自定义的，可以是多个类型的元祖， 只满足一个就是 True
-
issubclass(class, classinfo)
和上一个 isinstance 类似，只不过是直接判断类的，而不是实例
-
iter(object[, sentinel])
这个很熟悉了，把克迭代对象，转化为 迭代器
这个函数的解释很麻烦。
写一个文件读写的例子：
from functools import partial # 这个是偏函数，他返回的是函数对象哦，这里
相当于给了他一个初始参数 64
with open('mydata.db', 'rb') as f:
for block in iter(partial(f.read, 64), b''):
process_block(block)
关于：partial 函数 定义：
func = functools.partial(func, *args, **keywords)
func: 需要被扩展的函数，返回的函数其实是一个类 func 的函数
*args: 需要被固定的位置参数
**kwargs: 需要被固定的关键字参数
# 如果在原来的函数 func 中关键字不存在，将会扩展，如果存在，则会覆盖
关于 partial 的使用例子：
def add(*args, **kwargs):
# 打印位置参数
for n in args:
print(n)
print("-"*20)
# 打印关键字参数
for k, v in kwargs.items():
print('%s:%s' % (k, v))
add_partial = partial(add, 10, k1=10, k2=20)
add_partial(1, 2, 3, k3=20)
"""
10
1
2
3
--------------------
k1:10
k2:20
k3:20
可以看出，partial 只是为了传入参数的方便，并且 会把参数放到函数真正传入的参数之前。比如一个函数都要传入固定的几个参数值，那么可以统一用 partial 包装一下，精简代码之用
-
len(s)
返回对象的长度（元素个数）。实参可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）
-
class list([iterable])
-
locals()
在函数代码块但不是类代码块中调用 locals() 时将返回自由变量
def runoob(arg): # 两个局部变量：arg、z
... z = 1
... print (locals())
...
runoob(4)
{'z': 1, 'arg': 4}
在模块层级上 locals() 和 globals()是同一个字典
-
map(function, iterable, ...)
返回一个将 function 应用于 iterable 中每一项并输出其结果的迭代器
numbers1 = [1, 2, 3]
numbers2 = [4, 5, 6]
result = map(lambda x, y: x + y, numbers1, numbers2)
print(list(result))
>> [5、7、9]
-
max(iterable, *[, key, default])
返回最大值，很简单
-
memoryview(obj)
-
min(iterable, *[, key, default])
返回最小值 很简单
-
next(iterator[, default])
很熟悉，通过调用迭代器的 _ next _ 返回下一个值，
如果迭代器耗尽，则返回给定的 default，如果没有默认值则触发 StopIteration
可以返回默认值，以前并不知道，哈哈哈
-
class object
基类 它具有所有 Python 类实例的通用方法。这个函数不接受任何实参
-
oct(x)
整数返回8 进制的，方法同hex
-
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
如果该文件不能打开，则触发 OSError
打开文件这个函数还是有点多的内容。
一会仔细总结：
文件模式 r w a x + b
r 读
w 写（不存在新建）
a 追写 (w 是清空，append首字母记忆)
- (w+ 或 r+ a+ 表示可读可写，因为不存在 rw 或 wr,用 + 代替)
b 二进制操作内容 （默认为t 文本格式，可省略不写）
没有rw 的用法
其余知识 ，以后再增加
-
ord(c)
chr() 逆函数，把字符转化为他的unicode 码
-
pow(base, exp[, mod])
返回 base 的 exp 次幂 等价于 base ** exp
如果 mod 存在，则返回 base 的 exp 次幂对 mod 取余（比 pow(base, exp) % mod 更高效）
-
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
老朋友了
将 objects 打印到 file 指定的文本流，以 sep 分隔并在末尾加上 end。 sep, end, file 和 flush 如果存在，它们必须以关键字参数的形式给出。
非关键字参数都会被转换为字符串，就像是执行了 str() 如果没有给出 objects，则 print() 将只写入 end
file默认使用 sys.stdout 到控制台 也可是 文件对象 比如 f = open(xxx) 的f ,但是只能是 文本二进制数据，不能用 print() 而应该用 f.write()
-
class property(fget=None, fset=None, fdel=None, doc=None)
一个典型的用法是定义一个托管属性 x:
class C:
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.")
上面的x 就是一个特殊属性，他的值是 通过上面三个函数控制的。
如果 c 是 C 的实例，c.x 将调用getter，c.x = value 将调用setter， del c.x 将调用deleter
用装饰器等效
class C:
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
@property 装饰器会将 voltage() 方法转化为一个具有相同名称的只读属性的 "getter"，并会生成setter deleter 这个两个函数 并将 voltage 的文档字符串设置为 "Get the current voltage."
-
range(stop)
很熟悉
-
repr(object)
-
reversed(seq)
返回一个反向的 iterator seq 必须是一个具有 __reversed__() 方法的对象或者是支持该序列协议（具有从 0 开始的整数类型参数的 __len__()方法和 __getitem__()方法）。
-
round(number[, ndigits])
四舍五入 测试了一下，4.5 还是 4 4.51 就是5了
对于一般的 Python 对象 number, round 将委托给 number.round
-
class set([iterable])
返回一个新的 set 对象，可以选择带有从 iterable 获取的元素
set 是一个不重复的集合
-
setattr(object, name, value)
setattr(x, 'foobar', 123) 等价于 x.foobar = 123
-
class slice(stop) / slice(start, stop[, step]) 多态方法
创建切片对象
正常切片都是 [index,stop,step] 现在可以 xx（slice(..)） 等价于 xx[...]
主要是很多相同的切片，实现统一的切片定义，符合代码的规范
>>>myslice = slice(5) # 设置截取5个元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice] # 截取 5 个元素
[0, 1, 2, 3, 4]
-
sorted(iterable, *, key=None, reverse=False)
key 指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键 (例如 key=str.lower)。 默认值为 None (直接比较元素)。
reverse 为一个布尔值。 如果设为 True，则每个列表元素将按反向顺序比较进行排序
注意：字典默认按照key进行排序，返回key 列表，其他的都是对元素排序
sorted([5, 2, 3, 1, 4])
# [1, 2, 3, 4, 5]
sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
# [1, 2, 3, 4, 5]
sorted 比较的是 相当于 for i in iter 对i 进行排序，最后返回一个排序好的 i 列表。
指定排序key(来自迭代的元素)
student_tuples = [
('john', 'A', 15),
('jane', 'B', 12),
('dave', 'B', 10),
]
sorted(student_tuples, key=lambda student: student[2]) # sort by age
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
-
@staticmethod
静态方法不会接收隐式的第一个参数。要声明一个静态方法，请使用此语法
class C:
@staticmethod
def f(arg1, arg2, ...): ...
静态方法的调用可以在类上进行 (例如 C.f()) 也可以在实例上进行 (例如 C().f())
像所有装饰器一样，也可以像常规函数一样调用 staticmethod
class C:
builtin_open = staticmethod(open)
-
class str(object=b'', encoding='utf-8', errors='strict')
文本化对象
-
sum(iterable, /, start=0)
求和
-
super([type[, object-or-type]])
这个是子类调用父类的方法，python2 是super(当前obj,self).xx
Python3 是直接 super().xx
class C(B):
def method(self, arg):
super().method(arg) # This does the same thing as:
# super(C, self).method(arg) py2传的是 当前类，
并且 按照mro 顺序查找 第一个有改方法名的父类的这个方法
详细说明参见：
https://docs.python.org/zh-cn/3/library/functions.html#super
-
tuple([iterable])
-
class type(name, bases, dict)
通常与 object.__class__ 所返回的对象相同。
一般用 isinstance 比较好 ，因为他会判断子类的情况
-
vars([object])
返回模块、类、实例或任何其它具有 __dict__属性的对象的 __dict__ 属性
-
zip(*iterables)
也很熟悉
创建一个聚合了来自每个可迭代对象中的元素的迭代器。
他的长度是最短的元素长度
相当于:
def zip(*iterables):
# zip('ABCD', 'xy') --> Ax By
sentinel = object()
iterators = [iter(it) for it in iterables]
while iterators:
result = []
for it in iterators:
elem = next(it, sentinel)
if elem is sentinel:
return
result.append(elem)
yield tuple(result)
-
import
此函数会由 import 语句发起调用
这个以后再说把
