內建函数,内建函数扫除文盲

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

  假如迭代器中的放43个值为“真”则赶回 True, 不然赶回
False

  注意: 假若迭代器为空,再次来到 False

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

min()求最小值

ascii

any(iterable)

  假若迭代器中的率性1个值为“真”则赶回 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()获取二个对象(字符串或数值)的哈希值

bool([x])

将贰个值调换为Boolean,使用专门的学业的真测试程序。如若x是假或大意了,将重返False;不然将重临True.bool也是一个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]]**])

  创设几个 “可变的”
byte数组,能够动用整型,字符串和迭代器来开头化

  参数为字符串时,字符串中的每一个字符将退换为数组的因素,因而须求提供编码类型,类似utf-8,
ascii

  参数为整型时,整形值将作为数组的开端化大小,数组的成分则始于化为0

  参数为迭代器时,迭代器的每2个因素将作为数组的要素,由此迭代器的值必须为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数组,可以选用整型,字符串和迭代器来先导化

  参数为字符串时,字符串中的每四个字符将改变为数组的要素,由此须求提供编码类型,类似utf-8, ascii

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

  参数为迭代器时,迭代器的每三个因素将用作数组的要素,因而迭代器的值必须为0-25伍的整型,不然将发生11分。

>>> 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的1个不可变的本子,其余的能够参考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])重返浮点数的四舍伍入,n表示小数点后留下位数,默感到0.

callable(object)

若果object参数可以调用就回去True,不然重返False。就算回去True,它如故只怕调用失利,可是只要回到False,就永恒相当的小概调用成功。注类是可调用的(调用2个类重回一个实例);类的实举个例子果有贰个__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

  类是可调用的,调用后重回1个类的实例。对象要是含有了__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, 超越此限制将生出12分

>>> 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的二进制表示

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()将二个整数调换到八进制字符串

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

编写翻译string为3个代码对象。代码对象能够通过exec语句实践或许经过调用eval()总结。那filename参数钦点代码从哪个文件读取。要是不从文件中读取,就须传递一些可甄别的值(日常选取”)。kind参数钦点哪一类代码被编写翻译;若是是带有1多级语句组成的子符串能够‘exec’,如若是由3个表达式组成,就’eval’,借使由一个并行语句组成就‘singlw’(表达式语句总结的结果不是None将打字与印刷出来)。

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

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

classmethod(function)

  一般作为函数装饰器 @classmethod

  将类中的2个办法钦定为类情势。被内定的类措施第3个参数必须为cls(方法所在的类)

  类方法的调用可以直接通过类调用,即C.f();
也能够由此实例调用,即C().f()

  类情势有1个相比方便的用处便是作为类似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() 将⑩进制整数调换为1陆进制

complex( [real[, imag]])

开创八个复数real + imag*j或者将2个string可能number转化为多少个复数.
借使第一个参数是3个字符串,它将用作复数解释,函数将被调用,而忽视第三个参数。第三个参数不或然是四个字符串。每二个参数都恐怕是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*

  参数也得以为2个代表复数的字符串,不过字符串中不能够有空格。使用字符串作为参数时,未有第一个参数。***


  注1:
多少个参数的缺省值均为0

  注2:
直接用复数表达式 a+bj
创设的目标也是 complex 类型

>>> a = complex(1, 2)
>>> a
(1+2j)
>>> 
>>> b = 2+3j
>>> type(b)
<class 'complex'>
>>> 
>>> c = complex('5+6j')
>>> c
(5+6j)
>>> 
>>> d = complex(1+2j, 1+2j)
>>> d
(-1+3j)

delattr(object, name)

  删除对象的多个属性(不能够是目的的法门),不过不会潜移默化该类的任何对象。同
del object.name

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


