Python的列表和元组

最新推荐文章于 2023-05-28 23:56:28 发布

panxuej_shenx

最新推荐文章于 2023-05-28 23:56:28 发布

阅读量154

点赞数

分类专栏： IT知识分享文章标签： python 开发语言 pycharm

本文链接：https://blog.csdn.net/xwcj3/article/details/126805686

版权

IT知识分享专栏收录该内容

2 篇文章 0 订阅

订阅专栏

列表

列表查询

index：从左至右查询元素在列表中所处的位置，如果查询到该元素返回其第一次出现所在位置的正向下标，如果不存在则报错
count：查询指定元素在列表中出现的次数
in：查询指定元素是否在列表中
not in：查询指定元素是否不在列表中

# 索引查询
name_list=['java','php','python']
print(name_list[0])
print(name_list[1])
print(name_list[2])
print(name_list[-1])
print(name_list[-2])
print(name_list[-3])
# 结论: 列表中的索引和字符串中完全一致,
# 正向索引从0开始,从左至右依次递增
# 负向索引,从-1开始,从右至左依次递减
# index  查询指定元素在列表中的索引,如果查询成功则返回该元素的正向索引,否则报错
# index  是从左至右查询,返回第一次出现的索引位置
num_list = [1, 2, 3, 4, 5, 6, 7, 8, 5]
print(num_list.index(5))
# ValueError: 9 is not in list
# 如果没有查询到数据则会报错
#print(num_list.index(9))
# rindex  在列表中没有这个方法
# AttributeError: 'list' object has no attribute 'rindex'
print("------------------------------------------------")
#print(num_list.rindex(5))
# find  在列表中没有这个方法
# AttributeError: 'list' object has no attribute 'find'
# print(num_list.find(5))
# count  计数, 查询指定元素在列表中出现的次数
print(num_list.count(5))
# in  判断数据元素是否在列表内  如果在  True  如果不在False
# TypeError: argument of type 'int' is not iterable
#print(num_list in 5)
# 注意使用in或者not in  数据元素在左边,  列表或者其他数据序列在右侧
print(5 in num_list)  # True
print(9 in num_list)  # False
# not in  判断数据元素是否不在列表内  如果不在  True  如果在False
print(5 not in num_list)  # False
print(9 not in num_list)  # True

列表的增加

append：在类表的末尾追加数据
extend：将数据序列进行迭代依次提取出每一个元素添加到列表末尾
insert：在指定位置追加数据元素

num_list1=[1,2,3,4,6]
print(num_list1.append(5))
# 能够打印出1,2,3,4,5么?
# print(num_list.append(5)) # None
# 如果直接打印append方法的调用,将不会输出任何内容
# list类型在使用append 方法时不会产生新的列表,而是在原有列表上进行修改
# append 追加的数据,默认追加到列表末尾,追加完成后在原有数据上修改
print(num_list1)
# # str
# str1 = 'abc'
# # str类型数据,调用replace方法时,不会修改原有数据,而是产生了一个新的字符串
# str2 = str1.replace('abc', 'cba')
# print(str1)
# print(str2)

# extend  追加数据序列
list1=[1,2,3,4]
list2=[4,5,6]
list1.extend(list2)
print(list1)
print("----------------------")
print(list2)

# 其实底层逻辑就是讲括号内的数据序列迭代,依次放入调用该方法的列表中
# 追加字符串序列时,会将字母依次拆分并放入列表中
str1 = 'itcast'
list2.extend(str1)
print(list2)

num_list = [1, 2, 3, 4]
# 格式:列表.insert(要插入位置的索引, 要插入的对象)
# 在insert中第一个参数是要插入位置的索引,所以如果插入了数,则该被插入数据的索引变为第一参数所显示的索引
# 原来该位置的元素以及之后的元素下标+1(向后移动一位)
# 如果使用insert进行 插入,可能会造成索引混乱,原来引用的索引发生错误
# 在开发中除非明确所有的索引引用都修改完成,否则不要使用insert
# append 插入数据,要比insert插入数据更安全
num_list.insert(
    1,4
)
print(num_list)
num_list.insert(1, 5)
print(num_list)

