澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

澳门新萄京官方网站:內建函数,我的Python之旅

2019-06-08 作者:www.8455.com   |   浏览(126)
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)

回到八个数的相对值。参数也许是一个一般或长整型,或许一个浮点数。借使参数是一个复数,重临它的积。

数学生运动算(柒个) 类型调换(二五个) 系列操作(九个) 对象操作(四个) 反射操作(几个)
变量操作(二个) 交互操作(三个) 文件操作(3个) 编写翻译试行(陆个) 装饰器(二个)

 

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个要素为真就回到真。

澳门新萄京官方网站 1

all any

1 abs()

讲述:abs() 函数再次回到数字的相对值
语法: abs( x )
示例:

>>> abs(-10)
    10

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

2 divmod()

讲述:再次来到多少个数值的商和余数的元组(a // b, a % b)
语法:divmod(a, b)
示例:

>>> divmod(20,6)
    (3, 2)

any(iterable)

  假若迭代器中的猖獗三个值为“真”则赶回 True, 不然赶回 False

  注意:例如迭代器为空,重临 False

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

ascii(object)

  该函数再次来到表示对象的可打字与印刷ascii字符串,假如字符串中带有非ascii字符,则以x, u 或者 U 编码来代表

  函数实际是回来了目的的 __repr__() 方法的值

>>> a = 123
>>> a.__repr__()
'123'
>>> ascii(a)
'123'
>>> 
>>> b = 'test'
>>> b.__repr__()
"'test'"
>>> ascii(b)
"'test'"
>>>
>>> class MyTest:
...     def __repr__(self):
...         return 'Hello, world.'
... 
>>> t = MyTest()
>>> t.__repr__()
'Hello, world.'
>>> ascii(t)
'Hello, world.'

max()求最大值

bin

3 max()

讲述:再次回到可迭代对象的要素中的最大值恐怕有所参数的最大值
语法:max( x, y, z, .... )

示例:>>> max(1,2,6,8)
    8

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__() 方法再次回到的值调换为贰进制字符串

  注意: 要是指标未有__index__() 方法,将会产生非常

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

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

bool([x])

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

澳门新萄京官方网站 2

bool

4 min()

叙述:重临可迭代对象的成分中的最小值可能具有参数的最小值
语法:min( x, y, z, .... )
示例:

>>> min(1,2,6,8)
    1

bin(x)

  将整型调换为贰进制的字符串,字符串以'0b' 起头.

  可是身为将整型转变为贰进制,其实是将对象的__index__() 方法重返的值转换为二进制字符串

  注意: 若是目的未有__index__() 方法,将会发生10分

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

5 pow()

讲述:方法重临 x^y(x的y次方) 的值
语法:pow(x,y)
示例:

>>> pow(2,3)
    8

 bool(x)

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

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

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

  创制二个 “可变的” byte数组,能够接纳整型,字符串和迭代器来伊始化

  参数为字符串时,字符串中的每贰个字符将转移为数组的因素,由此需求提供编码类型,类似utf-8, ascii

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

  参数为迭代器时,迭代器的每二个成分将用作数组的因素,由此迭代器的值必须为0-255的整型,不然将生出卓殊。

>>> a = bytearray(10)
>>> a
bytearray(b'x00x00x00x00x00x00x00x00x00x00')
>>> a[0]
0
>>> len(a)
10
>>> 
>>> b = bytearray('abc', 'utf-8')
>>> b
bytearray(b'abc')
>>> b[0]
97
>>> 
>>> c = bytearray(range(1,5))
>>> c
bytearray(b'x01x02x03x04')
>>> c[0]
1
>>> 
>>> d = bytearray([1,2,3])
>>> d
bytearray(b'x01x02x03')
>>> d[1] = 20
>>> d
bytearray(b'x01x14x03')

sum(),对队列进行求和

bytes

6 round()

讲述:对浮点数x举行4舍5入求值
语法:round(x [, n])
示例:

>>> round(100.126,2)
    100.13

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

  创造三个 “可变的” byte数组,能够选取整型,字符串和迭代器来开头化

  参数为字符串时,字符串中的每三个字符将转移为数组的元素,由此须要提供编码类型,类似utf-8, ascii

  参数为整型时,整形值将用作数组的初阶化大小,数组的要素则开头化为0

  参数为迭代器时,迭代器的各类成分将作为数组的因素,由此迭代器的值必须为0-255的整型,不然将发出相当。

>>> a = bytearray(10)
>>> a
bytearray(b'x00x00x00x00x00x00x00x00x00x00')
>>> a[0]
0
>>> len(a)
10
>>> 
>>> b = bytearray('abc', 'utf-8')
>>> b
bytearray(b'abc')
>>> b[0]
97
>>> 
>>> c = bytearray(range(1,5))
>>> c
bytearray(b'x01x02x03x04')
>>> c[0]
1
>>> 
>>> d = bytearray([1,2,3])
>>> d
bytearray(b'x01x02x03')
>>> d[1] = 20
>>> d
bytearray(b'x01x14x03')

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

  bytesbytearray的3个不可变的版本,别的的能够参照bytearray

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

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

callable(object)

万壹object参数能够调用就回到True,不然再次来到False。虽然回去True,它依旧也许调用失利,然则要是回到False,就永久不容许调用成功。注类是可调用的(调用二个类重临3个实例);类的实比如果有2个__call__()方法正是可调用的。

澳门新萄京官方网站 3

callable

7 sum()

讲述:对成分类型是数值的可迭代对象中的每一种成分求和
语法:sum(iterable[, start])
参数:
iterable -- 可迭代对象,如:列表、元组、集合

start -- 钦点相加的参数,假设未有安装那个值,默感到0
示例:

>>> sum([3,2])
    5
>>> sum((2,5,6),10)
    23

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

  bytesbytearray的八个不可变的本子,别的的可以参见bytearray

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

callable(object)

  判定指标是否能够调用,假诺得以则赶回 True, 不然赶回 False

  类是可调用的,调用后回来三个类的实例。对象要是带有了__call__()艺术也是可调用的。

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

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

进制调换

chr(x)

归来二个ascii码是整数x的字符的字符串。举例,chr(9七)重返string 'a'.那和ord()刚好相反。

贰 类型转变

callable(object)

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

  类是可调用的,调用后赶回多少个类的实例。对象假诺含有了__call__()办法也是可调用的。

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

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

 chr(i)

  返回Unicode对应的字符。

  参数范围为 0 -- 1114111, 超越此限制将生出分外

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

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

classmethod(function)

回去函数的3个类格局。

1 bool()

讲述:用于将加以参数转变为布尔类型,要是未有参数,重临 False。
语法:bool(x)
示例:

>>> bool(4)
    True
>>> bool(0)
    False

 chr(i)

  返回Unicode相应的字符。

  参数范围为 0 -- 1114111, 超越此限制将时有爆发十分

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

classmethod(function)

  一般作为函数装饰器 @classmethod

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

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

  类措施有3个比较有利的用途正是作为类似C 中的开端化函数重载

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

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

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



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

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

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

编写翻译string为贰个代码对象。代码对象能够通过exec语句实践也许通过调用eval()总结。那filename参数钦定代码从哪些文件读取。如若不从文件中读取,就须传递一些可辨识的值(平时使用'')。kind参数钦赐哪个种类代码被编译;若是是含有一名目很多语句组成的子符串能够‘exec’,若是是由贰个表明式组成,就'eval',若是由二个并行语句组成就‘singlw’(表明式语句总计的结果不是None将打字与印刷出来)。

当编写翻译贰个多行语句时,应用四个警示:必须以'n'作为行结束符,同不常候输入必须至少以一个'n'作为完毕。假如是以'rn'作为行终止,使用string的repalce()方法将其改为‘n’.

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

2 int()

讲述:用于将3个字符串或数字调换为整型
语法:int(x, base=10)
参数:iterablex -- 字符串或数字。
base -- 进制数,暗中认可10进制。
示例:

>>> int(3.6)
    3
>>> int('12',8)
    10

classmethod(function)

  一般作为函数装饰器 @classmethod

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

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

  类措施有二个相比较便宜的用途就是作为类似C 中的开首化函数重载

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

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

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



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

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

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

  source -- 须求编写翻译的字符串

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

  mode -- 'eval' 配合 eval 使用, 'exec' 同盟多语句的 exec 使用,'single' 同盟单语句的 exec 使用

  注:实地衡量中,编写翻译的时候会判断mode, 但是推行的时候使用 exec 或者 eval,结果一样

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

hex() 将10进制整数转变为1六进制

complex( [real[, imag]])

始建叁个复数real imag*j大概将3个string恐怕number转化为一个复数. 要是第三个参数是三个字符串,它将用作复数解释,函数将被调用,而忽视第四个参数。第三个参数不或许是1个字符串。每3个参数都或者是一个数字类型包罗复数.即便imag省略了, 它默认为0,函数将用作3个数字调换函数像 int(), long() and float().倘诺参数都简短了,将回到0j.

澳门新萄京官方网站 4

complex

3 float()

叙述:用于将整数和字符串转变来浮点数
语法:float(x)
示例:

>>> float('2')
    2.0
>>> float(4)
    4.0

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

  再次来到2个复数。复数值为  real imag1j*

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


  注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

4 complex()

讲述:用于创制2个值为 real imag * j 的复数可能转载二个字符串或数为复数。若是第一个参数为字符串,则没有供给钦点第三个参数。
语法:complex([real[, imag]])
示例:

>>> complex(1,2)
    (1 2j)

complex([real[, imag]])

  再次回到二个复数。复数值为  real imag1j*

  参数也足感到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 是3个字符串


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

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

credits

5 str()

讲述:将指标转化为适应人读书的样式
语法:str(object='')
示例:

>>> a='abcd'
>>> str(a)
    'abcd

delattr(object, name)

  删除对象的2特质量(不能够是目的的主意),不过不会影响该类的任何对象。同 del object.name

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


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

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

  成立并重返三个字典对象。开头化参数能够有二种传播格局。

  关键字格局,将一直根据重大字生成字典

  迭代器情势,迭代器中的对象必须只有八个成分,第三个元素将作为key,第二个作为值

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

  注: 当然也足以直接使用字典作为参数来初叶化

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

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

delattr( object, name)

与setattr()相对的,参数是贰个对象和1个string.string必须是目的的壹脾品质。函数删除object这几个名称叫string的特性。举个例子,delattr(x, 'foobar')等价于del x.foobar

6 bytearray()

叙述:依照传入的参数创造3个新的字节数组,这一个数组里的成分是可变的,并且各样成分的值范围: 0 <= x < 25六
语法:bytearray([source[, encoding[, errors]]])
参数:
若果 source 为整数,则赶回3个尺寸为 source 的伊始化数组;
假诺 source 为字符串,则依据钦点的 encoding 将字符串转变为字节种类;
假如 source 为可迭代类型,则成分必须为[0 ,255] 中的整数;
假使 source 为与 buffer 接口壹致的对象,则此指标也得以被用来开始化 bytearray。
一经未有输入任何参数,暗中认可正是开首化数组为0个元素。
示例:

>>> bytearray([2,3,4])
    bytearray(b'x02x03x04')
>>> bytearray('python','GBK')
    bytearray(b'python')

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个可选的岗位参数或1组第壹词参数开首化3个字典。假若未有提交参数,再次来到一个空的字典。要是地点参数arg是3个炫目对象,重返叁个字典映射与映射对象同样的keys对应1律的值。那么地点参数应是二个队列,接济迭代的器皿,只怕是四个迭代目的。参数的每二个成分也务必是里面包车型客车1种,同期每1个包括四个目的。第三个作为新字典的key,同期第2个作为那个key的值。就算给定的key不只出现三次,那新字典将富含最后多个值。

假诺给出的是首要词参数,关键词和与其有关的值都将作为字典的项增加到字典中。假如多个ke既作为职责参数和作为四个至关心重视要词参数,关键词关联的值将保存在字典中。

澳门新萄京官方网站 5

再次来到都等价于{"one": 二, "two": 叁}

7 bytes()

描述:

  1. 重临值为叁个新的不得修改字节数组,每一个数字成分都无法不在0 - 25伍限制内,和bytearra函数的具有一样的作为,差异仅仅是回到的字节数组不可修改。
  2. 当一个参数都不传的时候,重回长度为0的字节数组
    语法:bytes([source[, encoding[, errors]]])
    示例:

    bytes('你好','utf-8') b'xe4xbdxa0xe5xa5xbd'

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符号表中名字的列表。借使有1个参数将尝试重返那一个参数对象的灵光属性。从指标的__dict__(如若定义了)属性,类或type对象收罗消息。那个列表不必然是一体化的。要是指标是2个模块对象,list包括模块属性的列表。借使目的是二个type或class对象,列表将含有属性的名字,同一时间递归其集散地的天性。不然,列表将涵盖对象属性的名字,类性质的名字,递归若基类的品质名字。结果列表按字母逐1排序。

8 memoryview()

叙述:根据传入的参数创造多个新的内部存款和储蓄器查看对象
所谓内部存款和储蓄器查看对象,是指对支撑缓冲区协议的数量举办李包裹装,在无需复制对象基础上同意Python代码访问
语法:memoryview(obj)
示例:

>>> s=memoryview(bytearray('abcd','utf-8'))            
>>> print(s[0])            
    97
>>> print(s[0:3])              
    <memory at 0x000002078A0B4048>
>>> print(s[0:3].tobytes())         
    b'abc'

divmod(a, b)

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

  注:a,b可认为整型只怕浮点型,不过不能是复数

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

enumerate(iterable, start=0)

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

  迭代器中的对象,第一个要素为序号(暗中认可从start=0发轫),第三个成分为流传迭代器中的对象。

  注: 多用于for遍历进度中,需求同不常候得到序号的情状。

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

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

divmod( a, b)

用八个数字(不是复数)作为参数,重回long除法获得的商和余数组成的1对数字。使用混合的操作类型,混合的类型,将使用使用二进制算术操作。对于一般和长整数,结果与(a // b, a % b)一样。对于浮点数结果和(q, a % b)同样,q平日是math.floor(a / b),但1旦是比一小,就为一.在其余动静下q * b a % b与a很周边,假诺a % b是非0的,它与b有同一的号子,同期0 <= abs(a % b) < abs(b).

澳门新萄京官方网站 6

divmod

9 ord()

叙述:再次回到Unicode字符对应的大背头
ord() 函数是 chr() 函数(对于7人的ASCII字符串)或 unichr() 函数(对于Unicode对象)的配对函数,它以3个字符(长度为一的字符串)作为参数,再次来到对应的 ASCII 数值,只怕 Unicode 数值,假设所给的 Unicode 字符高出了您的 Python 定义范围,则会抓住三个 TypeError 的要命。
语法:ord(s)
示例:

>>> ord('b')           
    98

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)

  将3个意味着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必须是1个队列, 一个迭代, 只怕其余对象它帮忙迭代.enumerate()重回的iterator的next()方法 重返2个元组包罗一定的数据(从0开端)和从迭代中拿走的相应的值。

10 chr()

叙述:再次回到整数所对应的Unicode字符
语法:chr(i)
示例:

>>> chr(100)               
    'd'
>>> chr(200)
    'È'
>>> chr(1)             
    'x01'

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

  将七个象征python表明式的字符串编写翻译成python言语并推行(慎用!

  重临值,假使传入参数是字符串只怕mode='eval'编写翻译的字节码,则赶回交互式运营结果,不然重回None

  globalslocals为高档用法,此处不举行。默许使用当前定名空间。

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

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

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

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

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

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

  重回值为None

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

  注1: 语句可以是多条

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

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

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

str()将指标转化为适应阅读的情势

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

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

expression参数是作为一个Python表明式被剖判和批评(本领上的话,多个标准列表)使用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()函数扶助从1个文书中实践语句。globals()和locals()函数分别再次来到当前的global和local字典,那对利用eval()或execfile()很有扶持

11 bin()

叙述:将整数调换来二进制字符串
语法:bin(x)
示例:

>>> bin(100)           
    '0b1100100'

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

  将1个象征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

12 oct()

叙述:将整数转化成八进制数字符串
语法:oct(x)
示例:

>>> oct(9)             
    '0o11'

filter(function, iterable)

  将三个可迭代的目的按传入的函数进行过滤。函数重临 True 的要素将保存,别的将被过滤掉。

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

float([x])

  创造并赶回3个浮点型的指标。

  x可感到3个数依然二个意味浮点数的字符串,缺省值为0

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

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

exit()

退出

13 hex()

讲述:将整数转变来1六进制字符串
语法:hex(x)
示例:

>>> hex(20)
    '0x14'

float([x])

  成立并赶回二个浮点型的指标。

  x可认为1个数仍旧五个意味浮点数的字符串,缺省值为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个列表。迭代能够是3个行列,一个支撑迭代的容器,或一个迭代器,即便Iterable的是四个字符串或3个元组,其结果也会有这体系型的,不然它始终是3个列表。假诺function是None,假定它是恒等函数,即,迭代是false其全部因素都被剔除。

请留心,filter(function,iterable),假若函数不为None等价于[item for item in iterable if function(item)],假使函数为None等价于[item for item in iterable if item]。

14 tuple()

讲述:依照传入的参数制造3个新的元组
语法:tuple( seq )
示例:

>>> tuple([1,2,3])
    (1, 2, 3)
>>> tuple({1,3,3})
    (1, 3)

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)

将字符串或数字转变或多个浮点数。若是参数是二个字符串,它必须包罗贰个恐怕带符号的10进制或浮点数,也许嵌入空格。否则,参数能够是二个平日或长整数或浮点数,重回1个与之一样值的浮点数(在Python的浮点精度内)。假使未有付诸参数,再次来到0.0。

15 list()

叙述:将元组调换为列表
语法:list( tup )
示例:

>>> list((1,2,3))
    [1, 2, 3]

frozenset([iterable])

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

16 dict()

讲述:依照传入的参数创造1个新的字典
语法:class dict(kwarg)
class dict(mapping,
kwarg)
class dict(iterable, kwarg)
参数:
kwargs -- 关键字
mapping -- 成分的器皿。
iterable -- 可迭代对象。
示例:

>>> dict(a='a', b='b', t='t') #传入关键字
    {'a': 'a', 'b': 'b', 't': 't'}
>>> 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}