>>> class MyTest():
...     def __init__(self):
...         self.test = 'test'
... 
>>> a = MyTest()
>>> a.test
'test'
>>> b = MyTest()
>>> b.test
'test'
>>> delattr(a, 'test')
>>> a.test
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyTest' object has no attribute 'test'
>>> 
>>> b.test
'test'

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

  创造并赶回2个字典对象。开端化参数能够有两种传播格局。

  关键字格局,将一向遵照入眼字生成字典

  迭代器方式,迭代器中的对象必须唯有五个因素,第3个因素将用作key,第3个作为值

  映射方式,其实也是壹种迭代器格局

  注: 当然也可以向来运用字典作为参数来开端化

>>> dict(one=1, two=2, three=3)
{'two': 2, 'one': 1, 'three': 3}
>>> 
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))
{'one': 1, 'two': 2, 'three': 3}
>>> 
>>> dict([('one', 1), ('two', 2), ('three', 3)])
{'one': 1, 'two': 2, 'three': 3}
>>> 
>>> dict({'one':1, 'two':2, 'three':3})
{'one': 1, 'two': 2, 'three': 3}

float()将整数和字符串调换到浮点数

delattr( object, name)

与setattr()绝对的,参数是一个目的和一个string.string必须是目的的八个属性。函数删除object这么些名称叫string的性子。比如,delattr(x,
‘foobar’)等价于del x.foobar

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}

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个可选的岗位参数或一组第一词参数伊始化二个字典。要是未有交到参数,重临多少个空的字典。假设地点参数arg是二个绚烂对象,重回一个字典映射与映射对象同样的keys对应平等的值。那么地点参数应是多个行列,援助迭代的容器,或许是三个迭代目标。参数的每2个要素也亟须是中间的壹种,同时每多个涵盖七个对象。第3个作为新字典的key,同时第3个作为那么些key的值。假若给定的key不只出现三遍,那新字典将包括最后一个值。

比如给出的是最首要词参数,关键词和与其息息相关休戚相关的值都将作为字典的项加多到字典中。假设贰个ke既作为任务参数和作为1个生死攸关词参数,关键词关联的值将保存在字典中。

美高梅开户网址 5

再次回到都等价于{“one”: 二, “two”: 三}

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~25五范围内的整数调换为相应的ascii字符

dir( [object])

要是未有参数,再次来到当前local符号表中名字的列表。要是有三个参数将尝试重返那么些参数对象的实惠属性。从目的的__dict__(假使定义了)属性,类或type对象搜聚音信。那些列表不必然是欧洲经济共同体的。假如目的是一个模块对象,list包括模块属性的列表。尽管目标是二个type或class对象,列表将涵盖属性的名字,同时递归其营地的习性。不然,列表将包蕴对象属性的名字,类特性的名字,递归若基类的属性名字。结果列表按字母逐1排序。

divmod(a, b)

  返回 (a // b, a
% b)
的元组

  注:a,b可认为整型或许浮点型,不过无法是复数

>>> divmod(7, 3)
(2, 1)
>>> 
>>> divmod(4.3, 1.5)
(2.0, 1.2999999999999998)
>>> 
>>> (4.3 // 1.5, 4.3 % 1.5)
(2.0, 1.2999999999999998)

enumerate(iterable, start=0)

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

  迭代器中的对象,第一个要素为序号(暗中同意从start=0开首),第3个成分为流传迭代器中的对象。

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

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

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

  将2个象征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必须是一个队列, 3个迭代,
只怕其余对象它帮忙迭代.enumerate()重返的iterator的next()方法
再次来到七个元组包括一定的数据(从0起始)和从迭代中获得的照料的值。

eval(expression, globals=None, locals=None)

  将3个表示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必须是3个字典。倘诺提供locals,locals能够是任何映射对象。

expression参数是作为二个Python表达式被解析和评价(才干上来讲,3个尺度列表)使用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()函数支持从1个文本中奉行语句。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)

  将3个可迭代的对象按传入的函数举办过滤。函数重临 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)

  将1个可迭代的靶子按传入的函数举办过滤。函数重回 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可感觉2个数照旧1个意味浮点数的字符串,缺省值为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的元素中布局二个列表。迭代得以是二个行列,1个支撑迭代的器皿,或1个迭代器,如若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个字符串,它必须带有叁个也许带符号的拾进制或浮点数,也许嵌入空格。不然,参数能够是一个惯常或长整数或浮点数,重返2个与之同样值的浮点数(在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])

  获取对象的八性情质的值。

  固然目的存在该属性则重临属性值。

  假若属性不设有,当传了default时返回default的值,不然产生12分。

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

  获取对象的2个属性的值。

  要是目的存在该属性则重返属性值。

  若是属性不设有,当传了default时返回default的值,不然发生10分。

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

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

  再次来到二个对象的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)

  再次回到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'

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)

