【README】

本文总结自《python编程快速上手-让繁琐工作自动化》第4章，非常棒的一本书，墙裂推荐；

• 1） python的序列数据类型：包括列表，字符串，由range()返回的范围对象，以及元组；
  • 对列表的操作，如按索引取值，切片，for循环，len函数，in和not in等操作符，都可以作用于序列数据类型及字符串类型；
• 2）列表数据类型：列表是一个值：由多个值构成的序列；如 [‘1’, ‘2’, ‘3’] ；
  • 列表中的值称为表项， 用逗号分隔；列表中的值，可以是不同类型； [‘1’, ‘2’, True]
• 3）元组数据类型：元组定义使用圆括号(1,2,3)，列表定义使用中括号[1,2,3] ； 元组不可变，列表可变

---

【4】python列表

【4.1】列表数据类型

1）列表是一个值：由多个值构成的序列；如 [‘1’, ‘2’, ‘3’] ；列表中的值称为表项， 用逗号分隔；

2）列表中的值，可以是不同类型； [‘1’, ‘2’, True]

list00 = ['1', '2', 3, 4, True]
print(list00)

3）列表中的元素还可以是列表

# 列表中的元素还可以是列表
twoDimensionArr = [['a11', 'a12', 'a13'], ['a21', 'a22', 'a23'], ['a31', 'a32', 'a33'], [41, 42.2, 'a43', 'a44', 'a45']]
print(twoDimensionArr[0])
print(twoDimensionArr[1])
print(twoDimensionArr[2])
print(twoDimensionArr[3])

# ['a11', 'a12', 'a13']
# ['a21', 'a22', 'a23']
# ['a31', 'a32', 'a33']
# [41, 42.2, 'a43', 'a44', 'a45']

---

【4.1.1】用索引取得列表中的单个值

# 用索引取得列表中的单个值
list01 = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(list01[0]) # a

【4.1.2】负数索引

1）-1 表示列表中的最后一个索引； -2表示列表中的倒数第2个索引；

# 负数索引
list01 = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(list01[-1]) # g
print(list01[-2]) # f

【4.1.3】利用切片获取子列表

1）切片：从列表中获取多个值，结果是一个新列表； 切片用一对方括号来表示，有2个由冒号分隔的整数； 如 list01[1:3]

• list01[2] ：一个列表和索引； （1个整数 ）
• list01[1: 3]：是一个列表和切片 （2个整数）

2）在一个切片中：第1个整数是开始索引（包含），第2个整数是结束索引（不包含）；

# 利用切片取得子列表
print("利用切片取得子列表")
list01 = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(list01[1:4]) # ['b', 'c', 'd']
print(list01[0:-1]) # ['a', 'b', 'c', 'd', 'e', 'f']
print(list01[:])  # ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(list01[0:])  # ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(list01[0:len(list01)])  # ['a', 'b', 'c', 'd', 'e', 'f', 'g']
print(list01[:2])  # ['a', 'b'] 下标0,1，不包含下标2的元素

【4.1.4】用索引改变列表中的值

# 修改列表中的元素
list01[0] = 'a_v2'
print(list01)
# ['a_v2', 'b', 'c', 'd', 'e', 'f', 'g']

【4.1.5】列表连接与复制

1） +操作符：用于连接2个列表；

2）*操作符：用于列表复制；

# 列表连接和列表复制
list02 = ['a1', 'a2', 'a3']
list03 = list02 + ['a4', 'a5', 'a6']
print(list03[:])
# ['a1', 'a2', 'a3', 'a4', 'a5', 'a6']

list04 = list02 * 2
print(list04[:])
# ['a1', 'a2', 'a3', 'a1', 'a2', 'a3']

【4.1.6】del语句删除列表中的元素

1）注意：需要说明的是， del语句删除列表中指定索引的元素，被删除元素后面的所有元素，都会向前移动一个索引；可能出现性能问题；

# 用del语句删除列表中的元素
list05 = [1, 2, 3]
del list05[0]
print(list05[:])
# [2, 3]

---

【4.2】使用列表

【4.2.1】列表用于循环

# 列表用于循环
# 遍历列表
for i in range(4):
    print(i)
# 0
# 1
# 2
# 3