getattr(object, name [, default])

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

  即便目的存在该属性则重返属性值。

  假设属性不设有,当传了default时返回default的值,不然发生特别。

  注:参数 name 是多少个字符串

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

globals()

  重返当前全局域的{对象: 值} 字典

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

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

frozenset( [iterable])

重回1个frozenset对象,其成分来自于Iterable。 Frozensets组未有更新的艺术,但足以哈希和别的组成员或作为字典键使用。一个frozenset的要素必须是不行更换。内部sets也应是frozenset对象。假设迭代一贯不点名,重回叁个新的空集,frozenset ([])。

17 set()

叙述:创立一个冬辰不重复成分集,可进展关联测试,删除重复数据,还足以测算交集、差集、并集等。
语法:class set([iterable])
示例:

>>> x=set('python')
>>> set(x)
{'n', 'p', 'y', 'h', 't', 'o'}

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

18 frozenset()

讲述:重回1个冻结的成团,冻结后群集无法再增加或删除任何因素
语法:class frozenset([iterable])
示例:

>>> a=frozenset([1,2,3])
>>> a
    frozenset({1, 2, 3})
>>> b=frozenset('python')
>>> b
    frozenset({'h', 't', 'o', 'p', 'y', 'n'})

hasattr(object, name)

  剖断1个指标是否存在钦定的品质。存在重返 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符号表字典的字典。那始终是近期模块字典(在二个函数或方法内,是在它被定义的模块,而不是被调用的模块)。