该参数是2个目的和二个字符串。假设字符串是目标的在那之中2本性质,结果为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的16进制字符串,字符串以’0x’先河,字符串中的字符都是小写格局表示。

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

调用内置的提携系统。
(此意义是为互相使用。)假如未有提交参数,交互式援助系统运行解释调整台。假如参数是二个字符串,然后是字符串被用作一个module,function,class,method,keyword或文书档案大旨名称和援救页面名字举办寻找后在调控台上打字与印刷出来。假设参数是此外其余种类的对象,将发出该对象的1个帮扶页面。

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用来拓展相比的因素,钦点可迭代对象的1个要平素进行排序,reverse排序规则,True为降序,False为升序。和list.sort()的差异:sorted会修改原始的list,list.sort()再次来到为None;此外list.sort()只为list定义,sorted函数能够承受任何iterable。eg:print(sorted({一:’A’,
二:”B”, 叁:”C”}))

hex(x)

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

 input([prompt])

  接收标准输入转为字符串并重返。

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

  注:若果读到 EOF 将发生11分。

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

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

  再次来到2个整型数。输入参数能够是二个数也许五个字符串(当然能够是其余对象,但那边不上课那种非主流用法)。

  参数为一个数时,重临对象的__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)

  再次来到一个整型数。输入参数能够是二个数依然3个字符串(当然可以是任何对象,但那边不上课这种非主流用法)。

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

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

 isinstance(object, classinfo)

  推断目标是还是不是属于钦命的类。(能够合作 type 使用)

  注1: 借使钦定类是当前线指挥部标的父类,决断结果也是 True

  **注2: 如果* classinfo
参数是二个元组,那么1旦对象属于中间的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 参数是一个元组,那么只要对象属于内部的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参数是1个元组,那么1旦类属于中间五个类的子类即重回 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]])

改造为字符串或数字为纯整数。借使参数是1个字符串,它必须带有3个或许有号子的十进制数作为1个Python整数,大概嵌入空格。以radix参数给出的基数为根基进行更改(那是暗许十),能够是其余在[2,36]范围内的平头,或零。假若基数为零,依据字符串的始末推断精确的基数。假设内定的基数x是否一个字符串,引发TypeError至极。不然,参数能够是二个见惯不惊或长整数或浮点数。转变浮点数截断为整数(直到零)。如若参数是整数范围之外的,将再次来到1个long
object。要是未有交给参数,重回0

issubclass(class, classinfo)

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

  注1: 类都以本人的子类

  注2: 如果 classinfo 参数是1个元组,那么只要类属于内部一个类的子类即再次回到
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 必须是三个可迭代的靶子。

  假如 sentinel 参数有值,则object 必须是3个 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的靶子,它恐怕是多个分包类或项目的对象的tuple,也大概蕴涵其余的递归元组(连串类型不接受)。固然classinfo不是3个类,类型或元组类,类型,也许那种元组,将抛出2个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)

  重返对象的长短。对象一般是1个行列和三个聚焦。

  就算是其余对象,则对象必须包涵 __len__()
方法,不然会发生11分。

>>> 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(直接或直接)的子类。二个类被以为是和煦的子类。
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])

  创设并赶回一个列表对象。假若未有传来参数,则赶回一个空驶列车表。

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

>>> list('abcd')
['a', 'b', 'c', 'd']
>>> list([1,2,3])
[1, 2, 3]

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

iter( o[, sentinel])