【补充】遍历列表

# 遍历列表
for i in [1, 2, 3]:
    print(i)
# 1
# 2
# 3

# 遍历列表2
arr01 = ['10', 20, 30, 40]
for i in range(len(arr01)):
    print('index=' + str(i) + ', value=' + str(arr01[i]))

# index=0, value=10
# index=1, value=20
# index=2, value=30
# index=3, value=40

【4.2.2】in 和 not in 操作符

1）in 和 not in 操作符：确定一个值是否在列表中；

arr01 = ['10', 20, 30, 40]
# in 和 not in 操作符
print('10' in arr01)
print('20' in arr01)
print(20 in arr01)
print(20 not in arr01)
# True
# False
# True
# False

# 20存在于arr01数组
print("=== 20存在于arr01数组 ===")
if 20 not in arr01:
    print(str(20) + '不存在于arr01数组')
else:
    print(str(20) + '存在于arr01数组')

【4.2.3】多重赋值技巧

# 多重赋值技巧 （类似于react的解构赋值）
print("=== 多重赋值技巧 === ")
colorArr = ['red', 'green', 'blue']
e1, e2, e3 = colorArr
print(e1, e2, e3) # red green blue 

【4.2.4】enumerate()函数与列表一起使用

# enumerate()与列表一起使用（类似于java的foreach循环）
print("\nenumerate()与列表一起使用（类似于java的foreach循环）")
colorArr = ['red', 'green', 'blue']
for index, value in enumerate(colorArr):
    print('index[' + str(index) + '] = ' + value)

# enumerate()与列表一起使用（类似于java的foreach循环）
# index[0] = red
# index[1] = green
# index[2] = blue

【4.2.5】random.choice() 和 random.shuffle() 与列表一起使用

# random.choice() 和 random.shuffle() 与列表一起使用
print("\n === random.choice() 和 random.shuffle() 与列表一起使用")
peopleArr = ['zhangsan', 'lisi', 'wangwu', 'zhaoliu']
print(random.choice(peopleArr)) # lisi

# 洗牌函数shuffle() 将就地修改列表，而不是返回新列表
print("\n\n=== 洗牌函数shuffle() 将就地修改列表，而不是返回新列表")
random.shuffle(peopleArr)
print(peopleArr)
print(peopleArr[:])

# ['wangwu', 'zhangsan', 'zhaoliu', 'lisi']
# ['wangwu', 'zhangsan', 'zhaoliu', 'lisi']

其中： random.choice(list)表示从列表list中返回一个随机选择的表项；

---

【4.3】增强的赋值操作

print("\n\n === 增强的赋值操作")

# 4.3 增强的赋值操作
age = 42
age += 1
print(age) # 43

age -= 3
print(age) # 40

增强的赋值操作：指的是通过 +=， -=, *=, /= 等操作符为变量赋值；

---

【4.4】列表的方法

1）列表的方法与函数是同一回事，只不过，列表的方法在一个值上进行调用；

【4.4.1】用index方法在列表中查找值

# 用index发发发在列表中查找值，返回索引下标
peopleArr = ['a', 'b', 'c', 'd']
print(peopleArr.index('a')) # 0

【注意】若传入的值在列表中不存在，则抛出ValueError错误；

【4.4.2】用append()方法和insert()方法在列表中添加值

1）用append()方法和insert()方法在列表中添加值， 列表被就地修改；

• list.append(‘e1’)方法：把e1添加到列表list的末尾；
• list.insert(1, ‘f1’)方法：把f1添加到列表list的索引为1的位置；

alphabetArr = ['a', 'b', 'c', 'd']
alphabetArr.append('e1')
print(alphabetArr)  # ['a', 'b', 'c', 'd', 'e1']

alphabetArr.insert(1, 'f1')
print(alphabetArr) # ['a', 'f1', 'b', 'c', 'd', 'e1']

【4.4.3】用remove方法删除列表中的值

print('\n=== 用remove方法删除列表中的值')
alphabetArr = ['a', 'b', 'c', 'd']
alphabetArr.remove('a')
print(alphabetArr) # ['b', 'c', 'd']

【4.4.4】用sort()方法将列表中的元素排序