19 enumerate()

讲述:用于将3个可遍历的数量对象(如列表、元组或字符串)组合为叁个索引系列,同期列出多少和数目下标,一般用在 for 循环在那之中。
语法:enumerate(sequence, [start=0])
示例:

>>> list1=['a','b','c']
>>> for index,value in enumerate(list1):
    print(index,value)  
    0 a
    1 b
    2 c
>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
    [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

澳门新萄京官方网站,hash(object)

  再次回到三个指标的hash值,假诺目的不可hash会生出极度。

>>> hash(10)
10
>>> 
>>> hash('test')
2595417156033713210
>>> 
>>> hash((1,2,3))
2528502973977326415
>>> 
>>> hash([1,2,3])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

help([object])

  展现对象的帮手消息。要是未有参数则进入帮助的并行格局。

>>> help(eval)

Help on built-in function eval in module builtins:

eval(source, globals=None, locals=None, /)
    Evaluate the given source in the context of globals and locals.

    The source may be a string representing a Python expression
    or a code object as returned by compile().
    The globals must be a dictionary and locals can be any mapping,
    defaulting to the current globals and locals.
    If only globals is given, locals defaults to it.

def is_odd(n):

      return n % 2 == 1

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

print(list(aList))

hasattr( object, name)

该参数是三个指标和八个字符串。若是字符串是目的的个中三性格质,结果为True,倘若未有回来False。 (那是经过调用的getattr(对象名称),看是或不是引发那么些与否。)

20 range()

叙述:函数可创立三个整数列表,一般用在 for 循环中。
语法:range(start, stop[, step])
示例:

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

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型对象时,则对象必须定义2个__index__() 方法,则赶回整型值,否则将时有发生至极。

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

迭代相关函数

hash()

回到对象(借使部分话)的哈希值。哈希值是整数。它们被用来在词典查找时,作为二个快速相比较字典keys键。具有一样的哈希值,数值相等(即便它们属于分化的门类,因为是一和壹.0的情景)。

21 iter()

叙述:用来扭转迭代器
语法:iter(object[, sentinel])
参数:object -- 补助迭代的集合对象。
sentinel -- 若是传递了第四个参数,则参数 object 必须是二个可调用的对象(如,函数),此时,iter 创造了3个迭代器对象,每一次调用那几个迭代器对象的__next__()方法时,都会调用 object。
示例:

>>> list2=[1,2,3,4]
>>> for i in iter(list2):
    print(i)
    1
    2
    3
    4

hex(x)

  重回x的1⑥进制字符串,字符串以'0x'初叶,字符串中的字符都是小写情势表示。

  当x不是多个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或文书档案宗旨名称和声援页面名字进行寻觅后在调控台上打字与印刷出来。倘诺参数是别的别的连串的靶子,将产生该对象的二个拉扯页面。

22 slice()

叙述:完结切丝对象,首要用在切除操作函数里的参数字传送递
语法:class slice(stop)
class slice(start, stop[, step])
参数:
start -- 开首地点
stop -- 停止地方
step -- 间距
示例:

>>> myslice=slice(4)
>>> myslice
slice(None, 4, None)
>>> arr=range(10)
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(arr[myslice])
[0, 1, 2, 3]

id(object)

  重临对象的中间ID值。

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

 input([prompt])

  接收标准输入转为字符串并再次回到。

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

  注:1旦读到 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", 叁:"C"}))

hex(x)

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

23 super()

叙述:依照传入的参数创制3个新的子类和父类关系的代理对象
super是用来消除多重承继难点的,直接用类名调用父类方法在利用单承袭的时候没难题,然而要是选拔多一而再,会涉及到找出顺序(MRO)、重复调用(钻石承接)等各类难题。
MRO 正是类的方式剖析顺序表, 其实也正是后续父类方法时的顺序表。
语法:super(type[, object-or-type])
参数:type -- 类。
object-or-type -- 类,一般是 self
示例:

>>> class A:
    pass

>>> class B(A):
    def add(self,x):
        supper().add(x)

 input([prompt])

  接收规范输入转为字符串并回到。

  prompt 为输入提醒字符串,可以大致。

  注:设若读到 EOF 将产生相当。

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

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

  重返3个整型数。输入参数能够是三个数要么三个字符串(当然可以是其余对象,但此间不上课这种非主流用法)。

  参数为1个数时,再次回到对象的__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()值。 (达成注意:这是目标的地方。)

二四 object:创建三个新的object对象

叙述:(一)object类是Python中全数类的基类,即使定义贰个类时未有一些名承继哪个类,则默许承继object类

>>> class C:
    pass
>>> issubclass(A,object)
True

(二)object类定义了全体类的有个别公共艺术

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

(三)object类未有定义 dict,所以不可能对object类实例对象尝试设置属性值

>>> s=object()
>>> s.name='sun' # 不能设置属性
Traceback (most recent call last):
  File "<pyshell#69>", line 1, in <module>
    s.name='sun'
AttributeError: 'object' object has no attribute 'name'
>>> class D:
    pass
>>> a=D()
>>> a.name='sun'    # 能设置属性

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

  重临八个整型数。输入参数能够是三个数要么三个字符串(当然能够是任何对象,但此处不上课这种非主流用法)。

  参数为3个数时,重临对象的__int__()方法的值,对于整型对象就是自身的值,对于浮点型对象就是整数局地。

  参数为三个字符串时,字符串必须代表1个②、捌、十、1陆进制,并传到相应的base值。

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

 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 参数是3个元组,那么只要对象属于内部的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参数是一个元组,那么只要类属于内部八个类的子类即重回 True

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

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

int( [x[, radix]])

改造为字符串或数字为纯整数。假使参数是二个字符串,它必须含有一个可能有标识的十进制数作为一个Python整数,大概嵌入空格。以radix参数给出的基数为底蕴进行调换(那是私下认可10),能够是任何在[2,36]限制内的整数,或零。假设基数为零,依据字符串的内容估量精确的基数。如若内定的基数x是还是不是3个字符串,引发TypeError万分。不然,参数能够是2个平日或长整数或浮点数。转变浮点数截断为整数(直到零)。就算参数是整数范围之外的,将赶回二个long object。假设未有交到参数,再次来到0

1 all()

讲述:用于剖断给定的可迭代参数 iterable 中的全体因素是不是都为 TRUE,若是是回来 True,不然再次回到 False。成分除了是 0、空、FALSE 外都算 TRUE
语法:all(iterable)
示例:

>>> all(['a','b','c'])
True
>>> all(['a','b',0])
False

issubclass(class, classinfo)

  判定三个类是或不是为钦点类的子类。

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

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

  假若 sentinel 参数未有传来则 object 必须是二个可迭代的靶子。

  即使 sentinel 参数有值,则object 必须是多个 callable 的对象,此时的遍历将再一次调用object, 直到重回值等于 sentinel(将发生StopIteration异常)

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

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

isinstance( object, classinfo)

重回true纵然该object参数是classinfo的三个实例,或其(直接或直接)子类的实例。也回到true假使classinfo是壹种type对象(new-style class)和是该品种或其(直接或直接)子类的对象。倘诺object不是class一个的实例恐怕给定类型的目的,函数再次来到false。假如classinfo既不是1个类的靶子也不是1个type的靶子,它也许是三个蕴涵类或项指标指标的tuple,也大概带有别的的递归元组(连串类型不接受)。假使classinfo不是1个类,类型或元组类,类型,只怕这种元组,将抛出一个TypeError非凡。

2 any()

讲述:用于推断给定的可迭代参数 iterable 是不是全部为 False,则赶回 False,纵然有2个为 True,则赶回 True。元素除了是 0、空、FALSE 外都算 TRUE。
语法:any(iterable)
示例:

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

iter(object [, sentinel])

  再次来到2个迭代器对象,用于遍历,一般与 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 1n'
>>> next(itf)
'test line 2n'
>>> next(itf)
'test line 3n'
>>> next(itf)
'n'
>>> next(itf)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> f.close()

len(s)

  重返对象的尺寸。对象一般是四个体系和贰个凑合。

  如果是任何对象,则对象必须含有 __len__() 方法,不然会发出拾分。

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

hasattr(object, attr)用于推断三个指标是或不是有某一属性

issubclass( class, classinfo)

回到true假如class是classinfo(直接或直接)的子类。贰个类被感到是团结的子类。 classinfo或然是类对象元组,在这种情景下元组中的每一种classinfo项将被开始展览测试。在其他任何景况下,抛出1个TypeError相当。

3 filter()

叙述:用于过滤类别,过滤掉不符合条件的因素,重返由符合条件成分构成的新列表。
该接受七个参数,第二个为函数,第二个为系列,体系的各类元素作为参数字传送递给函数举行判,然后再次来到True 或 False,最后将赶回 True 的要素放到新列表中。
语法:filter(function, iterable)
参数:function -- 决断函数。
iterable -- 可迭代对象。
示例:

>>> def is_odd(n):
    return n%2==1
>>> newslist=filter(is_odd,[1,2,3,4,5,6,7])
>>> list(newslist)
[1, 3, 5, 7]

len(s)

  重回对象的长短。对象一般是2个行列和1个聚众。

  假设是别的对象,则对象必须包罗 __len__() 方法,不然会生出特别。

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

list([iterable])

  创造并回到三个列表对象。纵然未有传来参数,则赶回一个空驶列车表。

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

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

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

iter( o[, sentinel])

回去贰个迭代器对象。第一个参数有不一样的解说,视第贰个参数的存在与否而定。如若未有第二个参数,o必须是二个目的的集合,协助迭代协议(__iter__()方法),也许它必须辅助体系协议(以整数0开始的参数__getitem__()方法)。如若它不援助那些协议,将抛出TypeError万分。假如第二个参数,sentinel,给出,然后o必须是可调用的靶子。在这种气象下开创的每四个迭代器无参调用o它的next()方法,借使重返值等于sentinel,将抛出StopIteration,不然将重临此外的值。

4 map()

讲述:根据提供的函数对点名种类做映射。
先是个参数 function 以参数系列中的每二个要素调用 function 函数,重返包涵每便 function 函数重返值的新列表
语法:map(function, iterable, ...)
参数:function -- 函数,有八个参数
iterable -- 一个或八个连串
示例:

>>> def square(x):
    return x ** 2
>>> list(map(square,[1,2,3,4]))
[1, 4, 9, 16]

list([iterable])

  创制并重临八个列表对象。纵然未有传来参数,则赶回二个空驶列车表。

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

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

locals()

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

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

isinstance() 用于剖断3个目的是不是是某一门类,类似type,但type不会以为子类是父类类型,isinstance会感到子类是父类类型

len(s)

回去3个对象的尺寸。参数能够是一个系列(字符串,元组或列表)或映射(词典)。

5 next()

叙述:重临可迭代对象中的下1个成分值
语法:next(iterator[, default])
示例:

>>> it=iter([1,2,3,5])
>>> while True:
    try:
        x=next(it)
        print(x)
    except StopIteration:
        break   
    1
    2
    3
    5

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

6 reversed()

讲述:反转体系生成新的可迭代对象
语法:reversed(seq)
reverse和reversed的界别:reverse是行使在list上的不二秘诀,reversed能够对持有可迭代的靶子开始展览排序操作
参数:seq -- 要改动的行列,能够是 tuple, string, list 或 range
示例:

>>> l3=['a','b','c']
>>> print(list(reversed(l3)))
    ['c', 'b', 'a']

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

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

  参数 key 可以改变默许的可比艺术。

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

list( [iterable])

再次回到二个列表的items与可迭代的门类同样的依次且同样的items。可迭代能够是3个行列,三个容器,帮助迭代,或贰个迭代器对象。借使可迭代已经是一个列表,将赶回三个别本,类似的于iterable[:]。例如,list('abc')返回['a', 'b', 'c']和list( (1, 2, 3) ) 返回[1,2,3]。假若未有付诸参数,重返贰个新的空驶列车表,[]。

7 sorted()

讲述:sorted() 函数对具有可迭代的对象进行排序操作
sort 与 sorted 区别:
sort 是接纳在 list 上的点子,sorted 能够对具备可迭代的目的举行排序操作。
list 的 sort 方法再次来到的是对已经存在的列表进行操作,而内建函数 sorted 方法再次回到的是叁个新的 list,而不是在本来的底蕴上开始展览的操作。
语法:sorted(iterable, key=None, reverse=False)
参数:iterable -- 可迭代对象。
key -- 重假若用来拓展相比的成分,只有2个参数,具体的函数的参数正是取自于可迭代对象中,钦赐可迭代对象中的一个要一贯进展排序。
reverse -- 排序规则,reverse = True 降序 , reverse = False 升序(私下认可)。
示例:

>>> sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5]
>>> example_list = [5, 0, 6, 1, 2, 7, 3, 4]
>>> sorted(example_list, reverse=True)
[7, 6, 5, 4, 3, 2, 1, 0]。

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

  再次来到最大值。要相比的参数可以是八个可迭代的对象,也能够一向传入对象列表。

  参数 key 能够变动暗许的可比艺术。

  当传入的是3个迭代器时,假诺迭代器为空,则赶回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)

  再次回到2个内部存款和储蓄器观看对象。传入的指标必须协理缓冲区交涉,内建目标中接济的有 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用作一些变量的值。

