内建函数扫盲,第八五章

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

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

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

 

python有部分常用的放置函数:

1.abx(x)

回去2个数的相对值。参数大概是二个一般或长整型,或许3个浮点数。倘若参数是叁个复数,重临它的积。

内建函数扫盲,第八五章。 

abs(x)

  求3个数的相对值。

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

数学函数

2.all(iterable)

假如迭代的持有因素都以真就赶回真。

abs(x)

  求2个数的相对值。

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

假诺迭代中有2个因素为真就回来真。

4858.com 1

all any

all(iterable)

  倘若迭代器中的全部值都为“真”则赶回 True, 不然赶回
False

  注意:
假诺迭代器为空,再次回到 True

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

any(iterable)

  假诺迭代器中的任意二个值为“真”则赶回 True, 不然赶回
False

  注意: 设若迭代器为空,重临 False

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

min()求最小值

ascii

any(iterable)

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

  注意:万1迭代器为空,重返 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)

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

  可是正是将整型转换为贰进制,其实是将指标的__index__()
方法再次回到的值转换为2进制字符串

  注意: 要是指标未有__index__() 方法,将会生出13分

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

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

bool([x])

将1个值转换为Boolean,使用专业的真测试程序。假使x是假或忽略了,将回到False;不然将再次回到True.bool也是多个class,它是int的三个子类,bool类无法进一步子类化。它仅有False和True三个实例。

4858.com 2

bool

bin(x)

  将整型转换为二进制的字符串,字符串以’0b’ 开头.

  可是身为将整型转换为二进制,其实是将指标的__index__()
方法重临的值转换为二进制字符串

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

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

 bool(x)

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

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

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

  参数为迭代器时,迭代器的每三个要素将用作数组的成分,由此迭代器的值必须为0-25五的整型,不然将发出十分。

>>> a = bytearray(10)
>>> a
bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
>>> a[0]
0
>>> len(a)
10
>>> 
>>> b = bytearray('abc', 'utf-8')
>>> b
bytearray(b'abc')
>>> b[0]
97
>>> 
>>> c = bytearray(range(1,5))
>>> c
bytearray(b'\x01\x02\x03\x04')
>>> c[0]
1
>>> 
>>> d = bytearray([1,2,3])
>>> d
bytearray(b'\x01\x02\x03')
>>> d[1] = 20
>>> d
bytearray(b'\x01\x14\x03')

sum(),对队列进行求和

bytes

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

  创立1个 “可变的”
byte数组,能够运用整型,字符串和迭代器来伊始化

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

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

  参数为迭代器时,迭代器的每四个要素将作为数组的要素,由此迭代器的值必须为0-25伍的整型,否则将发生卓殊。

>>> a = bytearray(10)
>>> a
bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
>>> a[0]
0
>>> len(a)
10
>>> 
>>> b = bytearray('abc', 'utf-8')
>>> b
bytearray(b'abc')
>>> b[0]
97
>>> 
>>> c = bytearray(range(1,5))
>>> c
bytearray(b'\x01\x02\x03\x04')
>>> c[0]
1
>>> 
>>> d = bytearray([1,2,3])
>>> d
bytearray(b'\x01\x02\x03')
>>> d[1] = 20
>>> d
bytearray(b'\x01\x14\x03')

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,就永远不容许调用成功。注类是可调用的(调用三个类再次来到一个实例);类的实例假设有1个__call__()方法正是可调用的。

4858.com 3

callable

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

  bytesbytearray的三个不可变的本子,其余的能够参见bytearray

>>> d = bytes([1,2,3])
>>> d
b'\x01\x02\x03'
>>> d[1] = 20
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'bytes' object does not support item assignment

callable(object)

  判断目的是或不是能够调用,固然得以则赶回 True, 不然赶回
False

  类是可调用的,调用后归来一个类的实例。对象就算带有了__call__()艺术也是可调用的。

  其实,只要能够写成 object() 的,都是callable

>>> def foo():
...     pass
... 
>>> callable(foo)
True
>>> 
>>> class MyTest:
...     def __call__(self):
...         pass
... 
>>> callable(MyTest)
True
>>> a = MyTest()
>>> callable(a)
True
>>> 
>>> b = 1
>>> callable(b)
False

