学习笔记-Python开发-006_数据类型_中

本文将会介绍列表类型list和元组类型tuple，它们大同小异，都是有序的容器类型，其区别在于能否修改数据。

1 列表

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

有序：按顺序存放
可变：可以更改列表内部值

1.1 定义方式

# list = [元素1,元素2,....]
demo_list = [1,"数据1",True]

相比之前的字符串方式，他可以通过对容器内部的元素进行操作。

# 列表
user_list = []
print(id(user_list)) # 140405167924800
user_list.append("铁锤")
print(id(user_list)) # 140405167924800
print(user_list)

# 字符串
user_str = ""
print(id(user_str)) # 140553207793264
user_str = "123" # 不支持append
print(id(user_str)) # 140552939694512
print(user_str)

我们通过对列表和字符串进行操作，然后查看其内存地址id发现。

列表无论增加多少数，其对应的内存空间地址不会发生改变。而字符串则会发生改变。

所以我们可以认为列表功能基本上都是直接操作列表内部，不会创建新的一份数据。而字符串都是新创建一份数据。

1.2 独有功能

Python中为所有的列表类型的数据提供了一批独有的功能。

1.2.1 追加，在原列表中尾部追加值

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

# 案例1：输入用户名形成列表，Q退出输入
user_list = []
while True:
    user = input("请输入用户名(Q退出)：")
    if user == "Q":
        break
    user_list.append(user)
print(user_list) 

# 案例2：输入游戏人数，根据人数填名字，填满即退出
welcome = "欢迎来到YU游戏".center(30,'*')
print(welcome)
user_count = 0
while True:
    count = input("请输入游戏人数：")
    if count.isdecimal():
        user_count = int(count)
        break
    else:
        print("输入错误，请输入数字")
message = "{}人参加YU游戏".format(user_count)
print(message)
user_name_list = []
for i in range(1,user_count + 1):
    tips = "请输入{}号玩家姓名：".format(i)
    user_name = input(tips)
    user_name_list.append(user_name)
print(user_name_list)

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

tools = ["搬砖","菜刀","榔头"]
tools.extend( [11,22,33] ) # weapon中的值逐一追加到tools中
print(tools) # ["搬砖","菜刀","榔头",11,22,33]

# 相当于
tools = ["搬砖","菜刀","榔头"]
num = [11,22,33]
for i in num:
    tools.append(i)
print(tools)

1.2.3 插入，在原列表的指定索引位置插入值 -> 原有及后面的值向后移

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

# 当索引值小于0的时候，会永远将数据放在最前面，如果索引大于长度，会将数据放在最后面->不会报错
user_list.insert(-20,"马化腾")
user_list.insert(200,"马云")
print(user_list)

# 案例
name_list = []
while True:
    name = input("请输入购买火车票用户姓名（Q/q退出）：")
    if name.upper() == "Q":
        break
    if name.startswith("***"): # 把名字姓******放到最前面
        name_list.insert(0, name)
    else:
        name_list.append(name)
print(name_list)

1.2.4 在原列表中根据值删除（从左到右找到第一个删除）

【慎用，里面没有会报错】

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

# 如果要避免报错，可以提前判断是否存在这个值
user_list = ["王宝强","陈羽凡","amber","贾乃亮","amber"]
if "amber" in user_list: # 判断user_list是否包含"amber"
	user_list.remove("amber")
print(user_list)

# 一次只删除一个值，如果需要把列表当中的多个值删除需要循环
user_list = ["王宝强","陈羽凡","amber","贾乃亮","amber"]
while True: # 使用循环把amber全都删除
    if "amber" in user_list:
        user_list.remove("amber")
	else:
        break
print(user_list)

# 案例：自动抽奖程序 -> 由于礼物只有一份，所以抽中需要删除奖品避免再次抽中
import random  # 随机模块
data_list = ["iphone12", "二手充气女友", "大保健一次", "泰国5日游", "避孕套"]
while data_list:
    name = input("自动抽奖程序，请输入自己的姓名：")
    # 随机从data_list抽取一个值出来
    value = random.choice(data_list)  # "二手充气女友"
    print("恭喜{}，抽中{}.".format(name, value))
    data_list.remove(value)  # "二手充气女友"

