Python（二）变量的6种基本类型

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

数据结构	是否可变	是否重复	是否有序	定义符号
列表（list）	可变	可重复	有序	[]
元组（tuple）	不可变	可重复	有序	()
字典（dictionary）	可变	可重复	无序	{key:value}
集合（set）	可变	不可重复	无序	{}

目录

列表

定义

可变对象

运算

截取（索引、切片）

列表常用方法

增加 add、 insert、 extend

删除 pop、 remove、 clear

排序 sort、 reverse

列表与字符串转换

元组

定义

不可变对象

运算

截取（索引、切片）

---

列表

定义

定义列表用[];  

列表是个筐，什么都能装

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))    
#a_list变量类型为： <class 'list'> id为 1676523959296
print('b_list变量类型为：',type(b_list),'id为',id(b_list))
#b_list变量类型为： <class 'list'> id为 1676524221696

可变对象

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

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

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

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

运算

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])  #索引为0的值为： a
print('切片:',a_list[1:3])        #切片: [2, 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, []]

c1 = a_list.append('add')       #最后位置插入元素;
print(c1,'列表',a_list)          
#None 列表 ['a', 2, 3, 3.14, [], 'add']

c2 = a_list.insert(0,'hello')   #在索引0的位置前插入元素;
print(c2,'列表',a_list)          
#None 列表 ['hello', 'a', 2, 3, 3.14, [], 'add']

c3 = a_list.extend(b_list)      #把b_list列表的元素扩展进去；
print(c3,'列表',a_list)          
#None 列表 ['hello', 'a', 2, 3, 3.14, [], 'add', 'b', 3, 2, 3.14, []]
c4 = a_list.extend('book')      #把字符串的元素扩展进去；
print(c4,'列表',a_list)          
#None 列表 ['hello', 'a', 2, 3, 3.14, [], 'add', 'b', 3, 2, 3.14, [], 'b', 'o', 'o', 'k']

删除 pop、 remove、 clear

a_list = ['a', 2, 3, 3.14, 2, 4, []]

a_list.pop()         #默认删除最后一个元素
print(a_list)        #['a', 2, 3, 3.14, 2, 4]

a_list.pop(0)        #删除索引为0的元素
print(a_list)        #[2, 3, 3.14, 2, 4]


a_list.remove(2)     #删除值为2的第一个元素
print(a_list)        #[3, 3.14, 2, 4]

a_list.clear()       #清空列表；   列表还是原来的列表，注意与a_list=[]区分
print(a_list)        #[]

排序 sort、 reverse

d_list = [2,4,5,3]

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

d_list.reverse()          
print('反序',d_list)         #反序 [2, 3, 4, 5]

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

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

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

d_list = [2,4,5,3]

c1 = sorted(d_list)
print(c1,'列表',d_list)       #[2, 3, 4, 5] 列表 [2, 4, 5, 3]

c2 = reversed(d_list)
print(list(c2),'列表',d_list) #[3, 5, 4, 2] 列表 [2, 4, 5, 3] 

列表与字符串转换

字符串转换成列表

p = 'python'
lst = list(p)       
print('转换前',p,'转换后',lst)  
#转换前 python 转换后 ['p', 'y', 't', 'h', 'o', 'n']

列表转换成字符串

p1 = ''.join(lst)
print('转换前',lst,'转换后',p1)
#转换前 ['p', 'y', 't', 'h', 'o', 'n'] 转换后 python

p2 = str(lst)
print('转换前',lst,'转换后',p2)
#转换前 ['p', 'y', 't', 'h', 'o', 'n'] 转换后 ['p', 'y', 't', 'h', 'o', 'n']

元组

定义

定义元组用( );

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

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

不可变对象

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

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

运算

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])   #索引为0的值为： a
print('切片:',a_list[1:3])         #切片: (2, 3)