进制转换

chr(x)

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

callable(object)

  判断目的是还是不是可以调用,如若可以则赶回 True, 否则赶回
False

  类是可调用的,调用后回去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(i)

  返回Unicode对应的字符。

  参数范围为 0 — 1114111, 当先此限制将时有爆发相当

>>> chr(97)
'a'
>>> chr(1666)
'ڂ'
>>> chr(1200000)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: chr() arg not in range(0x110000)

bin()重回二个整型int或long int的二进制表示

classmethod(function)

回到函数的四个类措施。

 chr(i)

  返回Unicode相应的字符。

  参数范围为 0 —
1114111
, 当先此限制将产生十二分

>>> chr(97)
'a'
>>> chr(1666)
'ڂ'
>>> chr(1200000)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: chr() arg not in range(0x110000)

classmethod(function)

  一般作为函数装饰器 @classmethod

  将类中的三个办法钦点为类格局。被钦定的类措施第3个参数必须为cls(方法所在的类)

  类方法的调用能够平昔通过类调用,即C.f();
也得以通超过实际例调用,即C().f()

  类措施有一个相比方便的用途正是作为类似C++中的开首化函数重载

class MyTest():
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day 

    @classmethod
    def from_string(cls, date_string):
        year, month, day = map(int, date_string.split('-'))
        return cls(year, month, day)

    def output(self):
        print('Birthday: {}-{}-{}'.format(self.year, self.month, self.day))



>>> a = MyTest(1989, 12, 26)
>>> a.output()
Birthday: 1989-12-26
>>> 
>>> b = MyTest.from_string('1990-1-1')
>>> b.output()
Birthday: 1990-1-1

oct()将2个整数转换到八进制字符串

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个格局钦赐为类格局。被钦赐的类措施第拾个参数必须为cls(方法所在的类)

  类方法的调用能够平素通过类调用,即C.f();
也得以透超过实际例调用,即C().f()

  类措施有二个比较便于的用途正是作为类似C++中的先导化函数重载

class MyTest():
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day 

    @classmethod
    def from_string(cls, date_string):
        year, month, day = map(int, date_string.split('-'))
        return cls(year, month, day)

    def output(self):
        print('Birthday: {}-{}-{}'.format(self.year, self.month, self.day))



>>> a = MyTest(1989, 12, 26)
>>> a.output()
Birthday: 1989-12-26
>>> 
>>> b = MyTest.from_string('1990-1-1')
>>> b.output()
Birthday: 1990-1-1

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

  该函数将含有python语句的字符串编写翻译成可实行的字节码,编写翻译的结果同盟
eval, 或 exec 使用。

  source — 要求编写翻译的字符串

  filename — 存款和储蓄字符串的公文

  mode — ‘eval’ 配合 eval 使用, ‘exec’ 同盟多语句的 exec
使用,’single’ 协作单语句的 exec 使用

  注:实地度量中,编写翻译的时候会判定mode, 不过进行的时候使用
exec 或者 eval,结果壹致

>>> a = compile('1+2', filename='',  mode='eval')
>>> eval(a)
3
>>> 
>>> b = compile('for i in range(3): print(i)', filename='', mode='exec')
>>> exec(b)
0
1
2
>>> 
>>> c = compile('print("Hello, world.")', filename='', mode='exec')
>>> exec(c)
Hello, world.

hex() 将拾进制整数转换为16进制

complex( [real[, imag]])

创办三个复数real + imag*j或然将八个string恐怕number转化为多少个复数.
假若第多个参数是一个字符串,它将作为复数解释,函数将被调用,而忽略第3个参数。首个参数不容许是一个字符串。每一个参数都恐怕是一个数字类型包蕴复数.如若imag省略了,
它暗中认可为0,函数将用作二个数字转换函数像 int(), long() and
float().假若参数都简短了,将回来0j.

4858.com 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,结果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.

complex([real[, imag]])

  再次来到二个复数。复数值为  real + imag\1j*

  参数也能够为1个象征复数的字符串,可是字符串中不能够有空格。使用字符串作为参数时,未有第三个参数。***


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

  注2: 直接用复数表明式 a+bj 成立的对象也是 complex