1.2.5 在原列表中根据索引剔除某个元素（根据索引位置删除）

user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
#               0       1      2      3       4
user_list.pop(1)
print(user_list) #  ["王宝强","Alex","贾乃亮","Alex"]

# 如果不写序号，默认删除最后一个
user_list.pop()
print(user_list) # ["王宝强","Alex","贾乃亮"]

# 可以将被删除的元素进行接收
item = user_list.pop(1) 
print(item) # "Alex"
print(user_list) # ["王宝强","贾乃亮"]


# 案例 -> 购票系统
user_queue = []

while True:
    name = input("成都 -> 北京 请输入购票人姓名，按Q结束:").strip()
    if name == "Q" or name == "q":
        break
    user_queue.append(name)
print(user_queue)

ticket_count = 3 # 余票三张
for tc in range(ticket_count):
    failed_user = user_queue.pop(0) # 列表中取出序号为0的元素，然后从列表中删除
    print("尊敬的旅客{name},您的票已出".format(name=failed_user))

# 未购票成功
print("尊敬的旅客朋友{}，非常抱歉的通知您，由于余票不足，请您使用其他的交通方式".format(user_queue))

1.2.6 清空原列表

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

1.2.7 根据值获取索引（从左到右找到第一个删除）

【慎用，找不到报错】

user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
#               0       1      2       3      4
if "Alex" in user_list: # 先检查元素是否在列表
	index = user_list.index("Alex")
	print(index) # 2
else:
    print("不存在")

1.2.8 列表元素排序

数字排序

num_list = [11, 22, 4, 5, 11, 99, 88]
print(num_list)
num_list.sort()  # 让num_list从小到大排序
num_list.sort(reverse=True)  # # 让num_list从大到小排序 reverse=True等于反转
print(num_list)

字符串排序

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

排序原理

sort的排序原理 -> 字符串排序会将字符串转换成unicode码点 -> 然后一位对一位进行比较 -> 如果比较那一位有空的就为小
补充：unicode可以使用函数ord('值')进行查询 -> 10进制表示

# 王宝器 [29579, 23453, 24378]
# Ab陈羽凡 [65, 98, 38472, 32701, 20961]
# Alex [65, 108, 101, 120]

例如，Ab陈羽凡和Alex第一位A是65，王宝器第一位王是29579，则王宝器在第三位，那么比较第二位，Ab陈羽凡的b是98，Alex的l是108，则顺序是['Ab陈羽凡', 'Alex', '王宝强']

代码演示如下：

# 比较的原理

c_demo1 = "孙一山"
c_demo2 = "孙一山二扇"

demo1 = list(c_demo1)
demo2 = list(c_demo2)

if len(demo1) >= len(demo2):
    l_name = len(demo1)
    b = l_name - len(demo2) # 计算补充长度
    for i in range(b):
        demo2.append("")
else:
    l_name = len(demo2)
    b = l_name - len(demo1)
    for i in range(b):
        demo1.append("")

for i in range(l_name):
    if demo1[i] > demo2[i]:
        max = c_demo1
        break
    elif demo1[i] < demo2[i]:
        max = c_demo2
        break
    else:
        pass
    
print("比较大的数是{}".format(max))

注意：排序时内部元素无法进行比较时，程序会报错（尽量数据类型统一），例如字符串与整数不能进行比较，而布尔和整数可以进行比较

1.2.9 反转原列表

user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
user_list.reverse()

print(user_list)

1.3 公共功能

1.3.1 相加

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

data = ["赵四","刘能"] + ["宋晓峰","范德彪"]
print(data) # ["赵四","刘能","宋晓峰","范德彪"]

v1 = ["赵四","刘能"]
v2 = ["宋晓峰","范德彪"]
v3 = v1 + v2
print(v3) # ["赵四","刘能","宋晓峰","范德彪"]

1.3.2 相乘

列表*整型 将列表中的元素再创建N份并生成一个新的列表

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

v1 = ["赵四","刘能"]
v2 = v1 * 2
print(v1) # ["赵四","刘能"]
print(v2) # ["赵四","刘能","赵四","刘能"]

1.3.3 运算符in包含

