1. 运算类

abs(X)

返回一个数的绝对值

min, max(iterable, key=None)

返回iterable里的最大/小值，key是个函数指定根据元素的什么属性查找。

max(persons, key=lambda p: p.age)
min(persons, key=lambda p: p.age)

pow(x, y[, mod])

x的y次方，如果mode存在，则是x的y次方再取余，比pow(x, y) % mod效率高。

pow(2, 3) == 2**3
pow(2, 3, 5) == 2**3 % 5

round(number, ndigits)

四舍五入到小数点后ndigits位，如果ndigits被省略，返回整数。

round(1.3478, 2)  # 1.35

sum(iterable, start=0)

对iterable元素求和，再加上start。

sum([4, 2, 3], 11)   #20

divmod(a, b)

返回a除以b的（商，余数）。

divmod(37, 5)    # (7, 2)

2. 类型转换

int(x)

对于输入的数字或者是字符串x，返回x的整数形式，如果x数值为空时，则返回0。

float(x)

对于输入的数字或者是字符串x，返回x的浮点数形式，如果x数值为空时，则返回0.0。

complex([real[, imag]])

将字符串或数字转换为复数。

complex(2, 3)    # (2+3j)
complex('2+3j')    # (2+3j)

bool(x)

将x转换为True或False

str(x)

将x转换为字符串

bytearray(x, encoding=’utf-8’)

将x转换为可变数组bytearray。bytearray无字面值语法。

bytearray('alex', encoding='utf-8')  # bytearray(b'alex')

bytes(x, encoding=’utf-8’)

将x转换为不可变数组bytes。字面值语法：引号前加b.

bytes('alex', encoding='utf-8')  # b'alex'

字符串和bytes转换。

name_bytes = 'alex'.encode('utf-8')
name_str = name_bytes.decode('utf-8')

memoryview(obj)

创建一个引用 obj 的 memoryview。 obj 必须支持缓冲区协议。 支持缓冲区协议的内置对象包括 bytes 和 bytearray。访问bytes的memoryview，元素都是数组1-255。

>>> v = memoryview(b'abcefg')
>>> v[1]
98
>>> v[-1]
103
>>> v[1:4]
<memory at 0x7f3ddc9f4350>
>>> bytes(v[1:4])
b'bce'

3. 进制转换

bin(int)

将一个整数转变为一个前缀为“0b”的二进制字符串。

bin(3)  => '0b11'

oct(int)

将一个整数转换为一个前缀为“0o”的八进制字符串。

oct(12) => '0o14'

hex(int)

将一个整数转换为一个前缀为“0x”的十六进制字符串。

hex(35) => '0x23'

ord(char) / chr(x)

char是单个字符，返回对应的Unicode码。chr是逆函数，数字转换成字符。

ord('a') => 97
chr(99) => 'c'

4. 数组操作

list([iterable])

构造器将构造一个列表，其中的项与 iterable 中的项具有相同的的值与顺序。 iterable 可以是序列、支持迭代的容器或其它可迭代对象。 如果 iterable 已经是一个列表，将创建并返回其副本，类似于 iterable[:]。 例如，list(‘abc’) 返回 [‘a’, ‘b’, ‘c’] 而 list( (1, 2, 3) ) 返回 [1, 2, 3]。 如果没有给出参数，构造器将创建一个空列表 []。

dict(mapping) / dict(**kwargs)

类方法构造dict。

dict(name="alex", age=18)
dict([('name', 'alex'), ('age', 18)])

set([iterable]) / frozenset([iterable])

元素必须为hashable。

set([ 1, 2, 1, 2, 3, 2, 1]) => {1, 2, 3}

tuple([iterable])

类方法构造tuple。

enumerate(iterable, start=0)

返回一个迭代器，元素是 (index, element)。

enumerate(['Spring', 'Summer', 'Fall', 'Winter']) =>
(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')

range(stop) / range(start, stop[, step])

返回一个不可变的整数序列，通常用在for循环里。

list(range(5))   => [0, 1, 2, 3, 4]
range(2, 11, 2)) => [2, 4, 6, 8, 10]

iter(object[, sentinel])

返回一个iterator对象，调用next()方法，获得下一个数据。

没有sentinel，第一个参数是个iterable，每次next()返回iterable里的下个元素。没数据了raise StopIterator。