类型

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

类型转换

copyright

complex([real[, imag]])

  再次回到一个复数。复数值为  real + imag\1j*

  参数也足以为三个意味复数的字符串,然则字符串中不可能有空格。使用字符串作为参数时,未有第二个参数。***


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

  注2:
直接用复数表明式 a+bj
创制的靶子也是 complex 类型

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

delattr(object, name)

  删除对象的贰天品质(无法是目的的艺术),可是不会潜移默化该类的别的对象。同
del object.name

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


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

credits

delattr(object, name)

  删除对象的二个属性(不能够是指标的艺术),可是不会潜移默化该类的别的对象。同
del
object.name

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


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

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

  创设并赶回一个字典对象。伊始化参数能够有二种传播方式。

  关键字形式,将平素遵照主要字生成字典

  迭代器格局,迭代器中的对象必须唯有八个要素,第壹个要素将用作key,第一个作为值

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

  注: 当然也得以平昔采取字典作为参数来发轫化

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

float()将整数和字符串转换成浮点数

delattr( object, name)

4858.com,与setattr()相对的,参数是三个目的和3个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()用于制造三个复数,形如real+imag*j

dict( [arg])

以多个可选的岗位参数或1组第二词参数早先化八个字典。要是没有提交参数,重回三个空的字典。假如地点参数arg是叁个炫耀对象,重返贰个字典映射与映射对象相同的keys对应平等的值。那么位置参数应是七个行列,支持迭代的容器,只怕是3个迭代目的。参数的每个成分也必须是内部的一种,同时每二个带有三个对象。第一个作为新字典的key,同时第一个作为这几个key的值。如果给定的key不只出现2次,这新字典将包涵最终一个值。

假定给出的是最主要词参数,关键词和与其相关的值都将作为字典的项添加到字典中。假诺2个ke既作为任务参数和当作三个关键词参数,关键词关联的值将保留在字典中。

4858.com 5

再次回到都等价于{“one”: 2, “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包蕴模块属性的列表。如若目标是1个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)

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

  迭代器中的对象,第二个元素为序号(私下认可从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).

4858.com 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)

  将1个象征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()方法