归来一个迭代器对象。第一个参数有例外的分解,视第三个参数的留存与否而定。如若未有第3个参数,o必须是2个目的的会面,帮忙迭代协议(__iter__()方法),也许它必须协理种类协议(以整数0上马的参数__getitem__()方法)。假如它不帮忙这个协议,将抛出TypeError至极。假如第2个参数,sentinel,给出,然后o必须是可调用的对象。在那种状态下创办的每三个迭代器无参调用o它的next()方法,假诺再次回到值等于sentinel,将抛出StopIteration,不然将回来其余的值。

list([iterable])

  创造并赶回一个列表对象。假如未有传来参数,则赶回二个空驶列车表。

  传入的参数必须是3个可迭代的,迭代器中的每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()
用于决断2个对象是或不是是某一门类,类似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, …)

  再次来到二个迭代器。迭代器中的每三个目标将是传播的迭代器依据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, …)

  重返贰个迭代器。迭代器中的每2个目的将是传播的迭代器依据function的映射。

  如若超出八个参数,后边的参数适用于 function
有多少个参数的景观,由此后边的迭代器的长短无法小于 iterable

>>> for i in map(lambda x: x**2, [1,2,3]):
...     print(i)
... 
1
4
9
>>> for i in map(lambda x,y: x**y, [2,2,2], [1,2,3]):
...     print(i)
... 
2
4
8

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

  再次来到最大值。要比较的参数能够是多少个可迭代的对象,也得以从来传入对象列表。

  参数 key 可以转移暗中同意的相比艺术。

  当传入的是三个迭代器时,假诺迭代器为空,则赶回default值,假使未有传到default将生出非凡。

>>> max([3,5,1,7,9,2])
9
>>> max('aaa', 'bbb', 'ccc')
'ccc'
>>> 
>>> max([(4,2), (3,3), (2,4)], key=lambda x: x[1])
(2, 4)
>>> max([], default='empty')
'empty'

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

list( [iterable])

回到2个列表的items与可迭代的花色同样的依次且一样的items。可迭代能够是叁个系列,贰个器皿,扶助迭代,或三个迭代器对象。假使可迭代已经是三个列表,将回到2个别本,类似的于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将时有发生1贰分。

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

  内部存款和储蓄器观望对象提供三个共享的内部存款和储蓄器,能够在不必要复制的情状以分歧的办法访问共享内部存款和储蓄器。在大方多少管理时相比较有用。

>>> 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项。若是3个迭代比另三个短,将以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])

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

可选的key参数内定带四个参数的排序函数,用于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不是多少个int型对象时,则对象必须定义一个__index__()
方法,则赶回整型值,不然将生出十分。

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

open()用于张开1个文件,创建贰个file对象

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

三个Iterable参数,重临当中三个非常的小的非空可迭代项,(如三个字符串,元组或列表)。如有八个参数,重临最小的参数。

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

oct(x)

  重返x的8进制字符串,字符串以’0o’开首,字符串中的字符都是小写方式表示。

  当x不是3个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个文本,重回七个文件的对象。open的行使分外丰裕,那里为扫除文盲,只表达最常用最大旨的用法。

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

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

  参数 mode,展开模式

    - ‘r’,  只读格局,若是文件不存在将产生相当。

    - ‘w’, 
写格局展开,假设文件存在,原来的文章件将被覆盖,尽管不设有将创制新文件。

    - ‘x’,创造2个新文件并开采,倘使文件存在将时有产生卓殊。

    - ‘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的采纳13分丰盛,那里为扫除文盲,只表达最常用最核心的用法。

  参数 file,
文件名,路线可感觉相对,也足感到相对。

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

  参数 mode,张开形式

    - ‘r’,  只读情势,假若文件不设有将发生非常。

    - ‘w’, 
写方式展开,假若文件存在,最初的作品件将被遮住,如若不设有将创立新文件。

    - ‘x’,创立1个新文件并打开,假使文件存在将时有发生十一分。

    - ‘a’, 