numIterator = iter([1, 2, 3, 4, 5])
for i in range(10):
    print(next(numIterator))

有sentinel，第一个参数是callable的object，每次next()调用一次callable，如果返回和sentinel相等，则raise StopIteration。

class Person(object):
    def __init__(self):
        self._start = 0
    
    def __call__(self):
        self._start += 1
        return self._start

objIterator = iter(Person(), 5)
for i in range(10):
    print(next(objIterator)) # raise StopIteration on 5

slice(stop) / slice(start, stop[, step])

返回slice对象，代表序列的索引，即可以用有名索引来截取序列。

str = "Alex ZHANG"

firt_name_index = slice(4)
str[firt_name_index] => 'Alex'

family_name_index = slice(5, len(str))
str[family_name_index] => 'ZHANG'

object()

在Python中，object类是所有类的基类，object函数不接受任何参数，返回的是一个没有任何特征的对象。

super()

用来调用父类的方法，最常用的父类的__init__，如果有多个父类，则从第一个父类找。找不到再从父类的父类中找。

Method resolution order

5. 排序操作

sorted(iterable, key=None, reverse=False)

对元素排序，key是函数指定根据什么排序，reverse表示逆排序，返回新的list。

names = ['john', 'alex', 'trump', 'biden']
sorted(names) => ['alex', 'biden', 'john', 'trump']
sorted(names, key=lambda name: name[-1]) => ['john', 'biden', 'trump', 'alex']

reversed(seq)

对于输入的序列seq进行反转，生成新的可迭代对象并返回。

6. 序列操作

sequences (序列) 是python的基本数据类型，包含str, list和tuple。

all(iterable)

返回True如果所有元素为真，会有短路。

any(iterable)

返回True如果有元素为True，会有短路。

map(func, iterable)

对iterable的每个元素都apply func，返回新map（注意不是list）。

nums = [1, 2, 3]
new = map(lambda x: x*2, nums)

filter(func, iterable)

对每个元素，执行func，返回True的留下，返回的是filter（不是list）。

nums = [1, 2, 3, 4]
new = filter(lambda x: x > 1, nums)

next(iterator[, default])

返回迭代器里的下个元素，没有则raise StopIteration异常。

zip(*iterables)

根据多个输入，返回一个元祖的迭代器，以最短的那个结束。

a = [1, 2, 3, 4, 5, 6]
b = ['a', 'b', 'c']
for val in zip(a, b):
    print(val)
----------------------
(1, 'a')
(2, 'b')
(3, 'c')

itertools.zip_longest(*iter, fillvalue=None)

同zip，但是以最长的结束。

import itertools
a = [1, 2, 3, 4, 5, 6]
b = ['a', 'b', 'c']
for val in itertools.zip_longest(a, b, fillvalue='w'):
    print(val)
--------------------------
(1, 'a')
......
(5, 'w')
(6, 'w')

7. 对象元素操作

help(object)

通过help函数可以帮助用户来查询不同对象的信息，包括内置方法、属性等信息。主要用于interactive console。

id(object)

返回object对象的标识值，这个标识值是一个整数，且在对象的生命周期中保持唯一。对于CPython来说，返回的是对象内存地址。

hash(object)

如果object对象有对应的哈希值则返回对应的哈希值。

type(object)

返回对象的类型，等同于object.__class__。

a = Person('alex')
print(type(a))  # <class '__main__.Person'>
print(a.__class__)  # <class '__main__.Person'>

dir([object])

主要用在交互式，没有参数，返回local scope里的所有名字；有object参数，返回object的所有属性。

注意：在__init__里给self添加的属性，dir会显示；其它方法里添加的，不会显示。

len(object)

返回object对象的长度或者是所包含的元素个数。

repr(object)

repr函数返回包含一个对象的可打印表示形式的字符串。repr 是representation的简写，通过函数__repr__(self)，可以控制repr返回值。

ascii(object)

把repr(object)的结果转义成ascii字符串，non-ASCII使用\x, \u or \U来转义。

format(value ,format_spec)

format函数将 value 转换为 由format_spec参数控制的“格式化”表示形式，多用在字符串的格式化处理中。

vars(object)

函数返回模块、类、实例等具有 __dict__属性的对象的 __dict__属性。

__dict__方便可以查看类的属性，dir()的输出太多了。

8. 属性操作

isinstance(object, classinfo)

函数用来判断object对象是否属于classinfo的类型，如果是则返回True，否则返回False。