再次回到3个元组包罗一定的多少(从0发轫)和从迭代中获取的对应的值。

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

  将贰个代表python表明式的字符串编写翻译成python言辞并施行(慎用!

  再次来到值,假使传入参数是字符串也许mode=’eval’编写翻译的字节码,则赶回交互式运营结果,不然再次来到None

  globalslocals为高级用法,此处不开始展览。暗许使用当前定名空间。

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

  注2: 字符串中可以带领变量,但变量必须在指令空间中定义。

  注3: 能够相称compile()使用

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

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

  将叁个意味python表达式的字符串编写翻译成python讲话并履行(慎用!

  重回值为None

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

  注1: 语句能够是多条

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

  注3: 能够包容compile()使用

>>> exec('for i in range(5): print(i)')
0
1
2
3
4

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

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

该参数是三个字符串和可选的globals和locals。即便提供globals,globals必须是1个字典。借使提供locals,locals能够是此外映射对象。

expression参数是当做一个Python表明式被解析和评价(技术上的话,二个口径列表)使用globals以及locals字典作为global和local名字空间。假若提供了globals字典但未有’__builtins__’,当前globals在表明式被分析前被复制到globals中。那意味表明式能够完全访问标准__builtin__模块和受限的条件。要是locals字典省略则默许为globals字典。尽管多个字典都被略去,表明式在调用eval的条件中履行。重临值是总计表明式的结果。语法错误报告为exceptions。
例如:

>>> x = 1

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

2

此函数也足以用来实施任意代码的对象(如compile()成立的)。在那种状态下,传入3个代码对象,而不是贰个字符串。该代码对象必须已编写翻译传给’eval’作为那种参数。

升迁:EXEC语句协助是动态执行语句。execfile()函数辅助从二个文书中实施语句。globals()和locals()函数分别重临当前的global和local字典,这对应用eval()或execfile()很有帮带

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

  将2个意味python表达式的字符串编写翻译成python讲话并推行(慎用!

  重临值为None

  globalslocals为高级用法,此处不开始展览。私下认可使用当前定名空间。

  注1: 语句能够是多条

  注2: 字符串中能够引导变量,但变量必须在指令空间中定义。

  注3: 能够合作compile()使用

>>> exec('for i in range(5): print(i)')
0
1
2
3
4

filter(function, iterable)

  将二个可迭代的指标按传入的函数实行过滤。函数再次回到 True
的要素将保留,其它将被过滤掉。

>>> a = [1,2,3,4,5,6,7,8,9]
>>> list(filter(lambda x: x % 2, a))
[1, 3, 5, 7, 9]

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

exec

filter(function, iterable)

  将二个可迭代的对象按传入的函数进行过滤。函数重返 True
的要素将保存,其余将被过滤掉。

>>> a = [1,2,3,4,5,6,7,8,9]
>>> list(filter(lambda x: x % 2, a))
[1, 3, 5, 7, 9]

float([x])

  创设并再次来到三个浮点型的指标。

  x能够为一个数也许二个表示浮点数的字符串,缺省值为0

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

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

exit()

退出

float([x])

  成立并回到贰个浮点型的靶子。

  x能够为多个数要么3个意味着浮点数的字符串,缺省值为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的是多少个字符串或贰个元组,其结果也有那连串型的,否则它一向是叁个列表。假设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)

将字符串或数字转换或3个浮点数。假诺参数是贰个字符串,它必须带有二个也许带符号的10进制或浮点数,大概嵌入空格。不然,参数可以是八个1般或长整数或浮点数,重回八个与之相同值的浮点数(在Python的浮点精度内)。要是未有付诸参数,再次来到0.0。

frozenset([iterable])

  传入1个可迭代的靶子,创立一个不可变的成团。除了成分无法添加删除此之外,别的和可变集合类似。

  假诺未有参数,则创设3个空集合。

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

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

all(),any()的参数都以元组或列表,不一致:all()假使拥有因素都不是0、”、False或许iterable为空,重回True,不然再次来到False;any()就算具有因素为空、0、False则赶回False,如若不都为空、0、False,则赶回True;all()参数是空驶列车表或空元组,重返True,any()重临False。

format

getattr(object, name [, default])

  获取对象的一个特性的值。

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

  纵然属性不存在,当传了default时返回default的值,不然产生分外。

  注:参数 name 是三个字符串

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

globals()

  再次回到当前全局域的{对象: 值} 字典

>>> globals()
{'__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__', '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__doc__': None, 'a': <__main__.MyTest object at 0x7f04880fb780>, '__spec__': None, 'MyTest': <class '__main__.MyTest'>}

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

frozenset( [iterable])

回去三个frozenset对象,其元平昔自于Iterable。
Frozensets组未有立异的主意,但能够哈希和别的组成员或当作字典键使用。1个frozenset的要素必须是不足更改。内部sets也应是frozenset对象。若是迭代从不点名,重临四个新的空集,frozenset
([])。

globals()

  再次来到当前全局域的{对象: 值} 字典

>>> globals()
{'__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__', '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__doc__': None, 'a': <__main__.MyTest object at 0x7f04880fb780>, '__spec__': None, 'MyTest': <class '__main__.MyTest'>}

hasattr(object, name)

  判断一个对象是还是不是存在钦赐的性质。存在重返 True, 不然赶回
False

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


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

  重临2个对象的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个字符串。要是字符串是目的的中间贰个天性,结果为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不是3个int型对象时,则对象必须定义3个__index__()
方法,则赶回整型值,不然将爆发13分。

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

迭代相关函数

hash()

归来对象(假若部分话)的哈希值。哈希值是整数。它们被用来在词典查找时,作为一个飞快比较字典keys键。具有同样的哈希值,数值相等(尽管它们属于区别的项目,因为是1和一.0的事态)。

hex(x)

  再次回到x的1陆进制字符串,字符串以’0x’开首,字符串中的字符都是小写情势表示。

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

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

id(object)

  重临对象的内部ID值。

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

next(iterator[,defaul]) 重回迭代器的下三个品种。

help(object)

调用内置的支持系统。
(此功效是为互相使用。)假诺未有交到参数,交互式协助系统运行解释控制台。如若参数是1个字符串,然后是字符串被当作贰个module,function,class,method,keyword或文书档案大旨名称和支援页面名字进行检索后在控制台上打字与印刷出来。倘使参数是任何其余类型的目的,将发生该目的的3个扶助页面。

id(object)

  重返对象的内部ID值。

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

 input([prompt])

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

  prompt 为输入提醒字符串,能够省略。

  注:要是读到 EOF 将发生相当。

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

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

hex(x)

转移1个(任意大小)整数为十6进制字符串。

 input([prompt])

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

  prompt
为输入提示字符串,能够回顾。

  注:就算读到 EOF 将时有爆发十二分。

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

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

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

  参数为八个数时,重返对象的__int__()方法的值,对于整型对象就是自己的值,对于浮点型对象正是整数有的。

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

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

iter()用于转移迭代器

id(object)

归来对象的“identity”。那是七个平头(或长整型),那是确定保障是唯壹的,与对象的生命周期一样长。四个非重叠的生命周期的指标恐怕有一样的ID()值。
(完成注意:那是目的的地点。)

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

  再次来到一个整型数。输入参数能够是二个数要么二个字符串(当然能够是别的对象,但那边不上课那种非主流用法)。

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

  参数为一个字符串时,字符串必须代表1个二、8、十、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
参数是二个元组,那么只要对象属于内部的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个元组,那么1旦对象属于中间的一个类即再次来到 True


>>> a = 12
>>> b = 25
>>> isinstance(a, int)
True
>>> isinstance(a, type(b))
True
>>> class A:
...     pass
... 
>>> class B(A):
...     pass
... 
>>> a = A()
>>> b = B()
>>> isinstance(a, A)
True
>>> isinstance(b, B)
True
>>> isinstance(a, B)
False
>>> isinstance(b, A)
True
>>> isinstance(a, (A,B))
True

issubclass(class, classinfo)

  判断一个类是还是不是为钦点类的子类。

  注1: 类都以自小编的子类

  注2: 如果 classinfo参数是二个元组,那么一旦类属于中间三个类的子类即再次来到 True

>>> class A:
...     pass
... 
>>> class B(A):
...     pass
... 
>>> issubclass(B, A)
True
>>> issubclass(A, B)
False
>>> issubclass(A, A)
True
>>> issubclass(A, (A,B))
True

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

int( [x[, radix]])

转移为字符串或数字为纯整数。借使参数是三个字符串,它必须含有二个或然有记号的10进制数作为二个Python整数,大概嵌入空格。以radix参数给出的基数为根基举办更换(那是默许10),能够是其余在[2,36]界定内的整数,或零。假诺基数为零,遵照字符串的始末估算正确的基数。假如钦赐的基数x是或不是1个字符串,引发TypeError极度。不然,参数可以是七个普通或长整数或浮点数。转换浮点数截断为整数(直到零)。就算参数是整数范围之外的,将赶回1个long
object。假设没有交到参数,再次回到0

issubclass(class, classinfo)

  判断一个类是不是为钦定类的子类。

  注1: 类都是本身的子类

  注2: 如果 classinfo 参数是3个元组,那么只要类属于内部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

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的三个实例,或其(直接或直接)子类的实例。也回到true假设classinfo是1种type对象(new-style
class)和是该品种或其(直接或直接)子类的对象。假若object不是class1个的实例恐怕给定类型的指标,函数重临false。若是classinfo既不是一个类的靶子也不是二个type的对象,它只怕是多少个包罗类或项目标目的的tuple,也或者带有别的的递归元组(类别类型不接受)。若是classinfo不是三个类,类型或元组类,类型,或然那种元组,将抛出八个TypeError非常。

iter(object [, sentinel])

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

  假如 sentinel 参数未有传来则 object 必须是叁个可迭代的指标。

  假设 sentinel 参数有值,则object 必须是一个 callable
的靶子,此时的遍历将再也调用object, 直到重回值等于
sentinel(将时有爆发StopIteration异常)

>>> it = iter([1,2,3])
>>> next(it)
1
>>> next(it)
2
>>> next(it)
3
>>> next(it)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> 
>>> for i in iter([1,2,3]):
...     print(i)
... 
1
2
3
>>> f = open('test.txt', 'r')
>>> itf = iter(f.readline, '')
>>> next(itf)
'test line 1\n'
>>> next(itf)
'test line 2\n'
>>> next(itf)
'test line 3\n'
>>> next(itf)
'\n'
>>> next(itf)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> f.close()

len(s)

  再次来到对象的尺寸。对象一般是三个体系和二个聚众。

  要是是别的对象,则对象必须包括 __len__()
方法,否则会发生万分。

>>> a = [1, 2, 3]
>>> len(a)
3
>>> b = 'abcdefg'
>>> len(b)
7
>>> 
>>> class MyTest:
...     def __len__(self):
...         return 5
... 
>>> c = MyTest()
>>> len(c)
5

hasattr(object, attr)用于判断三个对象是还是不是有某一属性

issubclass( class, classinfo)

回来true要是class是classinfo(直接或直接)的子类。贰个类被认为是投机的子类。
classinfo恐怕是类对象元组,在那种场合下元组中的每个classinfo项将被举行测试。在此外任何动静下,抛出几个TypeError很是。

len(s)

  再次回到对象的尺寸。对象一般是3个种类和多个会面。

  假若是其余对象,则对象必须含有 __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])

  创制并回到二个列表对象。要是未有传到参数,则赶回3个空驶列车表。

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

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

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

