我的Python成长之路---第三天---Python基础（13）---2016年1月16日（雾霾）

五、Python的常用的内置函数

　　Python为我们准备了大量的内置函数，如下图所示



　　这里我们只讨论红框内的内置函数

　　abs(x)

　　返回一个数的绝对值（模），参数可以是真说或浮点数

>>> abs(-10)
10

　　all(iterable)

　　如果可迭代对象（列表、元祖等）中所有的元素都是True，则返回True，否则返回False。相当于and

>>> all([1, True, 1 == 1])
True

　　any(iterable)

　　如果可迭代对象中任意一个元素是True，则返回True，相当于or

>>> any([None, "", [], (), {}, 0, False])
False
>>> any([None, "", [], (), {}, 0, True])
True

　　说明：可以看出，通常情况下“空”（None，空字符串、空列表，0等等）都是表示False

　　bin(x)

　　返回一个整数的二进制字符串

>>> bin(10)
'0b1010'

　　说明：Python使用0b开头表示这是一个二进制表达式

　　class bool([x])

　　返回或者新建一个布尔值对象，如果不传递参数默认返回False

>>> bool()
False
>>> bool(10)
True

　　chr(i)

　　返回一个整数所对应的Unicode编码所对应的字符

>>> chr(89999)
'\U00015f8f'
>>> chr(97)
'a'

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

　　创建一个字典对象，以通过关键字参数，mapping对象，字典对象等参数方式创建

>>> dict()
{}
>>> dict(k1 = 'v1', k2 = 'v2')
{'k1': 'v1', 'k2': 'v2'}
>>> dict((['k1', 'v1'], ['k2', 'v2']))
{'k1': 'v1', 'k2': 'v2'}
>>> dict({'k1':'v1', 'k2':'v2'})
{'k1': 'v1', 'k2': 'v2'}

　　dir([object])

　　返回当前域或指定模块、对象中的所有变量名和方法名

>>> dir()
['__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']
>>> dir("")
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

　　divmod(a, b)