8 zip()

讲述:用于将可迭代的目的作为参数,将对象中对应的元素打包成三个个元组,然后重临由那些元组组成的列表。
如果每种迭代器的要素个数分裂等,则赶回列表长度与最短的靶子一样,利用 *号操作符,能够将元组解压为列表。
语法:zip([iterable, ...])
参数: iterabl -- 三个或多个迭代器;
示例:

>>> a=[1,2,3]
>>> b=['a','b','c']
>>> list(zip(a,b))
[(1, 'a'), (2, 'b'), (3, 'c')]

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'

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项。要是二个迭代比另1个短,将以None实行扩大。假诺function是None,将假诺为identity function,若是有多少个参数,map()重临三个列表包括全部iterables相应的门类的元组组成。可迭代的参数或许是2个种类或任何可迭代的对象,结果一连一个列表。

四 对象操作

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

  重返最小值。用法与 max 类似

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

next(iterator [, default])

  再次回到迭代器中的下3个。一般与 iter() 同盟使用。

  当迭代形成之后,假如传入了default参数,则返回default的值,不然产成澳门新萄京官方网站:內建函数,我的Python之旅第五天。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

澳门新萄京官方网站:內建函数,我的Python之旅第五天。        def sm():

              print('静态方法调用')

class B(A):

       pass

