day008-python内置函数
一、ptthon内置函数
二、内置函数详细概述
2.1 abs(x)：函数返回数字的绝对值。
注意：
1）x -- 数值表达式，可以是整数，浮点数，复数。
2)如果参数是一个复数，则返回它的大小。
>>> abs(-2)
2
2.2 all(iterable)：函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、None、False 外都算 True。
注意：
1）iterable -- 元组或列表。
2）元素除了是 0、空、None、False 外都算 True。
3）空元组、空列表返回值为True
>>> all(['a', 'b', 'c', 'd']) # 列表list，元素都不为空或0
True
>>> all(['a', 'b', '', 'd']) # 列表list，存在一个为空的元素
False
>>> all([0, 1，2, 3]) # 列表list，存在一个为0的元素
False >>> all(('a', 'b', 'c', 'd')) # 元组tuple，元素都不为空或0
True
>>> all(('a', 'b', '', 'd')) # 元组tuple，存在一个为空的元素
False
>>> all((0, 1, 2, 3)) # 元组tuple，存在一个为0的元素
False >>> all([]) # 空列表
True
>>> all(()) # 空元组
True
2.3 any(iterable)：函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。元素除了是 0、空、FALSE 外都算 TRUE
注意：
1）iterable -- 元组或列表。
2）如果都为空、0、false，则返回false，如果不都为空、0、false，则返回true。
>>>any(['a', 'b', 'c', 'd']) # 列表list，元素都不为空或0
True >>> any(['a', 'b', '', 'd']) # 列表list，存在一个为空的元素
True >>> any([0, '', False]) # 列表list,元素全为0,'',false
False >>> any(('a', 'b', 'c', 'd')) # 元组tuple，元素都不为空或0
True >>> any(('a', 'b', '', 'd')) # 元组tuple，存在一个为空的元素
True >>> any((0, '', False)) # 元组tuple，元素全为0,'',false
False >>> any([]) # 空列表
False >>> any(()) # 空元组
False
2.4 ascii(object) 函数类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符。
注意：
1）object-- 对象。
2）返回字符串。
>>> ascii('yusheng_liang')
"'yusheng_liang'"
2.5 bin(x) 返回一个整数 int 或者长整数 long int 的二进制表示。
注意：
1）x-- int 或者 long int 数字。
2）返回字符串。
>>>bin(10)
'0b1010'
>>> bin(20)
'0b10100'
2.6 bool(x) 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。bool 是 int 的子类。
注意：
1）x-- 要进行转换的参数。
2）返回True或False。
>>>bool()
False
>>> bool(0)
False
>>> bool(1)
True
>>> bool(2)
True
>>> issubclass(bool, int) # bool 是 int 子类
True
2.7 bytearray(x) 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
bytearray()语法:
class bytearray([source[, encoding[, errors]]])
参数说明：
1）如果 source 为整数，则返回一个长度为 source 的初始化数组；
2）如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
3）如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
4）如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
5）如果没有输入任何参数，默认就是初始化数组为0个元素。
>>>bytearray()
bytearray(b'')
>>> bytearray([1,2,3])
bytearray(b'\x01\x02\x03')
>>> bytearray('yusheng_liang', 'utf-8')
bytearray(b'yusheng_liang')
2.8 bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。
bytes()语法
class bytes([source[, encoding[, errors]]])
参数说明：
1）如果 source 为整数，则返回一个长度为 source 的初始化数组；
2）如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
3）如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
4）如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
5）如果没有输入任何参数，默认就是初始化数组为0个元素。
>>>a = bytes([1,2,3,4])
>>> a
b'\x01\x02\x03\x04'
>>> type(a)
<class 'bytes'>
>>>
>>> a = bytes('hello','ascii')
>>>
>>> a
b'hello'
>>> type(a)
<class 'bytes'>
2.9 callable(object) 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象 object 绝对不会成功。
注意：
1）object-- 对象。
2）可调用返回True，否则返回False
3）对于函数、方法、lambda 函式、 类以及实现了 __call__ 方法的类实例, 它都返回 True。
>>>callable(0)
False
>>> callable("yusheng_liang")
False >>> def add(a, b):
... return a + b
...
>>> callable(add) # 函数返回 True
True
>>> class A: # 类
... def method(self):
... return 0
...
>>> callable(A) # 类返回 True
True
>>> a = A()
>>> callable(a) # 没有实现 __call__, 返回 False
False
>>> class B:
... def __call__(self):
... return 0
...
>>> callable(B)
True
>>> b = B()
>>> callable(b) # 实现 __call__, 返回 True
True
2.10 chr(i) 用一个整数作参数，返回一个对应的字符。
注意：
1）i-- 可以是10进制也可以是16进制的形式的数字，数字范围为0到1114111（16进制为0x0FFFF）。
2）返回值是当前整数对应的ASCII字符。
>>>chr(0x30)
''
>>> chr(97)
'a'
>>> chr(8364)
'€'
2.11 classmethod 修饰符对应的函数不需要实例化，不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，可以来调用类的属性，类的方法，实例化对象等。
注意：
1）无参数。
2）返回函数的类方法。
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
#
#foo
2.12 compile() 函数将一个字符串编译为字节代码。
compile()语法：
compile(source, filename, mode[, flags[, dont_inherit]])
参数说明：
1）source -- 字符串或者AST（Abstract Syntax Trees）对象。。
2）filename -- 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
3）mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
4）flags -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
5）flags和dont_inherit是用来控制编译源码时的标志
>>>str = "for i in range(0,10): print(i)"
>>> c = compile(str,'','exec') # 编译为字节代码对象
>>> c
<code object <module> at 0x10141e0b0, file "", line 1>
>>> exec(c)
0
1
2
3
4
5
6
7
8
9
>>> str = "3 * 4 + 5"
>>> a = compile(str,'','eval')
>>> eval(a)
17
2.13 complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。
compile()语法：
class complex([real[, imag]])
参数说明：
1）real--int, long, float或字符串
2）imag--int, long, float
3）返回一个复数。
>>>complex(1, 2)
(1 + 2j) >>> complex(1) # 数字
(1 + 0j) >>> complex("") # 当做字符串处理
(1 + 0j) # 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错
>>> complex("1+2j")
(1 + 2j)
2.14 delattr() 函数用于删除属性。
delattr()语法：
delattr(object, name)
参数说明：
1）object--对象。
2）name--删除对象的属性。
class Coordinate:
x = 10
y = -5
z = 0 point1 = Coordinate() print('x = ',point1.x)
print('y = ',point1.y)
print('z = ',point1.z) delattr(Coordinate, 'z') print('--删除 z 属性后--')
print('x = ',point1.x)
print('y = ',point1.y)
2.15 dict() 函数用于创建一个字典。
dict()语法：
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
参数说明：
1）**kwarg--关键字
2）mapping--元素的容器
3）iterable--可迭代对象
4）返回值是一个字典。
>>>dict() # 创建空字典
{}
>>> dict(a='a', b='b', t='t') # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函数方式来构造字典
{'three': 3, 'two': 2, 'one': 1}
>>> dict([('one', 1), ('two', 2), ('three', 3)]) # 可迭代对象方式来构造字典
{'three': 3, 'two': 2, 'one': 1}
>>>
2.16 dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
dir()语法：
dir([object])
参数说明：
1）object--对象、变量、类型
2）返回模块的属性列表。
>>>dir() # 获得当前模块的属性列表
['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice']
>>> dir([ ]) # 查看列表的方法
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
2.17 divmod() 函数接收两个数字类型（非复数）参数，返回一个包含商和余数的元组(a // b, a % b)。
divmod()语法：
divmod(a, b)
参数说明：
1）a--数字，非复数
2）b--数字，非复数
注意：
1）如果参数 a 与 参数 b 都是整数，函数返回的结果相当于 (a // b, a % b)。
2）如果其中一个参数为浮点数时，函数返回的结果相当于 (q, a % b)，q 通常是 math.floor(a / b)，但也有可能是 1 ，比小，不过 q * b + a % b 的值会非常接近 a。
3）如果 a % b 的求余结果不为 0 ，则余数的正负符号跟参数 b 是一样的，若 b 是正数，余数为正数，若 b 为负数，余数也为负数，并且 0 <= abs(a % b) < abs(b)。
>>> divmod(7, 2)
(3, 1)
>>> divmod(8, 2)
(4, 0)
>>> divmod(8, -2)
(-4, 0)
>>> divmod(3, 1.3)
(2.0, 0.3999999999999999)
2.18 enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
enumerate()语法：
enumerate(sequence, [start=0])
参数说明：
1）sequence--一个序列，迭代器或其他支持迭代的对象。
2）start--下标起始位置
3）返回enumerate(枚举)对象。
>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>>list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>>list(enumerate(seasons, start=1)) # 小标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
#普通的for循环
>>>i = 0
>>>seq = ['one', 'two', 'three']
>>>for element in seq:
... print(i, seq[i])
... i += 1
...
0 one
1 two
2 three #for循环使用enumerate
>>>seq = ['one', 'two', 'three']
>>>for i, element in enumerate(seq):
... print(i, seq[i])
...
0 one
1 two
2 three
2.19 eval() 函数用来执行一个字符串表达式，并返回表达式的值。
eval()语法：
eval(expression[, globals[, locals]])
参数说明：
1）expression -- 表达式。
2）globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
3）locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
4）返回表达式计算结果。
>>>x = 7
>>> eval( '3 * x' )
21
>>> eval('pow(2,2)')
4
>>> eval('2 + 2')
4
>>> n=81
>>> eval("n + 4")
85
2.20 exec 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码。
exec()语法：
exec(object[, globals[, locals]])
参数说明：
1）object：必选参数，表示需要被指定的Python代码。它必须是字符串或code对象。如果object是一个字符串，该字符串会先被解析为一组Python语句，然后在执行（除非发生语法错误）。如果object是一个code对象，那么它只是被简单的执行。
2）globals：可选参数，表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象。
3）locals：可选参数，表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。如果该参数被忽略，那么它将会取与globals相同的值。
4）exec 返回值永远为 None。
>>>exec('print("Hello World")')
Hello World
# 单行语句字符串
>>> exec("print ('runoob.com')")
runoob.com
# 多行语句字符串
>>> exec ("""for i in range(5):
... print ("iter time: %d" % i)
... """)
iter time: 0
iter time: 1
iter time: 2
iter time: 3
iter time: 4
2.21 filter(function, iterable) 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。
filter()语法：
filter(function, iterable)
参数说明：
1）接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
2）function -- 判断函数。
3）iterable -- 可迭代对象。
4）返回一个迭代器对象。
#过滤出列表中的所有奇数
def is_odd(n):
return n % 2 == 1 tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)
2.22 float(x) 函数用于将整数和字符串转换成浮点数。
float(x)语法：
class float([x])
参数说明：
1）x -- 整数或字符串。
2）返回浮点数。
>>>float(1)
1.0
>>> float(112)
112.0
>>> float(-123.6)
-123.6
>>> float('') # 字符串
123.0
2.23 format() 字符串格式化，format 函数可以接受不限个参数，位置可以不按顺序。
format 基本语法是通过 {} 和 : 来代替以前的 %
format()实例一：str.format()
>>>"{} {}".format("hello", "world") # 不设置指定位置，按默认顺序
'hello world'
>>> "{0} {1}".format("hello", "world") # 设置指定位置
'hello world'
>>> "{1} {0} {1}".format("hello", "world") # 设置指定位置
'world hello world'
format()实例二：设置参数
#!/usr/bin/python
# -*- coding: UTF-8 -*- print("网站名：{name}, 地址 {url}".format(name="百度", url="www.baidu.com")) # 通过字典设置参数
site = {"name": "百度", "url": "www.baidu.com"}
print("网站名：{name}, 地址 {url}".format(**site)) # 通过列表索引设置参数
my_list = ['百度', 'www.baidu.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的 结果为：
网站名：百度, 地址 www.baidu.com
网站名：百度, 地址 www.baidu.com
网站名：百度, 地址 www.baidu.com
format()实例三：str.format() 传入对象
#!/usr/bin/python
# -*- coding: UTF-8 -*- class AssignValue(object):
def __init__(self, value):
self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value)) # "0" 是可选的
format()实例四：数字格式化
>>> print("{:.2f}".format(3.1415926));
3.14
2.24 frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
frozensetA()语法：
class frozenset([iterable])
参数说明：
1）iterable -- 可迭代的对象，比如列表、字典、元组等等。
2）返回新的 frozenset 对象，如果不提供任何参数，默认会生成空集合。
>>>a = frozenset(range(10)) # 生成一个新的不可变集合
>>> a
frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b = frozenset('runoob')
>>> b
frozenset(['b', 'r', 'u', 'o', 'n']) # 创建不可变集合
>>>
2.25 getattr() 函数用于返回一个对象属性值。
getattr()语法：
getattr(object, name[, default])
参数说明：
1）object -- 对象。
2）name -- 字符串，对象属性。
3）default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。
>>>class A(object):
... bar = 1
...
>>> a = A()
>>> getattr(a, 'bar') # 获取属性 bar 值
1
>>> getattr(a, 'bar2') # 属性 bar2 不存在，触发异常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'bar2'
>>> getattr(a, 'bar2', 3) # 属性 bar2 不存在，但设置了默认值
3
>>>
2.26 globals() 函数会以字典类型返回当前位置的全部全局变量。
>>> a ='yusheng'
>>> print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'is_add': <function is_add at 0x000000000324FF28>, 'tmlist': <filter object at 0x0000000003242D30>, 'new_list': [1, 3, 5, 7, 9], 'site': {'name': 'tt', 'url': 'uu'}, 'my_list': ['uu', 'ee'], 'fu': <class '__main__.fu'>, 'my_value': <__main__.fu object at 0x0000000003257EF0>, 'a': 'yusheng'}
2.27 hasattr() 函数用于判断对象是否包含对应的属性。
hasattr()语法：
hasattr(object, name)
参数说明：
1）object -- 对象。
2）name -- 字符串，属性名。
3）返回值，如果对象有该属性返回 True，否则返回 False。
#!/usr/bin/python
# -*- coding: UTF-8 -*- class test:
x = 10
y = -5
z = 0 point1 = test()
print(hasattr(point1, 'x'))
print(hasattr(point1, 'no')) # 没有该属性 结果为：
True
False
2.28 hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
hash()语法：
hash(object)
参数说明：
1）object--对象
2）返回值，返回对象的哈希值。
>>>hash('test') # 字符串
2314058222102390712
>>> hash(1) # 数字
1
>>> hash(str([1,2,3])) # 集合
1335416675971793195
>>> hash(str(sorted({'':1}))) # 字典
7666464346782421378
2.29 help() 函数用于查看函数或模块用途的详细说明。
>>>help('sys') # 查看 sys 模块的帮助
……显示帮助信息……
>>>help('str') # 查看 str 数据类型的帮助
……显示帮助信息……
>>>a = [1,2,3]
>>>help(a) # 查看列表 list 帮助信息
……显示帮助信息……
>>>help(a.append) # 显示list的append方法的帮助
……显示帮助信息……
2.30 hex() 函数用于将一个指定数字转换为 16 进制数。
>>>hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
>>> hex(12)
'0xc'
>>> type(hex(12))
<class 'str'> # 字符串
2.31 id() 函数用于获取对象的内存地址。
>>>a = 'runoob'
>>> id(a)
4531887632
>>> b = 1
>>> id(b)
140588731085608
2.32 input() 函数接受一个标准输入数据，返回为 string 类型
注意：在 Python3.x 中 raw_input() 和 input() 进行了整合，去除了 raw_input( )，仅保留了input( )函数，其接收任意任性输入，将所有输入默认为字符串处理，并返回字符串类型。
>>>a = input("input:")
input:123 # 输入整数
>>> type(a)
<class 'str'> # 字符串
>>> a = input("input:")
input:runoob # 正确，字符串表达式
>>> type(a)
<class 'str'> # 字符串
2.33 int() 函数用于将一个字符串或数字转换为整型。
>>>int() # 不传入参数时，得到结果0
0
>>> int(3)
3
>>> int(3.6)
3
>>> int('',16) # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制
18
>>> int('0xa',16)
10
>>> int('',8)
8
2.34 isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
isinstance() 与 type() 区别：type() 不会认为子类是一种父类类型，不考虑继承关系。isinstance() 会认为子类是一种父类类型，考虑继承关系。如果要判断两个类型是否相同推荐使用 isinstance()。
>>>a = 2
>>> isinstance (a,int)
True
>>> isinstance (a,str)
False
>>> isinstance (a,(str,int,list)) # 是元组中的一个返回 True
True
2.35 issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
#!/usr/bin/python
# -*- coding: UTF-8 -*- class A:
pass
class B(A):
pass print(issubclass(B,A)) # 返回 True
2.36 iter() 函数用来生成迭代器。
iter()语法：
iter(object [, sentinel])
参数说明：
1）object -- 支持迭代的集合对象。
2）sentinel -- 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
3）返回值，返回迭代器对象。
>>>lst = [1, 2, 3]
>>> for i in iter(lst):
... print(i)
...
1
2
3
2.37 len() 方法返回对象（字符、列表、元组等）长度或项目个数。
>>>str = "runoob"
>>> len(str) # 字符串长度
6
>>> l = [1,2,3,4,5]
>>> len(l) # 列表元素个数
5
2.38 list() 方法用于将元组或字符串转换为列表。
注意：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
#!/usr/bin/python3 aTuple = (123, 'Google', 'Runoob', 'Taobao')
list1 = list(aTuple)
print ("列表元素 : ", list1) str="Hello World"
list2=list(str)
print ("列表元素 : ", list2) 结果为：
列表元素 : [123, 'Google', 'Runoob', 'Taobao']
列表元素 : ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']
2.39 locals() 函数会以字典类型返回当前位置的全部局部变量。
>>>def runoob(arg): # 两个局部变量：arg、z
... z = 1
... print (locals())
...
>>> runoob(4)
{'z': 1, 'arg': 4} # 返回一个名字/值对的字典
>>>
2.40 map() 会根据提供的函数对指定序列做映射。
map()语法：
map(function, iterable, ...)
参数说明：
1）function -- 函数
2）iterable -- 一个或多个序列
>>>def square(x) : # 计算平方数
... return x ** 2
...
>>> map(square, [1,2,3,4,5]) # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数
[1, 4, 9, 16, 25] # 提供了两个列表，对相同位置的列表数据进行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]
2.41 max() 方法返回给定参数的最大值，参数可以为序列。
#!/usr/bin/python3
print ("max(80, 100, 1000) : ", max(80, 100, 1000))
print ("max(-20, 100, 400) : ", max(-20, 100, 400))
结果为：
max(80, 100, 1000) : 1000
max(-20, 100, 400) : 400
2.42 memoryview() 函数返回给定参数的内存查看对象(Momory view)。
注意：所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。
memoryview()在python3.x的应用
>>>v = memoryview(bytearray("abcefg", 'utf-8'))
>>> print(v[1])
98
>>> print(v[-1])
103
>>> print(v[1:4])
<memory at 0x10f543a08>
>>> print(v[1:4].tobytes())
b'bce'
2.43 min() 方法返回给定参数的最小值，参数可以为序列。
#!/usr/bin/python3
print ("min(80, 100, 1000) : ", min(80, 100, 1000))
print ("min(-20, 100, 400) : ", min(-20, 100, 400))
结果为：
min(80, 100, 1000) : 80
min(-20, 100, 400) : -20
2.44 next() 返回迭代器的下一个项目。
next()语法：
next(iterator[, default])
参数说明：
1）iterator -- 可迭代对象
2）default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。
#!/usr/bin/python
# -*- coding: UTF-8 -*- # 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
try:
# 获得下一个值:
x = next(it)
print(x)
except StopIteration:
# 遇到StopIteration就退出循环
break 结果为：
1
2
3
4
5
2.45 oct() 函数将一个整数转换成8进制字符串
>>>oct(10)
''
>>> oct(20)
''
>>> oct(15)
''
>>>
2.46 open() 函数用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。
注意：使用 open() 函数一定要保证关闭文件对象，即调用 close() 函数。
open()语法：
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
参数说明：
1）file: 必需，文件路径（相对或者绝对路径）。
2）mode: 可选，文件打开模式
3）buffering: 设置缓冲
4）encoding: 一般使用utf8
5）errors: 报错级别
6）newline: 区分换行符
7）closefd: 传入的file参数类型
8）opener:
>>>f = open('test.txt')
>>> f.read()
'RUNOOB1\nRUNOOB2\n'
2.47 ord() 函数是 chr() 函数（对于 8 位的 ASCII 字符串）的配对函数，它以一个字符串（Unicode 字符）作为参数，返回对应的 ASCII 数值，或者 Unicode 数值。
>>>ord('a')
97
>>> ord('€')
8364
>>>
2.48 pow() 方法返回 xy（x的y次方） 的值。
>>> pow(100,2)
10000
>>> pow(-110,2)
12100
>>> pow(100,-2)
0.0001
>>>
2.49 print() 方法用于打印输出，最常见的一个函数。
>>> print('my name is yusheng_liang')
my name is yusheng_liang
>>> print(123)
123
>>>
2.50 property() 函数的作用是在新式类中返回属性值。
2.51 Python3 range() 函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以打印的时候不会打印列表。
range()语法：
range(stop)
range(start, stop[, step])
参数说明：
1）start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
2）stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
3）step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
range()实例一：
>>>range(5)
range(0, 5)
>>> for i in range(5):
... print(i)
...
0
1
2
3
4
>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list(range(0))
[]
>>>
range()实例二：有两个参数或三个参数的情况
>>>list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]
>>> list(range(0, 10, 2))
[0, 2, 4, 6, 8]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> list(range(1, 0))
[]
>>>
2.52 repr() 函数将对象转化为供解释器读取的形式。
>>>s = 'RUNOOB'
>>> repr(s)
"'RUNOOB'"
>>> dict = {'runoob': 'runoob.com', 'google': 'google.com'};
>>> repr(dict)
"{'google': 'google.com', 'runoob': 'runoob.com'}"
2.53 reversed 函数返回一个反转的迭代器。
#!/usr/bin/env python3 # 字符串
seqString = 'Runoob'
print(list(reversed(seqString))) # 元组
seqTuple = ('R', 'u', 'n', 'o', 'o', 'b')
print(list(reversed(seqTuple))) # range
seqRange = range(5, 9)
print(list(reversed(seqRange))) # 列表
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList))) 结果为：
['b', 'o', 'o', 'n', 'u', 'R']
['b', 'o', 'o', 'n', 'u', 'R']
[8, 7, 6, 5]
[5, 3, 4, 2, 1]
2.54 round() 方法返回浮点数x的四舍五入值。
round()语法：
round( x [, n] )
参数说明：
1）x -- 数字表达式。
2）n -- 表示从小数点位数，其中 x 需要四舍五入，默认值为 0。
print ("round(56.659,1) : ", round(56.659,1))
print ("round(80.264, 2) : ", round(80.264, 2))
结果为：
round(56.659,1) : 56.7
round(80.264, 2) : 80.26
2.55 set()函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
>>>x = set('runoob')
>>> y = set('google')
>>> x, y
(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l'])) # 重复的被删除
>>> x & y # 交集
set(['o'])
>>> x | y # 并集
set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])
>>> x - y # 差集
set(['r', 'b', 'u', 'n'])
2.56 setattr() 函数对应函数 getattr()，用于设置属性值，该属性不一定是存在的。
>>>class A(object):
... bar = 1
...
>>> a = A()
>>> getattr(a, 'bar') # 获取属性 bar 值
1
>>> setattr(a, 'bar', 5) # 设置属性 bar 值
>>> a.bar
5
2.57 slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
2.58 sorted() 函数对所有可迭代的对象进行排序操作。
>>>sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5] # 默认为升序
2.59 staticmethod 返回函数的静态方法。
2.60 str() 函数将对象转化为适于人阅读的形式。
2.61 sum() 方法对系列进行求和计算。
>>>sum([0,1,2])
3
>>> sum((2, 3, 4), 1) # 元组计算总和后再加 1
10
>>> sum([0,1,2,3,4], 2) # 列表计算总和后再加 2
12
2.62 super() 函数是用于调用父类(超类)的一个方法。
注意：super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。
MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
python 3.x实例：
class A:
def add(self, x):
y = x+1
print(y)
class B(A):
def add(self, x):
super().add(x)
b = B()
b.add(2) #
2.63 tuple 函数将列表转换为元组。
2.64 type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。
# 一个参数实例
>>> type(1)
<type 'int'>
>>> type('runoob')
<type 'str'>
>>> type([2])
<type 'list'>
>>> type({0:'zero'})
<type 'dict'>
>>> x = 1
>>> type( x ) == int # 判断类型是否相等
True # 三个参数
>>> class X(object):
... a = 1
...
>>> X = type('X', (object,), dict(a=1)) # 产生一个新的类型 X
>>> X
<class '__main__.X'>
2.65 vars() 函数返回对象object的属性和属性值的字典对象。
>>>print(vars())
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, '__package__': None}
>>> class yy:
... a = 1
...
>>> print(vars(yy))
{'a': 1, '__module__': '__main__', '__doc__': None}
>>> run = yy()
>>> print(vars(yy))
{}
2.66 zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
2.67 __import__() 函数用于动态加载类和函数 。
最新文章
- 值得订阅的Android 开发者博客
- 每天一个linux命令（45）：route命令
- TortoiseGit GitHub 使用指南
- android 中uri.parse()用法
- sqlserver不能直接create table as select
- linux下利用curl监控web应用状态
- Ext 常用组件解析
- 基于python2.7通过boto3实现ec2表格化
- for循环语句以及输出语句
- Linux开机时停在 Starting sendmail 不动了的解决方案
- .NET平台开源项目速览(21)Cron任务调度CronNET
- python---自己来打通节点，链表，栈，应用
- 【nodejs】初识 NodeJS（二）
- python3命令行ImportError: No module named 'xxxx'的问题
- C166 8位字节位运算赋值-代码优化
- (转)处理SQL中的异常并记录错误日志
- 【Android开发】之Fragment生命周期
- Docker的volume机制实现容器数据的持久性存储
- PHP 如何获取二维数组中某个key的集合(高性能查找)
- SRCNN之后的深度学习超分辨率