追加情势打开,假若文件存在,张开后指针指向文件尾部,固然不设有将创立新文件。

    - ‘b’,  2进制格局展开。

    - ‘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()将可迭代的对象作为参数,将对象中对应的要素打包成1个个元组,然后回到zip对象。假若各个迭代器的因素个数不平等,则zip对象涵盖的列表长度与最短的目标一样,利用*号操作符,能够将元组解压为zip对象。

object()

归来3个新特点的目标。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)

更动一(大肆大小)整数到三个八进制字符串。

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

  打字与印刷函数。能够2回打字与印刷多个目的。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]])

开荒2个文书,`File
Objects’。借使文件不能开采,IOError至极引发。当展开1个文本,最佳调用open(),而不是一贯用file构造。

前五个参数与stdio的fopen()函数同样:filename是要展开的文本名,mode是叁个字符串,表示该公文是如何被张开。

mode,最常用的值是’r’读,’w’写(文件即使已存在就截断),和’a’追加(在部分Unix系统意味着全数写入追加到文件尾巴部分,无论其现在的seek地方)。假如情势被略去,默以为’r’等。当张开2个二进制文件,你应该方式值加上’b’,张开二进制方式,从而抓好可行性。
(在一些不区分贰进制文件和文件文件的系统扩展‘b’,,它将用作文书档案)。下边是mode的大概值:

可选bufsize参数内定文件的所需缓冲区大小:0表示无缓冲,壹表示行缓冲,任何别的的正数使用其大小(在约)的三个缓冲区。负数bufsize,使用系统私下认可,那tty设备平常采纳行缓冲和任何文件的通通缓冲。如果轻松,使用系统默许。

形式’r+’,
‘w+’和’a+’展开文件进行更新(请留意,’w+’截断该文件)。附加’b’的情势在分别2进制和文书文件的系统上以二进制情势打开文件,系统上平素不这几个差距,加入了’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)

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

  函数再次回到1个装潢属性,将涉及 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(start, stop[,step])

ord(x)

给定3个尺寸为一的字符串,重返3个平头,当参数是二个Unicode对象,代表字符的Unicode代码,或参数是3个七人字符串,代表其字节值,。比方,ord(‘a’)重临整数九七,ord(u’\u2020′)再次回到8224。那是5个人串chr()和用来Unicode对象的unichr()的逆函数。倘使给出Unicode参数和Python是UCS二Unicode的,字符的代码点必须在界定[0 ..
65535]内,不然字符串的尺寸是二,抛出三个TypeErro。

property(fget=None, fset=None, fdel=None, doc=None)

  属性装饰器。能够一本万利的拜会对象的某部属性,防止间接操作内部属性。

  函数重临一个装潢属性,将关乎 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(stop)  range(start, stop [, step])

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

  当唯有2个参数时,体系为0到stop(不包蕴stop值), 步进为一

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

重临可迭代对象,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值), 步进为一

  当有多少个参数时,系列为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)

  再次来到1个连串逆序的迭代器。

  要是是自定义对象,需求贯彻 __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])

  创设三个凑合对象。假如未有参数则创设三个空集结。

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

>>> 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参数被简单,暗许为一。假如简单start参数,默以为0。step不能为零(不然引发ValueError)

set([iterable])

  成立1个集结对象。即使未有参数则创立三个空集结。

  参数必须是可迭代的。迭代器中的同样的对象将只会保留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}

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

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

  当唯有多个参数时,体系为0到stop(不包含stop值), 步进为1

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

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

  可是貌似可以直接在类别中用分片语法,举例 a为三个列表,分片语法为:
a[start:stop:step]

>>> myslice = slice(1,5,1)
>>> a = [1,2,3,4,5,6,7,8,9]
>>> a[myslice]
[2, 3, 4, 5]
>>> a[1:5:1]
[2, 3, 4, 5]

repr(object)

归来1个字符串,个中包蕴二个目标的可打印形式。有时是对能够访问1个平常的函数的操作很有用。对于众多项目,该函数使得试图重返3个字符串,会爆发3个对象与传递给eval()一样的值发生的目的一样。

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

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

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

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)

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

  成立并赶回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])

  对3个系列求和。

  参数start, 指定八个伊始值,暗许是0

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

setattr( object, name, value)

与getattr()相呼应。该参数是二个目的,2个字符串和1个大肆值。该字符串能够是长存属性名称或八个新的习性。函数分配给该属性值,只要该目的允许的话。比方,setattr(x,
‘foobar’, 12三),也正是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])

重返三个切开对象,它代表的是range(start, stop,
step)内定的限定。start和step参数默认为None。切成丝对象有只读数据属性start,stop和step,它只是回来参数值(或默许)。未有任何显明的功能,但它们的当作数值Python和其余第一方扩张使用。当使用扩充索引语法时也时有发生切成块对象。比如:“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]]])

归来2个新的排序的列表,包括Iterable的项。

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

cmp钦赐带多个参数(Iterable的成分),重临自1个负数,零或正数的函数“cmp=lambda
x,y: cmp(x.lower(), y.lower())“。

key钦赐带几个参数的函数,用来从列表各个成分中领到三个相比key:“key=str.lower”

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

貌似来讲,key和reverse调换进程是遥远快于钦定一个也便是cmp的功用。那是因为cmp是为各种列表成分调用很数次,而key和reverse接触各个成分只有1遍。

tuple([iterable])

  创设并回到2个元组对象。

  能够应用一个可迭代对象开首化元组。

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

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

  两个成效。传入的参数个数差异,功能各异

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

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

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

  参数name, 类名

  参数bases, 类的基类,使用四个元组传入,因此能够有多个父类。

  参数dict, 类的习性和章程字典。{属性名=属性值,方法名=函数名},
当中“函数名”是一个早就定义的函数

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

>>> a = [1,2,3]
>>> type(a)
<class 'list'>
>>> 
>>> def test_func():
...     print('This is a test func.')
... 
>>> b = type('MyTest', (object, ), dict(test_attr='Hello', test_method=test_func))
>>> type(b)
<class 'type'>
>>> b.test_attr
'Hello'
>>> b.test_method()
This is a test func.

staticmethod( function)

函数重回多少个静态方法。静态方法未有吸收1个带有的率先个参数

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

  多少个效益。传入的参数个数不相同,成效各异

  多个参数时,重临对象所属的类。

  多个参数时,动态创立贰个自定义类的目标。

  当供给动态创设多个类时,

  参数name, 类名

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

  参数dict, 类的性情和艺术字典。{属性名=属性值,方法名=函数名},
个中“函数名”是八个已经定义的函数

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

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

回去2个字符串,在这之中包罗对象可打字与印刷的叙述。对于字符串,那将重临字符串自身。与repr(object)分裂的是,str(object))并不延续试图重回2个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*)

  将多少个系列进行重新组合,重临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)]

 

): 内建函数扫除文盲,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只怕是二个类别,容器援助迭代,或迭代器对象。如若iterable已是元组,直接重临。举例,tuple(‘abc’)重临(‘a’,
‘b’, ‘c’) 和tuple([1, 2, 3])再次来到(一, 贰,
三)。如果未有交给参数,再次来到二个新的空元组,()。

type( object)

归来对象的项目。重回值是多少个项目对象。

vars( [object])

一旦没有参数,遵照今后的local符号表再次回到3个字典。如若是二个模块,类或类的实例对象作为参数(或任何任何有__dict__脾性),根据目的的符号表重返2个字典。重临的字典不应被被改造:在对应符号表上的震慑是未定义的。

zip( [iterable, …])

其一函数重临1个元组列表,个中的第i元组包蕴各样体系或iterables的第i个因素。再次回到的列表被截断长度为参数最短的队列的尺寸。当有多个参数是壹致长度,zip()类似于用无参数开首化的map()
。二个单身系列参数,它回到一个元组的列表。不带参数,它回到3个空驶列车表

发表评论

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

网站地图xml地图