再不重返

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__(卡塔尔(英语:State of Qatar) 方法,将会爆发相当

>>> 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'x00x00x00x00x00x00x00x00x00x00')
>>> 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'x01x02x03x04')
>>> c[0]
1
>>> 
>>> d = bytearray([1,2,3])
>>> d
bytearray(b'x01x02x03')
>>> d[1] = 20
>>> d
bytearray(b'x01x14x03')

bytes([source[, encoding[, errors]]**])

  bytesbytearray的贰个不可变的版本,其余的能够参照他事他说加以考察bytearray

>>> d = bytes([1,2,3])
>>> d
b'x01x02x03'
>>> 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(方法所在的类卡塔尔(英语:State of Qatar)

  类方法的调用可以直接通过类调用,即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 + imag1j*

  参数也足认为三个代表复数的字符串,不过字符串中不能够有空格。使用字符串作为参数时,未有第4个参数。***


  注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,第3个作为值

  映射情势,其实也是生龙活虎种迭代器情势

  注: 当然也得以直接行使字典作为参数来开头化

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

  globalslocals为高等用法,此处不开展。暗中同意使用当前命名空间。

  注1: 语句必需是单条语句

  注2: 字符串中得以辅导变量,但变量必需在命令空间中定义。

  注3: 能够同盟compile()使用

>>> eval('2+5')
7
>>> x = 3
>>> eval('x**2 + 3*x + 5')
23

 exec(object, [globals[, locals]])

  将一个表示python表达式的字符串编写翻译成python言语并实践(慎用!

  重回值为None

  globalslocals为高档用法,此处不进行。暗中同意使用当前定名空间。

  注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 1n'
>>> next(itf)
'test line 2n'
>>> next(itf)
'test line 3n'
>>> 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 line1n'
>>> 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='nnn')
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值卡塔尔(英语:State of Qatar),步进为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)]

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website