iter( o[, sentinel])

回到多个迭代器对象。第四个参数有两样的解释,视第2个参数的留存与否而定。假如未有第一个参数,o必须是2个目的的汇集,帮忙迭代协议(__iter__()方法),大概它必须帮忙系列协议(以整数0始发的参数__getitem__()方法)。要是它不匡助这一个协议,将抛出TypeError很是。假设第贰个参数,sentinel,给出,然后o必须是可调用的对象。在那种场地下创办的每三个迭代器无参调用o它的next()方法,假若重返值等于sentinel,将抛出StopIteration,不然将重临别的的值。

list([iterable])

  创制并重临贰个列表对象。借使未有传来参数,则赶回3个空驶列车表。

  传入的参数必须是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()
用于判断四个指标是还是不是是某一品类,类似type,但type不会以为子类是父类类型,isinstance会认为子类是父类类型

len(s)

回到1个指标的长度。参数可以是二个队列(字符串,元组或列表)或映射(词典)。

locals()

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

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

map(function, iterable, …)

  重返1个迭代器。迭代器中的每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

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将生出11分。

>>> 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个迭代器对象。假使可迭代已经是三个列表,将回到一个副本,类似的于iterable[:]。例如,list(‘abc’)返回[‘a’,
‘b’, ‘c’]和list( (1, 2, 3) )
返回[1,2,3]。假若未有交到参数,再次回到1个新的空驶列车表,[]。

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

  再次回到最大值。要比较的参数能够是二个可迭代的靶子,也足以一向传入对象列表。

  参数 key 能够转移私下认可的比较艺术。

  当传入的是三个迭代器时,如果迭代器为空,则赶回default值,假使未有传来default将生出相当。

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