issubclass(class, classinfo)

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

hasattr(object, name)

判断object是否有叫name的属性（不包括父类的），方法也叫属性。相当于判断object.__dict__是否包含name。

getattr(object, name)

返回object的叫name的属性，如果是函数可以再次调用。类似Java的反射，但更简单。

getattr(obj, 'add')(1, 2) => 3

setattr(object, name, value)

动态给object添加属性。

def add(x, y):
    return x + y
obj.add = add
print(getattr(obj, 'add')(1, 2))

delattr(object, name)

删除object中叫name的属性。

__import__(module)

动态导入module，然后通过反射来调用。这里的反射指：getattr(object, name)。

welcome_module.py

class Welcome(object):
    @staticmethod
    def welcome(str):
        print("Hi ! % s Welcome to GfG" % str)

动态导入welcome_module，调用welcome函数。
class Dimport:
    def __init__(self, module_name, class_name):
        module = __import__(module_name)
        my_class = getattr(module, class_name)
        my_class.welcome('User_1')
obj = Dimport("welcome_module", "Welcome")

import如果写在局部作用域内，那这个import的module只能在局部内能访问。

def hi():
    import os
    print(os.path.join('a', 'b'))

hi()
print(os.path.join('c', 'd'))   // compile failure

callable(object)

如果对象 object 是可调用的就返回 True，否则返回 False。

9. 变量操作

globals()

返回作用域内的全局变量和其数值所构成的字典，既是当前module的字典。对于函数而言，返回的是定义函数的module的字典，而不是调用函数的module。

locals()

与globals函数对应的，locals函数返回的是当前作用域下局部变量和其数值所构成的字典。

10. 人机交互

print(*objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)

可以print多个，以sep（默认空格）分隔，文件末尾加‘\n’，默认print到stdout。

flush表示是否立即输出，对于有缓存的（由file决定），它会先缓存再一次性输出。如果flush=True，则每次print都立即输出。

input([prompt])

返回用户输入的字符串。

name = input("What's your name? ")
print(name)
----------------------------------
What's your name? Alex
Alex

open(file, mode=’r’)

打开 file 并返回对应的 file object对象，mode对应的是向file文件进行读或者是写等操作。如果该文件不能被打开，那么程序会引发 OSError报错。

11. 编译操作

compile(source, filename, mode, flag, dont_inherit, optimize)

将源码编译成代码对象（code object），可以被exec执行。参数：

• source Required. The source to compile, can be a String, a Bytes object, or an AST object
• filename Required. The name of the file that the source comes from. If the source does not come from a file, you can write whatever you like
• mode Required. Legal values:
  • eval – if the source is a single expression
  • exec – if the source is a block of statements
  • single – if the source is a single interactive statement
• flags Optional. How to compile the source. Default 0
• dont-inherit Optional. How to compile the source. Default False
• optimize Optional. Defines the optimization level of the compiler. Default -1

codeInString = 'a = 8\nb=7\nsum=a+b\nprint("sum =",sum)'
codeObject = compile(codeInString, 'sumstring', 'exec')
exec(codeObject)    # 15

exec(object)

动态执行代码，如果object是code object则直接执行；如果是字符串，当成python语句执行。没有返回值。

a = [1, 2, 3]
exec("for i in a: print('value is', i)")
----------------------------------------
value is 1
value is 2
value is 3

eval(expression)

eval函数会将字符串expression当成有效的表达式来求值并返回计算结果。eval函数只能单个运算表达式，而不能是复杂的代码逻辑或者是赋值运算。跟JavaScript里的eval一样。

a = [1, 2, 3]
b = eval('[i*2 for i in a]')
print(b)
----------------------------
[2, 4, 6]

12. 函数装饰器

@classmethod

classmethod的作用是将一个方法封装成类方法，可以在不创建类对象的前提下调用该装饰器修似的方法。

@staticmethod

staticmethod方法是将类中的方法转换为静态的方法，静态方法不会接受隐式的参数，同样也可以在不创建类对象的前提下调用静态方法。

property(fget=None, fset=None, fdel=None, doc=None)

作为装饰器，property可以将类方法转换为类属性来使用。

直接调用property

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

    # be after all methods, otherwise ‘getx/setx/selx’ cannot be found
    x = property(getx, setx, delx, "I'm the 'x' property.")

@property

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