20230410-Python-元组与列表-day7

Posted 2023-04-11 阴阳怪气

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了20230410-Python-元组与列表-day7相关的知识，希望对你有一定的参考价值。

元组与列表

4月10

列表的应⽤场景
列表的格式
列表的常⽤操作
列表的循环遍历
列表的嵌套使⽤

元组的应⽤场景
定义元组
元组常⻅操作

列表的应用场景

思考：如果⼀个班级100位学⽣，每个⼈的姓名都要存储到变量，应该如何书写程序？声明100个变量吗？
答：列表即可，列表⼀次性可以存储多个数据。

列表形式

列表可以一次性存多个数据，且可以为不同类型的数据类型

li1 = ["123", "王五", "李四"]

列表的常用操作

列表的作用是一次性存储多个数据，可以对这些数据进行 增 , 删 , 改 , 查 操作

查询

根据小标查询

li1 = ["123", "王五", "李四"]

print(li1[0])
print(li1[1])
print(li1[2])

函数

index()：返回指定数据所在位置的下标

语法

# 列表序列.index(数据, 开始位置下标, 结束位置下标)

li1 = ["张三", "李四", "王五", "张三"]
print(li1.index("张三", 1, 4))

count()：统计指定数据在当前列表中出现的次数

li1 = ["张三", "李四", "王五", "张三"]

print(li1.count("张三")

len()：访问列表长度，即列表中数据的个数

li1 = ["张三", "李四", "王五", "张三"]

print(len(li1))

in 与 not in

in：判断指定数据在某个列表中，存在则返回Ture，不在返回Fulse

not in：判断指定数据在某个列表中，存在着为Fulse，不在返回Ture

li1 = ["张三", "李四", "王五", "张三"]

name = input("请输入你要找的人：")
if name in li1:
    print("他在这里".format(name))
else:
    print(f"name他不在")

增加

作用：增加指定数据到列表中

函数

append()：列表结尾追加数据

# 列表序列.append(数据)
li1 = ["张三", "李四", "王五"]

li1.append("yuwen")
print(li1)

#输出结果
[\'张三\', \'李四\', \'王五\', \'yuwen\']

如果appand(),追加的数据是一个序列，则追加整哥序列到列表中

li1 = ["张三", "李四", "王五"]
li2=["篮球","足球","乒乓"]
li1.append(li2)
print(li1)

#输出结果
[\'张三\', \'李四\', \'王五\', [\'篮球\', \'足球\', \'乒乓\']]

li1 = ["张三", "李四", "王五"]

print(id(li1))
li1.append("yuwen")
print(li1,id(li1))

#输出结果
2192101762560
[\'张三\', \'李四\', \'王五\', \'yuwen\'] 2192101762560
# 列表是可变的
# 修改之后，内存地址如果不变，那他就是

extend()：

列表尾部追加数据，如果数据是一个序列，则将这个序列数据逐一添加列表

li1 = ["张三", "李四", "王五"]

li1.extend("yuwen")
print(li1)

#输出结果
[\'张三\', \'李四\', \'王五\', \'y\', \'u\', \'w\', \'e\', \'n\']

如果添加的一个序列，则序列会将序列里每一个元素添加进去

li1 = ["张三", "李四", "王五"]
li2 = ["篮球", "足球", "乒乓"]

li1.extend(li2)
print(li1)

#输出结果
[\'张三\', \'李四\', \'王五\', \'篮球\', \'足球\', \'乒乓\']

insert()：指定位置插入数据

语法：

li1 = ["张三", "李四", "王五"]

li1.insert(2,"yuwen")
print(li1)

#输出结果
[\'张三\', \'李四\', \'yuwen\', \'王五\']

删除

输出列表中的数据

del：

删除整个列表

#del 数据列表
li1 = ["张三", "李四", "王五"]

del li1
print(li1)

#输出结果
NameError: name \'li1\' is not defined

删除指定数据（根据索引删除）

li1 = ["张三", "李四", "王五"]

del li1[1]
print(li1)

#输出结果
[\'张三\', \'王五\']

pop()：删除指定下标（默认是最后一个），并返回该删除后的结果

li1 = ["张三", "李四", "王五", "赵六"]

li1.pop()
print(li1)

li1.pop(0)
print(li1)

#输出结果
[\'张三\', \'李四\', \'王五\']
[\'李四\', \'王五\']

remove()：删除列表中第一个匹配项

li1 = ["张三", "李四", "王五", "张三"]

li1.remove("张三")
print(li1)

#输出结果
[\'李四\', \'王五\', \'张三\']

clear()：清除列表

li1 = ["张三", "李四", "王五", "张三"]

li1.clear()
print(li1)

#输出结果
[]

修改

修改指定下标数据

直接修改

li1 = ["张三", "李四", "王五", "张三"]
li1[0] = "yuwen"
print(li1)

#输出结果
[\'yuwen\', \'李四\', \'王五\', \'张三\']

reverse()：逆置

li1 = ["张三", "李四", "王五", "12312", "abc"]
li1.reverse()
print(li1)

#输出结果
[\'abc\', \'12312\', \'王五\', \'李四\', \'张三\']

sort()

排序

语法

reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）

# 列表序列.sort(reverse=False)
li = [2,3,5,6,1,4,8]
li.sort(reverse=False)
print(li)
# [1, 2, 3, 4, 5, 6, 8]

li.sort(reverse=True)
print(li)
# [8, 6, 5, 4, 3, 2, 1]

复制

copy()

复制一个列表

name_list = [\'张三\', \'李四\', \'王五\',\'赵六\']
name_li2 = name_list.copy()
print(name_li2)
# [\'张三\', \'李四\', \'王五\',\'赵六\']

列表的循环遍历

依次打印列表中的各个数据

for循环

name_list = [\'张三\', \'李四\', \'王五\',\'赵六\']
for i in name_list:
    print(i)

while循环

i = 0
name_list = [\'Tom\', \'Lily\', \'Rose\']
while i < len(name_list):
    print(name_list[i])
    i += 1

列表的嵌套

所谓列表嵌套指的就是⼀个列表⾥⾯包含了其他的⼦列表

# 找到篮球
name_list = [[\'张三\', \'李四\', \'阿坤\'], [\'唱\', \'跳\', \'篮球\'], [\'甲\', \'乙\', \'丙\']]
# 第⼀步：按下标查找到篮球所在的列表
print(name_list[1])
# 第⼆步：从李四所在的列表⾥⾯，再按下标找到数据李四
print(name_list[1][2])

元组

思考：如果想要存储多个数据，但是这些数据是不能修改的数据，怎么做？

定义元组

定义元组使⽤⼩括号，且逗号隔开各个数据，数据可以是不同的数据类型。

# 多个数据元组
t1 = (10, 20, 30)

# 单个数据元组
t2 = (10,)

注意：如果定义的元组只有⼀个数据，那么这个数据后⾯也好添加逗号，否则数据类型为唯⼀的这个数据的数据类型

元组的常⻅操作

元组数据不⽀持修改，只⽀持查找，具体如下

根据下标查找

tuple1 = (\'aa\', \'bb\', \'cc\', \'bb\')
print(tuple1[0])

index()：

查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index⽅法相同。

tuple1 = (\'aa\', \'bb\', \'cc\', \'bb\')
print(tuple1.index(\'aa\'))

count()：

统计某个数据在当前元组出现的次数。

tuple1 = (\'aa\', \'bb\', \'cc\', \'bb\')
print(tuple1.count(\'bb\'))

len()：

统计元组中数据的个数。

tuple1 = (\'aa\', \'bb\', \'cc\', \'bb\')
print(len(tuple1))

元组内的直接数据如果修改则⽴即报错

但是如果元组⾥⾯有列表，修改列表⾥⾯的数据则是⽀持的。

tuple2 = (10, 20, [\'aa\', \'bb\', \'cc\'], 50, 30)
print(tuple2[2]) # 访问到列表
# [\'aa\', \'bb\', \'cc\']
tuple2[2][0] = \'aaaaa\'
print(tuple2)
# (10, 20, [\'aaaaa\', \'bb\', \'cc\'], 50, 30)

python系列python元组与字典

博主QQ：819594300

博客地址：http://zpf666.blog.51cto.com/

有什么疑问的朋友可以联系博主，博主会帮你们解答，谢谢支持！

本博文目录：

一、元组 | 二、字典 | 三、字典的使用方法

前言：列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，这对处理网站的用户列表或游戏中的角色列表至关重要。然而，有时候你需要创建一些列不可修改的元素，元组就可以满足你这样的需求。Python将不能修改的值称为不可变的，而不可变的列表就被称为元组。

正文部分：

一、元组

1、元组的概念

元组：（tuple），有序列表叫元组，tuple和list非常类似，不同之处是list列表可以修改元素，而元组是无法修改定义好的元素的。

元组使用“（）”小括号来定义。

定义元组后，就可以使用索引来访问其元组，就像访问列表元素一样。

元组的类型是“tuple”。

xidamingzhu这个tuple不能变了，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用xidamingzhu[0]，xidamingzhu[-1]，但不能赋值成另外的元素。

那不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。

如果要定义一个空的tuple，可以写成()：

但是，要定义一个只有1个元素的tuple，如果你这么定义：

那么这定义的不是tuple，而是1这个整数，这是因为小括号()既可以表示tuple，又可以表示数学公式中的小括号。这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然整数是1。

那么你想说，我就是想定只有一个元素的元组，那怎么办？

答案是好办，解决办法如下：

只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：

Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。

2）消除对tuple的元素不变的误解

下面通过一个例子来说明一个可爱的tuple。

看了这个例子，你可能会有疑问，不是说元组的元素不可修改吗？这怎么可修改。

我的答案是，你别急，继续看下面的分析。

这个tuple定义的时候有3个元素，分别是‘a‘，‘b‘和一个list。

我们先看看定义的时候tuple包含的3个元素：

当我们把list的元素‘A‘和‘B‘修改为‘X‘和‘Y‘后，tuple变了，表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”,是说tuple的每个元素，指向永远不变。即指向‘a‘，就不能改成指向‘b‘，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

理解了“指向不变”后，要创建一个内容也不变的tuple怎么做？那就必须保证tuple的每一个元素本身也不能变。

元组可以使用函数count()和index()：

3）遍历元组中的所有值

4）如想改变tuple的元素，只能重新赋值整个元组

二、字典

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。

1）字典使用{}定义

说明：举个例子，假设要根据同学的名字查找对应的成绩，如果用list实现，需要两个list：

用list查找过程是这样的：给定一个名字，要查找对应的成绩，就先要在name中找到对应的位置，再从score取出对应的成绩，list越长，耗时越长。

如果用dict实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢。

下面用python编写一个dict（字典），内容如下：

为什么dict查找速度这么快？因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个字，一个办法是把字典从第一页往后翻，直到找到我们想要的字为止，这种方法就相当于在list中查找元素的方法，list越大，查找越慢。

第二种方法是先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典大小的增加而变慢。

dict就是第二种实现方式，给定一个名字，比如“王五”，dict在内部就可以直接计算出王五对应的存放成绩的“页码”，也就是75这个数字存放的内存地址，直接取出来，所以速度非常快。

这种key-value存储方式，在放进去的时候，必须根据key算出value的存放位置，这样，取的时候才能根据key直接拿到value。

把数据放入dict的方法，除了初始化时指定外，还可以通过key放入：

由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉：

如果key不存在，dict就会报错：

要避免key不存在的错误，有两种办法。

一是通过in判断key是否存在：

二是通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value：

注意：返回None的时候Python的交互式命令行不显示结果。

要删除一个key，用pop(key)方法，对应的value也会从dict中删除：

请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。

和list比较，dict有以下几个特点：

dict特点：

①查找和插入的速度极快，不会随着key的增加而变慢；

②需要占用大量的内存，内存浪费多，而list相反；

list特点：

①查找和插入的时间随着元素的增加而增加；

②占用空间小，浪费内存很少。

所以，dict是用空间来换取时间的一种方法。

说明：dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（hash），要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key。

三、字典的使用方法

1)定义一个字典

2）删除字典中所有key和value值

3）将a字典的元素赋值给b

、

这里有个特别需要注意的点需要说明一下：

举一个例子来说明一下：

①定义一个字典a，然后让b和c通过两种方式让字典a的元素赋值给自己一份。

②增加字典a的元素（即：key-value）

③再来查看字典b和字典c的元素

会发现字典b的元素没有随着字典a的增加而增加，而字典c倒是随着字典a的增加而增加，这个情况和我们在第一篇python那篇博文中所说的数值、字符串不随着原有数值、字符串的改变而改变，这里却是改变了，这是因为python规定，字典c=字典a的时候，在内存里面，字典c直接就是指向字典a，而b=a.copy()的方式，在内存里是让字典b指向a此时此刻所对应的元素，一旦字典a改变了，b还是指向原有的那些元素，而不发生改变，而c因为直接就是指向的a，所以a改变，c也跟着改变，这一点和数值、字符串正好相反，这一点需要特别的注意。

4）只定义key值，（）中的内容可以来自于定义好的一个字典，或者一个列表，只定义key值，value值为none