# extend 和append 进行对比
list1 = [1, 2, 3, 4]
list2 = [5, 6, 7, 8]
# append将list2 当做一个元素追加到列表末尾
list1.append(list2)  # [1, 2, 3, 4, [5, 6, 7, 8]]
# extend将list2 当做多个元素进行拆分后追加
list1.extend(list2)  # [1, 2, 3, 4, 5, 6, 7, 8]
print(list1)

列表中的删除

del 先对列表中的元素进行查找（使用下标），找到后使用del删除
pop：删除类表中指定下标位置的元素，如果不指定默认删除最后一个，并且返回被删除的值
remove：删除指定值的下标，只删除丛左至右的第一次出现的该值元素
clear：清空列表，和重新赋值为空有逻辑上的区别。

num_list=[1,2,3,4,5,6]
#del num_list
print(num_list)
#del num_list[1]
print(num_list)
for i in num_list:
    if i==2:
        del i
print(num_list)
# 如果要是循环中能够删除么?
# 此处并没有删除,因为i是临时变量,我们使用del是在讲i和2的引用关系删除,但是num_list 和 2 的引用关系没有删除
# pop  删除指定索引的元素,并且返回该元素
list1 = [1, 2, 3, 4]
# 删除后可以返回被删除的对象
print(list1.pop(2))
print(list1)
# IndexError: pop index out of range
# 使用pop进行删除的元素下标一定要存在
# print(list1.pop(12))
# 删除后,指定索引位置的元素消失后边的元素统一向左移动一位
# pop也会造成索引变换
# 如果不给pop进行传值,默认删除最后一个元素
print(list1.pop())
# 查看删除后结果
print(list1)
# remove 删除指定的元素(从左至右第一次出现的元素)
list1 = [1, 2, 3, 3, 4, 2, 1]
# 删除列表中的2
# 将从左至右查询第一次遇到的2进行了删除,并不能删除类表中所有的的2
list1.remove(2)
print(list1)
# remove会返回被删除的内容? 不会
print(list1.remove(3))  # None
# remove删除的内容不存在会怎样?
# list1.remove(123)  # ValueError: list.remove(x): x not in list
# clear  清空列表
# 就是讲列表置为[],但是与list1 = [] 有本质区别
list1.clear()
print(list1)  # []

列表的修改

使用索引修改：列表[索引] = 新值

查询列表索引值必须在列表中存在
reverse: 列表的反转
sort：列表的排序，默认为升序

reverse：可以进行列表倒排，降序
key:添加函数，使排序规则更加复杂多变


```python
# 通过索引进行修改
list1 = [1, 2, 3, 4]
# 通过索引查找到指定位置的数据,并进行修改
list1[1] = 6
print(list1)
# IndexError: list assignment index out of range
# 获取的元素位置,必须是存在的
# list1[6] = 6
print(list1)
# 通过索引修改可以同时修改多个值么?  不能
# list1[(2,3)] = 6,7
# 可以使用对多变量赋值的形式修改多个值
list1[2],list1[3]=9,7
print(list1)
# reverse  列表的反转
list1 = [1, 2, 3, 4]
print(list1.reverse())
print(list1)
# sort  排序
list2 = [2, 6, 43, 2, 41, 421]
list2.reverse()
list2.sort()
print(list2)
# 方法二: 可以直接使用倒叙排列
# list2.sort(reverse=True)  # [421, 43, 41, 6, 2, 2]
# print(list2)
列表遍历
for遍历
while遍历


##  while遍历列表

```python
# len()函数可以查询列表的长度
list10 = [12, 123, 1, 1, 1234, 12, 34, 8]
print(len(list10))
i=0
while i<len(list10):
    print(list10[i])
    i+=1
    # for 遍历列表
    # 推荐使用for循环遍历容器类型(数据序列)
    for i in list10:
        print(i)
for i in list10:
    print(i)

列表的嵌套

