python -- 列表list，元组tuple
python -- 列表list，元组tuple
列表-list
在python里，列表的表现形式是用[]。
name = [] # 这是一个空列表
name_list = ['用户1','用户2'] # 这是非空列表的形式
列表的操作
定义一个空列表
name = []
列表的定位，输出、修改
name = ['用户0','用户1','用户2']
print(name) # 这里的name会打印出['用户0', '用户1', '用户2']
name[0] = '用户1'
name[1] = '用户2'
name[2] = '用户3'
print(name) # 这里的name会打印出['用户1', '用户2', '用户3']
# 这里是列表的定位输出效果
print('\033[32;1mThe 1st element at name(list) is {0}\033[0m'.fotmat(name[0]))
列表的切片
name = ['用户0','用户1','用户2','用户3','用户4','用户5']
print(name)
print('\033[30;1m-----------------------\033[0m') # black
# 以下是列表的切片功能,切片的特点是顾头不顾尾。
print(name[0:2]) # 这里是打印['用户0', '用户1']
# 这里的name[0:2]的格式还是列表
print(type(name[0:2])) # <class 'list'>
print('\033[32;1m------------------------\033[0m') # green
# 切片值只要是0，就可以省略
print(name[:2]) # 这里是打印['用户0', '用户1']
print(name[:]) # print(name[:]) = print(name)
print(name[-2:])
print('\033[31;1m------------------------\033[0m') # red
print(name[1:4]) # 这里是打印['用户1', '用户2', '用户3']
print(name[-1]) # 这里是打印列表中最后一个元素 用户5
print(type(name[-1])) # <class 'str'>
print(name[-2:]) # 这里是打印，从倒数第二个切到最后一个，即取最后两个元素，但是这里出来的是列表
print('\033[33;1m------------------------\033[0m') # yellow
# 按照步长来切片
print(name[:-1:2]) # 从第一个到最后一个，隔一个打印
print(name[:-1:3]) # 从第一个到最后一个，隔3取一个值(含当前元素)
列表的追加 list.append('str') list.insert(3,'str')
- list.append('str')
- list.insert(3,'str')
name = ['用户0','用户1','用户2','用户3','用户4','用户5']
print(name[-1])
# 在列表的最后加一个元素
name.append('用户6')
print(name[-1])
# insert 是在需要插入的地方将元素写入
name.insert(3,'插队人')
print(name[3])
append只能加一个元素，如果要两个，就要写两句代码
列表的修改
name = ['用户0','用户1','用户2','用户3','用户4','用户5']
print(name)
name[-1] = '用户55'
print(name)
# 将第一个元素由字符串换成列表
name[0] = ['用户组']
# 列表套列表的格式
print(name)
列表的复制 list.copy()
由于计算的存储格式，导致copy只是一种浅copy，即指复制第一层的数据，至于嵌套的格式，是将内嵌的元素的内存地址赋值。所以出现了浅copy的效果。
name = ['用户0', '用户1', '用户2', '用户3', '用户4', '用户5']
# 通过list.copy()复制一份给name2列表，浅copy
name2 = name.copy()
print(name)
print(name2)
name2[2] = '路人1'
print(name)
print(name2)
name[1] = '路人2'
print(name)
print(name2)
print('\033[34;1m-----------------\033[0m')
name3 = ['用户1', '用户2', '用户3', ['路人1', '路人2'], '用户5']
name4 = name3.copy()
print(name3)
print(name4)
name3[2] = '好人1'
name3[3][1] = '好人2'
print(name3)
print(name4)
导入copy模块，实现浅copy和深copy
import copy
print('\033[34;1m-----------------\033[0m')
name3 = ['用户1', '用户2', '用户3', ['路人1', '路人2'], '用户5']
# copy.copy还是浅copy
name4 = copy.copy(name3)
# copy.deepcopy这是深copy，其实用处不大，等于在内存里有开辟一个空间，并且完全复制一份
name5 = copy.deepcopy(name3)
print('\033[32;1m{0}\033[0m'.format(name3))
print('\033[33;1m{0}\033[0m'.format(name4))
print('\033[34;1m{0}\033[0m'.format(name5))
print('\033[38;1m--------------------------------------------------------\033[0m')
name3[2] = '好人1'
name3[3][1] = '好人2'
print('\033[35;1m{0}\033[0m'.format(name3))
print('\033[36;1m{0}\033[0m'.format(name4))
print('\033[37;1m{0}\033[0m'.format(name5))
列表的删除 list.remove('str') list.clear() del list
- list.remove('str')
- del list[下标]
- list.pop(下标)，不加下标，默认是最后一个
- list.clear(),清空列表内容，变成空列表
name = ['用户0','用户1','用户2','用户3','用户4','用户5']
print(name)
# 通过知道元素内容，删除
name.remove('用户2')
print(name)
# 通过下标，删除
del name[0]
print(name)
# 通过pop()，删除，默认是列表中最后一个元素
name.pop()
print(name)
# 通过pop()加下标，删除
name.pop(1)
print(name)
name = ['用户0','用户1','用户2','用户3','用户4','用户5']
# 清空列表内的元素，变成空列表
name.clear()
print(name)
列表的查询，排序，扩容 list.index('str') list.count('str') list.reverse() list.sort() list.extend(list2)
- list.index('str')，查找元素所在列表中的下标
- list.count('str')，查询元素在列表中的个数
- list.reverse()，反转列表的顺序
- list.sort()，按ASCII码排序，特殊符->数字->大写->小写
- list.extend(list2)，将list2的内容并如list
name = ['用户0','用户1','用户2','用户3','用户4','用户5']
print(name)
# 查找“用户2”的下标
print(name.index('用户2'))
# 通过获得下标后的结果，通过下标来找到列表中的元素
print(name[name.index('用户2')])
# 查询“用户”的下标，但是列表中没有“用户”，所以会报错
# print(name.index('用户'))
# 查询列表中同一名称的数量
print(name.count('用户5'))
# 将列表的元素反转排列
name.reverse()
print(name)
# 按ASCII排序
name.sort()
print(name)
# 将extend内的列表添加到entend前的列表
name2 = ['路人1','路人2','路人3']
name.extend(name2)
print(name)
print(name2)
index 和 enumerate的用法
name = ['用户0','用户1','用户2','用户3','用户4','用户5']
print(name)
#查找“用户2”的下标
print(name.index('用户2'))
for i, k in enumerate(name):
if i == 2:
print('-----我是插队的-----')
continue
print(i)
for i in enumerate(name):
if i == 2:
print('-----我是插队的-----')
continue
print(i)
'''
以下是上面程序的效果，注意比较后两个print的区别。
['用户0', '用户1', '用户2', '用户3', '用户4', '用户5']
2
0
1
-----我是插队的-----
3
4
5
(0, '用户0')
(1, '用户1')
(2, '用户2')
(3, '用户3')
(4, '用户4')
(5, '用户5')
'''
列表的循环
name = ['用户1', '用户2', '用户3', ['路人1', '路人2'], '用户5']
for i in name:
print(type(i),i)
元组-tuple
元组其实跟列表差不多，也是存一组数，只不过它一旦创建，便不能再修改，所以又叫只读列表。只能查，切片，不能修改，一旦生成就不能修改。
元组的写法，不再是中括号[]，而是小括号（）。
元组只有两个操作方法
- count：统计
- index：取下标。
什么时候用元组
自己写的程序，中间有些值，连数据库的值，不能被改变，就可以把内容变成元组。
写在后面
- 列表内的元素有顺序
- 列表可以切片
- 列表可以定位插入
- 列表可以定位修改
- 列表内的元素可以重复
- 元组是一个只读列表。
| 作用 | 代码 | 用法 | 备注 |
|---|---|---|---|
| 追加 | append | list.append('str') | 只能输入一个str |
| 插入 | insert | list.insert(1,'str') | 在特定的位置加str |
| 复制 | copy | list.copy() | 浅copy |
| 删除 | remove | list.remove('str') | 只能输入一个str |
| 删除 | clear | list.clear() | 清除list内所有元素 |
| 删除 | del | del list | 系统内功能 |
| 索引 | index | list.index('str') | 返回str的下标 |
| 计数 | count | list.count('str') | 返回str的个数 |
| 反转 | revserse | list.reverse() | 将list顺序反转 |
| 排序 | sort | list.sort() | 将list按ASCII排序 |
| 扩展 | extend | list.extend(list2) | 将list2扩展到list中 |
list_tuple = [(1, 2), (3, 4), (4, 5), (6, 7)]
for a, b in list_tuple:
print(a, b)
print('--------------------')
for t in list_tuple:
print(t)
'''
1 2
3 4
4 5
6 7
--------------------
(1, 2)
(3, 4)
(4, 5)
(6, 7)
'''
