abs(x)
求一个数的绝对值。
>>> abs(13) 13 >>> abs(-15) 15
all(iterable)
如果迭代器中的所有值都为“真”则返回 True, 否则返回 False
注意: 如果迭代器为空，返回 True
>>> all([1,1,1]) True >>> all([1,0,1]) False >>> all([]) True
any(iterable)
如果迭代器中的任意一个值为“真”则返回 True, 否则返回 False
注意: 如果迭代器为空，返回 False
>>> any([1,0,0]) True >>> any([0,0,0]) False >>> any([]) False
ascii(object)
该函数返回表示对象的可打印ascii字符串，如果字符串中含有非ascii字符，则以\x, \u 或者 \U 编码来表示
函数其实是返回了对象的 __repr__() 方法的值
>>> a = 123 >>> a.__repr__() ‘123‘ >>> ascii(a) ‘123‘ >>> >>> b = ‘test‘ >>> b.__repr__() "‘test‘" >>> ascii(b) "‘test‘" >>> >>> class MyTest: ... def __repr__(self): ... return ‘Hello, world.‘ ... >>> t = MyTest() >>> t.__repr__() ‘Hello, world.‘ >>> ascii(t) ‘Hello, world.‘
bin(x)
将整型转换为二进制的字符串，字符串以‘0b‘ 开头.
不过说是将整型转换为二进制，其实是将对象的__index__() 方法返回的值转换为二进制字符串
注意: 如果对象没有__index__() 方法，将会产生异常
>>> bin(11) ‘0b1011‘ >>> class MyTest(): ... def __index__(self): ... return 5 ... >>> t = MyTest() >>> bin(t) ‘0b101‘
bool(x)
如果对象为“真”则返回 True, 否则返回 False
>>> bool(0) False >>> bool(1) True
bytearray([source[, encoding[, errors]]])
创建一个 “可变的” byte数组，可以使用整型，字符串和迭代器来初始化
参数为字符串时，字符串中的每一个字符将转换为数组的元素，因此需要提供编码类型，类似utf-8, ascii等
参数为整型时，整形值将作为数组的初始化大小，数组的元素则初始化为0
参数为迭代器时，迭代器的每一个元素将作为数组的元素，因此迭代器的值必须为0-255的整型，否则将产生异常。
>>> a = bytearray(10) >>> a bytearray(b‘\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00‘) >>> a[0] 0 >>> len(a) 10 >>> >>> b = bytearray(‘abc‘, ‘utf-8‘) >>> b bytearray(b‘abc‘) >>> b[0] 97 >>> >>> c = bytearray(range(1,5)) >>> c bytearray(b‘\x01\x02\x03\x04‘) >>> c[0] 1 >>> >>> d = bytearray([1,2,3]) >>> d bytearray(b‘\x01\x02\x03‘) >>> d[1] = 20 >>> d bytearray(b‘\x01\x14\x03‘)
bytes([source[, encoding[, errors]]])
bytes是bytearray的一个不可变的版本，其他的可以参考bytearray
>>> d = bytes([1,2,3]) >>> d b‘\x01\x02\x03‘ >>> d[1] = 20 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: ‘bytes‘ object does not support item assignment
callable(object)
判断对象是否可以调用，如果可以则返回 True, 否则返回 False
类是可调用的，调用后返回一个类的实例。对象如果包含了__call__() 方法也是可调用的。
其实，只要可以写成 object() 的，都是callable的
>>> def foo(): ... pass ... >>> callable(foo) True >>> >>> class MyTest: ... def __call__(self): ... pass ... >>> callable(MyTest) True >>> a = MyTest() >>> callable(a) True >>> >>> b = 1 >>> callable(b) False
chr(i)
返回Unicode对应的字符。
参数范围为 0 -- 1114111, 超过此范围将产生异常
>>> chr(97) ‘a‘ >>> chr(1666) ‘?‘ >>> chr(1200000) Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: chr() arg not in range(0x110000)
classmethod(function)
一般作为函数装饰器 @classmethod
将类中的一个方法指定为类方法。被指定的类方法第一个参数必须为cls(方法所在的类)
类方法的调用可以直接通过类调用，即C.f(); 也可以通过实例调用，即C().f()
类方法有一个比较方便的用处就是作为类似C++中的初始化函数重载
class MyTest(): def __init__(self, year, month, day): self.year = year self.month = month self.day = day @classmethod def from_string(cls, date_string): year, month, day = map(int, date_string.split(‘-‘)) return cls(year, month, day) def output(self): print(‘Birthday: {}-{}-{}‘.format(self.year, self.month, self.day)) >>> a = MyTest(1989, 12, 26) >>> a.output() Birthday: 1989-12-26 >>> >>> b = MyTest.from_string(‘1990-1-1‘) >>> b.output() Birthday: 1990-1-1
compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
该函数将含有python语句的字符串编译成可执行的字节码，编译的结果配合 eval, 或 exec 使用。
source -- 需要编译的字符串
filename -- 存储字符串的文件
mode -- ‘eval‘ 配合 eval 使用, ‘exec‘ 配合多语句的 exec 使用，‘single‘ 配合单语句的 exec 使用
注：实测中，编译的时候会判断mode, 但是执行的时候使用 exec 或者 eval，结果一样
>>> a = compile(‘1+2‘, filename=‘‘, mode=‘eval‘) >>> eval(a) 3 >>> >>> b = compile(‘for i in range(3): print(i)‘, filename=‘‘, mode=‘exec‘) >>> exec(b) 0 1 2 >>> >>> c = compile(‘print("Hello, world.")‘, filename=‘‘, mode=‘exec‘) >>> exec(c) Hello, world.
complex([real[, imag]])
返回一个复数。复数值为 real + imag*1j
参数也可以为一个表示复数的字符串，但是字符串中不能有空格。使用字符串作为参数时，没有第二个参数。
注1: 两个参数的缺省值均为0
注2: 直接用复数表达式 a+bj 创建的对象也是 complex 类型
>>> a = complex(1, 2) >>> a (1+2j) >>> >>> b = 2+3j >>> type(b) <class ‘complex‘> >>> >>> c = complex(‘5+6j‘) >>> c (5+6j) >>> >>> d = complex(1+2j, 1+2j) >>> d (-1+3j)
delattr(object, name)
删除对象的一个属性（不能是对象的方法），但是不会影响该类的其他对象。同 del object.name
注: 参数 name 是一个字符串
>>> class MyTest(): ... def __init__(self): ... self.test = ‘test‘ ... >>> a = MyTest() >>> a.test ‘test‘ >>> b = MyTest() >>> b.test ‘test‘ >>> delattr(a, ‘test‘) >>> a.test Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: ‘MyTest‘ object has no attribute ‘test‘ >>> >>> b.test ‘test‘
dict(**kwarg) dict(mapping, **kwarg) dict(iterable, **kwarg)
创建并返回一个字典对象。初始化参数可以有三种传入方式。
关键字方式，将直接根据关键字生成字典
迭代器方式，迭代器中的对象必须只有两个元素，第一个元素将作为key，第二个作为值
映射方式，其实也是一种迭代器方式
注: 当然也可以直接使用字典作为参数来初始化
>>> dict(one=1, two=2, three=3) {‘two‘: 2, ‘one‘: 1, ‘three‘: 3} >>> >>> dict(zip([‘one‘, ‘two‘, ‘three‘], [1, 2, 3])) {‘one‘: 1, ‘two‘: 2, ‘three‘: 3} >>> >>> dict([(‘one‘, 1), (‘two‘, 2), (‘three‘, 3)]) {‘one‘: 1, ‘two‘: 2, ‘three‘: 3} >>> >>> dict({‘one‘:1, ‘two‘:2, ‘three‘:3}) {‘one‘: 1, ‘two‘: 2, ‘three‘: 3}
dir([object])
很有用的帮助函数。显示当前命名空间，对象或者类的所有属性和方法。
object 可以为对象或者类，如果省略表示当前的命名空间
>>> class MyTest(): ... pass ... >>> def foo(): ... pass ... >>> a = 1 >>> >>> dir() [‘MyTest‘, ‘__builtins__‘, ‘__doc__‘, ‘__loader__‘, ‘__name__‘, ‘__package__‘, ‘__spec__‘, ‘a‘, ‘foo‘] >>> >>> import math >>> dir(math) [‘__doc__‘, ‘__loader__‘, ‘__name__‘, ‘__package__‘, ‘__spec__‘, ‘acos‘, ‘acosh‘, ‘asin‘, ‘asinh‘, ‘atan‘, ‘atan2‘, ‘atanh‘, ‘ceil‘, ‘copysign‘, ‘cos‘, ‘cosh‘, ‘degrees‘, ‘e‘, ‘erf‘, ‘erfc‘, ‘exp‘, ‘expm1‘, ‘fabs‘, ‘factorial‘, ‘floor‘, ‘fmod‘, ‘frexp‘, ‘fsum‘, ‘gamma‘, ‘gcd‘, ‘hypot‘, ‘inf‘, ‘isclose‘, ‘isfinite‘, ‘isinf‘, ‘isnan‘, ‘ldexp‘, ‘lgamma‘, ‘log‘, ‘log10‘, ‘log1p‘, ‘log2‘, ‘modf‘, ‘nan‘, ‘pi‘, ‘pow‘, ‘radians‘, ‘sin‘, ‘sinh‘, ‘sqrt‘, ‘tan‘, ‘tanh‘, ‘trunc‘] >>> >>> d = dict() >>> dir(d) [‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__delitem__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__setattr__‘, ‘__setitem__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘clear‘, ‘copy‘, ‘fromkeys‘, ‘get‘, ‘items‘, ‘keys‘, ‘pop‘, ‘popitem‘, ‘setdefault‘, ‘update‘, ‘values‘]
divmod(a, b)
返回 (a // b, a % b) 的元组
注：a，b可以为整型或者浮点型，但是不能是复数
>>> divmod(7, 3) (2, 1) >>> >>> divmod(4.3, 1.5) (2.0, 1.2999999999999998) >>> >>> (4.3 // 1.5, 4.3 % 1.5) (2.0, 1.2999999999999998)
enumerate(iterable, start=0)
返回一个可迭代的枚举类型。
迭代器中的对象，第一个元素为序号（默认从start=0开始），第二个元素为传入迭代器中的对象。
注: 多用于for遍历过程中，需要同时得到序号的情况。
>>> names = [‘Tom‘, ‘Jack‘, ‘Lily‘] >>> for i, name in enumerate(names, start=1): ... print(i ,name) ... 1 Tom 2 Jack 3 Lily
eval(expression, globals=None, locals=None)
将一个表示python表达式的字符串编译成python语句并执行（慎用！）
返回值，如果传入参数是字符串或者mode=‘eval‘编译的字节码，则返回交互式运行结果，否则返回None
globals和locals为高级用法，此处不展开。默认使用当前命名空间。
注1: 语句必须是单条语句
注2: 字符串中可以带入变量，但变量必须在命令空间中定义。
注3: 可以配合compile()使用
>>> eval(‘2+5‘) 7 >>> x = 3 >>> eval(‘x**2 + 3*x + 5‘) 23
exec(object, [globals[, locals]])
将一个表示python表达式的字符串编译成python语句并执行（慎用！）
返回值为None
globals和locals为高级用法，此处不展开。默认使用当前命名空间。
注1: 语句可以是多条
注2: 字符串中可以带入变量，但变量必须在命令空间中定义。
注3: 可以配合compile()使用
>>> exec(‘for i in range(5): print(i)‘) 0 1 2 3 4
filter(function, iterable)
将一个可迭代的对象按传入的函数进行过滤。函数返回 True 的元素将保留，其它将被过滤掉。
>>> a = [1,2,3,4,5,6,7,8,9] >>> list(filter(lambda x: x % 2, a)) [1, 3, 5, 7, 9]
float([x])
创建并返回一个浮点型的对象。
x可以为一个数或者一个表示浮点数的字符串，缺省值为0
>>> float(3) 3.0 >>> float(‘1.23‘) 1.23
format(value [, format_spec])
将value按格式化转化为字符串，并返回。
目前较多的用法是调用字符串的format方法。
format_spec 指定格式化方式，此处不展开（将会有专题博文）。
>>> format(10, ‘b‘) ‘1010‘ >>> format(‘555‘, ‘0>5‘) ‘00555‘
frozenset([iterable])
传入一个可迭代的对象，创建一个不可变的集合。除了元素不能添加删除外，其他和可变集合类似。
如果没有参数，则创建一个空集合。
>>> a = frozenset([1,2,2,3,4,5]) >>> a frozenset({1, 2, 3, 4, 5}) >>> 2 in a True
getattr(object, name [, default])
获取对象的一个属性的值。
如果对象存在该属性则返回属性值。
如果属性不存在，当传了default时返回default的值，否则产生异常。
注:参数 name 是一个字符串
>>> class MyTest(): ... def __init__(self): ... self.test = ‘test‘ ... >>> a = MyTest() >>> getattr(a, ‘test‘) ‘test‘ >>> getattr(a, ‘foo‘, ‘attr not exist‘) ‘attr not exist‘ >>> >>> getattr(a, ‘foo‘) Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: ‘MyTest‘ object has no attribute ‘foo‘
globals()
返回当前全局域的{对象: 值} 字典
>>> globals() {‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__name__‘: ‘__main__‘, ‘__package__‘: None, ‘__loader__‘: <class ‘_frozen_importlib.BuiltinImporter‘>, ‘__doc__‘: None, ‘a‘: <__main__.MyTest object at 0x7f04880fb780>, ‘__spec__‘: None, ‘MyTest‘: <class ‘__main__.MyTest‘>}
hasattr(object, name)
判断一个对象是否存在指定的属性。存在返回 True, 否则返回 False
注: 参数name 是一个字符串
>>> class MyTest(): ... def __init__(self): ... self.test = ‘test‘ ... >>> a = MyTest() >>> hasattr(a, ‘test‘) True >>> hasattr(a, ‘foo‘) False
hash(object)
返回一个对象的hash值，如果对象不可hash会产生异常。
>>> hash(10) 10 >>> >>> hash(‘test‘) 2595417156033713210 >>> >>> hash((1,2,3)) 2528502973977326415 >>> >>> hash([1,2,3]) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unhashable type: ‘list‘
help([object])
显示对象的帮助信息。如果没有参数则进入帮助的交互模式。
>>> help(eval) Help on built-in function eval in module builtins: eval(source, globals=None, locals=None, /) Evaluate the given source in the context of globals and locals. The source may be a string representing a Python expression or a code object as returned by compile(). The globals must be a dictionary and locals can be any mapping, defaulting to the current globals and locals. If only globals is given, locals defaults to it.
hex(x)
返回x的16进制字符串，字符串以‘0x‘开头，字符串中的字符都以小写形式表示。
当x不是一个int型对象时，则对象必须定义一个__index__() 方法，则返回整型值，否则将产生异常。
>>> hex(64) ‘0x40‘ >>> hex(-10) ‘-0xa‘
id(object)
返回对象的内部ID值。
>>> id(123) 10923328 >>> id(‘test‘) 140589176043704 >>> id([1,2,3]) 140589199591816
input([prompt])
接收标准输入转为字符串并返回。
prompt 为输入提示字符串，可以省略。
注：如果读到 EOF 将产生异常。
>>> s = input(‘Enter: ‘) Enter: hello >>> s ‘hello‘
int(x=0) int(x, base=10)
返回一个整型数。输入参数可以是一个数或者一个字符串（当然可以是其他对象，但这里不讲解这种非主流用法）。
参数为一个数时，返回对象的__int__()方法的值，对于整型对象就是自身的值，对于浮点型对象就是整数部分。
参数为一个字符串时，字符串必须表示一个2、8、10、16进制，并传入相应的base值。
>>> int(3) 3 >>> int(1.25) 1 >>> int(‘101‘, 2) 5 >>> int(‘54‘, 8) 44 >>> int(‘123‘, 10) 123 >>> int(‘F3‘, 16) 243
isinstance(object, classinfo)
判断对象是否属于指定的类。（可以配合 type 使用）
注1: 如果指定类是当前对象的父类，判断结果也是 True
注2: 如果 classinfo 参数是一个元组，那么只要对象属于其中的一个类即返回 True
>>> a = 12 >>> b = 25 >>> isinstance(a, int) True >>> isinstance(a, type(b)) True >>> class A: ... pass ... >>> class B(A): ... pass ... >>> a = A() >>> b = B() >>> isinstance(a, A) True >>> isinstance(b, B) True >>> isinstance(a, B) False >>> isinstance(b, A) True >>> isinstance(a, (A,B)) True
issubclass(class, classinfo)
判断一个类是否为指定类的子类。
注1: 类都是自身的子类
注2: 如果 classinfo 参数是一个元组，那么只要类属于其中一个类的子类即返回 True
>>> class A: ... pass ... >>> class B(A): ... pass ... >>> issubclass(B, A) True >>> issubclass(A, B) False >>> issubclass(A, A) True >>> issubclass(A, (A,B)) True
iter(object [, sentinel])
返回一个迭代器对象，用于遍历，一般与 next() 配合使用。
如果 sentinel 参数没有传入则 object 必须是一个可迭代的对象。
如果 sentinel 参数有值，则object 必须是一个 callable 的对象，此时的遍历将重复调用object, 直到返回值等于 sentinel（将产生StopIteration异常）
>>> it = iter([1,2,3]) >>> next(it) 1 >>> next(it) 2 >>> next(it) 3 >>> next(it) Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration >>> >>> for i in iter([1,2,3]): ... print(i) ... 1 2 3 >>> f = open(‘test.txt‘, ‘r‘) >>> itf = iter(f.readline, ‘‘) >>> next(itf) ‘test line 1\n‘ >>> next(itf) ‘test line 2\n‘ >>> next(itf) ‘test line 3\n‘ >>> next(itf) ‘\n‘ >>> next(itf) Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration >>> f.close()
len(s)
返回对象的长度。对象一般是一个序列和一个集合。
如果是其他对象，则对象必须包含 __len__() 方法，否则会产生异常。
>>> a = [1, 2, 3] >>> len(a) 3 >>> b = ‘abcdefg‘ >>> len(b) 7 >>> >>> class MyTest: ... def __len__(self): ... return 5 ... >>> c = MyTest() >>> len(c) 5
list([iterable])
创建并返回一个列表对象。如果没有传入参数，则返回一个空列表。
传入的参数必须是一个可迭代的，迭代器中的每一个对象将作为列表的一个元素。
>>> list(‘abcd‘) [‘a‘, ‘b‘, ‘c‘, ‘d‘] >>> list([1,2,3]) [1, 2, 3]
locals()
返回当前命名空间的{对象: 值} 字典。
>>> def foo(): ... i = 1 ... j = 2 ... k = 3 ... print(locals()) ... >>> foo() {‘i‘: 1, ‘k‘: 3, ‘j‘: 2}
map(function, iterable, ...)
返回一个迭代器。迭代器中的每一个对象将是传入的迭代器根据function的映射。
如果超过两个参数，后面的参数适用于 function 有多个参数的情况，因此后面的迭代器的长度不能小于 iterable
>>> for i in map(lambda x: x**2, [1,2,3]): ... print(i) ... 1 4 9 >>> for i in map(lambda x,y: x**y, [2,2,2], [1,2,3]): ... print(i) ... 2 4 8
max(iterable [, key, default]) max(arg1, arg2, *args [, key])
返回最大值。要比较的参数可以是一个可迭代的对象，也可以直接传入对象列表。
参数 key 可以改变默认的比较方式。
当传入的是一个迭代器时，如果迭代器为空，则返回default值，如果没有传入default将产生异常。
>>> max([3,5,1,7,9,2]) 9 >>> max(‘aaa‘, ‘bbb‘, ‘ccc‘) ‘ccc‘ >>> >>> max([(4,2), (3,3), (2,4)], key=lambda x: x[1]) (2, 4) >>> max([], default=‘empty‘) ‘empty‘
memoryview(obj)
返回一个内存观察对象。传入的对象必须支持缓冲区协议，内建对象中支持的有 bytes 和 bytearray 。
内存观察对象提供一个共享的内存，可以在不需要复制的情况以不同的方式访问共享内存。在大量数据处理时比较有用。
>>> a = memoryview(b‘abcdefg‘) >>> a <memory at 0x7f22addc3e88> >>> a[0] 97 >>> a[1] 98 >>> a.tolist() [97, 98, 99, 100, 101, 102, 103] >>> a.tobytes() b‘abcdefg‘ >>> a[1:3].tobytes() b‘bc‘
min(iterable [, key, default]) min(arg1, arg2, *args [, key])
返回最小值。用法与 max 类似
>>> min([3,5,1,7,9,2]) 1 >>> min(‘aaa‘, ‘bbb‘, ‘ccc‘) ‘aaa‘ >>> min((4,2), (3,3), (2,4), key=lambda x: x[1]) (4, 2) >>> min([], default=‘empty‘) ‘empty‘
next(iterator [, default])
返回迭代器中的下一个。一般与 iter() 配合使用。
当迭代完成以后，如果传入了default参数，则返回default的值，否则产成StopIteration异常
>>> it = iter([1,2,3]) >>> next(it) 1 >>> next(it) 2 >>> next(it) 3 >>> next(it) Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration >>> >>> it = iter([1,2,3]) >>> next(it, default=‘end‘) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: next() takes no keyword arguments >>> next(it, ‘end‘) 1 >>> next(it, ‘end‘) 2 >>> next(it, ‘end‘) 3 >>> next(it, ‘end‘) ‘end‘
object()
创建一个基本对象。该类是所有类的基类。
>>> a = object() >>> dir(a) [‘__class__‘, ‘__delattr__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__le__‘, ‘__lt__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__setattr__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘]
oct(x)
返回x的8进制字符串，字符串以‘0o‘开头，字符串中的字符都以小写形式表示。
当x不是一个int型对象时，则对象必须定义一个__index__() 方法，则返回整型值，否则将产生异常。
>>> oct(10) ‘0o12‘ >>> oct(16) ‘0o20‘
open(file, mode=‘r‘, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
打开一个文件，返回一个文件的对象。open的使用非常丰富，这里为扫盲，只说明最常用最基本的用法。
参数 file, 文件名，路径可以为相对，也可以为绝对。
参数 encoding，以何种编码方式打开文件，例如 ‘utf-8‘, ‘gbk‘等。
参数 mode，打开模式
- ‘r‘, 只读方式，如果文件不存在将产生异常。
- ‘w‘, 写方式打开，如果文件存在，原文件将被覆盖，如果不存在将创建新文件。
- ‘x‘，创建一个新文件并打开，如果文件存在将产生异常。
- ‘a‘, 追加方式打开，如果文件存在，打开后指针指向文件尾部，如果不存在将创建新文件。
- ‘b‘, 二进制模式打开。
- ‘t‘, 文本模式打开（缺省）
- ‘+‘, 读写方式打开，配合r, w, a使用
其中常用组合模式，r+, rb+, w+, wb+, a+, ab+
注: 为保证使用安全性，常配合 with 使用
>>> f = open(‘test.txt‘, ‘r‘, encoding=‘utf-8‘) >>> f.readline() ‘test line1\n‘ >>> f.close() >>> >>> with open(‘test.txt‘, ‘r‘) as f: ... print(f.readline()) ... test line1
ord(c)
返回字符的unicode码，该函数是chr()反向操作。
注: 参数必须是单一的字符
>>> ord(‘a‘) 97 >>> ord(chr(99)) 99 >>> chr(ord(‘k‘)) ‘k‘
pow(x, y [, z])
求 x 的 y 次方。结果相当于 x ** y
如果传入了参数 z，则相当于 (x ** y) % z
注: 如果 y 是负数，则不能传入 z
>>> pow(2, 3) 8 >>> pow(2, 4, 5) 1
print(*objects, sep=‘ ‘, end=‘\n‘, file=sys.stdout, flush=False)
打印函数。可以一次打印多个对象。sep, end, file, flush 如果需要修改，需以关键字形式指定。
参数sep，多个对象的打印内容之间的分割符。
参数end，所有对象内容输出完毕后输出的字符。
参数file, 输出的地方，默认是标准输出，可以修改成文件等具有write() 方法的对象。
参数flush, 是否立即输出。False 可能会暂时放入缓冲区。
注: 对于自定义的对象，如果想被print调用，需要具有 __str__() 方法
>>> print(‘hello,world‘) hello,world >>> print(‘hello‘, ‘world‘) hello world >>> print(‘hello‘, ‘world‘, sep=‘---‘) hello---world >>> print(‘hello‘, ‘world‘, end=‘\n\n\n‘) hello world >>> print(‘hello‘, ‘world‘, ‘123‘, flush=True) hello world 123 >>> >>> class MyTest: ... def __str__(self): ... return ‘test‘ ... >>> a = MyTest() >>> print(a) test
property(fget=None, fset=None, fdel=None, doc=None)
属性装饰器。可以方便的访问对象的某个属性，避免直接操作内部属性。
函数返回一个装饰属性，将关联 fget, fset, fdel 函数
参数doc提供一个帮助信息。
当用@property装饰类方法时，方法名将作为装饰属性，方法定义为只读。此时如果需要set和del需要配合@method.setter和@method.deleter使用
注1: 两种实现方式中，get, set 和 del 都不是必须全部存在的
注2: 两种实现方式中，get函数都只能有self参数
class MyTest: def __init__(self): self._x = None def getx(self): return self._x def setx(self, v): self._x = v def delx(self): del self._x x = property(getx, setx, delx, "The ‘_x‘ property") class MyTest2: def __init__(self): self._x = None @property def x(self): return self._x @x.setter def x(self, v): self._x = v @x.deleter def x(self): del self._x >>> a = MyTest() >>> a.x >>> >>> a = MyTest() >>> print(a.x) None >>> a.x = ‘test‘ >>> print(a.x) test >>> del a.x >>> print(a.x) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "/home/taopeng/Workspace/CodeWars/tmp.py", line 7, in getx return self._x AttributeError: ‘MyTest‘ object has no attribute ‘_x‘ >>> b = MyTest2() >>> print(b.x) None >>> b.x = 3 >>> print(b.x) 3 >>> del b.x >>> print(b.x) Traceback (most recent call last): File "<stdin>", line 1, in <module> File "/home/taopeng/Workspace/CodeWars/tmp.py", line 25, in x return self._x AttributeError: ‘MyTest2‘ object has no attribute ‘_x‘
range(stop) range(start, stop [, step])
生成一个数字序列迭代器。
当只有一个参数时，序列为0到stop(不包括stop值)， 步进为1
当有两个参数时，序列为start到stop(不包括stop值)，步进为1
三个参数时，即可自定义步进
>>> list(range(5)) [0, 1, 2, 3, 4] >>> list(range(3,9)) [3, 4, 5, 6, 7, 8] >>> list(range(1,10,2)) [1, 3, 5, 7, 9]
repr(object)
和 ascii() 类似，返回对象的可打印字符串。
自定义对象如果需要 repr()，需要定义__repr__() 方法
>>> a = 123 >>> repr(a) ‘123‘ >>> b = ‘test‘ >>> repr(b) "‘test‘" >>> class MyTest: ... def __repr__(self): ... return ‘Hello, world‘ ... >>> c = MyTest() >>> repr(c) ‘Hello, world‘
reversed(seq)
返回一个序列逆序的迭代器。
如果是自定义对象，需要实现 __reversed__() 方法或者支持序列协议
>>> list(reversed([1,2,3,4,5]))
[5, 4, 3, 2, 1]
round(number [, ndigits])
保留指定的小数位，返回一个最接近的数。
参数 ndigits 默认为None， 即只保留整数部分。
注1: 该函数当向上和向下取近似距离相同时，优先取较小的偶数。
注2: ndigits 如果填0，虽然只保留整数位，但是会返回浮点型
>>> round(1.1) 1 >>> round(1.8) 2 >>> round(1.5) 2 >>> round(2.5) 2 >>> round(3.5) 4 >>> round(3.14, 1) 3.1 >>> round(3.16, 0) 3.0
set([iterable])
创建一个集合对象。如果没有参数则创建一个空集合。
参数必须是可迭代的。迭代器中的相同的对象将只会保留一个。
>>> set([1,2,3]) {1, 2, 3} >>> set([1,1,2,2,3]) {1, 2, 3} >>> set(range(10)) {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
setattr(object, name, value)
给对像的指定属性赋值。如果对象不存在该属性，将先创建该属性。
注: 参数 name 是一个字符串
>>> class MyTest(): ... pass ... >>> a = MyTest() >>> setattr(a, ‘test‘, ‘hello‘) >>> getattr(a, ‘test‘) ‘hello‘ >>> setattr(a, ‘test‘, ‘hello, world‘) >>> getattr(a, ‘test‘) ‘hello, world‘ >>> a.test ‘hello, world‘
slice(stop) slice(start, stop [, step])
生成一个分片对象。用于对序列进行分片。
当只有一个参数时，序列为0到stop(不包括stop值)， 步进为1
当有两个参数时，序列为start到stop(不包括stop值)，步进为1
三个参数时，即可自定义步进
不过一般可以直接在序列中用分片语法，例如 a为一个列表，分片语法为: a[start:stop:step]
>>> myslice = slice(1,5,1) >>> a = [1,2,3,4,5,6,7,8,9] >>> a[myslice] [2, 3, 4, 5] >>> a[1:5:1] [2, 3, 4, 5]
sorted(iterable, *, key=None, reverse=False)
返回一个经过排序的列表。key, reverse参数必须以关键字形式传入。
需要排序的对象必须是可迭代的。
参数key，排序的关键字。
参数reverse，是否逆序，默认从小到大。
注: 参数*可以忽略。
>>> a = [5,6,3,1,7,4,9] >>> sorted(a) [1, 3, 4, 5, 6, 7, 9] >>> sorted(a, reverse=True) [9, 7, 6, 5, 4, 3, 1] >>> b = [‘B‘, ‘a‘, ‘g‘, ‘F‘, ‘z‘, ‘K‘] >>> sorted(b) [‘B‘, ‘F‘, ‘K‘, ‘a‘, ‘g‘, ‘z‘] >>> sorted(b, key=str.lower) [‘a‘, ‘B‘, ‘F‘, ‘g‘, ‘K‘, ‘z‘]
staticmethod(function)
一般作为函数装饰器使用 @staticmethod 。类似 classmethod
将类中的一个方法指定为静态方法。
静态方法的调用可以直接通过类调用，即C.f(); 也可以通过实例调用，即C().f()
个人感觉静态方法适合将函数归类打包
注:静态方法是可以继承的
>>> class MyTest: ... @staticmethod ... def static_test(): ... print(‘This is a static method‘) ... >>> >>> a = MyTest() >>> a.static_test() This is a static method >>> >>> MyTest.static_test() This is a static method
str(object=‘‘) str(object=b‘‘, encoding=‘utf-8‘, errors=‘strict‘)
创建并返回一个字符串对象。
可以使用指定的对象来初始化。初始化将使用对象的 __str__() 方法返回的值。
>>> str(12345) ‘12345‘ >>> str(‘test‘) ‘test‘ >>> str([1,2,3]) ‘[1, 2, 3]‘ >>> class MyTest: ... def __str__(self): ... return ‘Hello‘ ... >>> a = MyTest() >>> str(a) ‘Hello‘
sum(iterable [, start])
对一个序列求和。
参数start， 指定一个初始值，默认是0
>>> sum(range(5)) 10 >>> sum(range(5), 3) 13 >>> sum({1,2,3}) 6
super([type [, object-or-type]])
返回父类的方法、对象。一般用于继承处理中，特别是初始化。
在初始化中，super的参数可以省略。
class A: def __init__(self): print(‘Class A init‘) class B(A): def __init__(self): super().__init__() print(‘Class B init‘) class C(A): def __init__(self): super(C, self).__init__() print(‘Class C init‘) >>> b = B() Class A init Class B init >>> c = C() Class A init Class C init
tuple([iterable])
创建并返回一个元组对象。
可以使用一个可迭代对象初始化元组。
>>> tuple(range(5)) (0, 1, 2, 3, 4) >>> tuple(‘test‘) (‘t‘, ‘e‘, ‘s‘, ‘t‘)
type(object) type(name, bases, dict)
两个功能。传入的参数个数不同，功能不同
一个参数时，返回对象所属的类。
三个参数时，动态创建一个自定义类的对象。
当需要动态创建一个类时，
参数name, 类名
参数bases, 类的基类，使用一个元组传入，因此可以有多个父类。
参数dict, 类的属性和方法字典。{属性名=属性值，方法名=函数名}, 其中“函数名”是一个已经定义的函数
注: 直接通过字典传入的方法是一个静态方法。
>>> a = [1,2,3] >>> type(a) <class ‘list‘> >>> >>> def test_func(): ... print(‘This is a test func.‘) ... >>> b = type(‘MyTest‘, (object, ), dict(test_attr=‘Hello‘, test_method=test_func)) >>> type(b) <class ‘type‘> >>> b.test_attr ‘Hello‘ >>> b.test_method() This is a test func.
vars([object])
返回对象新添加的属性字典。如果没有参数，返回当前命名空间更新的属性字典。
实际上函数返回的就是对象 __dict__ 属性的值。
注: 在初始化时添加的属性不会放入 __dict__
>>> class MyTest: ... def __init__(self): ... a = 1 ... b = 2 ... >>> a = MyTest() >>> >>> vars(a) {} >>> a.c = 3 >>> vars(a) {‘c‘: 3} >>> a.__dict__ {‘c‘: 3} >>> >>> vars() {‘MyTest‘: <class ‘__main__.MyTest‘>, ‘a‘: <__main__.MyTest object at 0x7f1ca394f828>, ‘__doc__‘: None, ‘__package__‘: None, ‘__loader__‘: <class ‘_frozen_importlib.BuiltinImporter‘>, ‘__spec__‘: None, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__name__‘: ‘__main__‘}
zip(*iterables)
将多个序列进行重新组合，返回一个元组列表。
每个元组从各个序列中各提取一个值。因此元组的个数由最短的序列决定。
>>> list(zip([1,1,1], [2,2,2], [3,3,3])) [(1, 2, 3), (1, 2, 3), (1, 2, 3)] >>> >>> list(zip([1,2,3], [4,5,6], [7,8,9])) [(1, 4, 7), (2, 5, 8), (3, 6, 9)] >>> >>> list(zip([1,1,1], [2,2,2], [3,3])) [(1, 2, 3), (1, 2, 3)]