由于列表内部是由多个元素组成，可以通过in来判断元素是否在列表中，返回值True和False

user_list = ["狗子","二蛋","沙雕"] 
result = "kinght" in user_list
print(result) # False

# 案例1:pop -> .index找不到会报错
user_list = ["王宝强","陈羽凡","Alex","贾乃亮","Alex"]
if "Alex" in user_list:
	index = user_list.("Alex")
	user_list.pop(index)

# 案例：敏感词替换 -> 检查是否有敏感词
text = input("请输入文本内容：") # 按时打发第三方科技爱普生豆腐啊；了深刻的房价破阿偶打飞机
forbidden_list = ["草","欧美","日韩"]
for item in forbidden_list:
    text = text.replace(item,"**")
print(text)

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

1.3.4 获取长度

user_list = ["范德彪","刘华强",'尼古拉斯赵四']
print( len(user_list) )

1.3.5 索引，一个元素的操作

# 读
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
print( user_list[0] )
print( user_list[2] )
print( user_list[3] ) # 报错

# 改
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
user_list[0] = "武沛齐"
print(user_list) # ["武沛齐","刘华强",'尼古拉斯赵四']

# 删
user_list = ["范德彪","刘华强",'尼古拉斯赵四']
del user_list[1]
user_list.remove("刘华强")
ele = user_list.pop(1)

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

1.3.6 切片，多个元素的操作

读

user_list = ["范德彪","刘华强",'尼古拉斯赵四']

print( user_list[0:2] ) # ["范德彪","刘华强"]
print( user_list[1:] )
print( user_list[:-1] )

改

user_list = ["范德彪", "刘华强", '尼古拉斯赵四']

# 超出索引的部分会被添加在最后
user_list[0:2] = [11, 22, 33, 44] 
print(user_list) # 输出 [11, 22, 33, 44, '尼古拉斯赵四']

user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[2:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', 11, 22, 33, 44]

user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[3:] = [11, 22, 33, 44]
print(user_list) # 输出 ['范德彪', '刘华强', '尼古拉斯赵四', 11, 22, 33, 44]

# 超出索引范围，直接放于最后
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[10000:] = [11, 22, 33, 44] 
print(user_list) # 输出 ['范德彪', '刘华强', '尼古拉斯赵四', 11, 22, 33, 44]

# 负数都是放在最前面，并且替换掉了索引0，且前取后不取
user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
user_list[-10000:1] = [11, 22, 33, 44]
print(user_list) # 输出 [11, 22, 33, 44, '刘华强', '尼古拉斯赵四']

删

user_list = ["范德彪", "刘华强", '尼古拉斯赵四']
del user_list[1:]
print(user_list) # 输出 ['范德彪']

1.3.7 步长

user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
#              0        1        2          3       4
print( user_list[1:4:2] )
print( user_list[0::2] )
print( user_list[1::2] )
print( user_list[4:1:-1] ) # 倒序


# 案例：实现列表的翻转
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
new_data = user_list[::-1]
print(new_data)

data_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
data_list.reverse()
print(data_list)

# 给你一个字符串请实现字符串的翻转？
name = "武沛齐"
name = name[::-1]
# name.reverse() 字符串是不能使用reverse的

1.3.8 for循环

user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
for item in user_list:
	print(item)
  
# 序号取值 -> 有点画蛇添足
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]

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

切记，循环的过程中对数据进行删除会出现问题

user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
for item in user_list:
    if item.startswith("刘"):
        user_list.remove(item)     
print(user_list)

# 错误方式， 有坑，结果不是你想要的。
# 循环的时候同时进行删除，会导致for寻欢取出紊乱，因为for循环取出了索引0，被删除了，范德彪就会变成索引0，for循环再次取索引1的时候，取出的就是刘华强了，同理，刘华强被删除了，下一次取出的就直接是宋小宝，跳过了刘尼古拉斯赵四

# 正确的方式
# 倒着删除不会影响索引位置
user_list = ["刘的话", "范德彪", "刘华强", '刘尼古拉斯赵四', "宋小宝", "刘能"]
for index in range(len(user_list) - 1, -1, -1):
    item = user_list[index]
    if item.startswith("刘"):
        user_list.remove(item)
