延续上一章，本章介绍：list（列表）、tuple（元组）

目录

list（列表）

定义--方括号[ ]

可变对象

运算

截取（索引、切片）

列表常用方法

增加 add、 insert、 extend

删除 pop、 remove、 clear

排序 sort、 reverse

列表与字符串转换

tuple（元组）

定义 -- 小括号()

不可变对象

运算

截取（索引、切片）

---

list（列表）

定义--方括号[ ]

a_list = ['a', 2, 3, 3.14, []]                             
#定义列表用[];  列表是个筐，什么都能装b_list = ['b', 3, 2, 3.14, []]
#列表有顺序，顺序变了，ID不一样print('a_list变量类型为：',type(a_list),'id为',id(a_list))    
print('b_list变量类型为：',type(b_list),'id为',id(b_list))

可变对象

当对象的值发生变化，但内存地址没有改变时，则说明是可变类型；

列表是容器类对象，元素的变化不改变对象内存地址；

通过索引，修改列表中的值：

a_list = ['a', 2, 3, 3.14, []]
a_list[1] = 100                      
print('修改后：',a_list)

运算

b = ['python']
c = [123]
print('运算结果为:',b + c)       #拼接,运算结果为: ['python', 123]
print('运算结果为:',b * 3)       #重复3次,运算结果为: ['python', 'python', 'python']
print('运算结果为:','p' in b)    #字符中是否存在p,运算结果为: False
print('b的值为:',b,'b的长度为:',len(b))   #b的值为: ['python'] b的长度为: 1

截取（索引、切片）

列表是序列的一种，可以索引，可以切片（同字符串）

a_list = ['a', 2, 3, 3.14, []]print('索引为0的值为：',a_list[0])     print('切片:',a_list[1:3])           

列表常用方法

a_list = ['a', 2, 3, 3.14, []]
print('列表方法有：',dir(a_list))

增加 add、 insert、 extend

这个列表的元素增加了，但是列表这个容器的内存地址没有变；列表还是那个列表，只是列表中的元素增加了

a_list = ['a', 2, 3, 3.14, []]
b_list = ['b', 3, 2, 3.14, []]a_list.append('add')           #最后位置插入元素;  没有返回值，返回none
print('列表增加后值为',a_list)a_list.insert(0,'hello')       #在索引0的位置前插入元素;  没有返回值，返回none
print('列表增加后值为',a_list)a_list.extend(b_list)          #把b_list列表的元素扩展进去；  没有返回值，返回none
print('列表增加后值为',a_list)a_list.extend('book')          #把字符串的元素扩展进去； 没有返回值，返回none
print('列表增加后值为',a_list)

删除 pop、 remove、 clear

a_list.pop()           #默认删除最后一个元素
print('列表删除后值为',a_list)a_list.pop(0)          #删除索引为0的元素
print('列表删除后值为',a_list)a_list.remove('b')     #删除值为b的第一个元素
print('列表删除后值为',a_list)a_list.clear()         #清空列表；   列表还是原来的列表，注意与a_list=[]区分
print('列表删除后值为',a_list)

排序 sort、 reverse

d_list = [2,4,5,3]d_list.sort()                #默认从小到大排序
print('从小到大排序',d_list)d_list.sort(reverse=True)    #从大到小排序
print('从大到小排序',d_list)d_list.reverse()             #反序
print('反序',d_list)

sort方法和reverse方法不产生新的列表；

注意与切片区分：d_list[::-1]  产生了新的列表；

注意与内置函数区分：内置函数sorted排序，内置函数reversed反序，产生了新的列表；

d_list = [2,4,5,3]sorted(d_list)
print('旧列表',d_list,'排序后',sorted(d_list))            reversed(d_list)
print('旧列表',d_list,'反序后',list(reversed(d_list)))    

列表与字符串转换

字符串转换成列表

p = 'python'
lst = list(p)       
print('转换前',p,'转换后',lst)

列表转换成字符串

p1 = ''.join(lst)   
print('转换前',lst,'转换后',p1)p2 = str(lst)
print('转换前',lst,'转换后',p2)

tuple（元组）

定义 -- 小括号()

定义元组用( );

当元组中只有一个值时，值后面必须加一个逗号： b=(666)是int型   b=(666,)是元组

c_list = ('a', 2, 3, 3.14, [])                    
print('c_list变量类型为：',type(c_list))

不可变对象

当对象的值发生变化，内存地址也发生改变时，则说明是不可变类型

这里注意与列表的区别，元组是不能修改的，值不能改变！！！

运算

b = ('python',)
c = (123,)
print('运算结果为:',b + c)       #拼接,运算结果为: ('python', 123)
print('运算结果为:',b * 3)       #重复3次,运算结果为: ('python', 'python', 'python')
print('运算结果为:','p' in b)    #字符中是否存在p,运算结果为: False
print('b的值为:',b,'b的长度为:',len(b))   #b的值为: ('python',) b的长度为: 1

截取（索引、切片）

元组是序列的一种，可以索引，可以切片（同列表）

a_list = ('a', 2, 3, 3.14, [])print('索引为0的值为：',a_list[0])     print('切片:',a_list[1:3])