A.cm()

B.cm()

A.sm()

B.sm()

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

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

可选的key参数钦赐带2个参数的排序函数,用于list.sort()。key参数,假若有,必须在以keyword的花样(举个例子,"max(a,b,c,key=func)")。

1 help()

讲述:用于查看函数或模块用途的细致操作
语法:help([object])
重回值:重临对象支持新闻
示例:

>>> help('sys')
Help on built-in module sys:
NAME
    sys
    .....

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

2 dir()

叙述:函数不带参数时,重回当前界定内的变量、方法和定义的品种列表;带参数时,重临参数的性质、方法列表。借使参数包括方法__dir__(),该办法将被调用。借使参数不带有__dir__(),该方法将最大限度地搜罗参数消息。
语法:dir([object])
示例:

>>> dir()               
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']

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型对象时,则对象必须定义3个__index__() 方法,则赶回整型值,不然将发生卓殊。

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

open()用于展开三个文件,创造1个file对象

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

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

可选的key参数钦命带叁个参数的排序函数,用于list.sort()。key参数,假诺有,必须在以keyword的样式(譬喻,"max(a,b,c,key=func)")。

3 id()

叙述:用于获取对象的内部存款和储蓄器地址
语法:id([object])
示例:

>>> a='abc'                 
>>> id(a)                   
2203966126936

oct(x)

  再次来到x的八进制字符串,字符串以'0o'开始,字符串中的字符都以小写情势表示。

  当x不是二个int型对象时,则对象必须定义3个__index__() 方法,则赶回整型值,不然将产生特别。

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

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

  展开1个文件,再次回到二个文书的指标。open的选择特别丰盛,这里为扫除文盲,只表明最常用最基本的用法。

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

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

  参数 mode,张开方式

    - 'r',  只读情势,倘若文件不设有将发出11分。

    - 'w',  写格局展开,即便文件存在,最初的文章件将被遮盖,假使不存在将创立新文件。

    - 'x',创立三个新文件并开荒,假若文件存在将暴发11分。

    - 'a',  追加情势张开,如若文件存在,展开后指针指向文件后面部分,假设不存在将成立新文件。

    - ‘b',  二进制格局张开。

    - 't',  文本情势展开(缺省)

    - ' ', 读写情势打开,合营r, w, a使用

    个中常用组合形式,r , rb , w , wb , a , ab

  注: 为保险使用安全性,常协作 with 使用

>>> f = open('test.txt', 'r', encoding='utf-8')
>>> f.readline()
'test line1n'
>>> f.close()
>>> 
>>> with open('test.txt', 'r') as f:
...     print(f.readline())
... 
test line1

format()格式化函数

next

4 hash()

叙述:用于获取取一个指标(字符串也许数值等)的哈希值
语法:hash(object)
示例:

>>> hash('python')              
6061303635929480506

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

  展开贰个文本,返回一个文件的对象。open的运用极度丰盛,这里为扫除文盲,只表明最常用最宗旨的用法。

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

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

  参数 mode,展开格局

    - 'r',  只读情势,要是文件不设有将发生非常。

    - 'w',  写格局展开,假设文件存在,最初的小说件将被覆盖,假使不存在将开革新文件。

    - 'x',创建二个新文件并展开,假诺文件存在将产生非凡。

    - 'a',  追加格局张开,假使文件存在,展开后指针指向文件尾巴部分,如果不存在将创造新文件。

    - ‘b',  二进制情势打开。

    - 't',  文本情势张开(缺省)

    - ' ', 读写格局张开,合营r, w, a使用

    其中常用组合方式,r , rb , w , wb , a , ab

  注: 为保障使用安全性,常协作 with 使用

>>> f = open('test.txt', 'r', encoding='utf-8')
>>> f.readline()
'test line1n'
>>> f.close()
>>> 
>>> with open('test.txt', 'r') as f:
...     print(f.readline())
... 
test line1

ord(c)

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

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

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

zip()将可迭代的对象作为参数,将目的中对应的要素打包成3个个元组,然后回到zip对象。假使各种迭代器的因素个数不壹致,则zip对象涵盖的列表长度与最短的目的一样,利用*号操作符,能够将元组解压为zip对象。

object()

归来四个新特色的靶子。object是有着new style class的基类。它的方法是新样式类的保有实例共有的。

5 type()

叙述:函数若是您唯有第叁个参数则赶回对象的连串,八个参数重返新的连串对象。
isinstance() 与 type() 区别:
type() 不会感到子类是一种父类类型,不考虑继续关系。
isinstance() 会以为子类是一种父类类型,考虑继续关系。
一旦要咬定三个项目是不是同样推荐应用 isinstance()。
语法:class type(name, bases, dict)
参数:name -- 类的名号。
bases -- 基类的元组。
dict -- 字典,类钦定义的命名空间变量
再次回到值:二个参数再次回到对象类型, 多少个参数,再次回到新的类型对象。
示例:

