python基础：Python元组、列表

妖狐艹你老母 2022-04-01 03:14 410阅读 0赞

列表：
概念：列表是一个有序的，可修改的，元素以逗号分割，以中括号包围的序列。
列表的索引和字符串的索引类似，但不完全相同，因为列表可以修改，所以我们可以通过列表的索引来修改列表。
一、列表的定义以及查看列表类型：
name = [“Eric”,“Mary”,“Tom”]
type(name)


创建列表
# lst = [1, 2.34, ‘hello’, False]
# 查看列表中的数据
# print(lst)
# 查看列表的数据类型
# print(type(lst)) #
二、通过索引获取列表中的元素，索引从0开始
# lst = [1, 2.34, ‘hello’, False]
# num = lst[1]
# print(num) # 2.34
# ret = lst[4]
# print(ret) # 索引越界异常
# length = len(lst)
# print(length) # 4 长度从1开始计算
三、使用for循环取出每一个元素
# i=‘hello’
# for i in lst:
# print(i)
# h
e
l
l
o

四、列表的增删改查
append（）：追加，在列表的尾部加入指定的元素
insert（）：将指定的元素插入到对应的索引位上，注意负索引倒序插入，超过索引就会在末尾插入
extend（）：将指定序列的元素依次追加到列表的尾部(合并),不会去重复内容
# lst = [‘悟空’, ‘八戒’, ‘唐三藏’]
# 1.向列表中添加数据 append(),insert(),+ ,extend()
# lst.append(‘白骨精’) # 将数据追加到列表的后面
# print(lst)
# lst.insert(1, ‘白龙马’) # 指定索引位置添加元素。
# print(lst)

  1. # lst2 = ['宋江', '李逵', '悟空']
  2. #
  3. # # lst3 = lst + lst2  # 列表之间可以相加，将所有的内容放到一个新的列表中，并且不会自动去重
  4. # # print(lst3)
  5. #
  6. # lst.extend(lst2)
  7. # print(lst)
  9. # lst = ['悟空', '八戒', '唐三藏']
  10. # s='hello'
  11. # lst.extend(s)
  12. # print(lst)
  14. # s='hello'
  15. # s1="-".join(s)
  16. # print(s)
  17. # print(s1)
  18. 5、删除操作

pop 弹出，返回并删除指定索引位上的数据，默认删除索引为-1的数据(从右向左删除)
remove 从左往右删除一个指定的元素
del 删除整个列表或列表的数据，删除后将不复存在，del是python内置功能，不是列表独有的
clear 删除列表中所有元素，然后变成一个空列表
# lst = [‘悟空’, ‘八戒’, ‘唐三藏’]
# lst.pop(0) # 指定索引删除数据，如果索引不存在则报错
# print(lst)
# lst.remove(‘八戒’) # 根据内容删除
# print(lst)
# lst.clear() # 清除所有内容，变成空列表[]
# print(lst)
# del lst # 删除列表
# print(lst)
六、修改操作

  1. # lst = ['悟空', '八戒', '唐三藏']
  2. # lst[0] = '猴哥'  # 通过索引来修改内容
  3. # print(lst)

七、查询 操作
count 计数，返回要计数的元素在列表当中的个数
index 查找，从左往右返回查找到的第一个指定元素的索引，如果没有找到，报错
# lst = [‘悟空’, ‘八戒’, ‘唐三藏’, ‘悟空’]
# # 1.通过索引获取元素
# # ret = lst[0]
# # print(ret)
# # num = lst.count(‘八戒’) # 根据内容统计个数
# # print(num)
# # index = lst.index(‘悟空’) # 根据内容返回索引值
# # print(index)
# length = len(lst)
# print(length)
# ret = lst.index(‘悟空’, 1, length) # 指定位置查找
# print(ret)
八、列表的切片

  1. # lst = ['a', 'b', 'c', 'd', 'e']
  2. # ret = lst[0:4:2]
  3. # print(ret)
  4. # print(lst)

九、列表的排序
reverse 顺序倒序
sort 按照ascii码表顺序进行排序
# lst = [‘tom’, ‘jerry’, ‘carl’, ‘zs’, ‘ls’]
# print(lst)
# # lst.sort() # 升序排序
# # print(lst)
# lst.sort(reverse=True) # 降序排序
# print(lst)
如果一个方法有返回值，就需要使用一个变量来接受，
如果一个方法没有返回值，就不需要使用变量来接受。
怎么看方法的返回值 快捷键 ctrl+Q

  1. # lst = [1, 2, ['悟空', '八戒'], 3]
  2. # # 获取 八戒
  3. # ret = lst[2][1]  # 先找到内部列表，然后再找到内容
  4. # print(ret)

