【亚洲必赢官网】第八伍章,內建函数

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

Python标准库(三.x): 内建函数扫除文盲,python叁.x

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

 

python有一部分常用的放到函数:

1.abx(x)

归来一个数的相对值。参数只怕是三个惯常或长整型,只怕2个浮点数。假设参数是三个复数,重回它的积。

 

abs(x)

  求一个数的相对值。

>>> abs(13)
13
>>> abs(-15)
15

数学函数

2.all(iterable)

假诺迭代的持有因素都以真就回到真。

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

abs() 获取相对值

3.any(iterable)

一经迭代中有贰个因素为真就赶回真。

亚洲必赢官网 1

all any

all(iterable)

  如果迭代器中的全体值都为“真”则赶回 True, 不然赶回
False

  注意:
倘若迭代器为空,重返 True

>>> all([1,1,1])
True
>>> all([1,0,1])
False
>>> all([])
True

any(iterable)

  若是迭代器中的任意3个值为“真”则赶回 True, 不然赶回
False

  注意: 比方迭代器为空,重返 False

>>> any([1,0,0])
True
>>> any([0,0,0])
False
>>> any([])
False

min()求最小值

ascii

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

max()求最大值

bin

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__() 方法,将会生出11分

>>> bin(11)
'0b1011'
>>> class MyTest():
...     def __index__(self):
...         return 5
... 
>>> t = MyTest()
>>> bin(t)
'0b101'

hash()获取三个指标(字符串或数值)的哈希值

bool([x])

将2个值转变为Boolean,使用正式的真测试程序。假使x是假或忽视了,将回来False;不然将赶回True.bool也是1个class,它是int的多个子类,bool类不可能进一步子类化。它仅有False和True四个实例。

亚洲必赢官网 2

bool

bin(x)

  将整型转换为贰进制的字符串,字符串以’0b’ 初阶.

  不过正是将整型转变为2进制,其实是将对象的__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

pow(),c风格的两回方,math.pow(x, y)

bytearray

 bool(x)

  若是指标为“真”则赶回 True, 不然赶回
False

>>> bool(0)
False
>>> bool(1)
True

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

  创设2个 “可变的”
byte数组,可以行使整型,字符串和迭代器来发轫化

  参数为字符串时,字符串中的每二个字符将转移为数组的成分,因而需要提供编码类型,类似utf-8,
ascii

  参数为整型时,整形值将作为数组的伊始化大小,数组的要素则始于化为0

  参数为迭代器时,迭代器的每多少个因素将用作数组的要素,由此迭代器的值必须为0-25五的整型,否则将爆发至极。

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

sum(),对队列进行求和

bytes

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

  bytesbytearray的三个不可变的本子,其余的能够参见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

round(x[, n])重临浮点数的4舍5入,n表示小数点后留下位数,默认为0.

callable(object)

要是object参数能够调用就赶回True,不然再次回到False。若是回去True,它如故可能调用败北,可是假若回到False,就长久不容许调用成功。注类是可调用的(调用二个类再次回到一个实例);类的实例假设有三个__call__()方法正是可调用的。

亚洲必赢官网 3

callable

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

  bytesbytearray的二个不可变的本子,别的的能够参照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(x)

回来二个ascii码是整数x的字符的字符串。例如,chr(玖七)再次回到string
‘a’.那和ord()刚好相反。

callable(object)

  剖断目的是不是足以调用,假使能够则赶回 True, 不然赶回
False

  类是可调用的,调用后回去3个类的实例。对象假诺带有了__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)

bin()再次来到八个整型int或long int的二进制表示

classmethod(function)

再次回到函数的一个类措施。

 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

oct()将二个整数转变来8进制字符串

compile(string, filename, kind[, flags[, dont_inherit]])

编写翻译string为1个代码对象。代码对象能够通过exec语句推行只怕经过调用eval()总计。这filename参数钦命代码从哪些文件读取。如若不从文件中读取,就须传递1些可甄别的值(常常采用”)。kind参数钦命哪个种类代码被编写翻译;纵然是含有1体系语句组成的子符串能够‘exec’,假如是由3个表明式组成,就’eval’,假设由一个互为语句组成就‘singlw’(表达式语句总计的结果不是None将打字与印刷出来)。

当编写翻译二个多行语句时,应用几个警示:必须以’\n’作为行甘休符,同时输入必须至少以二个’\n’作为达成。要是是以’\r\n’作为行终止,使用string的repalce()方法将其改为‘\n’.

可选的参数flags和dont_inherit调整影响string编写翻译的future语句。

classmethod(function)

  壹般作为函数装饰器 @classmethod

  将类中的二个办法内定为类措施。被钦命的类措施第3个参数必须为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.

hex() 将10进制整数调换为1陆进制

complex( [real[, imag]])