memoryview(obj)

  重临1个内部存款和储蓄器观望对象。传入的指标必须扶助缓冲区商业事务,内建指标中援救的有
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意义1样。要是有一而再关系,子类方法调用类方法时,传递的类变量cls时子类,而非父类。

map( function, iterable, …)

行使function在iterable的每三个项上并赶回3个列表。倘诺有其它可迭代的参数,函数必须选择许多参数应用于来自全体iterables项。要是三个迭代比另2个短,将以None进行扩展。假如function是None,将若是为identity
function,借使有几个参数,map()重返三个列表包括全部iterables相应的花色的元组组成。可迭代的参数也许是二个种类或其余可迭代的对象,结果三番五次贰个列表。

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

  再次回到最小值。用法与 max 类似

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

next(iterator [, default])

  再次来到迭代器中的下三个。1般与 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个最大的非空可迭代项,(如1个字符串,元组或列表)。如有多少个参数,重返最大的参数。

可选的key参数钦赐带贰个参数的排序函数,用于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()

  创设3个骨干对象。该类是全体类的基类。

>>> a = object()
>>> dir(a)
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

oct(x)

  再次来到x的8进制字符串,字符串以’0o’开头,字符串中的字符都是小写格局表示。

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

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

open()用于打开一个文本,创造二个file对象

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

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

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

