day03-数据类型（中）

1.列表

列表，是一个有序且可变的容器，在里面可以存放多个不同类型的元素。

1.1 定义

user_list = ["苍老师", "田馥甄", "王楚然"]
number_list = [24, 124, 1354, 25, 34]

user_list = []
user_list.append("铁锤")
user_list.append(123)
user_list.append(True)
print(user_list)    # ['铁锤', 123, True]

不可变类型：字符串、布尔、整型（已最小，内部数据无法进行修改）
可变类型：列表（内部数据元素可以修改）

1.2 独有功能

python中为所有的列表类型的数据提供了一批独有的功能。
在开始学习列表的独有功能之前，先来做一个字符串和列表的对比：

• 字符串，不可变，即：创建好之后内部就无法修改。【独有功能都是新创建一份数据】

name = "alex"
data = name.upper()

• 列表，可变，即：创建好之后内部元素可以修改。【独有功能基本上都是直接操作列表内部，不会创建新的一份数据】

user_list = ["白鹿", "李沁"]
user_list.append("陈钰琪")
print(user_list)        # ['白鹿', '李沁', '陈钰琪']

列表中的常见独有功能如下：

1. 追加，在原列表中尾部追加值。

data_list = []
v1 = input("请输入姓名")
data_list.append(v1)

v2 = input("请输入姓名")
data_list.append(v2)

print(data_list)

2. 批量追加，将一个列表中的元素逐一添加另外一个列表。

tools = ["那是", "223", "214"]
weapon = [21, 423, 54, 25]
tools.extend(weapon)
print(tools)    # ['那是', '223', '214', 21, 423, 54, 25]

3. 插入，在原列表的指定索引位置插入值

user_list = ["苍老师", "大桥未久", "有坂深雪"]
user_list.insert(0, "马蓉")
user_list.insert(2, "李小龙")
print(user_list)    # ['马蓉', '苍老师', '李小龙', '大桥未久', '有坂深雪']

user_list = ["苍老师", "大桥未久", "有坂深雪"]
user_list.insert(100, "马蓉")
user_list.insert(-7666, "李小龙")
print(user_list)    # ['李小龙', '苍老师', '大桥未久', '有坂深雪', '马蓉']

4. 在原列表中根据值删除（从左到右找到第一个删除）【慎用，里面没有会报错】

user_list = ["王宝强", "陈羽凡", "贾乃亮", "alex", "alex"]
user_list.remove("alex")
print(user_list)    # ['王宝强', '陈羽凡', '贾乃亮', 'alex']

5. 在源列表中根据索引踢出某个元素

user_list = ["王宝强", "陈羽凡", "贾乃亮", "alex", "alex"]
ele = user_list.pop()   # 删除最后一个，将值赋给ele
item = user_list.pop(2)     # 删除索引为2的值，将值赋给item
print(user_list)        # ['王宝强', '陈羽凡', 'alex']

6. 清空原列表

user_list = ["王宝强", "陈羽凡", "贾乃亮", "alex", "alex"]
user_list.clear()
print(user_list)    # []

7. 根据值获取索引（从左到右找到第一个）【慎用，找不到报错】

user_list = ["王宝强", "陈羽凡", "贾乃亮", "alex", "alex"]
index = user_list.index("alex")
print(index)    # 3

8. 列表元素排序

user_list = ["王宝强", "陈羽凡", "贾乃亮", "alex", "alex", "1"]
user_list.sort()
print(user_list)

# 验证如何排序
data_list = []
for item in user_list:
    group = []
    for char in item:
        num = ord(char)
        group.append(num)
    data_list.append(group)
print(data_list)

注意：排序时内部元素无法进行比较时，程序会报错（尽量数据类型统一）

9. 反转原列表

user_list = ["王宝强", "陈羽凡", "贾乃亮", "alex", "alex", "1"]
user_list.reverse()
print(user_list)    # ['1', 'alex', 'alex', '贾乃亮', '陈羽凡', '王宝强']

1.3 公共功能

1. 相加，两个列表相加获取生成一个新的列表

data = ["赵四", "刘能"] + ["宋晓锋", "范德比"]
print(data)     # ['赵四', '刘能', '宋晓锋', '范德比']

2. 相乘，列表*整型，将列表中的元素再创建N份并生成一个新的列表。

data = ["赵四", "刘能"] * 2
print(data)     # ['赵四', '刘能', '赵四', '刘能']

3.运算符in包含，由于列表内部是由多个元素组成，可以通过in来判断元素是否在列表中。

data = ["赵四", "刘能"] * 2
result = "赵四" in data
print(result)       # True

注意：列表检查元素是否存在时，是采用逐一比较的方式，效率会比较低。

4. 获取长度

data = ["赵四", "刘能"] * 2
print(len(data))    # 4

5. 索引，一个元素的操作

data = ["赵四", "刘能", "范德比"]
print(data[0])  # 赵四
print(data[1])  # 刘能
print(data[2])  # 范德比