创办四个复数real + imag*j大概将一个string大概number转化为2个复数.
假若第三个参数是贰个字符串,它将作为复数解释,函数将被调用,而忽略第2个参数。第一个参数不容许是1个字符串。每二个参数都大概是一个数字类型包含复数.假如imag省略了,
它私下认可为0,函数将用作多少个数字调换函数像 int(), long() and
float().假如参数都简短了,将回来0j.

亚洲必赢官网 4

complex

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)

类型转变

copyright

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 是1个字符串


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

int()将2个字符串或数字传换来整数,int(x, base=拾)

credits

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

  创立并回到三个字典对象。初叶化参数能够有几种传播方式。

  关键字方式,将一向依照重大字生成字典

  迭代器格局,迭代器中的对象必须唯有七个元素,第3个元素将作为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}

float()将整数和字符串转变来浮点数

delattr( object, name)

与setattr()相对的,参数是贰个对象和3个string.string必须是指标的2性子情。函数删除object那几个名称为string的习性。例如,delattr(x,
‘foobar’)等价于del x.foobar

dict(\*kwarg)  dict(mapping, **kwarg【亚洲必赢官网】第八伍章,內建函数。)  dict(iterable, **kwarg*)

  创立并赶回二个字典对象。初叶化参数可以有两种传播方式。

  关键字方式,将一向依据重点字生成字典

  迭代器格局,迭代器中的对象必须唯有五个因素,第1个要素将作为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']

complex()用于成立2个复数,形如real+imag*j

dict( [arg])

以3个可选的地点参数或一组第3词参数开首化一个字典。假若未有付诸参数,重临三个空的字典。假如地点参数arg是三个辉映对象,再次来到3个字典映射与映射对象同样的keys对应1律的值。那么地点参数应是二个队列,援助迭代的器皿,或然是三个迭代指标。参数的每一个因素也非得是在那之中的一种,同时每3个暗含四个指标。第3个作为新字典的key,同时第3个作为这么些key的值。即使给定的key不只出现一次,那新字典将包罗最终三个值。

假若给出的是第一词参数,关键词和与其相关的值都将作为字典的项增加到字典中。借使三个ke既作为职责参数和当作1个至关心器重要词参数,关键词关联的值将保留在字典中。

亚洲必赢官网 5

再次回到都等价于{“one”: 二, “two”: 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)

chr() 将0~255限制内的平头转变为对应的ascii字符

dir( [object])

1经未有参数,再次来到当前local符号表中名字的列表。要是有叁个参数将尝试再次回到那一个参数对象的管事属性。从指标的__dict__(假诺定义了)属性,类或type对象搜罗新闻。那一个列表不自然是完好的。假设目的是1个模块对象,list包罗模块属性的列表。纵然指标是三个type或class对象,列表将含有属性的名字,同时递归其营地的特性。不然,列表将富含对象属性的名字,类天性的名字,递归若基类的质量名字。结果列表按字母逐一排序。

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)

  重返2个可迭代的枚举类型。

  迭代器中的对象,第二个因素为序号(私下认可从start=0发轫),第1个要素为流传迭代器中的对象。

  注: 多用于for遍历进程中,需求同时获得序号的图景。

>>> names = ['Tom', 'Jack', 'Lily']
>>> for i, name in enumerate(names, start=1):
...     print(i ,name)
... 
1 Tom
2 Jack
3 Lily

ord() 意义和chr()相反,以字符为参数,重返对应的ascii数值。

divmod( a, b)

用多个数字(不是复数)作为参数,重回long除法获得的商和余数组成的1对数字。使用混合的操作类型,混合的体系,将应用使用二进制算术操作。对于一般和长整数,结果与(a
// b, a % b)一样。对于浮点数结果和(q, a % b)同样,q平常是math.floor(a /
b),但要是是比一小,就为一.在任何情形下q * b + a % b与a很类似,倘若a %
b是非0的,它与b有一样的标识,同时0 <= abs(a % b) < abs(b).

亚洲必赢官网 6

divmod

