所谓内置函数，就是Python提供的, 可以直接拿来直接用的函数，比如大家熟悉的print，range、input等，也有不是很熟，但是很重要的，如enumerate、zip、join等，Python内置的这些函数非常精巧且强大的.

对初学者来说，经常会忽略，但是偶尔会碰到，我也是用了一段时间python之后才发现，哇还有这么好的函数，每个函数都非常经典，而且经过严格测试，使用内置函数，不用自己闭门造车，并且代码简洁易读了很多，真是方便又实用，值得花时间进行体系化研究学习。喜欢技术交流的小伙伴，文末提供技术交流群

初学者的代码之所以写的不简洁，不是因为学的不够好，而是学的不够多，很多内置的东西都没学透。(初学者一定要买一本基础书籍了解语言的基本框架，推荐下面这一本，当然其他任何的书都可以)

一、数字相关

01 数据类型

bool()

描述：测试一个对象是True, 还是False.bool 是 int 的子类。

语法：class bool([x])

参数：x – 要进行转换的参数。

案例：

bool([0,0,0])
True

bool([])
False

issubclass(bool, int)  # bool 是 int 子类
True

int()

/*/描述：//*int() 函数用于将一个字符串或数字转换为整型。 x可能为字符串或数值，将x 转换为一个普通整数。如果参数是字符串，那么它可能包含符号和小数点。如果超出了普通整数的表示范围，一个长整数被返回。

/*/语法：//*int(x, base =10)

参数：

• x – 字符串或数字。
• base – 进制数，默认十进制。

案例：

int('12',16)
18

int('12',10)
12

float()

描述：将一个字符串或整数转换为浮点数

语法：class float([x])

参数：x – 整数或字符串

案例：

float(3)
3.0

float('123') 
 123.0

complex()

描述：创建一个复数

语法：class complex([real[, imag]])

参数：

real – int, long, float或字符串；

imag – int, long, float；

案例：

complex(1,2)
(1+2j) 

complex('1')
(1+0j)
complex("1+2j")
(1+2j)

02 进制转换

bin()

描述：bin() 返回一个整数 int 或者长整数 long int 的二进制表示。将十进制转换为二进制

语法：bin(x)

参数：x – int 或者 long int 数字

案例：

bin(2)
'0b10'

bin(20)
'0b10100'

oct()

/*/描述：//*将十进制转换为八进制 otc() 将给的参数转换成八进制

/*/语法：//*oct(x)

/*/参数：//*x – 整数。

案例：

oct(8)
'0o10'

oct(43)
'0o53'

hex()

描述：hex() 函数用于将10进制整数转换成16进制，以字符串形式表示。

/*/语法：//*hex(x)

/*/参数：//*x – 10进制整数。

案例：

将十进制转换为十六进制
hex(43)
'0x2b'#43等于2B

hex(15)
'0xf'

03 数学运算

abs()

/*/描述：//*返回数字绝对值或复数的模

/*/语法：//*abs( x )

/*/参数：//*x 数值表达式。

案例：

abs(-6)
6
abs(5j+4)
6.4031242374328485

divmod()

/*/描述：//*divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。

/*/语法：//*divmod(a, b)

/*/参数：//*a: 数字–被除数

b: 数字–除数

案例：

divmod(11,3)
(3, 2)

divmod(20,4)
(5, 0)

round()

/*/描述：//*round() 函数返回浮点数x的四舍五入值。

/*/语法：//*round( x [, n] )

参数：

• x – 数值表达式。
• n --代表小数点后保留几位

案例：

round(10.0222222, 3)
10.022

pow()

描述：pow(x，y) 方法返回x的y次方的值，等价于x/*/*y。函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z

/*/语法：//*pow(x, y[, z])

参数：

• x – 数值表达式。
• y – 数值表达式。
• z – 数值表达式。

案例：

pow(10, 2)
100

10**2
100

pow(4,3,5)
 4
等价于4**3%

sum()

/*/描述：//*sum() 方法对系列进行求和计算。

