Python Note -- Day 7. 数据类型详解-列表、列表推导式，迭代器

14. 1 数据类型详解 - 列表

14.1.1 列表的定义与操作

• 可以使用 中括号定义 []
• 使用list函数定义
• 元素可以是任意类型，通常用于存放同类项目的集合

1. 列表的拼接
   alist1 = [1,2,3,4]
   blist2 = ['a','b','c','d','e']
   print(alist1+blist2)
2. 列表元素的重复，乘以数字
   print(alist1*3)
3. 检测元素是否存在于列表
   res = 'a' in alist1
4. 列表的索引 通过下标获取指定元素
5. 通过下标修改元素 blist2[-2] = 'dd'
   print(blist2)
6. 不能通过下标添加元素

1. 列表元素中追加元素 list.append()

alist.append('ff')  
print(alist)

1. 列表元素的删除

• 通过下标进行
  del alist[0]
  print(alist)
• list.pop()

res = alist.pop() # 出栈，提取出列表中最后一个元素
print(res)
print(alist) # 被提取后就没了，输出新的列表

1. 获取列表长度 len()
   ree = len(alist)

PS：
使用迭代查找一个list中最小和最大值，并返回一个tuple：

def findMinAndMax(L):
    mi = mx = None
    for x in L:
        if mi == None or x < mi:      # 注意位置！ if x - mi<0 or mi == None:
            mi = x                    # 会报错 TypeError: '<' not supported between instances of 'int' and 'NoneType'
        if mx == None or x > mx :
            mx = x
    return(mi,mx)

14.1.2 列表的切片

list[start[:end[:step]]]

1. list[:],lsit[::] == list
2. list[start:] 从指定位置开始到列表最后
3. list[:end] 从开始到指定位置 之前 结束！！
4. list[start:end] 从指定位置开始到指定位置 之前 结束 !!
5. list[::-1] 倒着获取列表数据！！！

alist = ['lih','Gasua','ann','jane','mike','kim']
print(alist[:4:2])  # ['lih', 'ann']

list[::-1] 倒着获取列表数据！！

14.1.3 使用切片对列表元素进行删除和更新

• 从指定下标开始，到指定下标 之前 结束，替换为对应的数据（若是容器类型，会拆分分成每个元素进行赋值

            0     1       2     3      4     5
alist = ['lih','Gasua','ann','jane','mike','kim']
alist[2:4] = 'a'       # ['lih', 'Gasua', 'a', 'mike', 'kim']
alist[2:4] = 'aa'      # ['lih', 'Gasua', 'a', 'a','mike','kim']
alist[2:4] = 'abcc'    # 当成容器，['lih', 'Gasua', 'a', 'b', 'c', 'c', 'mike', 'kim']

alist[2:6:2] = ['a','b']   #['lih', 'Gasua', 'a', 'jane', 'b', 'kim']

需要与要更新的元素个数对应！！！

• 切片删除 (指定位置)

alist = ['lih','Gasua','ann','jane','mike','kim']
del alist[2:4]  # ['lih', 'Gasua', 'mike', 'kim']
# del alist[2:6:2]  # ['lih', 'Gasua', 'jane', 'kim']
print(alist)

14.1.4 列表的相关函数 - 重点 ！！

一些通过指定位置进行操作，一些直接添加数据，要分清楚

查找添加删除

• len(list) 检测当前列表的长度列表中元素的个数
• list.count(x) 检测当前列表中元素出现的次数

alist = ['lih','Gasua','ann','jane','mike','kim']
res = alist.count('kim')
print(res)