enumerate(iterable, start=0)

  重回三个可迭代的枚举类型。

  迭代器中的对象,第1个因素为序号(暗许从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

bool()将加以参数转变为布尔类型,假设未有参数,再次来到False。bool是int的子类。

enumerate( iterable)

再次回到enumerate对象. iterable必须是二个种类, 贰个迭代,
大概其它对象它支持迭代.enumerate()重回的iterator的next()方法
再次来到一个元组包涵一定的数码(从0开端)和从迭代中赢得的照应的值。

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

str()将对象转化为适应阅读的方式

eval( expression[, globals[, locals]])

该参数是三个字符串和可选的globals和locals。如若提供globals,globals必须是二个字典。假如提供locals,locals能够是别的映射对象。

expression参数是作为二个Python表达式被解析和评价(手艺上来讲,1个原则列表)使用globals以及locals字典作为global和local名字空间。若是提供了globals字典但未有’__builtins__’,当前globals在表达式被解析前被复制到globals中。那意味表明式能够完全访问标准__builtin__模块和受限的环境。假若locals字典省略则默以为globals字典。假使七个字典都被简单,表达式在调用eval的环境中进行。再次来到值是持筹握算表明式的结果。语法错误报告为exceptions。
例如:

>>> x = 1

>>> print eval(‘x+1’)

2

此函数也得以用来举行任意代码的靶子(如compile()创制的)。在那种意况下,传入三个代码对象,而不是1个字符串。该代码对象必须已编写翻译传给’eval’作为那种参数。

提示:EXEC语句援助是动态试行语句。execfile()函数帮助从二个文件中试行语句。globals()和locals()函数分别再次来到当前的global和local字典,那对利用eval()或execfile()很有扶持

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

  将2个表示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]

列表、元组、字典相关函数

exec

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

  创设并回到3个浮点型的靶子。

  x可以为二个数要么四个意味浮点数的字符串,缺省值为0

>>> float(3)
3.0
>>> float('1.23')
1.23

dict() 生成字典,dict()生成空字典,dict(a=’e’, b=’f’,
c=’g’),传加入关贸总协定组织键字,{‘a’:’e’, ‘b’:’f’, ‘c’:’g’},dict(zip([‘one’,
‘two’, ‘three’], [1, 2, 3])),dict([(‘one’, 1), (‘two’, 2),
(‘three’, 3)])

exit()

退出

float([x])

  创立并再次回到三个浮点型的指标。

  x可认为二个数依然2个象征浮点数的字符串,缺省值为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'

list()将元组转变为列表

filter( function, iterable)

function重临true时从iterable的成分中布局3个列表。迭代能够是贰个行列,三个支撑迭代的容器,或二个迭代器,假如Iterable的是三个字符串或贰个元组,其结果也有那体系型的,不然它始终是1个列表。要是function是None,假定它是恒等函数,即,迭代是false其全部因素都被删去。

请留意,filter(function,iterable),借使函数不为None等价于[item for item
in iterable if function(item)],倘诺函数为None等价于[item for item in
iterable if item]。

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

tuple()将列表转变为元组

float(x)

将字符串或数字转变或一个浮点数。如若参数是3个字符串,它必须包蕴一个只怕带符号的10进制或浮点数,恐怕嵌入空格。不然,参数能够是贰个普通或长整数或浮点数,再次回到贰个与之相同值的浮点数(在Python的浮点精度内)。假若没有交到参数,重回0.0。

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

  获取对象的2本特性的值。

  假若目的存在该属性则重临属性值。

  要是属性不存在,当传了default时返回default的值,不然产生非凡。

  注:参数 name 是3个字符串

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

all(),any()的参数都以元组或列表,区别:all()假设具有因素都不是0、”、False或然iterable为空,再次来到True,不然重返False;any()倘若具备因素为空、0、False则赶回False,假如不都为空、0、False,则赶回True;all()参数是空驶列车表或空元组,重返True,any()再次来到False。

format

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

slice(stop),或slice(start, stop[, step])达成切成条对象。print([1, 2,
3, 4, 5, 6, 7][slice(3)])

frozenset( [iterable])

归来1个frozenset对象,其成分来自于Iterable。
Frozensets组未有更新的方法,但足以哈希和其余组成员或当作字典键使用。1个frozenset的因素必须是不行改造。内部sets也应是frozenset对象。如若迭代平昔不点名,再次回到八个新的空集,frozenset
([])。

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)

  判定3个对象是还是不是存在钦赐的习性。存在再次来到 True, 不然赶回
False

  **注: 参数*name *是3个字符串***


>>> class MyTest():
...     def __init__(self):
...         self.test = 'test'
... 
>>> a = MyTest()
>>> hasattr(a, 'test')
True
>>> hasattr(a, 'foo')
False

filter()用于过滤类别,函数重临filter对象

getattr( object, name[, default])

归来object名称为name属性的值。名称必须是二个字符串。倘诺该字符串是目的的个中属性名字,结果是该属性的值。例如,getattr(x,
‘foobar’)相当于x.foobar。要是钦赐的性质不存在,则赶回暗中同意提供的,不然抛出AttributeError

hasattr(object, name)

  推断二个目的是不是留存钦定的性质。存在再次回到 True, 不然赶回
False

  **注: 参数*name
*是2个字符串***


>>> class MyTest():
...     def __init__(self):
...         self.test = 'test'
... 
>>> a = MyTest()
>>> hasattr(a, 'test')
True
>>> hasattr(a, 'foo')
False

hash(object)

  再次来到1个目的的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'

eg。

globals()