/*/语法：//*sum(iterable[, start])

参数：

• iterable – 可迭代对象，如：列表、元组、集合。
• start – 指定相加的参数，如果没有设置这个值，默认为0。

案例：

a = [1,4,2,3,1]
sum(a)
11
 
sum(a,10) #求和的初始值为10
21

min()

/*/描述：//*min() 方法返回给定参数的最小值，参数可以为序列。

/*/语法：//*min( x, y, z, … )

参数：

• x – 数值表达式。
• y – 数值表达式。
• z – 数值表达式。

案例：

min(80, 100, 1000)
80
min([80, 100, 1000])
80

max()

/*/描述：//*max() 方法返回给定参数的最大值，参数可以为序列。

/*/语法：//*max( x, y, z, … )

参数：

• x – 数值表达式。
• y – 数值表达式。
• z – 数值表达式。

案例：

最大值：
max(3,1,4,2,1)
4

di = {'a':3,'b1':1,'c':4}
max(di)
'c'

二、数据结构相关

01 序列数据类型

1）列表和元组

list()

/*/描述：//*list() 函数创建列表或者用于将序列转换为列表。

/*/语法：//*list( iterable )

/*/参数：//*iterable – 可迭代序列。

案例：

序列为元组时

s=(123, 'xyz', 'zara', 'abc')
list(S)
[123, 'xyz', 'zara', 'abc']

序列为字符串

s= '小伍哥真是帅，特别帅' 
list(s)
['小', '伍', '哥', '真', '是', '帅', '，', '特', '别', '帅']

序列为字典

s = {'nanme':'小伍哥','age':30,'address':'Hangzhou'}
list(s)
['nanme', 'age', 'address']

tuple()

描述： 元组 tuple() 函数将列表转换为元组。

/*/语法：//*tuple( iterable )

/*/参数：//*iterable – 要转换为元组的可迭代序列。

案例：

tuple([1,2,3,4])
(1, 2, 3, 4)
 
tuple({'a':2,'b':4})    #针对字典 会返回字典的key组成的tuple
 ('a', 'b')

tuple('小伍哥真是帅，特别帅')
 ('小', '伍', '哥', '真', '是', '帅', '，', '特', '别', '帅')

2）集合数据类型

dict()

/*/描述：//*创建数据字典

语法：

class dict(/*/*kwarg)

class dict(mapping, /*/*kwarg)

class dict(iterable, /*/*kwarg)

参数：

• /*/*kwargs – 关键字
• mapping – 元素的容器。
• iterable – 可迭代对象。

案例：

#创建空字典
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':

set()

/*/描述：//*set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

/*/语法：//*class set([iterable])

/*/参数：//*iterable – 可迭代对象对象；

案例：

#返回一个set对象，可实现去重：
a = [1,4,2,3,1]
set(a)
{1, 2, 3, 4}

frozenset()

/*/描述：//*frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

/*/语法：//*class frozenset([iterable])

/*/参数：//*iterable – 可迭代的对象，比如列表、字典、元组等等。

案例：

创建一个不可修改的集合。
frozenset([1,1,3,2,3])
frozenset({1, 2, 3})

3）字符串

str()

/*/描述：//*str() 函数将对象转化为适于人阅读的形式。将字符类型、数值类型等转换为字符串类型

/*/语法：//*class str(object=’’)

/*/参数：//*object – 对象。

案例：

integ = 100
str(integ)
'100'

dict = {'baidu': 'baidu.com', 'google': 'google.com'};
str(dict)
"{'baidu': 'baidu.com', 'google': 'google.com'}"

format()

/*/描述：//*Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。基本语法是通过 {} 和 : 来代替以前的 % 。使用format()来格式化字符串时，使用在字符串中使用{}作为占位符，占位符的内容将引用format()中的参数进行替换。可以是位置参数、命名参数或者兼而有之。

format 函数可以接受不限个参数，位置可以不按顺序。

/*/语法：//*format(value, format_spec)

参数：

案例：

# 位置参数
'{}:您{}购买的{}到了！请下楼取快递。'.format('快递小哥','淘宝','快递')
'快递小哥:您淘宝购买的快递到了！请下楼取快递。'

#给批量客户发短息
n_list=['马云','马化腾','麻子','小红','李彦宏','二狗子']
for name in n_list:
    print('{0}：您淘宝购买的快递到了！请下楼取快递！'.format(name))
