python基础数据类型之列表,元组(基础二)
第四章 python基础数据类型之列表,元组(基础二)
python常用数据类型之组合数据类型：列表，元组。
4.1 列表 list
列表介绍
列表是python的基础数据类型之⼀ ,其他编程语⾔言也有类似的数据类型. 比如JS中的数 组, java中的数组等等. 它是以 [ ] 括起来, 每个元素⽤用' , '隔开而且可以存放各种数据类型，
常用定义方式一：
lst = [1, '李雷', "飞雪",Ture, [1,8,0,"百度"], ("我","叫", "元", "组"), "abc", {"我 叫":"dict字典"},{"我叫集合","集合"}]
li = [1,2,3,'123',True,[1,2,5]] # 容器 任意类型都可以
列表 == 书包
水杯
衣服
袜子
钱包
1,2,5
定义方式二
列表底层使用了for循环 "abc" 可迭代的字符串类型
li = list("abc")
print(li)
['a', 'b', 'c']
列表对比子字符串：
列表能存储大量的数据，子字符串存储少量数据，可以存放⼤大量量的数据. 32位 python可以存放: 536870912个元素, 64位可以存放: 1152921504606846975个元素.⽽而且列列 表是有序的(按照你保存的顺序),有索引, 可以切⽚片⽅方便便取值.
4.2 列表的索引和切片
列表对比字符串一样有序的也拥有索引，切片，步长。
4.2.1 索引
li = [1,2,3,"123",True]
# 0 1 2 3 4 #列表对于的元素索引值从0开始取值
print(lst[0]) # 获取第⼀个元素 1
print(lst[1]) # 获取第二个元素 2
print(lst[2]) # 获取第三个个元素 3
注意：列表取出的元素是什么类型就是什么类型
li = [1,2,3,'123',True]
print(li[3],type(li[3])) #获取第三个元素类型字符串str
123 <class 'str'>
print(li[4],type(li[4]))
True <class 'bool'> #获取第四个元素类型布尔值bool
4.2.2切片
列表的切片，使用索引值(下标)截取部分列表中元素的内容。
语法：list[star:end]
规则：顾头不顾尾，从start开始截取，截取到end位置，但是不包括end的元素。
默认从0开始截取
li = [1,2,3,"123",True]
# 0 1 2 3 4 #从左边往右边切取（索引值）从0开始取(有序支持)
# -5 -4 -3 -2 -1 #从右边往左边切取值（索引值）从-1开始取
print(li[:2]) #从0获取到2，不包含2 结果：[1, 2]
print(li[1:4]) #从1获取4，不包含4 结果：[2, 3, '123']
print(li[-1:]) #(取倒数第一个)从右边-1获取到0不包含0(对应方向为右边) 只取1个结果：True
4.2.3列表的步长
步长就是跳着取，跳几步取一次，控制取值的方向。
步长切片后还是原来的数据类型：
s = "alex"
print(type(s[1:3:1])) # 切片后还是原来的数据类型<class 'str'>
print(type(li[-1:-4:-1])) # <class 'list'>
步长: 如果是整数, 则从左往右取. 如果是负数. 则从右往左取. 默认是-1开始
切片语法：list[start: end:step] start: 起始位置 end: 结束位置 step:步⻓(步数)
li = [1,2,3,"123",True]
# 0 1 2 3 4
# -5 -4 -3 -2 -1
print(li[-1:-4:1])
#取-1到-4的值，不包含-4，方向向右，结果值[]需引入步长值改变取值方向。
li = [1,2,3,"123",True,[1,2,3,False],]
# 0 1 2 3 4 5
# -6 -5 -4 -3 -2 -1
print(li[-1:-4:-2]) #从-1开始到-4取值，左方向跳2步到-5结束不包含-5结果：[[1, 2, 3, False], '123']
#公式算法类似：起始+步长 -1+-2 = -3往右边(倒着)跳2步，-3+-2=-5
4.3 列表的增，删，改，查
4.3.1 列表的增
list列表是可变对象，所以直接在原来的对象上进行操作。
li = [1,2,3,"123",True]
li[2] = "注意"
print(li)
[1, 2, '注意', '123', True]
str字符串是不可变对象，所以任何操作对原字符串是不会有任何影响。
s = "123"
s[2] = "注意"
print(s)
#报错 TypeError: 'str' object does not support item assignment不允许改变
4.1.2 列表的增
append() 增加：
追加方式，默认添加在列表中元素的末尾。
错误写法：print(li.append('太亮')) 结果值：None
li = [1,2,3,'alex',3,[1,2,3]]
#0,1,2, 3, 4, 5
li.append('太亮') # 追加 添加在末尾 添加的操作
print(li)
[1, 2, 3, 'alex', 3, [1, 2, 3], '太亮']
insert() 插入
需要指定元素插入的位置(索引值)，原来的元素向后移动一位，所以执行效率低(依次插入空间内存地址)
语法: insert(seat,content)
li = [1,2,3,'alex',3,[1,2,3]]
li.insert(0,"太亮") #插入第一个参数(索引),第二参数要插入的内容（效率特别低)
print(li)
['太亮', 1, 2, 3, 'alex', 3, [1, 2, 3]]
extend() 迭代添加
extend()迭代添加底层原理类似for循环，依次将字符串的内容拆分成每个元素次往后循环添加到列表。
li = [1,2,3] # 扩展 -- 迭代添加 -- for
li.extend("abc")
print(li)
[1, 2, 3, 'a', 'b', 'c']
迭代添加实现的原理;
li = [1,2,3]
for i in "abc": #迭代添加开始
li.append(i) #迭代添加结束
print(li)
[1, 2, 3, 'a', 'b', 'c']
整型int,布尔bool对象不能被迭代
li = [1,2,3]
li.extend(123)
print(li)
#报错TypeError: 'int' object is not iterable
列表合并
l1 = [1, 2, 3]
l2 = ["a","b","c"]
print(l1+l2)
[1, 2, 3, 'a', 'b', 'c']
4.1.3 列表的删除
pop() 列表删除中唯独pop删除过程有返回值，返回的是被删除的内容，默认是删除在末尾元素。
语法：pop(index) 括号内指定被删除的索引(下标)。
li = [1,2,3,"abc",True]
li.pop(3)
print(li)
abc # 被删除的内容
[1, 2, 3, True] #删除后的结果
remove() 指定删除的元素名字进行删除，如果元素名字不存在就会报错。
li = [1,2,3,"abc",True]
li.remove(1)
print(li)
del 删除
标记删除，清除内存不用的资源，释放空间。
del是python的关键字，底层原理会计算所有元素出现的次数，在内存中进行分成统计，自动释放空间
li = [1,2,3,"abc",True]
del li #del li 将整个容器都删掉
print(li)
del 支持索引，切片步长删除
li = [1,2,3,"abc",True]
del li[2] #del支持索引删除
del li[0:3] #del支持切片删除
del li[::2] #del支持步长删除
print(li)
clear() 清空
li = [1,2,3,"abc",True]
li.clear() #清空列表结果:[]
print(li)
4.1.4 列表的修改
列表元素索引，切片，步长的修改。
列表的索引
li = ["水杯",2,3,"abc",]
li[1] = "奶瓶" 把二号元素替换成奶瓶
print(li)
['水杯', '奶瓶', 3, 'abc']
列表的切片
li = ["水杯",2,3,"abc",]
i[1:3] = [1,2,3] #在1到3范围添加列表[1,2,3]，1-3区间会展开放
print(li)
['水杯', 1, 2, 3, 'abc']
li = ["水杯",2,3,"abc",]
li[1:3] = "abcd"
print(li)
['水杯', 'a', 'b', 'c', 'd', 'abc']
li = ["水杯",2,3,"abc",]
l2 = [1,2,3,4,66,7]
li[1:3] = l2[4:] #l2[4:]从索引值4后面取出来的类型是列表[66,7]类型,迭代进去，可多可少。
print(li)
['水杯', 66, 7, 'abc']
li = ["水杯",2,3,"abc",]
li[1:2] = [] #从1-2范围全部变成空,不包含2
print(li)
['水杯', 3, 'abc']
题一：
li = [1,2,3,4,"abc",5]
li[0:2] = "ABCsadfsdf" #li[0:2]出的结果[3,4,"abc",5]被"ABCsadfsdf"迭代添加
print(li)
['A', 'B', 'C', 's', 'a', 'd', 'f', 's', 'd', 'f', 3, 4, 'abc', 5]
步长：
截取几个元素就放入几个元素
li = ["水杯",2,3,"abc",]
li[0:3:2] = "abcabc" #报错不明确区间,迭代的位置无法查找
print(li)
li = ["水杯",2,3,"abc",]
li[0:3:2] = [1,2,3],[1234] #截取几个元素就放入几个元素
print(li)
[[1, 2, 3], 2, [1234], 'abc']
4.1.5 列表的查讯
列表是一个可迭代对象，可以进行for循环查
#for循环
li = ["水杯",2,3,"abc",]
for em in li:
print(em)
一般查询
li = [1,2,3,4]
print(li)
print(li[1])
列表的其他操作：统计，排序，反转，长度
lst = ["太⽩", "太⿊", "太⽩"]
c = lst.count("太⽩") # 查询太⽩出现的次数
print(c)
lst = [1, 11, 22, 2]
lst.sort() # 排序. 默认升序
print(lst) l
st.sort(reverse=True) # 降序
print(lst)
lst = ["太⽩白", "太⿊黑", "五⾊色", "银王", "⽇日天", "太⽩白"]
print(lst)
lst.reverse()
print(lst)
l = len(lst) # 列列表的⻓长度
print(l)
4.3.6 列表的嵌套
采用降维度操作，一层一层的看就好
lst = [1, "小白", "lisir", ["码农", ["可乐"], "王林林"]]
print(lst[2]) # 找到lisir
print(lst[1:3]) #找到'小白', 'lisir'
print(lst[1][1]) #找到小白中的白
lst = [1, "小白", "lisir", ["码农", ["可乐"], "王林林"]] 将lisir拿到. 然后⾸首字⺟母⼤大写. 再扔回去
lst = [1, "小白", "lisir", ["马疼", ["可乐"], "王林林"]]#将lisir拿到. 然后⾸首字⺟母⼤大写. 再扔回去
s = lst[2] #将lisir拿到
s = s.capitalize() #⾸首字⺟母⼤大写
lst[2] = s
print(lst)
简单写法：
lst = [1, "小白", "lisir", ["码农", ["可乐"], "王林林"]]
lst[2] = lst[2].capitalize()
print(lst)
把小白变成小黑
lst = [1, "小白", "lisir", ["码农", ["可乐"], "王林林"]]
lst[1]= lst[1].replace("白", "黑")
print(lst)
把码农换成码云
lst = [1, "小白", "lisir", ["码农", ["可乐"], "王林林"]]
lst[3][0] = lst[3][0].replace("农", "云")
print(lst[3][0])
添加雪碧到列表
lst[3][1].append("雪碧")
print(lst)
4.3 元组tuple
元组: 俗称不可变的列列表.⼜又被成为只读列列表, 元组也是python的基本数据类型之⼀一, ⽤用⼩小括 号括起来, ⾥里里⾯面可以放任何数据类型的数据, 查询可以. 循环也可以. 切片也可以. 可以存一些任意类型的数据，但就是不能 改。存储一些不能修改的数据。
tu = (1) 括号中没有用逗号隔开就是元素本身不是元组。
tu = (1,) 小括号中的一个元素用逗号隔开的就是元组
tu = () 空的小括好就是元组
元组是有序的，索引，切片，步长，是不可变的数据类型
一般应用在配置文件程序中，为了防止误操作修改一些数据
4.3.1元组的查询
tu = (1, 2, 3, "lisir", 6)
print(tu)
print(tu[1]) #索引
print(tu[1:1000]) #切片 返回的是切片前的数据类型
print(tu[::2]) #步长
元组的for循环
tu = (1, 2, 3, "lisir", 6)
# for循环遍历元组
for el in tu:
print(el)
关于不可变, 注意: 这⾥里里元组的不可变的意思是⼦子元素不可变. ⽽而⼦子元素内部的⼦子元素是可 以变, 这取决于⼦子元素是否是可变对象
元素里面操作列表元素可以添加到元组的列表元素内
tu = (1, 2, [],3, "lisir", 6)
tu[2].append("hehe") # 可以改了了. 没报错
tu[2].append("你好")
print(tu)
元组也有count(), index(), len()
4.3.2 元组嵌套
tu = (1,2,3,(4,5,6,[6,7,8,(9,11,10),"abc"],"ABC"))
print(tu[3][3][3][1]) # [6,7,8,(9,11,10),"abc"]
print(tu[-1][-2][-1])