回去代表当前global符号表字典的字典。那始终是时下模块字典(在二个函数或艺术内,是在它被定义的模块,而不是被调用的模块)。

hash(object)

  重临一个目的的hash值,假设指标不可hash会时有爆发11分。

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

def is_odd(n):

      return n % 2 == 1

aList = filter(is_odd, [1, 2, 3, 4, 5, 6, 7])

print(list(aList))

hasattr( object, name)

该参数是3个对象和八个字符串。要是字符串是目的的中间八天性格,结果为True,假设未有回去False。
(那是透过调用的getattr(对象名称),看是还是不是引发那几个与否。)

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的1六进制字符串,字符串以’0x’伊始,字符串中的字符都是小写方式表示。

  当x不是二个int型对象时,则对象必须定义三个__index__()
方法,则赶回整型值,不然将发出相当。

>>> hex(64)
'0x40'
>>> hex(-10)
'-0xa'

迭代相关函数

hash()

重临对象(倘诺有的话)的哈希值。哈希值是整数。它们被用来在词典查找时,作为多个高效相比较字典keys键。具有一样的哈希值,数值相等(固然它们属于差别的品类,因为是一和一.0的意况)。

hex(x)

  重临x的1六进制字符串,字符串以’0x’开端,字符串中的字符都以小写格局表示。

  当x不是八个int型对象时,则对象必须定义多少个__index__()
方法,则赶回整型值,不然将时有产生相当。

>>> hex(64)
'0x40'
>>> hex(-10)
'-0xa'

id(object)

  重回对象的内部ID值。

>>> id(123)
10923328
>>> id('test')
140589176043704
>>> id([1,2,3])
140589199591816

next(iterator[,defaul]) 再次来到迭代器的下一个品种。

help(object)

调用内置的帮助系统。
(此功效是为相互使用。)借使未有交给参数,交互式帮忙系统运营解释调整台。假若参数是二个字符串,然后是字符串被视作3个module,function,class,method,keyword或文档焦点名称和救助页面名字实行搜索后在调节台上打印出来。若是参数是其他其余品种的指标,将发出该指标的3个救助页面。

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'

sorted(iterable, key=None,
reverse=False),key用来进展相比较的因素,钦命可迭代对象的2个要平昔展开排序,reverse排序规则,True为降序,False为升序。和list.sort()的差距:sorted会修改原始的list,list.sort()重返为None;其它list.sort()只为list定义,sorted函数能够承受任何iterable。eg:print(sorted({一:’A’,
二:”B”, 3:”C”}))

hex(x)

改造1个(任意大小)整数为十陆进制字符串。

 input([prompt])

  接收标准输入转为字符串并赶回。

  prompt
为输入提醒字符串,能够简简单单。

  注:壹经读到 EOF 将发出分外。

>>> s = input('Enter: ')
Enter: hello
>>> s
'hello'

 int(x=0)  int(x, base=10)

  重返三个整型数。输入参数能够是三个数要么三个字符串(当然能够是别的对象,但那里不上课这种雷人用法)。

  参数为多少个数时,重回对象的__int__()方法的值,对于整型对象正是小编的值,对于浮点型对象正是整数片段。

  参数为二个字符串时,字符串必须代表3个贰、八、10、1陆进制,并传播相应的base值。

>>> int(3)
3
>>> int(1.25)
1
>>> int('101', 2)
5
>>> int('54', 8)
44
>>> int('123', 10)
123
>>> int('F3', 16)
243

iter()用于转移迭代器

id(object)

归来对象的“identity”。那是二个平头(或长整型),这是保障是唯一的,与目的的生命周期同样长。多少个非重叠的生命周期的对象或者有同等的ID()值。
(完结注意:那是目的的地址。)

 int(x=0)  int(x, base=10)

  再次来到一个整型数。输入参数能够是八个数仍旧二个字符串(当然能够是别的对象,但这边不上课那种杀马特用法)。

  参数为二个数时,重返对象的__int__()方法的值,对于整型对象正是本人的值,对于浮点型对象正是整数片段。

  参数为二个字符串时,字符串必须代表多个二、八、十、1陆进制,并传播相应的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
参数是2个元组,那么一旦对象属于中间的叁个类即再次回到 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

面向对象相关函数

input()

赢得用户输入的值

 isinstance(object, classinfo)

  推断指标是还是不是属于内定的类。(能够协作 type 使用)

  注1: 假若内定类是当下目的的父类,判别结果也是 True

  **注2: 如果* classinfo 参数是叁个元组,那么壹旦对象属于内部的3个类即重回 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

setattr(object, name, value),getattr(object,
name)用于安装和获得属性,该属性必须存在。hasattr(object,
name)用于剖断属性是还是不是留存。

int( [x[, radix]])