马云：您淘宝购买的快递到了！请下楼取快递！
马化腾：您淘宝购买的快递到了！请下楼取快递！
麻子：您淘宝购买的快递到了！请下楼取快递！
小红：您淘宝购买的快递到了！请下楼取快递！
李彦宏：您淘宝购买的快递到了！请下楼取快递！
二狗子：您淘宝购买的快递到了！请下楼取快递！  
    
#名字进行填充 
for n in n_list:
    print('{0}：您淘宝购买的快递到了！请下楼取快递！'.format(n.center(3,'*')))
    
*马云：您淘宝购买的快递到了！请下楼取快递！
马化腾：您淘宝购买的快递到了！请下楼取快递！
*麻子：您淘宝购买的快递到了！请下楼取快递！
*小红：您淘宝购买的快递到了！请下楼取快递！
李彦宏：您淘宝购买的快递到了！请下楼取快递！
二狗子：您淘宝购买的快递到了！请下楼取快递！

'{0}, {1} and {2}'.format('gao','fu','shuai')
'gao, fu and shuai'

x=3
y=5
'{0}+{1}={2}'.format(x,y,x+y)

# 命名参数
'{name1}, {name2} and {name3}'.format(name1='gao', name2='fu', name3='shuai')
'gao, fu and shuai'

# 混合位置参数、命名参数
'{name1}, {0} and {name3}'.format("shuai", name1='fu', name3='gao')
'fu, shuai and gao'

#for循环进行批量处理
["vec_{0}".format(i) for i in range(0,5)]
['vec_0', 'vec_1', 'vec_2', 'vec_3', 'vec_4']

['f_{}'.format(r) for r in list('abcde')]
['f_a', 'f_b', 'f_c', 'f_d',

bytes()

/*/描述：//*将一个字符串转换成字节类型

/*/语法：//*class bytes([source[, encoding[, errors]]])

参数：

• 如果 source 为整数，则返回一个长度为 source 的初始化数组；
• 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
• 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
• 如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
• 如果没有输入任何参数，默认就是初始化数组为0个元素。

案例：

s = "apple"
bytes(s,encoding='utf-8')
b'apple'

bytes([1,2,3,4])
b'\x01\x02\x03\x04'

bytearray()

/*/描述：//*返回一个新字节数组. 这个数字的元素是可变的, 并且每个元素的值得范围是[0,256)

/*/语法：//*class bytearray([source[, encoding[, errors]]])

参数：

• 如果 source 为整数，则返回一个长度为 source 的初始化数组；
• 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
• 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
• 如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
• 如果没有输入任何参数，默认就是初始化数组为0个元素。

bytearray()
bytearray(b'')
bytearray([1,2,3])
bytearray(b'\x01\x02\x03')
bytearray('baidu', 'utf-8')
bytearray(b'baidu')

ord()

/*/描述：//*查看某个ascii对应的十进制数

/*/语法：//*ord©

/*/参数：//*c – 字符。

案例：

ord('A')
65

ord('~')
126

chr()

/*/描述：//*chr() 用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符。

/*/语法：//*chr(i)

/*/参数：//*i – 可以是10进制也可以是16进制的形式的数字。

案例：

查看十进制整数对应的ASCII字符
chr(65)
'A'
可以参考4案例中的表

ascii()

/*/描述：//*ascii() 函数返回任何对象（字符串，元组，列表等）的可读版本。

ascii() 函数会将所有非 ascii 字符替换为转义字符：

å 将替换为 \xe5。

/*/语法：//*ascii(object)

/*/参数：//*object–对象，可以是元组、列表、字典、字符串、set()创建的集合。

案例：

ascii('中国')
"'\\u4e2d\\u56fd'"

ascii('新冠肺炎')
"'\\u65b0\\u51a0\\u80ba\\u

ascii("My name is Ståle")
"'My name is St\\xe5le'"

print(ascii((1,2))) #元组
(1, 2)
print(type(ascii((1,2))))
<class 'str'>

print(ascii([1,2])) #列表
[1, 2]
print(type(ascii([1,2])))
<class 'str'>

print(ascii('？')) #字符串，非 ASCII字符，转义
'\uff1f'
print(type(ascii("？")))
<class 'str'>

print(ascii({1:2,'name':5})) #字典
{1: 2, 'name': 5}
print(type(ascii({1:2,'name':5})))
<class '

ASCII码表具体如下所示(节选)

| Bin(二进制) | Oct(八进制) | Dec(十进制) | Hex(十六进制) | 缩写/字符 | 解释 |
| 0000 0000 | 00 | 0 | 0x00 | NUL(null) | 空字符 |
| 0010 0001 | 041 | 33 | 0x21 | ! | 叹号 |
| 0010 0010 | 042 | 34 | 0x22 | " | 双引号 |
| 0010 1010 | 052 | 42 | 0x2A | /* | 星号 |
| ... | ... | ... | ... | ... | ... |
| 0111 1101 | 0175 | 125 | 0x7D | } | 闭花括号 |
| 0111 1110 | 0176 | 126 | 0x7E | ~ | 波浪号 |
| 0111 1111 | 0177 | 127 | 0x7F | DEL (delete) | 删除 |

repr()

返回一个对象的string形式

03 数据结构处理相关函数

len()

/*/描述：//*len() 函数返回对象（字符、列表、元组等）长度或项目个数。

/*/语法：//*len(s)

/*/参数：//*s – 对象。

案例：

#字典的长度
dic = {'a':1,'b':3}
len(dic)
2

#字符串长度
s='aasdf'
len(s)
5

#列表元素个数
l = [1,2,3,4,5]
len(l)

sorted()

/*/描述：//*sorted()函数对所有可迭代的对象进行排序操作。

/*/语法：//*sorted(iterable, key=None, reverse=False)

参数：

• iterable–可迭代对象。
• key–主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
• reverse – 排序规则,reverse=True降序 ,reverse = False升序(默认)。

案例：

a = [5,7,6,3,4,1,2]
b = sorted(a)       #保留原列表
a 
[5, 7, 6, 3, 4, 1, 2]
b
[1, 2, 3, 4, 5, 6, 7]
 
#利用key
L=[('b',2),('a',1),('c',3),('d',4)]

sorted(L, key=lambda x:x[1])  
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]

