python基础数据类型之列表,元组(基础二)

快来打我* 2021-11-02 02:04 257阅读 0赞

# 第四章 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,) 小括号中的一个元素用逗号隔开的就是元组