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