oct(x)

  重返x的八进制字符串,字符串以’0o’开端,字符串中的字符都是小写情势表示。

  当x不是1个int型对象时,则对象必须定义2个__index__()
方法,则赶回整型值,否则将爆发13分。

>>> 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’,成立一个新文件并开拓,假设文件存在将发出拾叁分。

    - ‘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()反向操作。

  注: 参数必须是纯粹的字符

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

zip()将可迭代的靶子作为参数,将对象中对应的因素打包成一个个元组,然后回来zip对象。借使每一个迭代器的元素个数不平等,则zip对象涵盖的列表长度与最短的对象相同,利用*号操作符,能够将元组解压为zip对象。

object()

回来八个新脾气的目的。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*)

  打印函数。能够1次打印多少个指标。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分外引发。当打开一个文书,最棒调用open(),而不是直接用file构造。

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

mode,最常用的值是’r’读,’w’写(文件假若已存在就截断),和’a’追加(在有个别Unix系统意味着全数写入追加到文件尾巴部分,无论其未来的seek地方)。要是方式被简单,暗中认可为’r’等。当打开3个二进制文件,你应有形式值加上’b’,打开贰进制形式,从而增强可行性。
(在少数不区分贰进制文件和文书文件的系统增添‘b’,,它将用作文书档案)。上面是mode的只怕值:

可选bufsize参数钦赐文件的所需缓冲区大小:0代表无缓冲,1意味着行缓冲,任何别的的正数使用其尺寸(在约)的2个缓冲区。负数bufsize,使用系统暗中同意,那tty设备平日选用行缓冲和别的文件的一点一滴缓冲。假若简单,使用系统私下认可。

形式’r+’,
‘w+’和’a+’打开文件举行翻新(请小心,’w+’截断该公文)。附加’b’的情势在区分二进制和文件文件的类别上以2进制格局打开文件,系统上尚无那些差距,出席了’b’未有效应。

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

  打字与印刷函数。能够1次打字与印刷三个指标。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装饰类方法时,方法老马作为装饰属性,方法定义为只读。此时1经供给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)

给定1个长短为1的字符串,再次来到三个整数,当参数是贰个Unicode对象,代表字符的Unicode代码,或参数是叁个七人字符串,代表其字节值,。例如,ord(‘a’)重临整数九7,ord(u’\u2020′)重临82二四。那是五位串chr()和用于Unicode对象的unichr()的逆函数。假如给出Unicode参数和Python是UCS2Unicode的,字符的代码点必须在限定[0 ..
65535]内,不然字符串的长短是贰,抛出3个TypeErro。

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

  生成1个数字种类迭代器。

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

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

  多个参数时,即可自定义步进

>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list(range(3,9))
[3, 4, 5, 6, 7, 8]
>>> list(range(1,10,2))
[1, 3, 5, 7, 9]

归来可迭代对象,start私下认可为0,step默认为壹。

pow( x, y[, z])

再次来到x的Y次方,若是给出z,重回x的y次方,模Z(比pow(x, y) %
z更使得)的。那五个参数的花样pow(x, y),也正是:x ** y

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

  生成叁个数字体系迭代器。

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

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

  再次回到叁个体系逆序的迭代器。

  借使是自定义对象,必要完结 __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])

  保留钦定的小数位,再次回到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])

  保留内定的小数位,再次来到2个最相仿的数。

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

  创造3个聚众对象。若是未有参数则创制二个空集合。

  参数必须是可迭代的。迭代器中的相同的靶子将只会保留1个。

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


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


