[数据结构与算法]不熟悉的内置函数

divmod(a, b)

• 返回一个包含商和余数的元组(a // b, a % b)

divmod(a, b)
# 参数说明：
# a: 数字
# b: 数字
# divmod(7, 2) =>(3, 1)

enumerate(iterable, start=0)

• 返回一个枚举对象。iterable 必须是一个序列，或iterator，或其他支持迭代的对象。enumerate() 返回
  的迭代器的__next__() 方法返回一个元组，里面包含一个计数值（从start 开始，默认为0）和通过
  迭代iterable 获得的值。

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

等价于`

def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
    n += 1

使用：

资料来源：https://blog.csdn.net/churximi/article/details/51648388

• 1,如果对一个列表，既要遍历索引又要遍历元素时，首先可以这样写：

list1 = ["这", "是", "一个", "测试"]
for i in range (len(list1)):
   print i ,list1[i]

上述方法有些累赘，利用enumerate()会更加直接和优美：

list1 = ["这", "是", "一个", "测试"]
for index, item in enumerate(list1):
    print index, item
>>>
0 这
1 是
2 一个
3 测试

• 2,如果要统计文件的行数，可以这样写：

count = len(open(filepath, 'r').readlines())

这种方法简单，但是可能比较慢，当文件比较大时甚至不能工作。

可以利用enumerate()：

count = 0
for index, line in enumerate(open(r"C:\Users\luckiness\Desktop\步骤.txt", 'r', encoding='UTF-8')):
    count += 1
print(count)

filter(function, iterable)

• 用iterable 中函数function 返回真的那些元素，构建一个新的迭代器。iterable 可以是一个序列，一个支
  持迭代的容器，或一个迭代器。如果function 是None ，则会假设它是一个身份函数，即iterable 中所
  有返回假的元素会被移除。
  请注意，filter(function, iterable) 相当于一个生成器表达式，当function 不是None 的时
  候为(item for item in iterable if function(item))；function 是None 的时候为(item
  for item in iterable if item)

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

format(value[, format_spec ])

print("{} {}".format("hello", "world"))  # 不设置指定位置，按默认顺序
print("{0} {1}".format("hello", "world"))  # 设置指定位置
print("{1} {0} {1}".format("hello", "world"))  # 设置指定位置
print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))

# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))

# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的

frozenset([iterable ])

• frozenset是冻结的集合，它是不可变的，存在哈希值，好处是它可以作为字典的key，也可以作为其它集合的元素。缺点是一旦创建便不能更改，没有add，remove方法

>>>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'])   # 创建不可变集合

map(function, iterable, …)

• map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回

def f(x):
    return x * x
print(set(map(f, [1, 2, 3, 4, 5, 6])))
print(list(map(f, [1, 2, 3, 4, 5, 6])))

list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])) # 把所有的数字转化为字符串

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

range(start, stop[, step ])

• 虽然被称为函数，但range 实际上是一个不可变的序列类型

slice(start, stop[, step ])

• 实现切片对象，主要用在切片操作函数里的参数传递

>>>myslice = slice(5)    # 设置截取5个元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice]         # 截取 5 个元素
[0, 1, 2, 3, 4]

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

• 根据iterable 中的项返回一个新的已排序列表。
  具有两个可选参数，它们都必须指定为关键字参数。
• key 指定带有单个参数的函数，用于从iterable 的每个元素中提取用于比较的键(例如key=str.lower)。
• 默认值为None (直接比较元素)。
• reverse 为一个布尔值。如果设为True，则每个列表元素将按反向顺序比较进行排序。

>>> example_list = [5, 0, 6, 1, 2, 7, 3, 4]
>>> sorted(example_list, reverse=True)
[7, 6, 5, 4, 3, 2, 1, 0]

>>> example_list = [5, 0, 6, 1, 2, 7, 3, 4]
>>> result_list = sorted(example_list, key=lambda x: x*-1) # 乘以-1后进行正序排序再返回值
>>> print(result_list)
[7, 6, 5, 4, 3, 2, 1, 0]

zip(*iterables, strict=False)

• 在多个迭代器上并行迭代，从每个迭代器返回一个数据项组成元组。

>>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
... print(item)
...
(1, 'sugar')
(2, 'spice')
(3, 'everything nice')

更正式的说法：zip() 返回元组的迭代器，其中第i 个元组包含的是每个参数迭代器的第i 个元素。
不妨换一种方式认识zip() ：它会把行变成列，把列变成行。这类似于矩阵转置。
zip() 是延迟执行的：直至迭代时才会对元素进行处理，比如for 循环或放入list 中。
值得考虑的是，传给zip() 的可迭代对象可能长度不同；有时是有意为之，有时是因为准备这些对象
的代码存在错误。Python 提供了三种不同的处理方案：
? 默认情况下，zip() 在最短的迭代完成后停止。较长可迭代对象中的剩余项将被忽略，结果会裁
切至最短可迭代对象的长度：

>>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
[(0, 'fee'), (1, 'fi'), (2, 'fo')]

• 通常zip() 用于可迭代对象等长的情况下。这时建议用strict=True 的选项。输出与普通
  的zip() 相同：。

>>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
[('a', 1), ('b', 2), ('c', 3)]

与默认行为不同的是，它会检查可迭代对象的长度是否相同，如果不相同则触发ValueError

>>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True))
Traceback (most recent call last):
...
ValueError: zip() argument 2 is longer than argument 1

如果未指定strict=True 参数，所有导致可迭代对象长度不同的错误都会被抑制，这可能会在
程序的其他地方表现为难以发现的错误。
? 为了让所有的可迭代对象具有相同的长度，长度较短的可用常量进行填充。这可由itertools.
zip_longest() 来完成。

极端例子是只有一个可迭代对象参数，zip() 会返回一个一元组的迭代器。如果未给出参数，则返回
一个空的迭代器。

zip() 与* 运算符相结合可以用来拆解一个列表:

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> list(zip(x, y))
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)
True