• list.index(x[,i[,j)) 查找指定元素x在列表中第一次出现的索引位置,没找到会报错

dlist = [1,2,3,4,11,22,1,2,3,4]
a = dlist.index(1,1)
print(a)    # 6

• list.insert(i,x) 在由i给出的索引位置 之前 将x插入列表, （超出为正在末添加，超出为负在首添加）

blist = ['lih','Gasua','kim','ann']
blist.insert(2,'oh')
print(blist)  # ['lih', 'Gasua', 'oh', 'kim', 'ann']

• list.pop(i) 可以对指定索引**位置**上的元素作 出栈 操作，返回出栈的元素！

clist = ['lih','Gasua','kim','ann']
c = clist.pop()  # 默认会把列表中最后一个元素 出栈
print(c)
print(clist)
clist.pop(1)
print(clist)

• list.remove(x) 可以指定列表中的**元素**进行 删除，返回None；
  只删除一个，若没找到则报错

dlist = [1,2,3,4,11,22,1,2,3,4]
a = dlist.remove(1)
print(a)
print(dlist)

• list.append(x) 向列表末尾追加新元素,返回值为None

alist = ['lih','Gasua','kim']
res = alist.append('nice')
print(res)   # None

• list.extend(t) 或 list += t
  只能接收 一个 容器类型数据，追加到原列表中

elist = [1,2,3,4]
# elist.extend('123') # [1, 2, 3, 4, '1', '2', '3']
elist.extend(['123','456'])
print(elist)  # [1, 2, 3, 4, '123', '456']

elist = [1,2,3,4]
t = ['3','4']
elist = elist + t
print(elist)
b = '123'
elist += b
print(elist)

• list.clear() 清空列表内容
  等同于 del list[:]

• list.reverse() 原列表翻转，无返回值

elist = [1,2,3,4]
elist.reverse()
print(elist)   # [4, 3, 2, 1]

• sort() 排序

flist = [1,22,33,-44,11,5,7,6]
flist.sort()  # 默认对元素进行从小到大的排序
flist.sort(reverse=True) # 对元素进行从大到小排序
flist.sort(key=abs) # 传递一个函数，按照函数返回值进行排序

• list.copy() 拷贝复制当前列表
  对多维列表中的元素进行操作，会将两个列表全改变

alist = ['a','b','c',[11,22,33]]
res = alist.copy()
print(res)
#del res[1]
print(res)
del res[3][1] # 多维，在内存中引用的地址是相同的
print(res)
print(alist)

14.1.5 深拷贝与浅拷贝

alist = ['a','b','c',[11,22,33]]
res = alist.copy()
print(alist,id(alist)) # 2283910780616
print(res,id(res))     # 2283906028040
print(alist[3],id(alist[3])) # 2136977265672
print(res[3],id(res[3]))     # 2136977265672
# 地址是同一个，列表中的多维列表是同一个元素（对象）
# copy()函数只能拷贝最外层数据，里面的拷贝不了，是浅拷贝
# 浅拷贝只能拷贝当前列表，不能拷贝其他多维元素

• 深拷贝就是不光拷贝当前列表，同时拷贝列表中的多维元素
  使用 copy模块中 深拷贝方法 deepcopy

import copy
alist = ['a','b','c',[11,22,33]]
res = copy.deepcopy(alist)
del res[3][1]

print(alist,id(alist)) # ['a', 'b', 'c', [11, 22, 33]] 32079560
print(res,id(res))     # ['a', 'b', 'c', [11, 33]] 3691080

14.1.6 列表推导式

List-Comprehensions
采用表达式的方式，对数据进行过滤或处理，把结果组成一个新的列表

1.基本方法
新列表 = [变量或变量处理结果 for 变量 in 容器类型数据]

• 示例1. 创建0-9的平方列表

# 普通方法
vlist = []
for i in range(0,10):
    vlist.append(i**2)
print(vlist)
# map函数和list函数
alist = list(map(lambda x:x**2,range(0,10)))
print(alist)

# 使用列表推导式  和普通方法一样
vlist = [i**2 for i in range(0,10)]
print(vlist)

• 示例2.'1234' ==> [2，4，6，8]

astr = '1234'
# 普通方法
a = int(astr)
new = []
for i in range(2,-1,-1):
    b = a % (10 ** i)
    a = a // (10 ** i)
    new.append(a*2)
    a = b
print(new)
# 或者
newlist = []
for i in astr:  # 注意注意是 astr 直接用！！
    newlist.append(int(i)*2)
print(newlist)

# 推导式
newl = [int(i)*2 for i in astr]
print(newl)

使用列表推导式+位运算 !

astr = '1234'
nl = [int(i)<< 1 for i in astr]
print(nl)

2.带有判断条件的列表推导式
新列表 = [变量或变量处理结果 for 变量 in 容器类型数据 条件表达式]
示例: 求0-9所有的偶数 ==》 []

new = [i for i in range(10) if i % 2 == 0]
print(new)

3.带有条件判断的多循环的推导式
[1,2,3][3,1,4] ==> 把两个列表中的元素 两两组合，要求组合的元素不能重复

aa = [(x,y) for x in [1,2,3] for y in [3,1,4] if x != y]
print(aa)

4.嵌套的列表推导式
列表推导式中的初始表达式可以是任何表达式，包括另一个列表推导式
例子： 把下面，3*4的矩阵，由3个长度为4的列表组成，行转列，列转行

matrix = [
        [1,2,3,4],
        [5,6,7,8],
        [9,10,11,12]
    ]

matrix = [
    [1,2,3,4],
    [5,6,7,8],
    [9,10,11,12]
]

# 理解部分
for arr in matrix:
    print(arr)  # 列表中每一行的结果，列表中的每个元素（每个列表）
for i in range(4):         # 列表中每一行的结果中输出第i个元素
    for arr in matrix:
        print(arr[i],end=' ')
    print()

# 常规方法
n2 = []
for i in range(4):
    n1 = []
    for arr in matrix:
        n1.append(arr[i])
    n2.append(n1)
print(n2)

#推导式
n2 = [[arr[i] for arr in matrix] for i in range(4)]
print(n2)

14.1.7 练习题

使用列表推导式使用九九乘法表
1.把字典中的键值对 转换成 a = b 的数据格式

字典{'user':'admin','age':20,'phone':'133'}
列表['user=admin','age=20','phone=133']
字符串 user=admin&age=20&phone=133

adict = {'user':'admin','age':20,'phone':'133'}
for i in adict:
    # print(i)   # return key !!
    print(i, adict[i])
alist = [f'{i}={adict[i]}' for i in adict ]
# alist = [i+'='+ str(adict[i]) for i in adict]
print(alist)
res = '&'.join(alist)
print(res)

2.用列表推导式把列表中所有字符全部转为小写 ['AAA','bbB','CCc']

list1 = ['AAA','bbB','CCc']
res = [i.lower() for i in list1]   # 注意！注意！！
print(res)

3.x是0-5间的偶数，y是0-5的奇数，把x，y组成元祖放到列表中

newlist = []
for x in range(6):
    for y in range(6):
        if x % 2 == 0 and y % 2 == 1:
            newlist.append((x,y))
print(newlist)

res = [(x,y) for x in range(6) for y in range(6) if x % 2 == 0 and y % 2 != 0]
print(res)

4.是用列表推导式完成九九乘法表
newlist = [f'{x}x{y}={x*y}' for x in range(1,10) for y in range(1,x+1) ]
print(newlist)

5.求M，N中矩阵和元素的乘积

M = [
    [1,2,3],
    [4,5,6],
    [7,8,9]
]
N = [
    [2,2,2],
    [3,3,3],
    [4,4,4]
]
实现乘积的结果：
1） [2,4,6,12,15,18,28,32,36]
2) [[2,4,6],[12,15,18],[28,32,36]]

newlist = []
for i in range(3):
    for j in range(3):
        newlist.append(M[i][j]*N[i][j])
print(newlist)

 

迭代器

* 迭代是Python最强大的功能之一，是访问集合元素的一种方式。
* 迭代器是一个可以记住遍历的位置的对象。
* 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
* 迭代器有两个基本的方法：iter() 和 next()。
* 字符串，列表或元组对象都可用于创建迭代器：

list1=[1,2,3,4,5]
a=iter(list1)
print(next(a)) # 输出迭代器的下一个元素
print(next(a)) 

# 迭代器可用 for 进行遍历
for i in a:
    print(i,end=' ')

# 使用 next() 遍历：
import sys
while True:
    try:
        print(next(a))
    except StopIteration:
        sys.exit()

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。