>>> type('qwer')                    
<class 'str'>
>>> class B:
    a=1                 
>>> B=type('B',(object,),dict(a=a))                 
>>> B                   
    <class '__main__.B'>

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)

调换一(大四大小)整数到贰个八进制字符串。

6 len()

叙述:方法再次来到对象(字符、列表、元组等)长度或项目个数
语法:len(s)
示例:

>>> len('abcd')                 
    4

pow(x, y [, z])

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

  假设传入了参数 z,则一定于 (x * y) % z*

  **注:*  如果 y 是负数,则无法流传 z


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

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

  打字与印刷函数。能够一次打字与印刷四个对象。sep, end, file, flush 如若要求修改,需以重大字格局内定。

  参数sep,多个指标的打字与印刷内容之间的分割符。

  参数end,全数指标内容输出完结后输出的字符。

  参数file, 输出的地点,暗中同意是正规输出,能够修改成文件等富有write() 方法的对象。

  参数flush, 是还是不是马上输出。False 大概会偶然放入缓冲区。

  注: 对于自定义的指标,假诺想被print调用急需具备 __str__() 方法

>>> print('hello,world')
hello,world
>>> print('hello', 'world')
hello world
>>> print('hello', 'world', sep='---')
hello---world
>>> print('hello', 'world', end='nnn')
hello world


>>> print('hello', 'world', '123', flush=True)
hello world 123
>>> 
>>> class MyTest:
...     def __str__(self):
...         return 'test'
... 
>>> a = MyTest()
>>> print(a)
test

range(stop)

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