print(user_list)

1.4 转换

首先int、bool无法转换成列表

str 转列表

name = "马化腾"
data = list(name)  # ['马', '化', '腾']
print(data)

元祖转列表

v1 = (11,22,33,44) # 元组
vv1 = list(v1)     # 列表 [11,22,33,44]

集合转列表

v2 = {"alex","eric","dsb"} # 集合
vv2 = list(v2) # 列表 ["alex","eric","dsb"]

1.5 其他

1.5.1 嵌套

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

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

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

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

print( data[0] ) # "谢广坤"
print( data[1] ) # ["海燕","赵本山"]
print( data[0][2] ) # "坤"
print( data[1][-1] ) # "赵本山"

# 嵌套增加值
data.append(666)
print(data) # [ "谢广坤",["海燕","赵本山"],True,[11,22,33,44],"宋小宝",666]
data[1].append("谢大脚")
print(data) # [ "谢广坤",["海燕","赵本山","谢大脚"],True,[11,22,33,44],"宋小宝",666 ]

# 嵌套删除值
del data[-2]
print(data) # [ "谢广坤",["海燕","赵本山","谢大脚"],True,[11,22,33,44],666 ]
data[-2][1] = "alex"
print(data) # [ "谢广坤",["海燕","赵本山","谢大脚"],True,[11,"alex",33,44],666 ]
data[1][0:2] = [999,666]
print(data) # [ "谢广坤",[999,666,"谢大脚"],True,[11,"alex",33,44],666 ]


# 案例 -> 嵌套创建用户列表
user_list = []
while True:
    user = input("请输入用户名(Q退出)：")
    if user == "Q":
        break
    pwd = input("请输入密码：")
    data = [user,pwd]
    user_list.append(data)
print(user_list)

2 元组

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

有序：按顺序存放
不可变：不可以更改列表内部值(值的内存地址)

如果元组内嵌套了一个可变容器，可变容器的内存地址不能被改变，可变容器内的值是可以改变的

2.1 定义

v1 = (11,22,33)
v2 = ("李杰","Alex")
v3 = (True,123,"Alex",[11,22,33,44])

# 注意：建议在元组的最后多加一个逗号，用于标识他是一个元组。
d1 = (1)  # 1 会被认为是单独类型加括号
d2 = (1,) # (1,)

2.2 独有功能

无

2.3 公共功能

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

data = ("赵四","刘能") + ("宋晓峰","范德彪")
print(data) # ("赵四","刘能","宋晓峰","范德彪")

v1 = ("赵四","刘能")
v2 = ("宋晓峰","范德彪")
v3 = v1 + v2
print(v3) # ("赵四","刘能","宋晓峰","范德彪")

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

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

v1 = ("赵四","刘能")
v2 = v1 * 2
print(v1) # ("赵四","刘能")
print(v2) # ("赵四","刘能","赵四","刘能")

2.3.3 获取长度

user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print( len(user_list) )

2.3.4 索引

user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print( user_list[0] )
print( user_list[2] )
print( user_list[3] )

2.3.5 切片

user_list = ("范德彪","刘华强",'尼古拉斯赵四',)
print( user_list[0:2] )
print( user_list[1:] )
print( user_list[:-1] )

2.3.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] )

# 案例
# 取翻转时候 字符串 & 元组 区别

## 元祖
user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
data = user_list[::-1]

## 列表
user_list = ["范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能"]
### 方案1
data = user_list[::-1]
print(data)
### 方案2
user_list.reverse()
print(user_list)

2.3.7 for循环

user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
for item in user_list:
	print(item)

# len + range + for + 索引
user_list = ("范德彪","刘华强",'尼古拉斯赵四',"宋小宝","刘能")
for index in range(len(user_list)):
    item = user_list[index]
    print(item)

2.4 转换

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

data = tuple(其他)
# str / list 

name = "武沛齐"
data = tuple(name)
print(data) # 输出 ("武","沛","齐")

name = ["武沛齐",18,"pythonav"]
data = tuple(name)
print(data) # 输出 ("武沛齐",18,"pythonav")

2.5 其他

2.5.1 嵌套

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

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

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