#按年龄排序
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=lambda s: s[2]) 
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

#按降序
sorted(students, key=lambda s: s[2], reverse=True)  
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
 
#降序排列
a = [1,4,2,3,1]
sorted(a,reverse=True) 
[4, 3, 2, 1, 1

sort 与 sorted 区别：

sort 是应用在list 的方法，sorted可以对所有可迭代的对象进行排序操作；list的sort 方法返回的是对已经存在的列表进行操作，无返回值，而内建函数sorted方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

reversed()

/*/描述：//*reversed函数返回一个反转的迭代器。

/*/语法：//*reversed(seq)

/*/参数：//*seq – 要转换的序列，可以是 tuple, string, list 或 range。

案例：

#反转列表
rev = reversed([1,4,2,3,1])
list(rev)
[1, 3, 2, 4, 1]

#反转字符串
rev = reversed('我爱中国')
list(rev)
['国', '中', '爱', '我']

''.join(rev)
'国中爱我'

s = '我的世界开始下雪'
''.join(reversed(s))
'雪下始开界世的

slice()

/*/描述：//*slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。返回一个表示由 range(start, stop, step) 所指定索引集的 slice对象

语法：

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

参数：

• start – 起始位置
• stop – 结束位置
• step – 间距

案例：

a = [1,4,2,3,1]
a[slice(0,5,2)] #等价于a[0:5:2]
[1, 2, 1]

a = list(range(10))
a[slice(3)]
[0, 1, 2

enumerate()

/*/描述：//*enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中。返回一个可以枚举的对象，该对象的next()方法将返回一个元组。enumerate在字典上是枚举、列举的意思。

/*/语法：//*enumerate(sequence, [start=0])

/*/参数：//*sequence – 一个序列、迭代器或其他支持迭代对象。

start – 下标起始位置。

案例：

L = ['Spring', 'Summer', 'Fall', 'Winter']
enumerate(L)
<enumerate at 0x226e1ee1138>#生成的额迭代器，无法直接查看

list(enumerate(L))#列表形式，可以看到内部结构，默认下标从0开始
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
 
list(enumerate(L, start=1)) #下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

for i,v in enumerate(L):
    print(i,v)
0 Spring
1 Summer
2 Fall
3 Winter

for i,v in enumerate(L,1):
    print(i,v)

1 Spring
2 Summer
3 Fall
4 Winter

s = ["a","b","c"]
 
for i ,v in enumerate(s,2):
    print(i,v)
2 a
3 b
4 c

普通的 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, element)
 
0 one
1 two
2 three
 
seq = ['one', 'two', 'three']
for i, element in enumerate(seq,2):
    print (i, element)
2 one
3 two
4 three

all()

/*/描述：//接受一个迭代器，如果迭代器(元组或列表)的所有元素都为真，那么返回True，否则返回False，元素除了是0、空、None、False外都算 True。//注意：//*空元组、空列表返回值为True，这里要特别注意。

/*/语法：//*all(iterable)

/*/参数：//*iterable – 元组或列表

案例：

all([1,0,3,6])
False
 
all([1,9,3,6])
True
 
all(['a', 'b', '', 'd'])
False

all([]) #空列表为真
True
 
all(()) #空元组为真
True

any()

/*/描述：//*接受一个迭代器，如果迭代器里有一个元素为真，那么返回True，否则返回False，元素除了是 0、空、None、False 外都算 True。

/*/语法：//*any(iterable)

/*/参数：//*iterable – 元组或列表

案例：

any([0,0,0,[]])
False
 
any([0,0,1])
True
 
any((0, '', False))  
False
 
any([]) # 空列表
False
 
any(()) # 空元组
False

zip()

描述：zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，/*/这样做的好处是节约了不少的内存。//我们可以使用 list() 转换来输出列表。，如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 / 号操作符，可以将元组解压为列表。

/*/语法：//*zip([iterable, …])

/*/参数：//*iterable 一个或多个迭代器

案例：

创建一个聚合了来自每个可迭代对象中的元素的迭代器：
x = [3,2,1]
y = [4,5,6]
list(zip(y,x))
[(4, 3), (5, 2), (6, 1)]

#搭配for循环，数字与字符串组合 
a = range(5)
b = list('abcde')
[str(y)+str(x) for x,y in zip(a,b)]
['a0', 'b1', 'c2', 'd3', 'e4']

#数数相乘
list1 = [2,3,4]
list2 = [5,6,7]
for x,y in zip(list1,list2):
    print(x,'*',y,'--',x*y)
2 * 5 -- 10
3 * 6 -- 18
4 * 7 -- 28

#元素个数与最短的列表一致
list(zip(x,b))
 [(3, 'a'), (2, 'b'), (1, 'c')]s

#与 zip 相反，zip(* ) 可理解为解压，返回二维矩阵式
a1, a2 = zip(*zip(a,b))          
a1
(0, 1, 2, 3, 4)
a2
('a', 'b', 'c', 'd',

filter()

/*/描述：//*filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

/*/语法：//*filter(function, iterable)

参数：

• function – 判断函数。
• iterable – 可迭代对象。

案例：

fil = filter(lambda x: x>10,[1,11,2,45,7,6,13])
fil
 <filter at 0x28b693b28c8>
list(fil)
[11, 45, 13]

def is_odd(n):
    return n % 2 == 1
 
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(list(newlist))
[1, 3, 5, 7, 9]

map()

描述：map() 会根据提供的函数对指定序列做映射。返回一个将 function 应用于 iterable 中每一项并输出其结果的迭代器

/*/语法：//*map(function, iterable, …)

参数：

• function – 函数
• iterable – 一个或多个序列

案例：

def square(x) :            # 计算平方数
    return x ** 2
list(map(square, [1,2,3,4,5]))   # 计算列表各个元素的平方
[1, 4, 9, 16, 25]

list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25]

# 提供了两个列表，对相同位置的列表数据进行相加
list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))
[3, 7, 11, 15, 19]

list(map(lambda x: x%2==1, [1,3,2,4,1]))
[True, True, False, False, Tru

三、和作用域相关

locals()

/*/描述：//*locals() 函数会以字典类型返回当前位置的全部局部变量。对于函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True。

/*/语法：//*locals()

globals()

描述： 函数会以字典类型返回当前位置的全部全局变量。

/*/语法：//*globals()

/*/参数：//*无

案例：

a='runoob'
print(globals()) # globals 函数返回一个全局变量的字典，包括所有导入的变量。

四、迭代器生成器

range()

/*/描述：//*range() 函数可创建一个整数列表，一般用在 for 循环中。

/*/语法：//*range(start, stop[, step])

参数：

• start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
• stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
• step：步长，默认为1。例如：range（0，5）等价于 range(0, 5, 1)

案例：

list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
list(range(1, 11))  # 从 1 开始到 11
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]

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

next()

/*/描述：//*next() 返回迭代器的下一个项目。next() 函数要和生成迭代器的iter() 函数一起使用。

/*/语法：//*next(iterator[, default])

参数：

• iterator – 可迭代对象
• default – 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发StopIteration异常。

案例：

不加默认值的情况，最后会报错StopIteration

it = iter([5,3,4,1])
next(it)
5
next(it)
3
next(it)
4
next(it)
1
next(it)
Traceback (most recent call last):
  File "<ipython-input-392-bc1ab118995a>", line 1, in <module>
    next(it)
StopIteration

加默认值的情况，最后迭代完了，会返回默认值

it = iter([0,1,2,3,4])
next(it,'结束了')
0
next(it,'结束了')
1
next(it,'结束了')
2
next(it,'结束了')
3
next(it,'结束了')
4
next(it,'结束了')
'结束了'

iter()

/*/描述：//*返回一个 iterator 对象

/*/语法：//*iter(object[, sentinel])

参数：

• object – 支持迭代的集合对象。
• sentinel – 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。

案例：

iter([0,1,2,3,4])
<list_iterator at 0x2aa87d32988>

for i in iter([0,1,2,3,4]):
print(i)
0
1
2
3
4

五、字符串类型代码的执行

eval()

/*/描述：//*将字符串str 当成有效的表达式来求值并返回计算结果取出字符串中内容

/*/语法：//*eval(expression[, globals[, locals]])

参数：

• expression – 表达式。
• globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
• locals – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。

案例：

s = "1 + 3 +5"
eval(s)
9

#要统计图片的数量
str1 = "['https://ww1.sin5n.jpg', 'https://ww1.siqk4he.jpg']"
len(eval(str1))
2

len(str1)
5

exec()

/*/描述：//*执行储存在字符串或文件中的Python语句，相比于eval，exec可以执行更复杂的Python代码。

/*/语法：//*exec(object, globals, locals)

参数：

• object-- 要执行的表达式。
• globals – 可选。包含全局参数的字典。
• locals – 可选。包含局部参数的字典。

案例：

执行字符串或compile方法编译过的字符串，没有返回值
s = "print('helloworld')"
r = compile(s,"<string>", "exec")
exec(r)
helloworld

x = 10
expr = """ z = 30 sum = x + y + z print(sum) """
def func():
    y = 20
    exec(expr)
    exec(expr, {'x': 1, 'y': 2})
    exec(expr, {'x': 1, 'y': 2}, {'y': 3, 'z': 4})
    
func()
60
33
34

compile()

/*/描述：//*compile() 将 source 编译成代码或 AST 对象，将字符串类型的代码编码, 代码对象能够通过exec语句来执行或者eval()进行求值

/*/语法：//*compile(source, filename, mode[, flags[, dont_inherit]])

参数：

• source – 字符串或者AST（Abstract Syntax Trees）对象。。
• filename – 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
• mode – 指定编译代码的种类。可以指定为 exec, eval, single。
• flags – 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。。
• flags和dont_inherit是用来控制编译源码时的标志

案例：

将字符串编译成python能识别或可以执行的代码，也可以将文字读成字符串再编译。
s = "print('helloworld')"
r = compile(s,"<string>", "exec")
 
r
<code object <module> at 0x000000000F819420, file "<string>", line 1>
exec(r)
helloworld

str = "for i in range(0,5): print(i)" 
c = compile(str,'','exec')   # 编译为字节代码对象 
c
<code object <module> at 0x000001EB82C91ED0, file "", line 1>

exec(c)
0
1
2
3
4

六、输入输出

print()

/*/描述：//*print() 方法用于打印输出，最常见的一个函数。在 Python3.3 版增加了 flush 关键字参数。print 在 Python3.x 是一个函数，但在 Python2.x 版本不是一个函数，只是一个关键字。

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

参数：

• objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
• sep – 用来间隔多个对象，默认值是一个空格。
• end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
• file – 要写入的文件对象。
• flush – 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。

print("Hello World")  
Hello World

#设置间隔符
print("www","baidu","com",sep=".")
www.baidu.com

input()

/*/描述：//*Python3.x 中 input() 函数接受一个标准输入数据，返回为 string 类型。获取用户输入内容

/*/语法：//*input([prompt])

/*/参数：//*prompt:–提示信息

案例：

a = input("input:")
input:1234
print(a)
123

七、内存相关

hash()

/*/描述：//*返回该对象的哈希值（如果它有的话）。哈希值是整数。它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值（即使它们类型不同，如 1 和 1.0），hash表.用空间换的时间 比较耗费内存，hash() 函数可以应用于数字、字符串和对象，不能直接应用于 list、set、dictionary。

/*/语法：//*hash(object)

/*/参数：//*object – 对象

案例：

在hash()对对象使用时，所得的结果不仅和对象的内容有关，还和对象的id()，也就是内存地址有关。
class Test:
    def __init__(self, i):
        self.i = i
for i in range(10):
    t = Test(1)
    print(hash(t), id(t))
-9223371853633304640 2931543538696
-9223371853633350840 2931542799496
-9223371853633350832 2931542799624
-9223371853633350756 2931542800840
-9223371853520958964 2933341069512
-9223371853633350668 2931542802248
-9223371853633350796 2931542800200
-9223371853633350748 2931542800968
-9223371853633350856 2931542799240
-9223371853633350880 2931542798856

/*/hash() 函数的用途：//*hash() 函数的对象字符不管有多长，返回的hash值都是固定长度的，也用于校验程序在传输过程中是否被第三方（木马）修改，如果程序（字符）在传输过程中被修改hash值即发生变化，如果没有被修改，则hash值和原始的hash值吻合，只要验证hash值是否匹配即可验证程序是否带木马（病毒）。

name1 = '正常程序代码'
name2 = '正常程序代码带病毒'
print(hash(name1)) 
-3048480827538126659
print(hash(name2)) 
-9065726187242961328

memoryview()

描述：memoryview() 函数返回给定参数的内存查看对象(Momory view)。返回由给定实参创建的“内存视图”对象， Python 代码访问一个对象的内部数据，只要该对象支持缓冲区协议 而无需进行拷贝

/*/语法：//*memoryview(obj)

/*/参数：//*obj – 对象

案例：

v = memoryview(bytearray("abcefg", 'utf-8'))
v[1]
98
v[-1]
98
 v[1:4]
<memory at 0x0000028B68E26AC8>
v[1:4].tobytes()
b'bce'

八、文件读写

open()

/*/描述：//*open() 函数用于打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。所以open（）读取文件分为两步。

/*/语法：//*open(name[, mode[, buffering]])

参数：

• name : 一个包含了你要访问的文件名称的字符串值。
• mode : mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读®。
• buffering : 如果 buffering 的值被设为 0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。如果将 buffering 的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。

打开文件的模式：

r： 打开一个文件用于只读，文件的指针将会放在文件的开头，这是默认模式。

w：打开一个文件用于写入，如果文件存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。

/*/a：打开一个文件用于追加，//*如果文件已存在，文件指针将会放在文件的结尾，如果文件不存在，创建新文件进行写入。

r+：打开一个文件用于读写，文件指针将会放在文件的开头。

w+：打开一个文件用于读写。如果该文件已存在，删除原有内容并从开头开始编辑；如果该文件不存在，创建新文件。

a+：打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾，如果该文件不存在，创建新文件用于读写。

rb：以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。

rb+：以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。

wb：以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。

wb+：以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。

ab：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

ab+：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

注意：当读取音视频、图片等二进制文件时，需要采用二进制的读取方法。

file对象方法

file.read([size])：size 未指定则返回整个文件，如果文件大小>2 倍内存则有问题，f.read()读到文件尾时返回""(空字串)。

file.readline()：返回一行。

file.readlines([size]) ：返回包含size行的列表, size 未指定则返回全部行。

for line in file: print(line)：通过迭代器访问。

/*/file.write()：//*如果要写入字符串以外的数据,先将他转换为字符串。

/*/file.tell()：//*返回一个整数,表示当前文件指针的位置(就是到文件头的比特数)。

/*/file.seek(偏移量,[起始位置])：//*用来移动文件指针。偏移量: 单位为比特，可正可负；起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾

/*/file.close()：//*关闭文件

案例：

file = open('test.txt',encoding='utf-8')   #打开文件
file.read()#直接显示文件所有内容
file.readline#显示第一行
file.close()  #关闭文件

https://docs.python.org/zh-cn/3/tutorial/inputoutput.html/#tut-files

test.txt存储的的内容如下

read()方法

file = open('test.txt')
file.read() 
'hello\npython\ni\nlove you'

readline(）方法

file = open('test.txt')
file.readline()
'hello\n'

readlines()方法

file= open('test.txt')
file.readlines()
['python\n', 'i\n', 'love you']

逐行读取

file = open('test.txt')
for line in file:
    print(line)
hello
python
i
love you

九、模块相关

__ import__()

/*/描述：//*该函数会导入 name 模块，有可能使用给定的 globals 和 locals 来确定如何在包的上下文中解读名称。 fromlist 给出了应该从由 name 指定的模块导入对象或子模块的名称。 标准实现完全不使用其 locals 参数，而仅使用 globals 参数来确定 import 语句的包上下文。level 指定是使用绝对还是相对导入。 0 (默认值) 意味着仅执行绝对导入。

语法：import(name, globals=None, locals=None, fromlist=(), level=0)

/*/参数：//*object – 对象

案例：

语句 import spam的结果将为与以下代码作用相同的字节码:

spam = __import__('spam.ham', globals(), locals(), [], 0)

十、获取帮助

help()

/*/描述：//*返回对象的帮助文档

/*/语法：//*help(object)

/*/参数：//*object – 对象

十、对象调用

callable()

/*/描述：//*callable() 函数用于检查一个对象是否是可调用的。如果返回 True，object 仍然可能调用失败；但如果返回 False，调用对象object绝对不会成功。对于函数、方法、lambda 函式、 类以及实现了 call 方法的类实例, 它都返回True。

这个函数一开始在 Python 3.0 被移除了，但在 Python 3.2 被重新加入。

/*/语法：//*callable(object)

/*/参数：//*object – 对象

案例：

#检查一个数字
callable(0)
False

#创建一个函数
def add(x,y):
    return x+y 
callable(add)
True

#创建一个带有__call__方法的类
class Dogs:
    def __call__(self):
        return 0
callable(Dogs)    
True

十一、内置属性

dir()

/*/描述：//*dir() 查看对象的内置属性, 访问的是对象中的__dir__()方法，函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用，如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

/*/语法：//*dir(object)

/*/参数：//*object 对象、变量、类型。

案例：

#获得当前模块的属性列表
dir()
['In','Out', 'exit', 'get_ipython', 'quit']

#查看列表的方法，使用dir([ ])或者dir(list())#查看列表的方法
print(dir(list()))
['__add__', ... 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

dir()访问的是对象中的__dir__()方法，因此下面的调用也能得到相同的结果：

list().__dir__()
[__repr__',, ... 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

print(dir(str))、print(dir(list))、print(dir(dict))、分别获取各个数据类型的方法，不带参数时返回当前范围内的变量，方法和定义的类型列表；带参数时返回参数的属性，方法列表。

hasattr()

/*/描述：//*函数用于判断对象是否包含对应的属性。

/*/语法：//*hasattr(object, name)

参数：

• object – 对象。
• name – 字符串，属性名。

案例：

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