1.1.列表定义
列表是python中内置有序可变序列，列表的所有元素放在一对中括号“[]”中，并使用逗号分隔开；
一个列表中的数据类型可以各不相同，可以同时分别为整数、实数、字符串等基本类型，甚至是列表、字典以及其他自定义类型的对象。
例如：
[1, 2, 3, 2.4, 5]
[0.01, "zhangsan", [1,2,3]]
创建
- 使用“=”直接将一个列表赋值给变量即可创建列表对象。例如：a_list = [], b_list = [1, 2, 3]
- 使用list()函数将元组、range对象、字符串或其他类型的可迭代对象类型的数据转换为列表。
例如：a_list = list("Hello")将字符串"hello"转换成列表['H', 'e', 'l', 'l', 'o']
删除 当不再使用时，使用del命令删除整个列表 例如：
>>>x = [1, 2, 3]
>>>del x[1] #删除指定位置元素
>>>x
[1, 3]
>>>del x #删除整个列表
>>>x
Traceback (most recent call last):
File "<pyshell#6>", line 1, in <module>
x
NameError: name 'x' is not defined
1.2.列表元素的增加
1.2.1.append()
向列表尾部追加一个元素，不改变其内存首地址，属于原地操作。例如：
x = [1, 2, 3]
x.append(4)
print(x)
输出：
[1, 2, 3, 4]
1.2.2.insert()
向列表任意位置插入一个元素，不改变其内存首地址，属于原地操作。
例如：
x = [1,3,4]
x.insert(1,2)
print(x)
输出：
[1, 2, 3, 4]
1.2.3.extend()
将另一个迭代对象的所有元素添加至该列表对象尾部，不改变其内存地址，属于原地操作。
例如：
x = [1,2]
x.extend([3,4])
print(x)
输出：
[1, 2, 3, 4]
1.3.运算符"+"和"*"
并不是真的为列表添加元素，而是创建一个新列表，不属于原地操作，而是返回新列表。
x = [1,2,3]
y = x + [4]
print(y)
y = x*2
print(y)
输出：
[1, 2, 3, 4]
[1, 2, 3, 1, 2, 3]
此时x保持不变，依旧是[1,2,3]
1.4.列表元素的删除
1.4.1.pop()
使用列表的pop()方法删除并返回指定（默认为最后一个）位置上的元素，如果给定的索引超出了列表的范围，则抛出异常。
x = [1,2,3,4]
print(x.pop())
print(x.pop(1))
输出：
4
2
1.4.2.remove()
删除首次出现的指定元素，如果列表中不错在要删除的元素，则抛出异常。
例如：
x = [1,2,3,4]
x.remove(2)
print(x)
输出：
[1, 3, 4]
1.4.3.del
删除列表中的指定位置上的元素。
例如：
x = [1,2,3,4]
del x[1]
print(x)
输出：
[1, 3, 4]
1.5.列表元素访问与计数
1.5.1.count()
统计指定元素在列表对象中出现的次数。
例如：
x = [1,2,3,3,4,5]
print(x.count(3))
print(x.count(0))
输出：
2
0
1.5.2.index()
获取指定元素首次出现的下标，若列表对象中不存在指定元素，则抛出异常。
例如：
x = [1,2,3,2,2,4]
print(x.index(2))
输出：
1
1.5.3.in
测试列表中是否存在某元素
例如：
x = [1,2,3,4]
print(3 in x)
print(5 in x)
输出：
True
False
1.6.列表排序
1.6.1.sort()
按照指定规则对所有元素进行排序，默认规则是直接比较规则大小。
例如：
aList = [3,4,5,6,7,9,11,13,15,17]
import random
random.shuffle(aList) #随机降序
print(aList)
aList.sort() #默认是升序排序
aList.sort(reverse = True) #降序排序
print(aList)
输出：
[15, 4, 13, 11, 5, 17, 9, 3, 7, 6]
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
1.6.2.reverse()
将列表中所有元素原地逆序排列。
例如：
x = [6,4,2,4,1]
print(sorted(x))
print(sorted(x,reverse = True))
print(x)
输出：
[1, 2, 4, 4, 6]
[6, 4, 4, 2, 1]
[6, 4, 2, 4, 1]
1.6.4.reversed()
返回一个逆序排列后的迭代对象，不对原列表做任何修改。
例如：
x = [1,5,3,6,2]
print(list(reversed(x)))
print(x)
输出：
[2, 6, 3, 5, 1]
[1, 5, 3, 6, 2]
1.7.用语序列操作的常用内置函数
1.7.1.len()
返回列表中的元素个数，同样适用于元组、字典、集合、字符串等。
1.7.2.max()、min()
返回列表中的最大或最小元素，同样适用于元组、集合、range对象等。
1.7.3.sum()
对列表的元素进行求和运算。
1.7.4.zip()
返回可迭代的zip对象。
例如：
aList = [1, 2, 3]
bList = [4, 5, 6]
cList = zip(aList, bList)
print(cList)
print(list(cList))
输出：
<zip object at 0x0000020CBC537D08>
[(1, 4), (2, 5), (3, 6)]
1.7.5.enumerate()
枚举列表元素，返回枚举对象，其中每个元素为包含下标和值的元组。该函数对元组、字符串同样有效。
例如：
for item in enumerate('abcdef'):
print(item)
输出：
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'd')
(4, 'e')
(5, 'f')
1.8.遍历列表的三种方式
a = ['a','b','c','d','e','f']
for i in a:
print(i)
for i in range(len(a)):
print(i,a[i])
for i,ele in enumerate(a):
print(i,ele)
输出：
a
b
c
d
e
f
0 a
1 b
2 c
3 d
4 e
5 f
0 a
1 b
2 c
3 d
4 e
5 f
1.9.列表推导式
列表推导式使用非常简洁的方式来快速生成满足特定需求的列表，代码具有非常强的可读性。
语法形式：[表达式 for 变量 in 序列或迭代对象]
列表推导式在逻辑上相当于一个循环，知识形式更加简洁。
lis = [i for i in range(100)]
print(lis)
使用列表推导式实现嵌套列表的平铺
ves = [[1,2,3],[4,5,6],[7,8,9]]
print([num for elem in ves for num in elem])
输出：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
过滤不符合条件的元素，从列表中选择符合条件的元素组成新的列表
aList = [-1,-4,6,7.5,-2.3,9,-11]
print([i for i in aList if i>0])
[6, 7.5, 9]
在列表推导式中使用多个循环，实现多序列元素的任意组合，并且可以结合条件语句过滤特定元素
print([(x,y) for x in range(3) for y in range(3)])
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
print([(x,y) for x in [1,2,3] for y in [3,1,4] if x != y])
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
列表练习
写一个循环，不断地问用户想买什么，用户选择一个商品编号，就把相应的商品添加到购物车里，最终用户输入q退出时，打印购物车里的商品列表
products = [['iphone',6888],['三星',30000],['小米',2500]]
shopping_car = []
flag = True
while flag:
print("******商品列表******")
for index,i in enumerate(products):
print("%s, %s| %s" %(index,i[0],i[1]))
choice = input("请输出您想购买的商品的编号：")
if choice.isdigit():#isdigit()判断变量是什么类型
choice = int(choice)
if choice >= 0 and choice < len(products):
shopping_car.append(products[choice])
print("已经将%s加入购物车" % (products[choice]))
else:
print("该商品不存在")
elif choice == "q":
if len(shopping_car)>0:
print("您打算购买以下商品：")
for index,i in enumerate(shopping_car):
print("%s. %s| %s" %(index,i[0],i[1]))
else:
print("您的购物车中没有添加商品")
flag = False
输出：
******商品列表******
0, iphone| 6888
1, 三星| 30000
2, 小米| 2500
请输出您想购买的商品的编号：0
已经将['iphone', 6888]加入购物车
******商品列表******
0, iphone| 6888
1, 三星| 30000
2, 小米| 2500
请输出您想购买的商品的编号：1
已经将['三星', 30000]加入购物车
******商品列表******
0, iphone| 6888
1, 三星| 30000
2, 小米| 2500
请输出您想购买的商品的编号：2
已经将['小米', 2500]加入购物车
******商品列表******
0, iphone| 6888
1, 三星| 30000
2, 小米| 2500
请输出您想购买的商品的编号：q
您打算购买以下商品：
0. iphone| 6888
1. 三星| 30000
2. 小米| 2500
1.10.列表切片
使用索引获取列表的元素（随机读取）
列表元素支持用索引访问，正向所以从0开始
colors = ["red","blue","green"]
print(colors[0])
print(colors[1])
print(colors[2])
print(colors[-1])
red
blue
green
green
1.10.1.列表的切片操作
切片操作不是列表特有的，python中的有序序列都支持切片，如字符串，元组。
切片的返回结果类型和切片对象类型一致，返回的是切片对象的子序列，如：对一个列表切片返回一个列表，字符串切片返回字符串。
格式：li[start:end:step]
start是切片起点索引，end是切片终点索引，但切片结果不包括终点索引的值。step是步长默认是1。
li=["A","B","C","D"]
t=li[0:3] #起点的0索引可以省略
print(t)
t=li[2:] #省略end，则切到末尾
print(t)
t=li[1:3]
print(t)
t=li[0:4:2] #从li[0]到li[3]，设定步长为2.
print(t)
如何确定start和end，是什么关系？在step的符号一定的情况下，start和end可以混合使用正向和反向索引，无论怎样，你都要保证start和end之间有和step反向一致元素间隔，否则会切出空列表。
t=li[0:2]
t=li[0,-2]
t=li[-4,-2]
t=li[-4,2]
上面的结果都是一样的：t为["A","B"]
t=li[-1:-3:-1]
t=li[-1:1:-1]
t=li[3:1:-1]
t=li[3:-3:-1]
上面的结果都是一样的：t为["D","C"]
t=li[-1:-3]
t=li[-1:1]
t=li[3:1]
t=li[3:-3]
都切出空列表
同时，step的正负决定了切片结果的元素采集的先后
省略start和end表示以原列表全部为目标
t=li[::-1] t--->["C","B","A"] #反向切，切出全部
t=li[:] t--->["A","B","C","D"] #正向切全部
1.10.2.使用切片来原地修改列表内容
aList = [3,5,7]
aList[len(aList):] = [9] #在尾部追加元素
print(aList)
aList[:3] = [1,2,3] #替换前3个元素
print(aList)
aList[:3] = [] #删除前3个元素
print(aList)
[3, 5, 7, 9]
[1, 2, 3, 9]
[9]
1.10.3.使用del与切片结合来删除列表元素
aList = [3,5,7,9,11]
del aList[:3] #删除前3个元素
print(aList)
bList = [3,5,7,9,11]
del bList[::2] #删除偶数位置上的元素
print(bList)
[9, 11]
[5, 9]
1.10.4.切片返回的是列表元素的浅复制
所谓浅复制，是指生成一个新的列表，并且把原列表中所有元素的引用都复制到新列表中。
例如：
aList = [3,5,7]
bList = aList #bList与aList指向同一个内容
print(bList)
bList[1] = 8 #修改其中一个对象会影响另一个
print(aList)
print(aList == bList) #判断两个列表的元素是否完全一致
print(aList is bList) #判断两个列表是同一个对象
print(id(aList)) #内存地址
aList = [3,5,7]
bList = aList[::] #切片，浅复制
print(aList == bList) #两个列表的元素完全一致
print(aList is bList) #两个列表不是同一个对象
print(id(aList) == id(bList)) #内存地址不一致
bList[1] = 8
print(bList)
print(aList)
[3, 5, 7]
[3, 8, 7]
True
True
2340905449608
True
False
False
[3, 8, 7]
[3, 5, 7]
1.11.元组
元组属于不可变序列，一旦常见，用任何方法都不可以修改其元素。从形式上，元组的所有元素放在一对圆括号中，元素之间用逗号分隔。
1.11.1.元组的创建与删除
创建 使用“=”将一个元组赋值给变量
例如：
x = (1,2,3) #直接把元组赋值给一个变量
print(x)
创建只有一个元素的元组
x = (3)
print(type(x))
x = (3,)
print(type(x))
<class 'int'>
<class 'tuple'>
创建空元组的方法
x = ()
print(x)
x = tuple()
print(x)
()
()
使用tuple函数将其他序列转换为元组
print(tuple(range(5)))
print(tuple('abcdefg')) #把字符串转换为元组
aList = [-1,-4,6,7.5,-2.3,9,-11]
print(tuple(aList)) #把列表转换为元组
(0, 1, 2, 3, 4)
('a', 'b', 'c', 'd', 'e', 'f', 'g')
(-1, -4, 6, 7.5, -2.3, 9, -11)
删除 使用del可以删除元组对象，不能删除元组中的元素
1.11.2.元组与列表的区别
- 元组中的数据一旦定义就不允许更改。
- 元组没有append()、expend()和insert()等方法，无法向元组中添加元素
- 元组没有remove()或pop()方法，也无法对元组元素进行del操作，不能从元组中删除元素。
- 从效果上看，tuple()冻结列表，而list()融化元组。
1.12.元组的优点
- 元组的速度比列表更快
- 元组对不需要改变的数据进行“写保护”将使得代码更加安全。
- 元组可用作字典键（特别是包含字符串、数值和其他元组这样的不可变数据的元组）。元组有时还作为函数的返回值返回（返回多个值）。