列表中嵌套其他的子列表，就是列表的嵌套
嵌套后的列表可以使用循环嵌套来进行遍历

# 列表的嵌套: 在一个列表中包含其他的列表元素
name_list = [['小明', '小红', '小绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']]
# 需求:想要获取李四的值
# 获取李四所在的子列表的索引,并通过索引获取该子列表值
print(name_list[2])
# 再从子列表中通过李四所在的索引获取其值
print(name_list[2][1])
# 如果我们想要获取嵌套列表中的每一个值,我们需要怎么做?
# 如果进行一次循环,每次循环所得到的都一级列表中的元素,也就是每一个子列表
for i in name_list:
    print(i)
# 如果想要对嵌套后的列表进行输出,需要进行循环嵌套
for sub_list in name_list:
    for name in sub_list:
        print(name)
# 这样就可以进行所有名称的输出了
# 如果当前的列表内的数据不都是子列表,有其他数据类型的数据,则不能直接使用循环嵌套,需要先进行类型判断

元组的定义

单元素元组：变量 = （数据，）
多元素元组：变量 = （数据1，数据2，数据3…）

# 元组:可以储存多个数据,但是元组内的数据不能被修改(元定义后只能被查询)
# 元组的定义:变量 = (数据1, 数据2, 数据3......)
tuple1 = (1, 2, 3, 4)
# 打印后可以展示元组中的全部信息
print(tuple1)  # (1, 2, 3, 4)
# 查询数据类型
print(type(tuple1))  # <class 'tuple'>

# 如果元组中只有一个元素怎么办? 在单一元素后添加逗号
tuple2 = (10)
print(type(tuple2))  # <class 'int'>

tuple3 = ('10')
print(type(tuple3))  # <class 'str'>

tuple4 = (10,)
print(type(tuple4))  # <class 'tuple'>

# 如果小括号包裹单一元素数据不添加逗号,则小括号的意义是提升算术运算符优先级

# 在定义元素或者传值时,元组的括号可以省略

tuple5 = 1, 2, 3, 4, 5
print(tuple5)  # (1, 2, 3, 4, 5)
print(type(tuple5))  # <class 'tuple'>

tuple6 = 5,
print(tuple6)  # (5,)
print(type(tuple6))

tuple7 = (1,2,3,)
print(tuple7)

元组的相关操作

元组中的数据不能增删改，所以只能查询
元组的查询方式
索引查询：和列表的使用方式一致
index ：从左至右查询指定元素在元组中第一次出现的位置索引，如果存在则返回正向索引，如果不存在则报错
count：查询指定元素在元组中出现的次数
len：查询元组的长度：也就是查询元组中元素的个数

# 元组的增删改:由于元组中的数据不可修改,所以元组中的数据不能进行增删改操作
tuple1 = (1, 2, 3, 4)
# 修改
print(tuple1[2])
# TypeError: 'tuple' object does not support item assignment
# 元组中的数据不能修改
# tuple1[2] = 6
# 删除
# TypeError: 'tuple' object doesn't support item deletion
# 元组中的数据不能删除
# del tuple1[2]

# 查询
# 通过索引进行查询
# 查询方法和列表一致
# 正向索引,从0开始,从左至右依次递增
# 负向索引,从-1开始,从右至左依次递减
tuple1 = (1, 2, 3, 4, 3)
# 需求:通过正向索引取出3
print(tuple1[2])
# 需求:通过负向索引取出3
print(tuple1[-2])

# index  查询指定元素在元组中所在的位置索引
# 需求:查询3所对应的索引值
# index是从左至右依次查询,返回第一个查到的数据的正向索引值
print(tuple1.index(3))  # 2
# 如果查询的内容不存在,则报错
# print(tuple1.index(8))  # ValueError: tuple.index(x): x not in tuple

# count 查询指定元素在元组中出现的次数
print(tuple1.count(3))  # 2
print(tuple1.count(1))  # 1

# len  查询元组的长度(对所有容器适用)  长度就是计算当前容器中有多少个元素
print(len(tuple1))  # 5