data[0] = "谢广坤"
print(data)     # ['谢广坤', '刘能', '范德比']

del data[1]		# 删除第一个位置的值
print(data)     # ['谢广坤', '范德比']

注意：超出索引范围会报错
提示：由于字符串是不可变类型，所以他只有索引读的功能，而列表可以进行读、改、删

6. 切片，多个元素的操作（很少用）

user_list = ["赵四", "刘能", "范德比"]
print(user_list[0:2])       # ['赵四', '刘能']
print(user_list[1:])        # ['刘能', '范德比']
print(user_list[:-1])       # ['赵四', '刘能']

user_list[0:2] = [11,22,33,44]
print(user_list)    # [11, 22, 33, 44, '范德比']

del user_list[1:]
print(user_list)    # [11]

7. 步长

user_list = ["赵四", "刘能", "范德比", "宋小宝", "刘德华"]
print(user_list[1:4:2])  # ['刘能', '宋小宝']
print(user_list[0::2])  # ['赵四', '范德比', '刘德华']
print(user_list[1::2])  # ['刘能', '宋小宝']
print(user_list[4:1:-1])  # ['刘德华', '宋小宝', '范德比']

8. for循环

user_list = ["赵四", "刘能", "范德比", "宋小宝", "刘德华"]
for item in user_list:
    print(item)

for index in range(len(user_list)):
    print(user_list[index])

切记，循环的过程中对数据进行删除会踩坑【面试题】

# 有坑，得到的结果不正确
user_list = ["刘德华", "范德比", "刘华强", "刘宋小宝", "宋小宝", "刘能"]
for item in user_list:
    if item.startswith("刘"):
        user_list.remove(item)
print(user_list)  # ['范德比', '刘宋小宝', '宋小宝']

# 正确的写法，倒叙着删除
user_list = ["刘德华", "范德比", "刘华强", "刘宋小宝", "宋小宝", "刘能"]
for index in range(len(user_list) - 1, -1, -1):
    if user_list[index].startswith("刘"):
        user_list.remove(user_list[index])
print(user_list)    # ['范德比', '宋小宝']

1.4 转换

• int、bool无法转换成列表
• str

name = "吴佩琦"
data = list(name)
print(data) # ['吴', '佩', '琦']

• 超前

v1 = (11,22,33)
vv1 = list(v1)

v2 = {"alex", "eric"}
vv2 = list(v2)

1.5 嵌套

列表属于容器，内部可以存放各种数据，所以也支持列表的嵌套，如：

data = ["谢广坤", ["海燕", "赵本山"], True, [11, 22, [999, 123], 33, 44], "宋小宝"]

对于嵌套的值，可以根据之前学习的索引知识点来进行学习，如：

data = ["谢广坤", ["海燕", "赵本山"], True, [11, 22, [999, 123], 33, 44], "宋小宝"]
print(data[0])  # 谢广坤
print(data[1])  # ['海燕', '赵本山']
print(data[0][2])   # 坤
print(data[1][-1])  # 赵本山

data.append(666)
print(data)     # ['谢广坤', ['海燕', '赵本山'], True, [11, 22, [999, 123], 33, 44], '宋小宝', 666]

data[1].append("谢大脚")
print(data)     # ['谢广坤', ['海燕', '赵本山', '谢大脚'], True, [11, 22, [999, 123], 33, 44], '宋小宝', 666]

del data[-2]
print(data)     # ['谢广坤', ['海燕', '赵本山', '谢大脚'], True, [11, 22, [999, 123], 33, 44], 666]

data[-2][1] = "alex"
print(data)     # ['谢广坤', ['海燕', '赵本山', '谢大脚'], True, [11, 'alex', [999, 123], 33, 44], 666]

1.6 列表阶段作业

li = ["alex", "WuSir", "ritian", "barry", "吴佩琦"]
print(len(li))
li.append("seven")
print(li)
li.insert(1, "Tony")
print(li)
li[2] = "Kelly"
print(li)
li[3] = "妖怪"
print(li)
data = [1, "a", 3, 4, "heart"]
li.extend(data)
print(li)
s = "qwert"
for char in s:
    li.append(char)
print(li)
li.remove("barry")
print(li)

del li[1]
li.pop(1)
print(li)

del li[2:5]

li = [1, 3, 2, "a", 4, "b", 5, "c"]

v1 = li[0:3]
print(v1)

v2 = li[3:6]
print(v2)

v3 = li[::2]
print(v3)

v4 = li[1:6:2]
print(v4)

v5 = li[1::2]
print(v5)

v6 = li[-1]
print(v6)

v7 = li[-3:0:-2]
print(v7)

lis = [2, 3, "k", ["qwe", 20, ["k1", ["tt", 3, "1"]], 89], "ab", "adv"]
lis[2] = lis[2].upper()
print(lis)

lis[1] = "100"
lis[3][2][1][1] = "100"
lis[3][2][1][0] = 101
lis[3].insert(0, "火车头")
print(lis)