十一、列表的拷贝
1、浅拷贝
对于浅copy来说，第一层创建的是 存地址，所以，对于第二层以及更深的层数来说，保持一致性。

  1. lst = ['貂蝉', '西施']
  2. lst1 = ['悟空', '八戒', lst]
  3. lst2 = lst1.copy()  # 将 lst1的内容拷贝一份给lst2
  4. print(lst1)  # ['悟空', '八戒', ['貂蝉', '西施']]
  5. print(lst2)  # ['悟空', '八戒', ['貂蝉', '西施']]
  6. print(id(lst1[2]))  # 35502856
  7. print(id(lst2[2]))  # 35502856
  9. # print(lst1)
  10. # print(id(lst1))
  11. # print(lst2)
  12. # print(id(lst2))
  13. # lst2[0] = '猴哥'  # 将 lst2中的悟空改成 猴哥
  14. # print('lst2--->', lst2)
  15. # print('lst1--->', lst1)
  16. # lst2[2][0] = '杨贵妃'
  17. # print('lst2--->', lst2)
  18. # print(id(lst))
  19. # print('lst1--->', lst1)
  20. # print(id(lst))
  21. 2、 深拷贝
  22. 深拷贝后的变量的第二层以及更深的层数的内存地址发生了改变，与原有变量的深层地址不再保持一致，如果拷贝后的变量的深层地址发生了变化，那么原来的变量的深层地址将不会发生改变。
  23. # 导入copy模块
  24. import copy
  26. lst = ['貂蝉', '西施']
  27. lst1 = ['悟空', '八戒', lst]
  28. lst2 = copy.deepcopy(lst1)
  29. print(lst1)
  30. print(id(lst1))
  31. print(lst2)
  32. print(id(lst2))
  33. # 修改第一层的内容
  34. # lst2[0] = '猴哥'
  35. print('lst1--->', lst1)
  36. print('lst2--->', lst2)
  37. # 修改第二层的内容
  38. # lst2[2][0] = '贵妃'
  39. print('lst1--->', lst1)  # ['悟空', '八戒', ['貂蝉', '西施']]
  40. print('lst2--->', lst2)  # ['悟空', '八戒', ['貂蝉', '西施']]
  41. # print(id(lst1[2]))  # 39409992
  42. # print(id(lst2[2]))  # 39411400

元组：
元组特点：元组是有序的，不能修改。
元组的定义:
(1).通过()来定义：变量名=(1,2,3,4,) 。以逗号分割的，以小括号包围的序列。
(2).通过tuple函数定义: lst=[1,2,3,4] 变量名=tuple(lst)
元组的优点:由于元组不可变，所以遍历元组比列表要快（较小的性能提升）。

一、元组的创建
# tup = (1, 2.2, True, ‘hello’)
# print(tup) # 打印变量名就可以查看元组中的内容
# print(type(tup)) #

二、访问元组
元组的索引和字符串以及列表完全一致。
1.通过索引，默认索引是从0开始的
# tup = (1, 2.2, True, ‘hello’)
# ret = tup[4] # 获取 2.2 值,一定要注意索引越界问题。
2.通过切片来获取内容
# tup = (1, 2.2, True, ‘hello’, ‘赵四’, ‘刘能’)
# tup1 = tup[0:4:1]
# print(tup1) # (1, 2.2, True, ‘hello’)
# print(tup)
三、访问多维元组

  1. # tup = (('zs', 10), ('ls', 11), ('ww', 12))
  2. # ret = tup[1][0]  # 先找到内层元组，然后再获取里面对应的值。
  3. # print(ret)

四、使用多个变量来接受元组中的值
注意:变量的个数和元组中的值的个数必须一一对应
# name, age, height, weight = (‘zs’, 32, 1.64, 150)
# print(name)
# print(age)
# print(height)
# print(weight)
使a与b的值互换
a=10
b=20
b,a=(a,b)
print(a) 20
print(b) 10

四、遍历 元组

  1. # tup = (('zs', 10), ('ls', 11), ('ww', 12))
  2. # for tup1 in tup:
  3. #     print(tup1)
  4. #     for info in tup1:
  5. #         print(info)
  7. # for name, age in tup:
  8. #     print(name, age)

五、元组的修改
说明：Python中不允许修改元组的数据，包括不能删除其中的元素。
元组是不可变的，也就是说，元组中的元素在被赋值后不能改变。但是，如果元素本身是一个可变数据类型的列表，那么其嵌套项可以被改变。
# tup = (‘zs’, ‘ls’, ‘ww’, [‘白骨精’, ‘糖三角’])
# # tup[0] = ‘赵四’ # 不能修改
# tup[3].insert(1, ‘宋江’)
# print(tup)
六、元组的一个逗号魅力

  1. # tup1 = ('1')         如果没有逗号，就是元素本身类型。
  2. # print(type(tup1))      #int
  3. # tup2 = (1,)             如果有逗号，就是元组
  4. # print(type(tup2))     #tuple

七、tuple()函数和list()函数
tuple函数的功能与list函数基本上一样的，以一个序列作为参数并把它转换为元组，如果参数是元组，那么该参数就会被原样返回。
# lst = [1, 2, 3]
# tup = tuple(lst)
# print(tup)
# tup = (‘a’, ‘b’, ‘c’)
# ret = list(tup)
# print(ret)
八、元组中的方法
index 从左往右返回第一个遇到的指定元素的索引，如果没有，报错
count 返回元组当中指定元素的个数
tup = (‘a’, ‘b’, ‘a’, ‘c’, ‘b’, ‘a’, ‘x’)
# ret = tup.index(‘b’) # 根据内容返对应的索引。
# ret = tup.index(‘a’, 2, len(tup))
# print(ret) # 5
ret = tup.count(‘a’)
print(ret)
s = ‘abde123’

发表评论

表情：
评论列表 （有 0 条评论，410人围观）

还没有评论，来说两句吧...

相关阅读

    相关 python元组、列表、数组

    元组：封闭的列表，一旦定义，就不可改变（不能添加、删除或修改） 列表：一个大仓库，你可以随时往里边添加和删除任何东西 1、什么情况下你需要使用元组而不是列表？ 当我们

    旧城等待，旧城等待，/ 0 赞/ 500 阅读