退换为字符串或数字为纯整数。借使参数是3个字符串,它必须含有四个大概有标记的10进制数作为1个Python整数,大概嵌入空格。以radix参数给出的基数为根基举行转移(那是私下认可10),能够是别的在[2,36]限制内的平头,或零。如若基数为零,依照字符串的始末臆度正确的基数。假诺钦定的基数x是还是不是八个字符串,引发TypeError格外。不然,参数能够是贰个平时或长整数或浮点数。调换浮点数截断为整数(直到零)。如若参数是整数范围之外的,将回到贰个long
object。借使未有交到参数,再次回到0

issubclass(class, classinfo)

  判别多个类是不是为内定类的子类。

  注1: 类都以本人的子类

  注2: 如果 classinfo 参数是3个元组,那么只要类属于内部四个类的子类即重回
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])

  重返四个迭代器对象,用于遍历,1般与 next() 合作使用。

  要是 sentinel 参数没有传来则 object 必须是2个可迭代的靶子。

  假设 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()

delattr(object, attr) 用于删除属性

isinstance( object, classinfo)

归来true要是该object参数是classinfo的多少个实例,或其(直接或直接)子类的实例。也回到true要是classinfo是一种type对象(new-style
class)和是该项目或其(间接或间接)子类的靶子。假使object不是class多个的实例大概给定类型的对象,函数重临false。若是classinfo既不是1个类的目的也不是一个type的靶子,它也许是3个包涵类或项指标目的的tuple,也大概带有其余的递归元组(系列类型不接受)。要是classinfo不是二个类,类型或元组类,类型,只怕那种元组,将抛出八个TypeError格外。

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

hasattr(object, attr)用于剖断1个目的是否有某一性质

issubclass( class, classinfo)

再次来到true假若class是classinfo(间接或直接)的子类。2个类被以为是友善的子类。
classinfo恐怕是类对象元组,在这种景色下元组中的每种classinfo项将被开始展览测试。在任何任何景况下,抛出多个TypeError万分。

len(s)

  重返对象的长短。对象壹般是二个行列和2个集合。

  假诺是别的对象,则对象必须蕴含 __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]

id()用于获取对象的内部存款和储蓄器地址

iter( o[, sentinel])

归来3个迭代器对象。第二个参数有两样的分解,视第一个参数的留存与否而定。假若未有第二个参数,o必须是三个目的的集纳,帮忙迭代协议(__iter__()方法),大概它必须帮助体系协议(以整数0初阶的参数__getitem__()方法)。假诺它不支持那一个协议,将抛出TypeError卓殊。借使第三个参数,sentinel,给出,然后o必须是可调用的靶子。在那种场所下开创的每三个迭代器无参调用o它的next()方法,假若再次回到值等于sentinel,将抛出StopIteration,不然将回到别的的值。

list([iterable])

  创制并赶回1个列表对象。假如未有传到参数,则赶回二个空驶列车表。

  传入的参数必须是3个可迭代的,迭代器中的每3个目的将用作列表的3个要素。

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

isinstance()
用于判定三个对象是还是不是是某1类别,类似type,但type不会以为子类是父类类型,isinstance会以为子类是父类类型

len(s)

回去2个目的的长度。参数能够是一个队列(字符串,元组或列表)或映射(词典)。

locals()

  重临当前定名空间的{对象: 值} 字典。

>>> def foo():
...     i = 1
...     j = 2
...     k = 3
...     print(locals())
... 
>>> foo()
{'i': 1, 'k': 3, 'j': 2}

map(function, iterable, …)

  再次来到二个迭代器。迭代器中的每1个对象将是传播的迭代器依照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

issubclass(B, A)用于剖断B是不是是A的子类,A、B都以类名

license

map(function, iterable, …)

  再次来到3个迭代器。迭代器中的每1个指标将是流传的迭代器根据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 能够改变暗许的可比艺术。

  当传入的是1个迭代器时,即使迭代器为空,则赶回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'

super() 用于调用父类的2个方法

list( [iterable])

回来二个列表的items与可迭代的品类1律的逐条且同样的items。可迭代能够是八个行列,二个器皿,支持迭代,或3个迭代器对象。借使可迭代已经是2个列表,将赶回1个别本,类似的于iterable[:]。例如,list(‘abc’)返回[‘a’,
‘b’, ‘c’]和list( (1, 2, 3) )
返回[1,2,3]。假如未有交给参数,重临四个新的空驶列车表,[]。

max(iterable [, key, default])  max(arg1, arg2, \args [, key]*)

  重临最大值。要比较的参数能够是二个可迭代的目的,也得以平素传入对象列表。

  参数 key 能够更动私下认可的可比艺术。

  当传入的是3个迭代器时,要是迭代器为空,则赶回default值,如若未有传到default将发出13分。

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

  再次来到多个内部存款和储蓄器观看对象。传入的对象必须援救缓冲区商谈,内建指标中援助的有