users = ["吴佩琦", "京女神", "萧大侠"]
for i in range(len(users)):
    print(i, users[i])

users = ["吴佩琦", "京女神", "萧大侠"]
for i in range(1, len(users) + 1):
    print(i, users[i - 1])

goods = ["汽车", "飞机", "火箭"]
index = input("请输入序号")
text = goods[int(index)]
messafe = "你选择的商品是{}".format(text)
print(message)

data = []
for i in range(0, 51):
    if i % 3 == 0:
        data.append(i)
print(data)

data = []
for i in range(0, 51):
    if i % 3 == 0:
        data.insert(0, i)
print(data)

li = ["alexC", "AbC", "egon", "riTiAn", "WuSir", "    aqc"]
res = []
for item in li:
    item = item.strip()
    if item.startswith("a"):
        res.append(item)
print(res)

2.元组

列表（list），是一个有序且可变的容器，在里面可以存放多个不同类型的元素。
元组（tuple），是一个有序且不可变的容器，在里面可以存放多个不同类型的元素。

2.1 定义

v1 = (11,22,33)
v2 = ("流量","阿飞")

# 建议，在元组的最后多加一个逗号

注意：建议在元组的最后多加一个逗号，用于标识他是一个元组

# 面试题
1.比较值 v1 = (1) 和 v2 = 1 和 v3 = (1,) 有什么区别？
v1和v2相同都是整型，v3是元组
2.比较值 v1 = ((1),(2),(3)) 和 v2 = ((1,),(2,),(3,),) 有什么区别？
v1中的元素全是整型，v2中的元素是元组

2.2 独有功能

无

2.3 公共功能

1. 相加，两个元组相加获取生成一个新的元组。

data = ("赵四", "刘能") + ("宋晓锋", "范德比")
print(data)     # ('赵四', '刘能', '宋晓锋', '范德比')

2. 相乘，元组*整型，将元组中的元素再创建N份并生成一个新的元组。

data = ("赵四", "刘能") * 2
print(data)     # ('赵四', '刘能', '赵四', '刘能')

3. 获取长度

data = ("赵四", "刘能")
print(len(data))    # 2

4. 索引，一个元素的操作

data = ("赵四", "刘能", "范德比")
print(data[0])  # 赵四
print(data[1])  # 刘能
print(data[2])  # 范德比

5. 切片，多个元素的操作（很少用）

user_list = ("赵四", "刘能", "范德比")
print(user_list[0:2])       # ('赵四', '刘能')
print(user_list[1:])        # ('刘能', '范德比')
print(user_list[:-1])       # ('赵四', '刘能')

6. 步长

user_list = ("赵四", "刘能", "范德比", "宋小宝", "刘德华")
print(user_list[1:4:2])  # ('刘能', '宋小宝')
print(user_list[0::2])  # ('赵四', '范德比', '刘德华')
print(user_list[1::2])  # ('刘能', '宋小宝')
print(user_list[4:1:-1])  # ('刘德华', '宋小宝', '范德比')

7. for循环

user_list = ("赵四", "刘能", "范德比", "宋小宝", "刘德华")
for item in user_list:
    print(item)

for index in range(len(user_list)):
    print(user_list[index])

2.4 转换

其他类型转换为元组，使用tuple，目前只有字符串和列表可以转换为元组

name = "吴佩琦"
data = tuple(name)
print(data)     # ('吴', '佩', '琦')

name = ["吴佩琦", 18, "python"]
data = tuple(name)
print(data)  # ('吴佩琦', 18, 'python')

2.5 嵌套

由于元组和列表都可以充当容器，它们内部可以放很多元素，并且也支持元素内的各种嵌套。

tu = ('今天姐姐不在家', '姐夫和小姨子在客厅聊天', ('姐夫问小姨子税后多少钱', '小姨子低声说道说和姐夫还提钱'))
tu1 = tu[0]
tu2 = tu[1]
tu3 = tu[2][0]
tu4 = tu[2][1]

print(tu1)      # 今天姐姐不在家
print(tu2)      # 姐夫和小姨子在客厅聊天
print(tu3)      # 姐夫问小姨子税后多少钱
print(tu4)      # 小姨子低声说道说和姐夫还提钱

2.6 作业

"" 和 [] 和  ()

v1 = "alex"
v2 = (1, 2)

a = [1,2,3]是个列表；
b = [(1),(2),(3)]是个列表，里面存放的是整型，跟a一样；
b = [(1,),(2,),(3,)]是个列表，里面存放的是元组

text = "wupeiqi|alex|eric"
lis = text.split("|")
res = tuple(lis)
print(res)

# 花色列表
color_list = ["红桃", "黑桃", "方片", "梅花"]

# 牌值
num_list = []
for num in range(1, 14):
    num_list.append(num)

result = []
for color in color_list:
    for num in num_list:
        temp = (color, num)
        result.append(temp)
print(result)