python进阶语法（一）迭代器、range、zip、enumerate内置函数、列表推导

python进阶语法（一）python进阶语法（一）迭代器、range、zip、enumerate内置函数、列表推导

一.迭代器

用for循环的方式遍历列表：

L = [1,2,3,4]  # 定义列表
for x in L:
    print(x,end="")  # end=""表示让结果在一行输出
    # 输出结果为：1234

另一种方式，迭代的方式遍历列表

L = [1,2,3,4]  # 定义列表
I = iter(L)
print(I.__next__())
print(I.__next__())
print(I.__next__())
print(I.__next__())
# 注意，如果再有一个print(I.__next__())将报错：StopIteration

列表，元组，字典，集合，字符串都是可迭代的数据类型。
iter方法将列表转换为一个迭代器对象，然后才能调用__next__()方法
迭代协议：所有带有__next__方法的对象都会提前进入下一个结果，而且当到达一系列结果的末尾时，__next__会引发StopIteration异常。

# 实例二
D = {
     "a":1,"b":2,"c":3,"d":4}
# 方式一:for循环遍历
for key in D:  # 对于字典D中的键
    print(key,":",D[key])  # D[key]表示字典D的键key对应的键值
# 方式二:for循环遍历
for (k,v) in D.items():
    print(k,":",v)
# 方式三:手动迭代
I = iter(D)
print(I.__next__())
print(I.__next__())
print(I.__next__())
key = I.__next__()
print(D[key],key)  # 打印键和键值

二.python range、zip、enumerate内置函数

range：返回一系列连续增加的整数，可作为for中的索引。
zip：返回一系列并行元素的元组，可用于在for中内遍历多个序列。
enumerate：同时生成可迭代对象中元素的值和索引，因为不必再手动计数。
1.range：

# range规定的范围区间是左闭右开的
print(list(range(5)))  # [0, 1, 2, 3, 4]
print(list(range(2,5)))  # [2, 3, 4]
print(list(range(0,10,2)))  # [0, 2, 4, 6, 8]
print(list(range(-3,3)))  # [-3, -2, -1, 0, 1, 2]
# eg:2
s = "happy birthday"
l = list(range(0,len(s)))
print(l)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
for i in l:
    print(s[i],end='')  # happy birthday
# eg:3
a = [1,2,3,4]
for i in range(len(a)):
    a[i] += 1
    print(a[i],end='')  # 2345
print(a)  # [2, 3, 4, 5]

2.zip

L1 = [1,2,3,4]
L2 = [5,6,7,8]
print(list(zip(L1,L2)))  # [(1, 5), (2, 6), (3, 7), (4, 8)]  # 里面是元组格式，外面由组成列表格式
for (x,y) in zip(L1,L2):  # 将L1，L2中的值组合起来
    print(x,"+",y,"=",x+y, end='')  # 1 + 5 = 62 + 6 = 83 + 7 = 104 + 8 = 12
# 当两个列表内的元素个数不一致时,按照少的对应，长的中有一部分对应不上
s1 = "123"
s2 = "xyzabc"
print(list(zip(s1,s2)))  # [('1', 'x'), ('2', 'y'), ('3', 'z')]
# 方式1:正常构造字典
D = {
     "name":"mrn","age":23,"city":"changchun"}
# 方式2:通过zip构造字典
keys = ["name","age","city"]
values = ["mrn","23","changchun"]
print(list(zip(keys,values)))  # [('name', 'mrn'), ('age', '23'), ('city', 'changchun')]
# 注意以上返回的是一个列表形的元组，并不是字典，要把它转换成字典的形式
D2 = {
     }  # 创建一个空字典
for (k,v) in zip(keys,values):
    D2[k] = v
print(D2)  # {'name': 'mrn', 'age': '23', 'city': 'changchun'}  # 现在就是字典的形式了
# 方式三:
keys = ["name","age","city"]
values = ["mrn","23","changchun"]
D3 = dict(zip(keys,values))
print(D3)  # {'name': 'mrn', 'age': '23', 'city': 'changchun'}

3.enumerate

s1 = "happybirthday"
for (index,item) in enumerate(s1):
    print(index,"-->",item)  # 将字符串给进去，enumerate就会自动给每个字符对应索引

注意：尽可能使用for循环为不是while循环，并且不要在for循环中使用range调用，除非迫不得已；zip可以接受任何类型的序列（本质上可以是所有的可迭代对象，包括文件）

三.列表推导

列表推导的优点：
1.列表推导比手动的for循环语句运行更快，解释器内部c语言编译。
2.列表推导只需要更少的代码。
3.列表推导占用的内存少，且大部分的工作在解释器内部完成。

L = [1,2,3,4]
L = [x+1 for x in L]
print(L)  # [2, 3, 4, 5]
for i in range(len(L)):
    L[i] += 1
    print(L[i],end='')  # 3456
s = [" hello"," world"," welcome"]
s = [item.strip() for item in s]
print(s)  # ['hello', 'world', 'welcome']每一项前面的空格被拿掉了

# eg:只保留列表中大于10的元素
numbers = [5,7,13,16,8,19,34,22,8]
# 方式一:for循环的形式
numbers_new = []
for i in range(len(numbers)):
    if numbers[i]>10:
        numbers_new.append(numbers[i])
print(numbers_new)  # [13, 16, 19, 34, 22]
# 方式二:列表推导
result = [x for x in numbers if x>10]
print(result)  # [13, 16, 19, 34, 22]

# eg:用列表推导实现for的嵌套
x = ['a','b','c','d']
y = ['1','2','3','4']
k = [i+j for i in x for j in y]
print(k)  # ['a1', 'a2', 'a3', 'a4', 'b1', 'b2', 'b3', 'b4', 'c1', 'c2', 'c3', 'c4', 'd1', 'd2', 'd3', 'd4']