bytesbytearray

  内部存款和储蓄器观看对象提供3个共享的内部存储器,能够在不要求复制的景色以差别的不二法门访问共享内部存款和储蓄器。在大气数据处理时相比有用。

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

staticmethod修饰符,注解静态方法,类不须要实例化就能够调用该格局。

locals()

履新并回到一个意味着当前local符号表的字典。警告:本词典的内容不应当被改变,改换大概不会影响由interpreter用作一些变量的值。

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'

classmethod修饰符,注明类方法,类措施的第贰个参数是cls,和实例方法的self意义同样。即使有持续关系,子类方法调用类方法时,传递的类变量cls时子类,而非父类。

map( function, iterable, …)

选取function在iterable的每三个项上并重回3个列表。借使有别的可迭代的参数,函数必须选取多数参数应用于来自全体iterables项。如果四个迭代比另2个短,将以None实行增加。假如function是None,将要是为identity
function,要是有两个参数,map()重返一个列表包涵全数iterables相应的花色的元组组成。可迭代的参数只怕是三个连串或任何可迭代的靶子,结果总是叁个列表。

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'

class A:

       @classmethod

        def cm(cls):

              print(‘类方法调用者:’, cls.__name__)

        @staticmethod

        def sm():

              print(‘静态方法调用’)

class B(A):

       pass

A.cm()

B.cm()

A.sm()

B.sm()

max( iterable[, args…][key])

1个Iterable参数,再次来到在那之中贰个最大的非空可迭代项,(如3个字符串,元组或列表)。如有多少个参数,再次回到最大的参数。

可选的key参数钦赐带3个参数的排序函数,用于list.sort()。key参数,如若有,必须在以keyword的格局(例如,”max(a,b,c,key=func)”)。

next(iterator [, default])

  重回迭代器中的下2个。一般与 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__']

其它

memoryview

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不是2个int型对象时,则对象必须定义1个__index__()
方法,则赶回整型值,不然将时有发生格外。

>>> oct(10)
'0o12'
>>> oct(16)
'0o20'

open()用于张开1个文书,制造3个file对象

min( iterable[, args…][key])

3个Iterable参数,重返当中三个微细的非空可迭代项,(如一个字符串,元组或列表)。如有四个参数,再次来到最小的参数。

可选的key参数钦定带三个参数的排序函数,用于list.sort()。key参数,倘诺有,必须在以keyword的样式(例如,”max(a,b,c,key=func)”)。

oct(x)

  再次来到x的八进制字符串,字符串以’0o’初叶,字符串中的字符都以小写方式表示。

  当x不是2个int型对象时,则对象必须定义1个__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

format()格式化函数

next