开辟三个文书,`File Objects'。假诺文件不能开发,IOError相当引发。当张开三个文件,最棒调用open(),而不是一贯用file构造。

前两个参数与stdio的fopen()函数一样:filename是要打开的文书名,mode是2个字符串,表示该公文是哪些被展开。

mode,最常用的值是'r'读,'w'写(文件倘诺已存在就截断),和'a'追加(在部分Unix系统意味着全数写入追加到文件尾巴部分,无论其未来的seek地点)。借使格局被简单,默以为'r'等。当张开三个二进制文件,你应当情势值加上'b',展开2进制形式,从而进步可行性。 (在少数不区分2进制文件和文件文件的体系扩大‘b’,,它将用作文档)。下边是mode的大概值:

可选bufsize参数钦命文件的所需缓冲区大小:0代表无缓冲,一意味着行缓冲,任何其余的正数使用其大小(在约)的2个缓冲区。负数bufsize,使用系统暗中认可,那tty设备经常采取行缓冲和此外文件的一点壹滴缓冲。倘若轻易,使用系统私下认可。

模式'r ', 'w '和'a '展开文件实行立异(请留意,'w '截断该公文)。附加'b'的形式在分别贰进制和文件文件的种类上以贰进制格局张开文件,系统上未有这些差异,参与了'b'未有效应。

7 ascii()

叙述:函数类似 repr() 函数, 再次来到二个意味着对象的字符串, 不过对于字符串中的非 ASCII 字符则再次回到经过 repr() 函数使用 x, u 或 U 编码的字符。
语法:ascii(object)
示例:

>>> ascii("abc")                
"'abc'"

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

  打字与印刷函数。能够三回打字与印刷多少个对象。sep, end, file, flush 借使需求修改,需以重视字格局内定。

  参数sep,多少个指标的打字与印刷内容之间的分割符。

  参数end,全数指标内容输出达成后输出的字符。

  参数file, 输出的地方,暗许是专门的学问输出,能够修改成文件等具有write() 方法的靶子。

  参数flush, 是不是登时输出。False 或然会有时放入缓冲区。

  注: 对于自定义的对象,如果想被print调用内需有所 __str__() 方法

>>> print('hello,world')
hello,world
>>> print('hello', 'world')
hello world
>>> print('hello', 'world', sep='---')
hello---world
>>> print('hello', 'world', end='nnn')
hello world


>>> print('hello', 'world', '123', flush=True)
hello world 123
>>> 
>>> class MyTest:
...     def __str__(self):
...         return 'test'
... 
>>> a = MyTest()
>>> print(a)
test

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

  属性装饰器。能够便宜的拜访对象的有些属性,防止直接操作内部属性。

  函数再次回到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)

给定2个尺寸为1的字符串,重回两个整数,当参数是三个Unicode对象,代表字符的Unicode代码,或参数是二个五位字符串,代表其字节值,。举个例子,ord('a')重返整数玖柒,ord(u'u2020')再次回到8224。这是6人串chr()和用于Unicode对象的unichr()的逆函数。即便给出Unicode参数和Python是UCS二Unicode的,字符的代码点必须在界定[0 .. 65535]内,不然字符串的长短是2,抛出2个TypeErro。

8 format()

讲述:Python二.六 开始,新扩展了一种格式化字符串的函数 str.format(),它加强了字符串格式化的作用。基本语法是透过 {} 和 : 来取代原先的 % 。format 函数能够承受不限个参数,地方能够不按顺序。
示例:

>>>"{} {}".format("hello", "world")    # 不设置指定位置,按默认顺序
'hello world'
>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'

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

  属性装饰器。能够方便的拜会对象的有个别属性,制止直接操作内部属性。

  函数重回贰个装修属性,将关系 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(stop)  range(start, stop [, step])

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

  当唯有3个参数时,连串为0到stop(不包含stop值), 步进为1

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

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

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

归来可迭代对象,start默以为0,step默以为一。

pow( x, y[, z])

重回x的Y次方,要是给出z,再次来到x的y次方,模Z(比pow(x, y) % z更使得)的。那多少个参数的花样pow(x, y),约等于:x ** y

9 vars()

讲述:重临当前功效域内的局地变量和其值组成的字典,大概重返对象的天性列表
语法:vars([object])
再次回到值:再次回到对象object的性质和属性值的字典对象,借使没有参数,就打字与印刷当前调用地点的天性和属性值 类似 locals()。
示例:

>>> print(vars())               
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'a': 'abc', 'B': <class '__main__.B'>}

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

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

  当唯有一个参数时,系列为0到stop(不包括stop值), 步进为1

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

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

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

repr(object)

  和 ascii() 类似,重回对象的可打字与印刷字符串。

  自定义对象固然须要 repr(),需求定义__repr__() 方法

>>> a = 123
>>> repr(a)
'123'
>>> b = 'test'
>>> repr(b)
"'test'"
>>> class MyTest:
...     def __repr__(self):
...         return 'Hello, world'
... 
>>> c = MyTest()
>>> repr(c)
'Hello, world'

print()

打印

5 反射操作

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

1 import()

叙述:用于动态加载类和函数。倘使四个模块平日转移就足以应用 import() 来动态载入
语法:import(name[, globals[, locals[, fromlist[, level]]]]) #name -- 模块名
示例:

a.py 文件代码:
#!/usr/bin/env python    
#encoding: utf-8  
import os  
print ('在 a.py 文件中 %s' % id(os))
test.py 文件代码:
#!/usr/bin/env python    
#encoding: utf-8  
import sys  __import__('a')        # 导入 a.py 模块

执行 test.py 文件,输出结果为:
在 a.py 文件中 4394716136

reversed(seq)

  再次来到2个队列逆序的迭代器。

  如若是自定义对象,要求达成 __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

2 isinstance()

叙述:isinstance() 函数来推断二个目的是还是不是是一个已知的项目,类似 type()。
isinstance() 与 type() 区别:
type() 不会感到子类是壹种父类类型,不思索继续关系。
isinstance() 会觉得子类是一种父类类型,考虑继续关系。
假诺要一口咬住不放多个品种是或不是壹律推荐使用 isinstance()。
语法:isinstance(object, classinfo)
示例:

>>> isinstance(1,int)               
True
>>> isinstance(a,(dict,int,list))                   
False

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

那是1个通用函数来创建包括算术级数的列表,那是平日使用于循环。该参数必须是一般整数。借使step参数被略去,默以为壹。借使不难start参数,默感觉0。step无法为零(不然引发ValueError)

3 issubclass()

讲述:判别类是不是是其它三个类还是项目元组中大4类成分的子类
语法:issubclass(class, classinfo)
参数:class -- 类。classinfo -- 类。
示例:

>>> class A:
    pass
>>> class B(A):
    pass
>>> print(issubclass(B,A))
True

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 是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函数会对参数类别桐月素实行储存

4 hasattr()

叙述:用于判定指标是否含有相应的习性。
语法:hasattr(object, name)
参数:object -- 对象。name -- 字符串,属性名。
示例:

class Coordinate:
    x = 10
    y = -5
    z = 0 
point1 = Coordinate() 
print(hasattr(point1, 'x'))
print(hasattr(point1, 'y'))
print(hasattr(point1, 'z'))
print(hasattr(point1, 'no'))  # 没有该属性

输出结果:

True
True
True
False

setattr(object, name, value)

  给对像的钦定属性赋值。假设指标不存在该属性,将先创造该属性。

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


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

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

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

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

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

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

  但是貌似能够直接在连串中用分片语法,比如 a为2个列表,分片语法为: 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)

再次来到贰个字符串,个中带有3个目的的可打字与印刷格局。有的时候是对可以访问3个平日的函数的操作很有用。对于众多类型,该函数使得试图再次回到一个字符串,会时有发生2个目的与传递给eval()一样的值产生的靶子同样。

5 getattr()

讲述:获取对象的属性值
语法:getattr(object, name[, default])
参数:
object -- 对象。
name -- 字符串,对象属性。
default -- 暗中认可再次来到值,假诺不提供该参数,在一向不对应属性时,将触发 AttributeError。
示例:

>>> class C:
    a='aaa'
>>> str1=C()
>>> getattr(str1,'a')
'aaa'

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

  生成3个分片对象。用于对队列进行分片。

  当唯有2个参数时,系列为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*)

  重回七个经过排序的列表。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必须是2个支撑种类协议的靶子(__len__()方法和__getitem__()以0起始的整数参数的不二秘技)

6 setattr()

叙述:对应函数 getatt(),用于安装属性值,该属性必须存在。
语法:setattr(object, name, value)
参数:
object -- 对象。
name -- 字符串,对象属性。
value -- 属性值
示例:

>>> class C:
    a='aaa' 
>>> str1=C()
>>> getattr(str1,'a')
'aaa'
>>> setattr(str1,'a','bbbb')
>>> str1.a
'bbbb'

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

归来浮点值x4舍5入到小数点后n位后数字。纵然n被回顾,默以为零。结果是一个浮点数。

7 delattr()

讲述:用于删除属性。delattr(x, 'foobar') 相等于 del x.foobar。
语法:delattr(object, name)
参数:object -- 对象。name -- 必须是目的的质量
示例:

>>> class Test:
    x=10
    y=9

>>> pri1=Test()
>>> print('x=',pri1.x)
x= 10
>>> print('y=',pri1.y)
y= 9
>>> delattr(Test,'y')
--删除 z 属性后--
>>> print('y=',pri1.y)
触发错误
Traceback (most recent call last):
  File "<pyshell#27>", line 1, in <module>
    print('y=',pri1.y)
AttributeError: 'Test' object has no attribute 'y'

staticmethod(function)

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

  将类中的三个艺术钦赐为静态方法  

  静态方法的调用可以一向通过类调用,即C.f(); 也能够透超过实际例调用,即C().f()

  个人认为静态方法适合将函数归类打包

  注:静态方法是能够持续的

>>> class MyTest:
...     @staticmethod
...     def static_test():
...         print('This is a static method')
... 
>>> 
>>> a = MyTest()
>>> a.static_test()
This is a static method
>>> 
>>> MyTest.static_test()
This is a static method

str(object='')  str(object=b'', encoding='utf-8', errors='strict')

  创设并赶回三个字符串对象。

  能够接纳内定的目的来开头化。早先化将接纳对象的 __str__() 方法再次回到的值。

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

set( [iterable])

再次回到其元素都是从iterable获得的set。成分必须是不足改换的。即使iterable未有一点点名,重回一个新的空集,设置([])

8 callable()

叙述:用于检查3个指标是不是是可调用的。假如回去True,object如故恐怕调用失败;但万壹回到False,调用对象ojbect相对不会成功。
对于函数, 方法, lambda 函式, 类, 以及落到实处了 call 方法的类实例, 它都回去 True。
语法:callable(object)
示例:

>>> def test(a,b):
    return a b
>>> callable(test)
True
>>> callable(111)
False

str(object='')  str(object=b'', encoding='utf-8', errors='strict')

  创立并重临三个字符串对象。

  能够使用钦命的对象来开头化。开首化将采取对象的 __str__() 方法再次回到的值。

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

sum(iterable [, start])

  对2个系列求和。

  参数start, 钦点2个开头值,默许是0

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

setattr( object, name, value)

与getattr()相呼应。该参数是3个目的,1个字符串和2个放四值。该字符串能够是水保属性名称或二个新的品质。函数分配给该属性值,只要该指标允许的话。举个例子,setattr(x, 'foobar', 123),也正是x.foobar = 1二3。

6 变量操作

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

1 globals()

讲述:重回当前成效域内的全局变量和其值组成的字典
语法:globals()
示例:

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

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

  重返父类的章程、对象。一般用来后续处理中,非常是开端化。

  在开端化中,super的参数能够几乎。

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

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


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


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

tuple([iterable])

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

  能够选择八个可迭代对象开首化元组。

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

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

重返1个新的排序的列表,包涵Iterable的项。

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

cmp钦命带四个参数(Iterable的成分),重回自2个负数,零或正数的函数“cmp=lambda x,y: cmp(x.lower(), y.lower())“。

key钦定带二个参数的函数,用来从列表每一个成分中领到八个比较key:“key=str.lower”

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

貌似来说,key和reverse调换过程是遥远快于内定叁个也等于cmp的机能。那是因为cmp是为各种列表元素调用很数十次,而key和reverse接触每一种成分只有三回。

2 locals()

叙述:会以字典类型再次回到当前岗位的全方位有的变量。
对此函数, 方法, lambda 函式, 类, 以及贯彻了 call 方法的类实例, 它都回到 True。
语法:locals()
示例:

>>> locals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'a': 'python'}
>>> def test2():
    a='hhh'
    print(locals())
>>> test2()
{'a': 'hhh'}

tuple([iterable])

  创立并赶回一个元组对象。

  能够接纳八个可迭代对象初步化元组。

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

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

  五个职能。传入的参数个数差别,功效不1

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

  四个参数时,动态创立一个自定义类的对象。

  当要求动态创设二个类时,

  参数name, 类名

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

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

函数再次回到2个静态方法。静态方法未有收受一个蕴涵的率先个参数

柒 交互操作

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

  八个效益。传入的参数个数分歧,功效分歧

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

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

  当要求动态创立四个类时,

  参数name, 类名

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

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

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

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

vars([object])

  重回对象新加上的属性字典。假使未有参数,再次来到当前命名空间创新的性质字典。

  实际上函数重回的正是指标 __dict__ 属性的值。

  注: 在起头化时加上的习性不会放入 __dict__

>>> class MyTest:
...     def __init__(self):
...         a = 1
...         b = 2
... 
>>> a = MyTest()
>>> 
>>> vars(a)
{}
>>> a.c = 3
>>> vars(a)
{'c': 3}
>>> a.__dict__
{'c': 3}
>>> 
>>> vars()
{'MyTest': <class '__main__.MyTest'>, 'a': <__main__.MyTest object at 0x7f1ca394f828>, '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__'}

str( [object])

回去3个字符串,当中涵盖对象可打印的描述。对于字符串,那将重临字符串自个儿。与repr(object)分化的是,str(object))并不总是试图再次回到八个eval()还行的字符串,其目的是回到1个可打字与印刷字符串。倘使未有提交参数,再次回到空字符串,''。

1 print()

叙述:向专门的职业输出对象打字与印刷输出
语法:print(*objects, sep=' ', end='n', file=sys.stdout)
参数:
objects -- 复数,表示能够三遍输出多个对象。输出七个对象时,须求用 , 分隔。
sep -- 用来间隔四个对象,暗中认可值是贰个空格。
end -- 用来设定以什么样最终。私下认可值是换行符 n,大家得以换来此外字符串。
file -- 要写入的文件对象。
示例:

>>> print('a')
a
>>> print('www','python','com',sep='.')
www.python.com

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

  将八个类别进行重新组合,再次回到一个元组列表。

  各种元组从各种体系中各提取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)]

 

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

2 input()

叙述:Python三.x 中 input() 函数接受3个规范输入数据,重回为 string 类型
语法:input([prompt]) #参数表达,prompt: 提醒消息
示例:

>>>a = input("input:")
input:123                  # 输入整数
>>> type(a)
<type 'int'>               # 整型

zip(iterables*)

  将多少个类别进行重新组合,重返1个元组列表。

  每种元组从各样连串中各提取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])

回来类型的超类。如若第3个参数被总结,重返的最好对象是未绑定。假若第三个参数是三个指标,isinstance(obj, type)必须是true。假如第3个参数是二个连串,issubclass(type贰, type)必须是true。super() 只可以用于新型类。

捌 文件操作

open()
讲述:用于打开三个文本,创设3个 file 对象,相关的法子才得以调用它实行读写
语法:open(name[, mode[, buffering]])
参数表达:
name : 贰个涵盖了你要访问的文件名称的字符串值。
mode : mode 决定了开采文件的格局:只读,写入,追加等。全体可取值见如下的完全列表。这一个参数是非强制的,暗中认可文件访问形式为只读(r)。
buffering : 若是 buffering 的值被设为 0,就不会有寄存。如若 buffering 的值取 一,访问文件时会寄存行。假使将 buffering 的值设为当先 ①的平头,注解了那正是的寄存区的缓冲大小。假诺取负值,寄存区的缓冲大小则为系统暗中认可。

tuple( [iterable])

重回二个元组的items与可迭代的iterable是同样的且有一致的1一。iterable大概是1个队列,容器辅助迭代,或迭代器对象。借使iterable已是元组,直接回到。比方,tuple('abc')重临('a', 'b', 'c') 和tuple([1, 2, 3])重临(一, ②, 3)。借使没有提交参数,重返3个新的空元组,()。

⑨ 编写翻译实施

type( object)

回到对象的花色。重回值是二个品类对象。

1 compile()

叙述:将字符串编写翻译为代码或然AST对象,使之能力所能达到通过exec语句来实践只怕eval举办求值
语法:compile(source, filename, mode[, flags[, dont_inherit]])
参数:
source -- 字符串可能AST(Abstract Syntax Trees)对象。。
filename -- 代码文件名称,如若不是从文件读代替码则传递一些可辨认的值。
mode -- 指确定人员编制写翻译代码的类型。能够内定为 exec, eval, single。
flags -- 变量功效域,局地命名空间,借使被提供,能够是别的映射对象。。
flags和dont_inherit是用来决定编译源码时的标识
示例:

>>> str='for i in range(0,5):print(i)'
>>> c=compile(str,'','exec')
>>> c
<code object <module> at 0x0000024A16DE5660, file "", line 1>
>>> exec(c)
0
1
2
3
4

vars( [object])

一经未有参数,根据现行反革命的local符号表再次回到3个字典。借使是2个模块,类或类的实例对象作为参数(或别的任何有__dict__属性),遵照指标的符号表重临3个字典。重返的字典不应被被修改:在对应符号表上的影响是未定义的。

2 eval()

叙述:用来施行一个字符串表明式,并赶回表明式的值
语法:eval(expression[, globals[, locals]])
参数:
expression -- 表达式。
globals -- 变量功用域,全局命名空间,借使被提供,则必须是贰个字典对象。
locals -- 变量成效域,局地命名空间,假设被提供,能够是其它映射对象。
示例:

>>> a=4
>>> eval('3*a')
12

zip( [iterable, ...])

以此函数重返二个元组列表,在那之中的第i元组蕴涵各种队列或iterables的第i个要素。再次来到的列表被截断长度为参数最短的连串的长短。当有多少个参数是同等长度,zip()类似于用无参数开头化的map() 。三个单身类别参数,它回到二个元组的列表。不带参数,它回到一个空驶列车表

3 exec()

讲述: 推行积累在字符串或文件中的 Python 语句,比较于 eval,exec能够实行更纷繁芜杂的 Python 代码。
语法:exec(object[, globals[, locals]])
参数:
object:必选参数,表示必要被内定的Python代码。它必须是字符串或code对象。假若object是贰个字符串,该字符串会先被分析为壹组Python语句,然后在进行(除非发生语法错误)。借使object是2个code对象,那么它只是被略去的试行。
globals:可选参数,表示全局命名空间(存放全局变量),假设被提供,则必须是二个字典对象。
locals:可选参数,表示最近部分命名空间(存放局地变量),假如被提供,能够是其余映射对象。假如该参数被忽视,那么它将会取与globals同样的值
示例:

>>> exec('print("hello world")')
hello world

4 repr()

讲述:将对象转化为供解释器读取的款式
语法:repr(object)
示例;

>>> repr('adg')
"'adg'"
>>> dict1={'key':'value'}
>>> repr(dict1)
"{'key': 'value'}"

十 装饰器

1 property()

叙述:在新式类中回到属性值
语法:class property([fget[, fset[, fdel[, doc]]]])
参数:
fget -- 获取属性值的函数
fset -- 设置属性值的函数
fdel -- 删除属性值函数
doc -- 属性描述消息
示例:

定义一个可控属性值 x
class C(object):
    def __init__(self):
        self._x = None
    def getx(self):
        return self._x
    def setx(self, value):
        self._x = value
    def delx(self):
        del self._x
    x = property(getx, setx, delx, "I'm the 'x' property.")

假定 c 是 C 的实例化, c.x 将触发 getter,c.x = value 将触发 setter , del c.x 触发 deleter。
比如给定 doc 参数,其将变成那一个属性值的 docstring,不然 property 函数就能够复制 fget 函数的 docstring(假使有些话)。

二 classmethod:标示方法为类措施的装饰器

讲述:修饰符对应的函数没有须要实例化,不必要 self 参数,但第二个参数需假诺意味本身类的 cls 参数,能够来调用类的习性,类的法门,实例化对象等
语法:classmethod
示例:

#!/usr/bin/python
# -*- coding: UTF-8 -*- 
class A(object):
    bar = 1
    def func1(self):  
        print ('foo') 
    @classmethod
    def func2(cls):
        print ('func2')
        print (cls.bar)
        cls().func1()   # 调用 foo 方法

A.func2()               # 不需要实例化
输出结果为:
func2
1
foo

3 staticmethod()

讲述:再次回到函数的静态方法。
该方法不强制供给传递参数,如下宣示二个静态方法:
class C(object):
@staticmethod
def f(arg1, arg2, ...):
...
上述实例评释了静态方法 f,类能够毫无实例化就足以调用该方法 C.f(),当然也得以实例化后调用 C().f()。
语法:staticmethod(function)
示例:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class C(object):
    @staticmethod
    def f():
        print('runoob');

C.f();          # 静态方法无需实例化
cobj = C()
cobj.f()        # 也可以实例化后调用

本文由澳门新萄京官方网站发布于www.8455.com,转载请注明出处:澳门新萄京官方网站:內建函数,我的Python之旅

关键词: