新濠天地 > c语言 > 要不再次回到,不然重临

原标题:要不再次回到,不然重临

浏览次数:84 时间:2019-09-26

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

Python标准库(3.x): 内建函数扫除文盲,python3.x

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

 

 

abs(x)

  求三个数的相对值。

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

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

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

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

ascii(object)

  该函数重回表示对象的可打字与印刷ascii字符串,如若字符串中饱含非ascii字符,则以x, u 或者 U 编码来表示

  函数实际是再次来到了对象的 __repr__() 方法的值

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

bin(x)

  将整型转变为二进制的字符串,字符串以'0b' 初始.

  但是身为将整型调换为二进制,其实是将对象的__index__() 方法重回的值转换为二进制字符串

  注意: 假诺目标未有__index__() 方法,将会生出十一分

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

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

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

 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的二个不可变的版本,别的的能够参见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

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

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)

 chr(i)

  返回Unicode对应的字符。

  参数范围为 0 -- 1114111, 当先此限制将发出非凡

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

classmethod(function)

  一般作为函数装饰器 @classmethod

  将类中的三个方法钦命为类措施。被内定的类方式第二个参数必得为cls(方法所在的类)

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

  类情势有贰个比较平价的用途便是作为类似C++中的初叶化函数重载

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

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

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



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

classmethod(function)

  一般作为函数装饰器 @classmethod

  将类中的叁个办法钦点为类格局。被钦赐的类措施第八个参数必需为cls(方法所在的类)

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

  类格局有叁个相比较方便的用处正是作为类似C++中的初步化函数重载

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

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

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



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

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

  该函数将饱含python语句的字符串编写翻译成可举行的字节码,编译的结果协作 eval, 或 exec 使用。

  source -- 要求编译的字符串

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

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

  注:实地度量中,编写翻译的时候会咬定mode, 然而实践的时候使用 exec 或者 eval,结果一样

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

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

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

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

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

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

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

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

complex([real[, imag]])

  再次来到三个复数。复数值为  real + 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)

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


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

delattr(object, name)

  删除对象的贰本性质(无法是目的的措施),不过不会潜濡默化该类的其余对象。同 del object.name

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


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

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

  创造并再次回到八个字典对象。初始化参数能够有二种传播格局。

  关键字格局,将直接依照重大字生成字典

  迭代器格局,迭代器中的对象必得唯有七个成分,第三个成分将作为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}

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

  成立并回到二个字典对象。开始化参数能够有二种传播情势。

  关键字格局,将一向依照主要字生成字典

  迭代器情势,迭代器中的对象必得独有七个要素,第一个要素将作为key,第2个作为值

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

  注: 当然也得以一向接纳字典作为参数来初阶化

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

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)

divmod(a, b)

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

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

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

