python 内置函数 必须搞定哦

image.png
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 是什么汉字？？

韩文大概是40000+ 之后了
有兴趣可以试试

• @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 _() 对象：

没有 __ 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])

和dir 有点像，但是会详细一点

• 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')

image.png
image.png

格式化字符串文字: 就是常见的 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

image.png
image.png

• class set([iterable])

返回一个新的 set 对象，可以选择带有从 iterable 获取的元素
set 是一个不重复的集合

image.png

• 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 语句发起调用
这个以后再说把