（期末复习） Python内置函数

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

it=iter(range(1,10))
print(next(it))
print(next(it))
print(next(it))
print(type(it))
print(list(it)) # 这是迭代器的特点：只可以遍历一次，不连续的遍历都会接着上次的结束点继续遍历，直到一次完整的遍历结束
print(next(it)) # 因为it迭代器中的所有数据都已经遍历了依次，系统会报错

# Traceback (most recent call last):
#   File "D:\软件课件\练习\内置函数.py", line 13, in <module>
#     print(next(it)) # 因为it迭代器中的所有数据都已经遍历了依次，系统会报错
# StopIteration
# 1
# 2
# 3
# <class 'range_iterator'>
# [4, 5, 6, 7, 8, 9]

(2) enumerate 函数：
对于有序集合，有时候会需要取出元素的索引，可以使用python内置的enumerate函数。
enumerate函数可以把一个**（可迭代对象）**变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身。

list_one = ['a','b','c']
for i in enumerate(list_one,start=1): # start表示下标的最初值,默认从0开始
    print(i)
    print(type(i)) # 类型是tuple
    print(i[0]) # 打印list的下标0 1 2
print(type(enumerate(list_one)))  # 在 Python 3.x 中为了减少内存，enumerate() 返回的是一个对象。
print(list(enumerate(list_one)))
print(dict(enumerate(list_one)))

# (1, 'a')
# <class 'tuple'>
# 1
# (2, 'b')
# <class 'tuple'>
# 2
# (3, 'c')
# <class 'tuple'>
# 3
# <class 'enumerate'>
# [(0, 'a'), (1, 'b'), (2, 'c')]
# {0: 'a', 1: 'b', 2: 'c'}

（3）zip(可迭代对象1，可迭代对象2，可迭代对象3…)函数：
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组.。
如果各个迭代对象的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
zip 方法在 Python 2 和 Python 3 中的不同：在 Python 3.x 中为了减少内存，zip() 返回的是一个对象（迭代器）。

打包：

a=[1,2,4]
b=['a','b','c','d']
c=['x','y','n']
zipp =zip(a,b,)
print(type(zipp)) # 在 Python 3.x 中为了减少内存，zip() 返回的是一个对象。
print(zipp)
for i in zipp:
    print(i)
    print(type(i))
print(list(zipp)) # zip方法可以返回的是一个迭代器，所以输出的是一个空列表
from collections import Iterator, Iterable, Generator
print(isinstance(zipp,Iterator))  # 检查是否是迭代器 True
print(isinstance(zipp,Iterable))  # 检查是否是迭代对象 True
print(isinstance(zipp,Generator)) # 检查是否是生成器 False

# <class 'zip'>
# <zip object at 0x0000028F4AA60880>
# (1, 'a')
# <class 'tuple'>
# (2, 'b')
# <class 'tuple'>
# (4, 'c')
# <class 'tuple'>
# []
# True
# True
# False

解包：

ip=zip(*zipp)
print(type(ip))
print(zip(*zipp))
print(list(ip))

# <class 'zip'>
# <class 'zip'>
# <zip object at 0x00000214FD964DC0>
# [(1, 2, 4), ('a', 'b', 'c')]

（4）range(start, stop, step) 函数：
参数说明：
start: 计数从 start 开始。默认是从 0 开始。
stop: 计数到 stop 结束，但不包括 stop。
step：步长，默认为1。

print(tuple(range(5)))
print(list(range(1,5)))
print(set(range(0,6,2)))

# (0, 1, 2, 3, 4)
# [1, 2, 3, 4]
# {0, 2, 4}

（5）sorted() 函数对所有可迭代的对象进行排序操作。

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

sorted(iterable, cmp=None, key=None, reverse=False)
参数说明：
iterable – 可迭代对象。
cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
print(sorted(students,key=lambda s:s[2])) # key通过匿名函数规定排序的规则是比较students中每个元素中下标为2的元素大小，升序
print(sorted(students, key=lambda s: s[2], reverse=True) ) # 降序

# [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
# [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

(6)eval （） 函数：
eval() 函数用来执行一个**(字符串)**表达式，并返回表达式的值

x=6
print(eval( '3 * x' ))
print(eval('pow(2,2)'))

# 18
# 4

(7)map()函数
map()函数会根据传入的函数对指定的序列做映射。
map()函数接收两个参数，一个是function函数，另一个参数是一个或多个序列。
map()函数会将传入的函数依次作用到传入序列的每个元素，并把结果作为新的序列返回。
map()函数的定义为：
map(function, sequence, sequence, …) -> list
例如，我们要对一个列表序列中的每个数值元素进行平方运算：

r = map(lambda x: x ** 2, [1, 2, 3, 4,]) # lambda 声明一个匿名函数
print(r)
print(list(r))
print("*"*20)

# [1, 4, 9, 16]

当map()函数的第二个参数中存在多个序列时，会依次将每个序列中相同位置的元素一起做参数并调用function函数。
例如，要对map()函数传入的两个序列中的元素依次求和，程序代码如下：

def San(x,y): # 定义一个函数
    return x+y
r1=map(San,[1, 2, 3, 4, 5], [6, 7, 8, 9, 10,11]) # 调用San函数对序列进行映射
print(list(r1))

当map()函数传入的序列有多个时，我们要注意function函数的参数数量，应和map()函数传入的序列数量相匹配。

r = map(lambda x, y: x + y, [1, 2, 3, 4, 5], [6, 7, 8, 9, 10,11])
print(list(r))

# [7, 9, 11, 13, 15]

(8)reduce()函数
reduce()函数把传入的函数作用在一个序列[x1, x2, x3, …]上，且这个函数必须要接收两个参数。
reduce()函数把第一次计算的结果继续和序列中的下一个元素做累积计算。reduce()函数的定义为：

reduce(function, sequence, initial) -> value
function参数是有两个参数的函数，reduce()函数依次在序列中取元素，并和上一次调用function函数的结果做参数，然后再次调用function函数。
例如：

from functools import reduce
r = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5],6) # 计算的顺序是：((((1+6)+2)+3)+4)+5
print(r)

# 21

求一个数的阶乘：

m=reduce(lambda x,y:x*y ,range(1,6),6)
print(m)

# 720