enumerate(iterable, start=0)

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

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

  注: 多用于for遍历进程中,须要同一时候获取序号的景况。

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

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)

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

  再次来到值,假设传入参数是字符串大概mode='eval'编写翻译的字节码,则赶回交互式运转结果,不然再次回到None

  globalslocals为高端用法,此处不举办。暗中认可使用当前定名空间。

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

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

  注3: 能够匹配compile()使用

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

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

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

  将二个表示python表明式的字符串编写翻译成python话语并实施(慎用!

  重回值为None

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

  注1: 语句能够是多条

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

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

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

filter(function, iterable)

  将一个可迭代的靶子按传入的函数实行过滤。函数重返 True 的成分将保留,别的将被过滤掉。

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

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

float([x])

  创造并回到叁个浮点型的靶子。

  x可以为五个数依然贰个意味浮点数的字符串,缺省值为0

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

format(value [, format_spec])

  将value按格式化转化为字符串,并回到。

  方今比较多的用法是调用字符串的format方法。

  format_spec 内定格式化方式,此处不开展(将会有专项论题博文)。

>>> format(10, 'b')
'1010'
>>> format('555', '0>5')
'00555'

format(value [, format_spec])

  将value按格式化转化为字符串,并赶回。

  近期很多的用法是调用字符串的format方法。

  format_spec 钦定格式化格局,此处不开展(将会有专项论题博文)。

>>> format(10, 'b')
'1010'
>>> format('555', '0>5')
'00555'

frozenset([iterable])

  传入二个可迭代的目的,创立多个不可变的汇集。除了成分不能够加多删除了这么些之外,其余和可变会集类似。

  若无参数,则开创一个空集结。

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

frozenset([iterable])

  传入二个可迭代的对象,成立几个不可变的聚合。除了成分不能够加多删除了那些之外,别的和可变集结类似。

  若无参数,则开创一个空群集。

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

getattr(object, name [, default])

  获取对象的叁天性质的值。

  假设指标存在该属性则重返属性值。

  如若属性不设有,当传了default时返回default的值,不然产生非常。

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

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

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

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'

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.

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的16进制字符串,字符串以'0x'初始,字符串中的字符皆以小写方式表示。

  当x不是四个int型对象时,则对象必得定义三个__index__() 方法,则赶回整型值,不然将生出非常。

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

hex(x)

  重回x的16进制字符串,字符串以'0x'开端,字符串中的字符都是小写情势表示。

  当x不是三个int型对象时,则对象必得定义三个__index__() 方法,则赶回整型值,不然将生出至极。

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

id(object)

  重回对象的其中ID值。

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

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'

 input([prompt])

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

  prompt 为输入指示字符串,能够轻巧。

  注:若果读到 EOF 将发出拾叁分。

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

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

  重临二个整型数。输入参数能够是一个数可能二个字符串(当然能够是别的对象,但此间不上课这种肥猪流用法)。

  参数为多少个数时,重临对象的__int__()方法的值,对于整型对象正是自身的值,对于浮点型对象就是整数有些。

  参数为三个字符串时,字符串必需代表一个2、8、10、16进制,并传到相应的base值。

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

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

  重临一个整型数。输入参数能够是三个数恐怕贰个字符串(当然能够是其余对象,但那边不上课这种非主流用法)。

  参数为七个数时,重返对象的__int__()方法的值,对于整型对象就是笔者的值,对于浮点型对象正是整数局地。

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

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

 isinstance(object, classinfo)

  判定指标是或不是属于钦定的类。(能够协作 type 使用)

  注1: 假设钦赐类是当前目的的父类,判别结果也是 True

  **注2: 如果* classinfo 参数是八个元组,那么一旦对象属于中间的贰个类即重临 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

 isinstance(object, classinfo)

  判定目的是或不是属于钦定的类。(能够协作 type 使用)

  注1: 若是钦命类是时下指标的父类,剖断结果也是 True

  **注2: 如果* classinfo 参数是叁个元组,那么只要对象属于内部的叁个类即再次来到 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

issubclass(class, classinfo)

  剖断多个类是不是为钦定类的子类。

  注1: 类都是自己的子类

  注2: 如果 classinfo 参数是三个元组,那么只要类属于内部三个类的子类即重临 True

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

iter(object [, sentinel])

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

  假使 sentinel 参数未有传来则 object 必需是三个可迭代的靶子。

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

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

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

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

list([iterable])

  创设并赶回二个列表对象。若无传来参数,则赶回八个空驶列车表。

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

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

list([iterable])

  成立并重临贰个列表对象。若无传到参数,则赶回多个空驶列车表。

  传入的参数必得是三个可迭代的,迭代器中的每叁个指标将用作列表的三个因素。

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

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

map(function, iterable, ...)

  重临三个迭代器。迭代器中的每三个对象将是传播的迭代器依照function的炫丽。

  如若超过多个参数,后边的参数适用于 function 有多少个参数的情事,因而前面包车型大巴迭代器的长度不能够小于 iterable

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

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

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

  参数 key 能够转移暗中同意的比较艺术。

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

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)

  重返七个内存观看对象。传入的对象必需援助缓冲区磋商,内建指标中帮衬的有 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'

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'

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

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

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

next(iterator [, default])

  重临迭代器中的下一个。一般与 iter() 同盟使用。

  当迭代达成以往,如若传入了default参数,则返回default的值,不然产成StopIteration异常

>>> it = iter([1,2,3])
>>> next(it)
1
>>> next(it)
2
>>> next(it)
3
>>> next(it)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> 
>>> it = iter([1,2,3])
>>> next(it, default='end')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: next() takes no keyword arguments
>>> next(it, 'end')
1
>>> next(it, 'end')
2
>>> next(it, 'end')
3
>>> next(it, 'end')
'end'

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