>>> class MyTest():
...     pass
... 
>>> a = MyTest()
>>> setattr(a, 'test', 'hello')
>>> getattr(a, 'test')
'hello'
>>> setattr(a, 'test', 'hello, world')
>>> getattr(a, 'test')
'hello, world'
>>> a.test
'hello, world'

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

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

  当唯有2个参数时,连串为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)

再次来到2个字符串,当中包括2个指标的可打字与印刷情势。有时是对能够访问2个平凡的函数的操作很有用。对于许多体系,该函数使得试图重回三个字符串,会时有发生二个对象与传递给eval()相同的值产生的靶子壹样。

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

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

  当唯有三个参数时,系列为0到stop(不包含stop值), 步进为壹

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

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

  然则貌似可以直接在系列中用分片语法,例如 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*)

  重返1个经过排序的列表。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肆舍5入到小数点后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’)

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

  能够行使钦赐的指标来开头化。发轫化将应用对象的 __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未有点名,重回3个新的空集,设置([])

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

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

  能够应用钦点的对象来开头化。早先化将使用对象的 __str__()
方法重回的值。

>>> str(12345)
'12345'
>>> str('test')
'test'
>>> str([1,2,3])
'[1, 2, 3]'
>>> class MyTest:
...     def __str__(self):
...         return 'Hello'
... 
>>> a = MyTest()
>>> str(a)
'Hello'

sum(iterable [, start])

  对贰个连串求和。

  参数start, 内定三个开端值,私下认可是0

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

setattr( object, name, value)

与getattr()相呼应。该参数是2个对象,二个字符串和2个任意值。该字符串能够是并存属性名称或1个新的性质。函数分配给该属性值,只要该指标允许的话。例如,setattr(x,
‘foobar’, 1贰三),也就是x.foobar = 1贰3。

sum(iterable [, start])

  对多少个体系求和。

  参数start, 内定八个起首值,私下认可是0

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

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

  重返父类的主意、对象。一般用来后续处理中,特别是起初化。

  在开首化中,super的参数可以简不难单。

class A:
    def __init__(self):
        print('Class A init')

class B(A):
    def __init__(self):
        super().__init__()
        print('Class B init')


class C(A):
    def __init__(self):
        super(C, self).__init__()
        print('Class C init')


>>> b = B()
Class A init
Class B init
>>> c = C()
Class A init
Class C init

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

归来八个新的排序的列表,包罗Iterable的项。

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

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

key钦定带五个参数的函数,用来从列表各样元素中提取一个比较key:“key=str.lower”

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

相似而言,key和reverse转换进度是远远快于钦定二个一定于cmp的意义。那是因为cmp是为各种列表成分调用很数13回,而key和reverse接触每种成分唯有3回。

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)

函数再次来到三个静态方法。静态方法未有接收三个暗含的率先个参数

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

  七个效益。传入的参数个数分歧,功能各异

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

  多个参数时,动态创设三个自定义类的指标。

  当必要动态创造一个类时,

  参数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))并不总是试图重临二个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*)

  将八个连串进行重新组合,重返贰个元组列表。

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

>>> 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(type2,
type)必须是true。super() 只可以用来最新类。

tuple( [iterable])

归来二个元组的items与可迭代的iterable是壹样的且有同一的相继。iterable大概是一个队列,容器扶助迭代,或迭代器对象。即便iterable已是元组,直接回到。例如,tuple(‘abc’)重返(‘a’,
‘b’, ‘c’) 和tuple([1, 2, 3])再次来到(1, 二,
3)。要是未有交到参数,重返二个新的空元组,()。

type( object)

回去对象的体系。再次来到值是一个档次对象。

vars( [object])

1经未有参数,依据今后的local符号表重返二个字典。要是是贰个模块,类或类的实例对象作为参数(或任何任何有__dict__特性),依据指标的符号表重回3个字典。再次回到的字典不应被被涂改:在对应符号表上的影响是未定义的。

zip( [iterable, …])

其一函数重临三个元组列表,当中的第i元组包罗每二个队列或iterables的第i个成分。再次回到的列表被截断长度为参数最短的行列的长度。当有四个参数是同样长度,zip()类似于用无参数起头化的map()
。三个独立连串参数,它回到3个元组的列表。不带参数,它回到2个空驶列车表

发表评论

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

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有