首页 > > 网络编程 > 其它 >

Python标准库(3.x): 内建函数扫盲

2018-06-18 01:25:01来源：未知阅读 ()

**Built-in Functions**
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

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)]

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有