　　返回两个数的得商和余数组成的元祖，相当于(a // b, a % b)

>>> divmod(10, 3)
(3, 1)

　　enumerate(iterable, start=0)

　　返回一个迭代器，每次迭代返回一个元祖包括一个计数器，和对iterable迭代取得的值，iterable可迭代对象，包括列表、元祖等。start表示计数器的开始值，默认是0

enu = enumerate(['abc', 'def', 'ghi'])
print(enu)
for i in enu:
print(i)

　　执行结果

<enumerate object at 0x0000000BE2D53510> # 可以看到返回的是一个enumerate对象
(0, 'abc')
(1, 'def')
(2, 'ghi')

　　注意：返回的是是一个迭代器，迭代完了空了，如果需要重复使用，最好转化为一个列表对象保存到变量中，并且计数器是从0开始计数的

>>> li = list(enumerate(['abc', 'def', 'ghi']))
>>> li
[(0, 'abc'), (1, 'def'), (2, 'ghi')]

　　可以指定start的开始值

>>> li = list(enumerate(['abc', 'def', 'ghi'], 2))
>>> li
[(2, 'abc'), (3, 'def'), (4, 'ghi')]

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

　　将的字符串形式的算数表达式进行计算，并返回结果

>>> eval('3 + 4 * (1 - 3)')
-5

　　filter(function, iterable)

　　接收一个函数和一个可迭代对象，将可迭代对象的每一个元素都作为参数执行函数，函数返回为真的放到一个新的可迭代对象中，并将新的可迭代对象返回

def is_dual(num):
if num % 2 == 0:
return True
else:
return False

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

print(list(filter(is_dual, nums))) # 由于返回的是filter对象，所以要转化为list列表对象进行查看

　　执行结果

[2, 4, 6, 8, 10, 12, 14, 16, 18]

　　class float([x])

　　创建一个浮点类型的对象

>>> float('0.5')
0.5
>>> float(0.5)
0.5

　　help([object])

　　返回某个对象的帮助信息

　　hex(x)

　　返回一个整数的16进制表达式

>>> hex(23)
'0x17'

　　说明：hex函数只接受整数类型的参数

　　id(object)

　　返回对象的id（可以理解为Python为每个对象的编号，或者理解为是Python对象内存地址的表达形式）

>>> id(1)
10455040
>>> id(2)
10455072

　　input([prompt])

　　接受用户从控制台的输入，并将用户输入的信息，以字符串的返回，prompt表示输入时前显示的字符串

>>> s = input('python>>')
python>>123
>>> s
'123'

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

　　创建一个整数类型的对象，默认如果创建的0，如果传递的是字符串类型的，可以把字符串表达式所表示的整数转化为整数类型，base表示的传递的字符串进制，默认是十进制

>>> int()
0
>>> int('1')
1
>>> int('1010', base = 2)
10

　　len(s)

　　返回一个对象的长度（或者元素的个数）

>>> len('abc')
3
>>> len([1, 2])
2

　　说明：所谓的长度一般只字符串，像整数、浮点数等数据类型没有len方法，会报如下错误

>>> len(10)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: object of type 'int' has no len()

　　class list([iterable])

　　将一个可迭代对象转化为列表

>>> list([1, 2, 3])
[1, 2, 3]
>>> list((1, 2, 3))
[1, 2, 3]
>>> list({'k1':'v1', 'k2':'v2'})
['k2', 'k1']

　　说明：可以看到字典只是把key组成了列表，因为字典真正迭代的是key，value只是与key对应而已

　　map(function, iterable, ...)

　　接收一个函数和一个可迭代对象，将可迭代对象里的每一个元素都做作为参数传递到函数中，并把函数的返回结果保存到一个map对象中

>>> map(lambda x: x**2, [1, 2, 3])
<map object at 0x7f0700026518>
>>> list(map(lambda x: x**2, [1, 2, 3]))
[1, 4, 9]

　　说明：函数可以是匿名函数，另外函数必须有返回值，如果没有返回值，虽然不会报错，但没有任何意义，例如

>>> def f(x):
...     x*2
...
>>> list(map(f, [1, 2, 3]))
[None, None, None]

　　max(iterable, *[, key, default])

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

　　返回可迭代对象中（或者2个以上参数中）最大的值

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

　　min(iterable, *[, key, default])

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

　　返回可迭代对象中（或者2个以上参数中）最大的值

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

　　oct(x)

　　将一个数转化为8进制的表达形式

>>> oct(9)
'0o11'

　　说明：Python中0o表示8进制

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

　　打开文件并返回文件文件对象，file表示文件名（可以是绝对路径，也可以是相对路径），mode表示打开方式，默认的是rt模式，表示只读的文本格式

　　ord(c)

　　返回一个字符的Unicode编码

>>> ord('a')
97
>>> ord('中')
20013

　　pow(x,y[,z])

　　如果只传递两个参数x和y，就计算x的y次方，相当于x ** y

　　参数z表示将x ** y的结果对z取模，相当于x ** y % z

>>> pow(2, 3)
8
>>> pow(2, 3, 3)
2

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

　　打印函数，object表示要输出的对象，sep表示多个对象之间的分隔符，默认是空格，end表示末尾的字符，默认是回车符，file表示输出的文件，默认为sys.stdout也就是终端（标准输出）

>>> print('abc')
abc
>>> print('abc','def', sep = '*')
abc*def
>>> print('abc','def', sep = '*', end = 'end')
abc*defend
>>> f = open('print.log', 'w')
>>> print('abc','def', sep = '*', end = 'end', file = f)
>>> f = open('print.log', 'r')
>>> f.read()
'abc*defend'

　　range(stop)

　　range(start, stop[, step])

　　生成大于等于start，小于stop步长为step的数字序列，start默认是0

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

　　reversed(seq)

　　翻转一个序列，序列对象必须是有序的，也就是对象必须包含__reversed__()方法

>>> reversed([0, 1, 2, 3, 4])
<list_reverseiterator object at 0x7fcc954acd68>
>>> list(reversed([0, 1, 2, 3, 4]))
[4, 3, 2, 1, 0]

　　round(number[, ndigits])

　　返回一个浮点数的后面保留ndigits位小数的结果，四舍五入，小数点位数不足，不补0

>>> round(1.236, 2)
1.24
>>> round(1.2, 2)
1.2

　　class set([iterable])

　　根据序列对象创建集合对象

>>> set([1, 2, 4, 2])
{1, 2, 4}

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

　　对一个序列对象进行排序，key接收一个函数，将序列的每一个函数处理返回的结果作为排序的依据，比如字符串都转换成小写排序或字典按照key或value排序等，reverse表示对排序的结果是否排序，默认字符串是先大写后小写的顺序排序的

>>> sorted(['A', 'b', 'c'])
['A', 'b', 'c']
>>> sorted(['A', 'b', 'C'])
['A', 'C', 'b']
>>> sorted(['A', 'b', 'C'], key = lambda x: x.lower())
['A', 'b', 'C']
>>> sorted(['A', 'b', 'C'], key = lambda x: x.lower(), reverse = True)
['C', 'b', 'A']

　　class str(object='')

　　创建一个字符串对象，或者将一个对象转化为字符串对象

>>> str('abc')
'abc'
>>> str(1234)
'1234'

　　sum(iterable[, start])

　　返回一个序列对象的相加的总和在加上start，start默认是0，序列对象要么全是数字要么都是字符串，字符串就相当于把它们都拼接在一起

>>> sum([1, 2, 4])
7
>>> sum([1, 2, 4], 1)
8

　　疑惑：说是可以使用字符串，但是报错

>>> sum(['ab', 'bc', 'cd'])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'

　　tuple([iterable])

　　创建一个元祖对象，或将一个对象转化为元祖

>>> tuple()
()
>>> tuple([1, 2, 4])
(1, 2, 4)

　　class type(object)

　　class type(name, bases, dict)

　　返回一个对象的类型

>>> type(1)
<class 'int'>
>>> type(str)
<class 'type'>

　　vars([object])

　　返回模块，类，实例或者任何其他有__dict__属性的对象的__dict__属性，默认是显示当前环境的

>>> vars()
{'f': <_io.TextIOWrapper name='print.log' mode='r' encoding='UTF-8'>, '__spec__': None, '__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__', '__doc__': None, '__package__': None, '__warningregistry__': {("unclosed file <_io.TextIOWrapper name='print.log' mode='w' encoding='UTF-8'>", <class 'ResourceWarning'>, 1): True}, '__loader__': <class '_frozen_importlib.BuiltinImporter'>}
>>> import sys
>>> vars(sys)
{'version_info': sys.version_info(major=3, minor=4, micro=0, releaselevel='final', serial=0), 'getswitchinterval': <built-in function getswitchinterval>, '__name__': 'sys', 'path_hooks': [<class 'zipimport.zipimporter'>, <function FileFinder.path_hook.<locals>.path_hook_for_FileFinder at 0x7fcc97b51ae8>],后面省略n多行

　　zip(*iterables)

　　将多个元素组成一个新的zip对象，zip对象的元素个数取决于元素最少的参数

>>> x = [1, 2, 3, 4]
>>> y = ['a', 'b', 'c']
>>> zip(x, y)
<zip object at 0x7fcc954aea08>
>>> list(zip(x, y))
[(1, 'a'), (2, 'b'), (3, 'c')]