print("\n\n=== 使用 sort()方法将列表的值排序")
alphabetArr = ['f', 'e', 'a', 'b', 'd', 'c']
alphabetArr.sort()
print(alphabetArr) # ['a', 'b', 'c', 'd', 'e', 'f']

alphabetArr.sort(reverse=True)
print(alphabetArr) # ['f', 'e', 'd', 'c', 'b', 'a']

【4.4.5】使用 reverse()方法反转列表中的值

print("使用 reverse()方法 反转列表中的值")
alphabetArr = ['a', 'b', 'c', 'd']
alphabetArr.reverse()
print(alphabetArr) # ['d', 'c', 'b', 'a']

---

【4.5】序列数据类型

1）python的序列数据类型：包括列表，字符串，由range()返回的范围对象，以及元组；

• 对列表的操作，如按索引取值，切片，for循环，len函数，in和not in等操作符，都可以作用于序列数据类型及字符串类型

# 4.6 序列数据类型
name = 'Student'
print(name[0]) # S
print(name[-2]) # n
print(name[0:4]) # Stud
print('St' in name) # True
print('t' in name) # True
for i in name:
    print(i)

# S
# t
# u
# d
# e
# n
# t

【4.5.1】可变和不可变数据类型

1）可变与不可变：

• 列表：可变，它的值可以新增，删除，修改；
• 字符串：不可变，不能被修改；改变一个字符串的正确方式是使用切片和连接构造一个新的字符串，或复制一个新的字符串；
• 元组：可变；

【4.5.2】元组数据类型

1）元组与列表区别：

• 元组定义使用圆括号(1,2,3)，列表定义使用中括号[1,2,3]；
• 元组不可变，列表可变；

2）元组的优点：

• 用元组告诉其他人，不打算改变这个序列的值；
• 因为元组不可变化，所以python底层可以优化，让使用元组的代码运行速度快于列表；

print('\n=== 元组数据类型 === ')
eggs = ('hello', 42, 53)
print(eggs[0]) # hello
print(eggs[1:]) # (42, 53)
print(len(eggs)) #

【4.5.3】变量的数据类型

print('\n=== 变量的数据类型 === ')
print(type(('hello', ))) # <class 'tuple'>
print(type(('hello')))  # <class 'str'>

【4.5.4】使用list()和tuple()来转换类型

1）使用list()和tuple()来转换类型， 分别转换为列表与元组

print('\n=== 使用list()和tuple()来转换类型， 分别转换为列表与元组')
tuple01 = tuple(['a1', 'a2', 'a3'])
print(type(tuple01)) # <class 'tuple'>
print(list(tuple01)) # ['a1', 'a2', 'a3']
print(list('hello')) # ['h', 'e', 'l', 'l', 'o']

---

【4.6】引用

1）什么是引用： 变量存储的是对计算机内存位置的引用，或者简单理解引用就是值的内存地址（我是这么理解的）

【4.6.1】标识和id()函数

1）id函数返回的是入参的唯一标识（内存地址的hash值）

# 标识和id()函数
a = 'hello'
print(id(a)) # 2897082779712
a += ' wolrd'
print(id(a)) # 2897082736432

2）通过id()函数来判断append()函数是否会创建新的列表

print("\n\n === append()方法不会创建新的列表，而是就地修改对象")
arr = ['a', 'b', 'c']
print(id(arr)) # 2844017850560
arr.append('d')
print(id(arr)) # 2844017850560

显然， append前后， 变量arr的值没有变，所以append()没有创建新的列表（变量）

【4.6.2】copy模块的copy() 和 deepcopy()

# import copy
print('\n=== copy模块的copy() 和 deepcopy()')
arr = ['a', 'b', 'c', 'd']
print(id(arr)) # 2250866974592

# copy模块的copy()复制
arr2 = copy.copy(arr)
print(id(arr2)) # 2250866981056

# 修改arr2的第1个元素， arr2发生改变，但arr没有变化
arr2[0] = 'apple'
print(arr2)  # ['apple', 'b', 'c', 'd']
print(arr) # ['a', 'b', 'c', 'd']

【补充】如果要复制的列表中包含了列表， 那就使用copy.deepcopy()函数来代替，deepcopy()将同时复制它们内部的列表；