open(file, mode=’r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

  展开3个文件,再次来到一个文件的目的。open的选取11分足够,那里为扫盲,只表达最常用最基本的用法。

  参数 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'

zip()将可迭代的指标作为参数,将对象中对应的成分打包成3个个元组,然后重返zip对象。假使各个迭代器的要素个数差异样,则zip对象涵盖的列表长度与最短的对象同样,利用*号操作符,能够将元组解压为zip对象。

object()

归来一个新特色的指标。object是享有new style
class的基类。它的措施是新样式类的有所实例共有的。

ord(c)

  重回字符的unicode码,该函数是chr()反向操作。

  注: 参数必须是10足的字符

>>> ord('a')
97
>>> ord(chr(99))
99
>>> chr(ord('k'))
'k'

pow(x, y [, z])

  求 xy 次方。结果一定于  x \* y*

  假诺传入了参数 z,则也就是 (x \* y) % z*

  **注:*  如果 y 是负数,则不能够传回 z


>>> pow(2, 3)
8
>>> pow(2, 4, 5)
1

a = [1, 2, 3]

b = [‘one’, ‘two’, ‘three’]

zipped = zip(a, b)

zipList = []

for it in zipped:

     print(it)

     zipList.append(it)

print(zipList)

for it in zip(*zipList):

     print(it)

oct(x)

改变一(任意大小)整数到三个八进制字符串。

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

range(stop)

open( filename[, mode[, bufsize]])

开发三个文书,`File
Objects’。假若文件不能够开采,IOError卓殊引发。当张开2个文本,最佳调用open(),而不是直接用file构造。

前三个参数与stdio的fopen()函数一样:filename是要张开的公文名,mode是八个字符串,表示该文件是何等被张开。

mode,最常用的值是’r’读,’w’写(文件借使已存在就截断),和’a’追加(在局部Unix系统意味着全部写入追加到文件尾巴部分,无论其以后的seek地方)。若是方式被简单,默感到’r’等。当张开2个②进制文件,你应当情势值加上’b’,张开二进制格局,从而进步可行性。
(在某个不区分二进制文件和文件文件的系统扩张‘b’,,它将用作文书档案)。下边是mode的或是值:

可选bufsize参数钦赐文件的所需缓冲区大小:0代表无缓冲,1象征行缓冲,任何此外的正数使用其尺寸(在约)的二个缓冲区。负数bufsize,使用系统私下认可,那tty设备平日选取行缓冲和别的文件的完全缓冲。如若轻松,使用系统暗许。

形式’r+’,
‘w+’和’a+’张开文件进行立异(请留意,’w+’截断该文件)。附加’b’的格局在分别二进制和文书文件的系统上以二进制方式张开文件,系统上从未有过那几个不相同,插手了’b’未有效果。

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)

  属性装饰器。能够壹本万利的走访对象的某些属性,制止直接操作内部属性。

  函数重回3个装修属性,将波及 fget, fset, fdel 函数

  参数doc提供3个推抢新闻。

  当用@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(start, stop[,step])

ord(x)

给定3个尺寸为一的字符串,再次回到1个平头,当参数是二个Unicode对象,代表字符的Unicode代码,或参数是1个五人字符串,代表其字节值,。例如,ord(‘a’)重回整数玖柒,ord(u’\u2020′)重临82二四。那是6人串chr()和用来Unicode对象的unichr()的逆函数。要是给出Unicode参数和Python是UCS二Unicode的,字符的代码点必须在界定[0 ..
65535]内,不然字符串的长度是二,抛出3个TypeErro。

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值), 步进为壹

  当有四个参数时,连串为start到stop(不包涵stop值),步进为一

  七个参数时,就可以自定义步进

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

回去可迭代对象,start默以为0,step默感觉壹。

pow( x, y[, z])

再次来到x的Y次方,假设给出z,重返x的y次方,模Z(比pow(x, y) %
z更实惠)的。那多个参数的款型pow(x, y),相当于:x ** y

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'

print()

打印

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]

property( [fget[, fset[, fdel[, doc]]]])

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

quit

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

  成立二个聚集对象。假如没有参数则创立3个空集合。

  参数必须是可迭代的。迭代器中的相同的指标将只会保留一个。

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

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

那是2个通用函数来创立包罗算术级数的列表,那是时常选拔于循环。该参数必须是习认为常整数。假诺step参数被略去,默感到一。若是轻松start参数,默以为0。step不可能为零(不然引发ValueError)

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 是3个字符串***


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

reduce()

reduce函数会对参数体系兰月素进行累积

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

  生成1个分片对象。用于对队列举行分片。

  当唯有八个参数时,类别为0到stop(不包罗stop值), 步进为壹

  当有四个参数时,种类为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]

repr(object)

归来多个字符串,在那之中饱含三个目的的可打印情势。有时是对能够访问贰个普通的函数的操作很有用。对于多数门类,该函数使得试图重回1个字符串,会产生3个目的与传递给eval()一样的值爆发的靶子同样。

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

  生成一个分片对象。用于对队列举办分片。

  当唯有1个参数时,类别为0到stop(不包蕴stop值), 步进为1

  当有七个参数时,种类为start到stop(不包罗stop值),步进为壹

  多个参数时,就能够自定义步进

  可是貌似能够直接在连串中用分片语法,例如 a为3个列表,分片语法为:
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']

reversed(seq)

回到二个反向迭代器。seq必须是叁个援助类别协议的指标(__len__()方法和__getitem__()以0伊始的平头参数的章程)

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

round( x[, n])

回来浮点值x四舍伍入到小数点后n位后数字。要是n被轻便,私下认可为零。结果是三个浮点数。

staticmethod(function)

  1般作为函数装饰器使用 @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’)

  创制并回到1个字符串对象。

  能够行使内定的靶子来起初化。伊始化将运用对象的 __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'

set( [iterable])

回来其成分都以从iterable获得的set。元素必须是不行退换的。假若iterable未有点名,重临一个新的空集,设置([])

str(object=”)  str(object=b”, encoding=’utf-8′, errors=’strict’)

  成立并回到3个字符串对象。

  能够运用钦赐的靶子来伊始化。开首化将动用对象的 __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])

  对2个系列求和。

  参数start, 内定一个初叶值,私下认可是0

>>> sum(range(5))
10
>>> sum(range(5), 3)
13
>>> sum({1,2,3})
6

setattr( object, name, value)

与getattr()相呼应。该参数是贰个目的,三个字符串和一个任意值。该字符串能够是存活属性名称或一个新的天性。函数分配给该属性值,只要该指标允许的话。例如,setattr(x,
‘foobar’, 12三),相当于x.foobar = 1二三。

sum(iterable [, start])

  对二个体系求和。

  参数start, 钦命1个初步值,暗许是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

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

回到多少个切块对象,它意味着的是range(start, stop,
step)钦赐的限量。start和step参数默以为None。切条对象有只读数据属性start,stop和step,它只是回去参数值(或默许)。未有别的鲜明的机能,但它们的作为数值Python和任何第2方扩充使用。当使用增添索引语法时也产生切成条对象。例如:“a[start:stop:step]”或“a[start:stop,
i]”。

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

sorted( iterable[, cmp[, key[, reverse]]])

回去一个新的排序的列表,包括Iterable的项。

可选参数cmp,key,reverse与list.sort()具同样涵义

cmp钦命带三个参数(Iterable的因素),再次来到自三个负数,零或正数的函数“cmp=lambda
x,y: cmp(x.lower(), y.lower())“。

key钦点带四个参数的函数,用来从列表每种成分中领取二个比较key:“key=str.lower”

reverse是1个布尔值。假如设置为True,则对列表中的成分进行排序,同时每一遍相比都以逆向的。

诚如来讲,key和reverse转换进度是遥远快于钦命3个一定于cmp的意义。那是因为cmp是为各样列表成分调用数次,而key和reverse接触各个成分唯有1遍。

tuple([iterable])

  成立并再次回到3个元组对象。

  能够行使2个可迭代对象伊始化元组。

>>> tuple(range(5))
(0, 1, 2, 3, 4)
>>> tuple('test')
('t', 'e', 's', 't')

type(object)  type(name, bases, dict)

  七个效用。传入的参数个数区别,效用不1

  贰个参数时,再次回到对象所属的类。

  多少个参数时,动态创造三个自定义类的目的。

  当必要动态创立两个类时,

  参数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.

staticmethod( function)

函数重回贰个静态方法。静态方法未有收取二个含有的第3个参数

type(object)  type(name, bases, dict)

  五个功效。传入的参数个数分歧,功效各异

  三个参数时,再次来到对象所属的类。

  四个参数时,动态创立七个自定义类的靶子。

  当须要动态创造三个类时,

  参数name, 类名

  参数bases, 类的基类,使用2个元组传入,因而得以有八个父类。

  参数dict, 类的习性和措施字典。{属性名=属性值,方法名=函数名},
在那之中“函数名”是四个壹度定义的函数

  注: 直接通过字典传入的方法是1个静态方法。

>>> 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__'}

str( [object])

回去多个字符串,在那之中包含对象可打字与印刷的叙述。对于字符串,那将重回字符串本人。与repr(object)区别的是,str(object))并不一而再试图再次回到四个eval()能够承受的字符串,其指标是回到一个可打字与印刷字符串。要是未有提交参数,再次来到空字符串,”。

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

  将三个连串举办重新组合,重临2个元组列表。

  各个元组从各种类别中各提取二个值。因而元组的个数由最短的队列决定。

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

 

): 内建函数扫除文盲,python叁.x
Built-in Functions abs() dict() help() min() setattr() all() dir() hex()
next() slice() any() divmod() id() object() sorted() a…

sum( iterable[, start])

求start和可迭代的从左至右的项和并回到总和。start默以为0。在可迭代的项,日常是数字,不能够是字符串。快捷,正确的连天的字符串连串的主意是透过调用”.join(sequence)。注意sum(range(n),
m)相当于reduce(operator.add, range(n), m)

zip(\iterables*)

  将八个体系进行重新组合,再次来到贰个元组列表。

  每种元组从种种种类中各提取1个值。因而元组的个数由最短的队列决定。

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

 

super( type[, object-or-type])

回来类型的超类。借使第一个参数被归纳,重回的特级对象是未绑定。假设第三个参数是一个指标,isinstance(obj,
type)必须是true。假诺第一个参数是二个品类,issubclass(type二,
type)必须是true。super() 只好用来最新类。

tuple( [iterable])

回去贰个元组的items与可迭代的iterable是同等的且有一样的顺序。iterable恐怕是3个队列,容器援助迭代,或迭代器对象。假使iterable已是元组,间接重回。例如,tuple(‘abc’)重回(‘a’,
‘b’, ‘c’) 和tuple([1, 2, 3])再次来到(一, 2,
三)。如若未有提交参数,重临一个新的空元组,()。

type( object)

回去对象的品类。再次回到值是1个类别对象。

vars( [object])

假使未有参数,依照现行反革命的local符号表再次来到3个字典。假如是二个模块,类或类的实例对象作为参数(或任何任何有__dict__性情),依据目的的符号表再次来到多个字典。重返的字典不应被被涂改:在对应符号表上的震慑是未定义的。

zip( [iterable, …])

以此函数重临一个元组列表,个中的第i元组包括每多个队列或iterables的第i个成分。重返的列表被截断长度为参数最短的行列的长度。当有多个参数是如出一辙长度,zip()类似于用无参数早先化的map()
。3个独自种类参数,它回到三个元组的列表。不带参数,它回到一个空驶列车表

网站地图xml地图