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)
'''

转载于:https://www.cnblogs.com/gzz041/p/7064358.html