object()

  创制多个基本对象。该类是全数类的基类。

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

oct(x)

  再次回到x的8进制字符串,字符串以'0o'起始,字符串中的字符都是小写方式表示。

  当x不是二个int型对象时,则对象必得定义贰个__index__() 方法,则赶回整型值,不然将时有产生非常。

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

oct(x)

  重临x的8进制字符串,字符串以'0o'开首,字符串中的字符都以小写形式表示。

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

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

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

  展开多个文本,再次回到三个文本的对象。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

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

  注: 参数必得是单纯的字符

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

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

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

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)

  属性装饰器。能够方便的拜谒对象的某部属性,制止直接操作内部属性。

  函数再次来到贰个装修属性,将涉嫌 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'

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

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

  函数再次来到贰个装饰属性,将关乎 fget, fset, fdel 函数

  参数doc提供一个支持新闻。

  当用@property装饰类方法时,方法宿将作为装修属性,方法定义为只读。此时一经急需set和del需求卓越@method.setter和@method.deleter使用

  注1: 二种完结方式中,get, set 和 del 都不是必需全体留存的

  注2: 三种完成方式中,get函数都只好有self参数

class MyTest:
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x

    def setx(self, v): 
        self._x = v 

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "The '_x' property")



class MyTest2:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        return self._x

    @x.setter
    def x(self, v): 
        self._x = v 

    @x.deleter
    def x(self):
        del self._x


>>> a = MyTest()
>>> a.x
>>> 
>>> a = MyTest()
>>> print(a.x)
None
>>> a.x = 'test'
>>> print(a.x)
test
>>> del a.x
>>> print(a.x)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/home/taopeng/Workspace/CodeWars/tmp.py", line 7, in getx
    return self._x
AttributeError: 'MyTest' object has no attribute '_x'



>>> b = MyTest2()
>>> print(b.x)
None
>>> b.x = 3
>>> print(b.x)
3
>>> del b.x
>>> print(b.x)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/home/taopeng/Workspace/CodeWars/tmp.py", line 25, in x
    return self._x
AttributeError: 'MyTest2' object has no attribute '_x'

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

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

  当独有二个参数时,类别为0到stop(不包罗stop值), 步进为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]

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'

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]

reversed(seq)

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

  假设是自定义对象,必要落成 __reversed__() 方法或然帮忙系列左券

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

round(number [, ndigits])

  保留钦点的小数位,再次回到多个最相近的数。

  参数 ndigits 默以为None, 即只保留整数部分。

  注1: 该函数当发展和向下取近似距离同样期,优先取不大的偶数。

  注2: ndigits 若是填0,纵然只保留整数位,可是会回来浮点型

>>> round(1.1)
1
>>> round(1.8)
2
>>> round(1.5)
2
>>> round(2.5)
2
>>> round(3.5)
4
>>> round(3.14, 1)
3.1
>>> round(3.16, 0)
3.0

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}

set([iterable])

  创制一个成团对象。若无参数则开创叁个空会集。

  参数必需是可迭代的。迭代器中的一样的指标将只会保留三个。

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

setattr(object, name, value)

  给对像的钦定属性赋值。倘若目的不设有该属性,将先创设该属性。

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


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

setattr(object, name, value)

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

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


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

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

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

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

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

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

  可是貌似能够直接在体系中用分片语法,比如 a为三个列表,分片语法为: a[start:stop:step]

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

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

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

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

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

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

  不过貌似能够直接在体系中用分片语法,比方 a为三个列表,分片语法为: a[start:stop:step]

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

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

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

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'

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

  对一个连串求和。

  参数start, 钦赐多个开始值,私下认可是0

>>> sum(range(5))
10
>>> sum(range(5), 3)
13
>>> sum({1,2,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

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

tuple([iterable])

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

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

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

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.

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

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

 

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

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

 

本文由新濠天地发布于c语言,转载请注明出处:要不再次回到,不然重临

关键词:

上一篇:新濠天地C#总复习

下一篇:新濠天地4.0中的三个比较根本的风味