威尼斯人线上娱乐

【威尼斯人线上娱乐】放到函数,內建函数

20 4月 , 2019  

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规范库(3.x): 内建函数扫盲,python3.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)

回到一个数的相对值。参数可能是三个日常或长整型,大概二个浮点数。若是参数是一个复数,再次来到它的积。

 

abs(x)

  求2个数的相对值。

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

数学函数

2.all(iterable)

万1迭代的拥有因素都以真就重临真。

abs(x)

  求1个数的相对值。

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

壹经迭代中有3个成分为真就回到真。

威尼斯人线上娱乐 1

all any

all(iterable)

  假设迭代器中的全数值都为“真”则赶回 True, 不然赶回
False

  注意:
要是迭代器为空,再次回到 True

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

any(iterable)

  倘使迭代器中的任性1个值为“真”则赶回 True, 不然赶回
False

  注意: 只要迭代器为空,再次回到 False

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

min()求最小值

ascii

any(iterable)

  假诺迭代器中的任意3个值为“真”则赶回 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__()
方法重回的值调换为2进制字符串

  注意: 倘使目的未有__index__() 方法,将会时有产生万分

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

hash()获取1个目的(字符串或数值)的哈希值

bool([x])

将多个值转变为Boolean,使用规范的真测试程序。固然x是假或马虎了,将重临False;不然将回来True.bool也是3个class,它是int的八个子类,bool类无法进一步子类化。它仅有False和True五个实例。

威尼斯人线上娱乐 2

bool

bin(x)

  将整型调换为2进制的字符串,字符串以’0b’ 开始.

  可是身为将整型转变为2进制,其实是将对象的__index__()
方法再次回到的值调换为贰进制字符串

  注意: 假若目的未有__index__() 方法,将会爆发11分

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

  创造贰个 “可变的”
byte数组,能够利用整型,字符串和迭代器来开始化

  参数为字符串时,字符串中的每1个字符将改造为数组的要素,由此供给提供编码类型,类似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')

sum(),对队列举行求和

bytes

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

  创立三个 “可变的”
byte数组,能够行使整型,字符串和迭代器来早先化

  参数为字符串时,字符串中的每1个字符将退换为数组的成分,因而需求提供编码类型,类似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舍伍入,n表示小数点后留下位数,默以为0.

callable(object)

要是object参数能够调用就回到True,不然重返False。假诺回到True,它如故恐怕调用退步,不过只要回到False,就长久不容许调用成功。注类是可调用的(调用三个类重回2个实例);类的实比借使有1个__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(玖7)再次回到string
‘a’.那和ord()刚好相反。

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)

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

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

  将类中的2个办法钦点为类情势。被钦点的类措施第二个参数必须为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为三个代码对象。代码对象能够通过exec语句试行可能经过调用eval()总结。那filename参数钦定代码从哪个文件读取。借使不从文件中读取,就须传递一些可识其他值(常常选拔”)。kind参数钦定哪一种代码被编译;假若是带有一多种语句组成的子符串能够‘exec’,要是是由一个表明式组成,就’eval’,若是由三个相互语句组成就‘singlw’(表明式语句总括的结果不是None将打字与印刷出来)。

当编写翻译一个多行语句时,应用四个警示:必须以’\n’作为行截至符,同时输入必须至少以1个’\n’作为完结。倘使是以’\r\n’作为行终止,使用string的repalce()方法将其改为‘\n’.

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

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,结果1律

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

创办3个复数real + imag*j恐怕将3个string或然number转化为一个复数.
假若第3个参数是贰个字符串,它将用作复数解释,函数将被调用,而忽视首个参数。第一个参数不恐怕是3个字符串。每3个参数都大概是3个数字类型包罗复数.若是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]])

  重回1个复数。复数值为  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 是3个字符串


>>> 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()将二个字符串或数字传换到整数,int(x, base=10)

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

  成立并回到1个字典对象。伊始化参数能够有二种传播格局。

  关键字格局,将直接依据首要字生成字典

  迭代器格局,迭代器中的对象必须唯有五个要素,第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必须是目标的三个属性。函数删除object那么些名字为string的天性。举个例子,delattr(x,
‘foobar’)等价于del x.foobar

dict(\*kwarg)  dict(mapping, **kwarg)  dict(iterable, **kwarg*)

  创立并回到2个字典对象。起先化参数能够有三种传播情势。

  关键字情势,将直接依据重大字生成字典

  迭代器格局,迭代器中的对象必须唯有八个成分,第三个因素将用作key,第三个作为值

  映射情势,其实也是1种迭代器格局

  注: 当然也得以直接动用字典作为参数来初步化

>>> 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()用于成立二个复数,形如real+imag*j

dict( [arg])

以三个可选的职位参数或壹组第1词参数开端化多少个字典。假如未有付诸参数,再次回到叁个空的字典。假诺地点参数arg是八个映射对象,再次来到二个字典映射与映射对象一样的keys对应平等的值。那么地方参数应是一个行列,扶助迭代的容器,大概是三个迭代目的。参数的每个要素也亟须是中间的壹种,同时每二个包括四个对象。第二个作为新字典的key,同时第3个作为那么些key的值。如若给定的key不只出现2遍,这新字典将含有最终2个值。

倘使给出的是必不可少词参数,关键词和与其连带的值都将作为字典的项增多到字典中。若是三个ke既作为任务参数和当作贰个第2词参数,关键词关联的值将保存在字典中。

威尼斯人线上娱乐 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])

假设未有参数,重回当前local符号表中名字的列表。倘诺有二个参数将尝试再次来到那些参数对象的管用属性。从目标的__dict__(假如定义了)属性,类或type对象收罗音讯。那个列表不必然是总体的。假设目的是叁个模块对象,list包括模块属性的列表。假如目标是3个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)

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

  迭代器中的对象,第一个因素为序号(暗中认可从start=0开始),第二个要素为流传迭代器中的对象。

  注: 多用于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除法获得的商和余数组成的一对数字。使用混合的操作类型,混合的品种,将选拔使用二进制算术操作。对于一般和长整数,结果与(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)

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

  迭代器中的对象,第2个要素为序号(暗中同意从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必须是三个队列, 2个迭代,
只怕其余对象它支持迭代.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]])

  将2个意味着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]])

该参数是2个字符串和可选的globals和locals。若是提供globals,globals必须是一个字典。假若提供locals,locals能够是其余映射对象。

expression参数是用作三个Python表明式被分析和商酌(才干上来说,三个准绳列表)使用globals以及locals字典作为global和local名字空间。尽管提供了globals字典但未有’__builtins__’,当前globals在表明式被解析前被复制到globals中。那表示表明式能够完全访问规范__builtin__模块和受限的条件。假设locals字典省略则默以为globals字典。假设七个字典都被回顾,表达式在调用eval的条件中实施。再次来到值是总括表明式的结果。语法错误报告为exceptions。
举个例子:

>>> x = 1

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

2

此函数也足以用来进行放4代码的对象(如compile()成立的)。在那种情形下,传入一个代码对象,而不是2个字符串。该代码对象必须已编译传给’eval’作为那种参数。

唤醒:EXEC语句匡助是动态实施语句。execfile()函数帮忙从三个文书中实施语句。globals()和locals()函数分别重返当前的global和local字典,那对选拔eval()或execfile()很有扶助

 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]

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

exec

filter(function, iterable)

  将2个可迭代的对象按传入的函数实行过滤。函数重临 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可以为3个数要么二个意味浮点数的字符串,缺省值为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可以为三个数要么几个表示浮点数的字符串,缺省值为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])

  传入3个可迭代的目的,成立四个不可变的集聚。除了成分无法加多删除此之外,其余和可变集结类似。

  如若未有参数,则创立三个空集结。

>>> a = frozenset([1,2,2,3,4,5])
>>> a
frozenset({1, 2, 3, 4, 5})
>>> 2 in a
True

tuple()将列表调换为元组

float(x)

将字符串或数字转变或八个浮点数。借使参数是二个字符串,它必须蕴含五个大概带符号的十进制或浮点数,恐怕嵌入空格。不然,参数能够是1个平凡或长整数或浮点数,重回2个与之一样值的浮点数(在Python的浮点精度内)。若是未有交到参数,重回0.0。

frozenset([iterable])

  传入一个可迭代的靶子,创建1个不可变的聚众。除了成分不能够增加删除此之外,别的和可变集结类似。

  如若未有参数,则创建1个空会集。

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

all(),any()的参数都以元组或列表,不一样:all()要是具备因素都不是0、”、False可能iterable为空,重返True,不然再次来到False;any()假设具备因素为空、0、False则赶回False,假使不都为空、0、False,则赶回True;all()参数是空驶列车表或空元组,重返True,any()重临False。

format

getattr(object, name [, default])

  获取对象的1脾气质的值。

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

  纵然属性不设有,当传了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'

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

再次来到叁个frozenset对象,其成分来自于Iterable。
Frozensets组未有革新的措施,但能够哈希和其他组成员或当作字典键使用。一个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)

  判别一个对象是还是不是存在钦点的特性。存在重返 True, 不然赶回
False

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


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


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

hash(object)

  重返3个对象的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符号表字典的字典。那始终是时下模块字典(在2个函数或艺术内,是在它被定义的模块,而不是被调用的模块)。

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.

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)

该参数是1个目标和1个字符串。假设字符串是目的的个中一性格质,结果为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__()
方法,则赶回整型值,否则将发生10分。

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

迭代连带函数

hash()

回到对象(如若有些话)的哈希值。哈希值是整数。它们被用来在词典查找时,作为贰个飞跃对比字典keys键。具备一样的哈希值,数值相等(即使它们属于不一致的连串,因为是一和1.0的景色)。

hex(x)

  重回x的1陆进制字符串,字符串以’0x’开头,字符串中的字符都以小写形式表示。

  当x不是3个int型对象时,则对象必须定义三个__index__()
方法,则赶回整型值,否则将发生11分。

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

id(object)

  再次来到对象的当中ID值。

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

next(iterator[,defaul]) 重临迭代器的下2个档期的顺序。

help(object)

调用内置的声援系统。
(此成效是为互相使用。)假诺未有付诸参数,交互式扶助系统运转解释调节台。如若参数是三个字符串,然后是字符串被当做四个module,function,class,method,keyword或文档大旨名称和援救页面名字实行查找后在调节台上打字与印刷出来。如若参数是任何其余门类的对象,将发生该目标的二个扶持页面。

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用来张开相比的因素,钦点可迭代对象的三个因从来进行排序,reverse排序规则,True为降序,False为升序。和list.sort()的区分:sorted会修改原始的list,list.sort()重返为None;别的list.sort()只为list定义,sorted函数能够承受任何iterable。eg:print(sorted({壹:’A’,
贰:”B”, 3:”C”}))

hex(x)

改造二个(率性大小)整数为十6进制字符串。

 input([prompt])

  接收规范输入转为字符串并重返。

  prompt
为输入提醒字符串,能够总结。

  注:壹经读到 EOF 将产生13分。

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

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

  再次回到多个整型数。输入参数能够是3个数要么一个字符串(当然能够是其余对象,但那边不上课那种社会的遗弃者用法)。

  参数为二个数时,再次来到对象的__int__()方法的值,对于整型对象正是自身的值,对于浮点型对象正是整数部分。

  参数为一个字符串时,字符串必须代表1个二、八、十、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)

  重回1个整型数。输入参数能够是三个数照旧1个字符串(当然能够是任何对象,但这边不上课那种非主流用法)。

  参数为一个数时,重返对象的__int__()方法的值,对于整型对象正是自家的值,对于浮点型对象正是整数局地。

  参数为三个字符串时,字符串必须代表二个二、八、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
参数是二个元组,那么只要对象属于中间的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

面向对象相关函数

input()

获得用户输入的值

 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

issubclass(class, classinfo)

  判别二个类是还是不是为钦命类的子类。

  注1: 类都以自家的子类

  注2: 如果 classinfo参数是2个元组,那么壹旦类属于中间一个类的子类即再次来到 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]])

改动为字符串或数字为纯整数。假若参数是一个字符串,它必须带有二个大概有标识的十进制数作为四个Python整数,或许嵌入空格。以radix参数给出的基数为底蕴进行转变(这是暗中同意十),能够是其它在[2,36]限制内的平头,或零。假如基数为零,依据字符串的剧情估计准确的基数。假若钦定的基数x是或不是四个字符串,引发TypeError格外。不然,参数能够是3个一般或长整数或浮点数。转变浮点数截断为整数(直到零)。借使参数是整数范围之外的,将赶回1个long
object。纵然未有交到参数,重临0

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 必须是3个可迭代的目的。

  假使 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的3个实例,或其(直接或直接)子类的实例。也回到true假若classinfo是1种type对象(new-style
class)和是该品种或其(直接或直接)子类的目的。假设object不是class二个的实例恐怕给定类型的靶子,函数重临false。倘使classinfo既不是贰个类的对象也不是3个type的目的,它恐怕是多个暗含类或项目标靶子的tuple,也说不定包括其余的递归元组(连串类型不收受)。若是classinfo不是一个类,类型或元组类,类型,或许那种元组,将抛出三个TypeError格外。

iter(object [, sentinel])

  重临叁个迭代器对象,用于遍历,一般与 next() 合营使用。

  假使 sentinel 参数未有传到则 object 必须是3个可迭代的对象。

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

  重回对象的长度。对象一般是3个队列和1个汇合。

  假使是其余对象,则对象必须含有 __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(直接或直接)的子类。3个类被以为是和谐的子类。
classinfo或许是类对象元组,在那种情景下元组中的每种classinfo项将被举办测试。在此外任何情形下,抛出贰个TypeError卓殊。

len(s)

  重返对象的长度。对象一般是七个队列和1个晤面。

  要是是其余对象,则对象必须包涵 __len__()
方法,不然会时有产生13分。

>>> 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个参数有分歧的表明,视第1个参数的留存与否而定。假诺没有第二个参数,o必须是3个目的的聚焦,帮助迭代协议(__iter__()方法),大概它必须协助种类协议(以整数0始发的参数__getitem__()方法)。假若它不补助这几个协议,将抛出TypeError格外。如果第三个参数,sentinel,给出,然后o必须是可调用的目的。在那种情状下创设的每四个迭代器无参调用o它的next()方法,假设重临值等于sentinel,将抛出StopIteration,不然将回到别的的值。

list([iterable])

  制造并回到1个列表对象。借使未有传到参数,则赶回2个空驶列车表。

  传入的参数必须是二个可迭代的,迭代器中的每二个目的将用作列表的二个成分。

>>> 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()
用于剖断3个对象是还是不是是某壹门类,类似type,但type不会感觉子类是父类类型,isinstance会以为子类是父类类型

len(s)

回到二个目标的长短。参数能够是八个行列(字符串,元组或列表)或映射(词典)。

locals()

  再次回到当前定名空间的{对象: 值} 字典。

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

map(function, iterable, …)

  重返一个迭代器。迭代器中的每3个目的将是流传的迭代器根据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, …)

  重回一个迭代器。迭代器中的每三个目的将是流传的迭代器依照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 能够转移暗中认可的可比艺术。

  当传入的是2个迭代器时,借使迭代器为空,则赶回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() 用于调用父类的三个格局

list( [iterable])

再次来到三个列表的items与可迭代的体系同样的逐条且同样的items。可迭代能够是二个行列,1个容器,补助迭代,或1个迭代器对象。即使可迭代已经是贰个列表,将回到1个别本,类似的于iterable[:]。例如,list(‘abc’)返回[‘a’,
‘b’, ‘c’]和list( (1, 2, 3) )
返回[1,2,3]。假诺未有提交参数,重临三个新的空驶列车表,[]。

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

  再次回到最大值。要相比较的参数能够是1个可迭代的对象,也能够直接传入对象列表。

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

  再次来到贰个内部存款和储蓄器阅览对象。传入的目的必须协理缓冲区共同商议,内建目的中援救的有
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的每四个项上并回到2个列表。假若有其它可迭代的参数,函数必须运用大多参数应用于来自全部iterables项。要是一个迭代比另二个短,将以None实行扩张。假设function是None,将假诺为identity
function,借使有三个参数,map()重返3个列表包括全体iterables相应的品种的元组组成。可迭代的参数也许是3个队列或别的可迭代的目的,结果总是一个列表。

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

  重临迭代器中的下3个。一般与 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])

三个Iterable参数,重返个中二个最大的非空可迭代项,(如1个字符串,元组或列表)。如有多少个参数,重临最大的参数。

可选的key参数钦赐带3个参数的排序函数,用于list.sort()。key参数,纵然有,必须在以keyword的款型(举个例子,”max(a,b,c,key=func)”)。

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

其它

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的捌进制字符串,字符串以’0o’起头,字符串中的字符都是小写方式表示。

  当x不是叁个int型对象时,则对象必须定义2个__index__()
方法,则赶回整型值,不然将生出分外。

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

open()用于张开七个文书,创制2个file对象

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

多个Iterable参数,再次来到当中三个小小的的非空可迭代项,(如三个字符串,元组或列表)。如有多少个参数,再次来到最小的参数。

可选的key参数钦命带三个参数的排序函数,用于list.sort()。key参数,借使有,必须在以keyword的款式(举例,”max(a,b,c,key=func)”)。

oct(x)

  再次来到x的八进制字符串,字符串以’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)

  张开3个文件,重临1个文书的目的。open的运用异常足够,那里为扫除文盲,只表明最常用最中央的用法。

  参数 file, 文件名,路线可感到相对,也得以为相对。

  参数 encoding,以何种编码方式张开文件,比如 ‘utf-8‘,
gbk‘等。

  参数 mode,打开情势

    - ‘r’,  只读方式,若是文件不存在将生出十一分。

    - ‘w’, 
写格局展开,即便文件存在,最初的文章件将被掩盖,假使不设有将创建新文件。

    - ‘x’,创造1个新文件并张开,借使文件存在将生出至极。

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

  展开三个文本,重临三个文件的对象。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()反向操作。

  注: 参数必须是单1的字符

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

zip()将可迭代的目的作为参数,将目的中对应的成分打包成七个个元组,然后重返zip对象。如若各个迭代器的因素个数分化样,则zip对象涵盖的列表长度与最短的靶子同样,利用*号操作符,能够将元组解压为zip对象。

object()

归来1个新特色的靶子。object是富有new style
class的基类。它的措施是新样式类的具有实例共有的。

ord(c)

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

  注: 参数必须是单一的字符

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

改动1(任性大小)整数到一个捌进制字符串。

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

  打字与印刷函数。能够3遍打字与印刷多少个目的。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’等。当展开1个贰进制文件,你应当形式值加上’b’,展开贰进制格局,从而提升可行性。
(在少数不区分二进制文件和文书文件的连串扩张‘b’,,它将作为文书档案)。上边是mode的或是值:

可选bufsize参数内定文件的所需缓冲区大小:0代表无缓冲,1表示行缓冲,任何别的的正数使用其尺寸(在约)的2个缓冲区。负数bufsize,使用系统默许,这tty设备通常选取行缓冲和任何文件的一点1滴缓冲。假设轻易,使用系统暗许。

形式’r+’,
‘w+’和’a+’打开文件实行更新(请留意,’w+’截断该文件)。附加’b’的方式在分别2进制和文书文件的系统上以贰进制方式展开文件,系统上并未有这么些分歧,参预了’b’未有效劳。

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

  打字与印刷函数。能够3次打字与印刷多少个对象。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)

  属性装饰器。能够方便的访问对象的某部属性,防止直接操作内部属性。

  函数重返2个装修属性,将关联 fget, fset, fdel 函数

  参数doc提供1个相助消息。

  当用@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)

给定三个长短为壹的字符串,再次回到2个整数,当参数是三个Unicode对象,代表字符的Unicode代码,或参数是3个八位字符串,代表其字节值,。举个例子,ord(‘a’)重返整数九七,ord(u’\u2020′)重临82二四。那是5个人串chr()和用于Unicode对象的unichr()的逆函数。借使给出Unicode参数和Python是UCS二Unicode的,字符的代码点必须在界定[0 ..
65535]内,否则字符串的长短是二,抛出三个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])

  生成三个数字类别迭代器。

  当唯有2个参数时,种类为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默以为1。

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

  生成贰个数字系列迭代器。

  当只有1个参数时,连串为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]

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)

  重返1个队列逆序的迭代器。

  假设是自定义对象,须要完成 __reversed__()
方法或许帮助系列协议

>>> list(reversed([1,2,3,4,5]))
[5, 4, 3, 2, 1]

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

reversed(seq)

  再次来到1个类别逆序的迭代器。

  假若是自定义对象,须要贯彻 __reversed__()
方法如故支持类别协议

>>> list(reversed([1,2,3,4,5]))
[5, 4, 3, 2, 1]

round(number [, ndigits])

  保留钦定的小数位,重回3个最接近的数。

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

  创立贰个集聚对象。假设未有参数则创制一个空会集。

  参数必须是可迭代的。迭代器中的一样的对象将只会保留一个。

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

那是叁个通用函数来创制蕴含算术级数的列表,这是日常利用于循环。该参数必须是平时整数。就算step参数被回顾,默感到1。假如轻便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 是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'

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

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

  当唯有三个参数时,种类为0到stop(不包涵stop值), 步进为一

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

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

  但是貌似能够直接在系列中用分片语法,比方 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)

回到二个字符串,在这之中蕴藏一个对象的可打字与印刷格局。有时是对可以访问一个日常的函数的操作很有用。对于大多品类,该函数使得试图重回多少个字符串,会发出一个目的与传递给eval()同样的值发生的目的同样。

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

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

  当只有二个参数时,系列为0到stop(不包含stop值), 步进为一

  当有五个参数时,体系为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*)

  再次来到2个经过排序的列表。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被轻便,默以为零。结果是3个浮点数。

staticmethod(function)

  一般作为函数装饰器使用 @staticmethod 。类似 classmethod

  将类中的1个措施钦点为静态方法  

  静态方法的调用能够一向通过类调用,即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'

set( [iterable])

回来其成分都以从iterable获得的set。成分必须是不可改造的。如若iterable未有点名,再次回到1个新的空集,设置([])

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'

sum(iterable [, start])

  对四个连串求和。

  参数start, 钦点八个开首值,私下认可是0

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

setattr( object, name, value)

与getattr()相呼应。该参数是3个对象,贰个字符串和1个任性值。该字符串能够是存活属性名称或多个新的属性。函数分配给该属性值,只要该目的允许的话。举个例子,setattr(x,
‘foobar’, 123),也正是x.foobar = 1二叁。

sum(iterable [, start])

  对多少个连串求和。

  参数start, 钦定3个伊始值,暗许是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])

再次来到1个切成块对象,它象征的是range(start, stop,
step)钦点的范围。start和step参数默认为None。切成丝对象有只读数据属性start,stop和step,它只是回去参数值(或暗许)。未有别的分明的效果,但它们的作为数值Python和别的第3方扩充使用。当使用扩充索引语法时也产生切成片对象。举例:“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]]])

再次回到1个新的排序的列表,包蕴Iterable的项。

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

cmp钦定带四个参数(Iterable的因素),重回自三个负数,零或正数的函数“cmp=lambda
x,y: cmp(x.lower(), y.lower())“。

key内定带贰个参数的函数,用来从列表各样成分中领到贰个比较key:“key=str.lower”

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

一般来说,key和reverse调换进程是遥远快于钦点三个一定于cmp的作用。这是因为cmp是为各类列表元素调用数次,而key和reverse接触每一种成分唯有3遍。

tuple([iterable])

  创制并赶回三个元组对象。

  能够利用七个可迭代对象起初化元组。

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

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

  多个功用。传入的参数个数差别,功效分裂

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

  多少个参数时,动态创立二个自定义类的对象。

  当需求动态创制贰个类时,

  参数name, 类名

  参数bases, 类的基类,使用1个元组传入,由此能够有两个父类。

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

  多少个功效。传入的参数个数不一致,作用不一

  3个参数时,重回对象所属的类。

  八个参数时,动态创立一个自定义类的目的。

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

  参数name, 类名

  参数bases, 类的基类,使用3个元组传入,由此得以有多个父类。

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

str( [object])

归来五个字符串,当中饱含对象可打字与印刷的描述。对于字符串,那将再次来到字符串本人。与repr(object)分化的是,str(object))并不总是试图再次回到3个eval()还不错的字符串,其目标是回到3个可打字与印刷字符串。假如未有提交参数,重回空字符串,”。

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

 

): 内建函数扫除文盲,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*)

  将多少个类别实行重新组合,重临二个元组列表。

  每一个元组从各样类别中各提取3个值。由此元组的个数由最短的行列决定。

>>> 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。借使第一个参数是2个种类,issubclass(type二,
type)必须是true。super() 只好用于新型类。

tuple( [iterable])

归来2个元组的items与可迭代的iterable是同样的且有雷同的次第。iterable也许是二个种类,容器援救迭代,或迭代器对象。就算iterable已是元组,直接重回。例如,tuple(‘abc’)再次回到(‘a’,
‘b’, ‘c’) 和tuple([1, 2, 3])重回(1, 2,
三)。若是未有交到参数,重返2个新的空元组,()。

type( object)

回来对象的体系。重临值是贰个品种对象。

vars( [object])

只要未有参数,根据后天的local符号表再次来到三个字典。假设是一个模块,类或类的实例对象作为参数(或其余任何有__dict__属性),遵照目的的符号表重返3个字典。再次来到的字典不应被被改换:在对应符号表上的震慑是未定义的。

zip( [iterable, …])

本条函数重临二个元组列表,当中的第i元组包括每3个体系或iterables的第i个因素。重临的列表被截断长度为参数最短的连串的长短。当有七个参数是千篇1律长度,zip()类似于用无参数起先化的map()
。2个独立种类参数,它回到一个元组的列表。不带参数,它回到三个空驶列车表


相关文章

发表评论

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

网站地图xml地图