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

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

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

python常用数据类型之组合数据类型：列表，元组。

4.1 列表 list

列表介绍

列表是python的基础数据类型之⼀ ,其他编程语⾔言也有类似的数据类型. 比如JS中的数 组, java中的数组等等. 它是以 [ ] 括起来, 每个元素⽤用’ , ‘隔开而且可以存放各种数据类型，

常用定义方式一：

lst = [1, ‘李雷’, “飞雪”,Ture, [1,8,0,”百度”], (“我”,”叫”, “元”, “组”), “abc”, {“我 叫”:”dict字典”},{“我叫集合”,”集合”}]

  1. li = [1,2,3,'123',True,[1,2,5]]   # 容器 任意类型都可以
  2. 列表 == 书包
  3.     水杯
  4.     衣服
  5.     袜子
  6.     钱包
  7.         1,2,5

定义方式二

列表底层使用了for循环 “abc” 可迭代的字符串类型

  1. li = list("abc")  
  2. print(li)
  3. ['a', 'b', 'c']

列表对比子字符串：

列表能存储大量的数据，子字符串存储少量数据，可以存放⼤大量量的数据. 32位 python可以存放: 536870912个元素, 64位可以存放: 1152921504606846975个元素.⽽而且列列 表是有序的(按照你保存的顺序),有索引, 可以切⽚片⽅方便便取值.

4.2 列表的索引和切片

列表对比字符串一样有序的也拥有索引，切片，步长。

4.2.1 索引

  1. li = [1,2,3,"123",True]
  2.     # 0 1 2  3     4    #列表对于的元素索引值从0开始取值
  3. print(lst[0])           # 获取第⼀个元素 1
  4. print(lst[1])           # 获取第二个元素 2
  5. print(lst[2])           # 获取第三个个元素 3

注意：列表取出的元素是什么类型就是什么类型

  1. li = [1,2,3,'123',True]
  2. print(li[3],type(li[3]))    #获取第三个元素类型字符串str
  3. 123 <class 'str'>
  4. print(li[4],type(li[4]))
  5. True <class 'bool'>         #获取第四个元素类型布尔值bool

4.2.2切片

列表的切片，使用索引值(下标)截取部分列表中元素的内容。

语法：list[star:end]

规则：顾头不顾尾，从start开始截取，截取到end位置，但是不包括end的元素。

默认从0开始截取

  1. li = [1,2,3,"123",True]
  2.     # 0 1 2   3      4      #从左边往右边切取（索引值）从0开始取(有序支持)
  3.     # -5 -4 -3 -2   -1      #从右边往左边切取值（索引值）从-1开始取
  4. print(li[:2])              #从0获取到2，不包含2 结果：[1, 2]
  5. print(li[1:4])             #从1获取4，不包含4 结果：[2, 3, '123']
  6. print(li[-1:])             #(取倒数第一个)从右边-1获取到0不包含0(对应方向为右边) 只取1个结果：True

4.2.3列表的步长

步长就是跳着取，跳几步取一次，控制取值的方向。

步长切片后还是原来的数据类型：

s = “alex”
print(type(s[1:3:1])) # 切片后还是原来的数据类型
print(type(li[-1:-4:-1])) #

步长: 如果是整数, 则从左往右取. 如果是负数. 则从右往左取. 默认是-1开始

切片语法：list[start: end:step] start: 起始位置 end: 结束位置 step:步⻓(步数)

  1. li = [1,2,3,"123",True]
  2.     # 0 1 2   3      4      
  3.     # -5 -4 -3 -2   -1
  4. print(li[-1:-4:1])   
  5. #取-1到-4的值，不包含-4，方向向右，结果值[]需引入步长值改变取值方向。
  7. li = [1,2,3,"123",True,[1,2,3,False],]
  8.     # 0 1 2   3     4       5
  9.     # -6 -5 -4 -3  -2       -1
  11. print(li[-1:-4:-2])     #从-1开始到-4取值，左方向跳2步到-5结束不包含-5结果：[[1, 2, 3, False], '123']
  12.                       #公式算法类似：起始+步长 -1+-2 = -3往右边(倒着)跳2步，-3+-2=-5

4.3 列表的增，删，改，查

4.3.1 列表的增

list列表是可变对象，所以直接在原来的对象上进行操作。

  1. li = [1,2,3,"123",True]
  2. li[2] = "注意"
  3. print(li)
  4. [1, 2, '注意', '123', True]

str字符串是不可变对象，所以任何操作对原字符串是不会有任何影响。

  1. s = "123"
  2. s[2] = "注意"
  3. print(s)
  4. #报错 TypeError: 'str' object does not support item assignment不允许改变

4.1.2 列表的增

append() 增加：

追加方式，默认添加在列表中元素的末尾。

错误写法：print(li.append(‘太亮’)) 结果值：None

  1. li = [1,2,3,'alex',3,[1,2,3]]
  2.      #0,1,2,  3,    4, 5
  3. li.append('太亮')          # 追加  添加在末尾  添加的操作
  4. print(li)
  5. [1, 2, 3, 'alex', 3, [1, 2, 3], '太亮']

insert() 插入

需要指定元素插入的位置(索引值)，原来的元素向后移动一位，所以执行效率低(依次插入空间内存地址)

语法: insert(seat,content)

  1. li = [1,2,3,'alex',3,[1,2,3]]
  2. li.insert(0,"太亮")   #插入第一个参数(索引),第二参数要插入的内容（效率特别低)
  3. print(li)
  4. ['太亮', 1, 2, 3, 'alex', 3, [1, 2, 3]]

extend() 迭代添加

extend()迭代添加底层原理类似for循环，依次将字符串的内容拆分成每个元素次往后循环添加到列表。

  1. li = [1,2,3]            # 扩展 -- 迭代添加  -- for
  2. li.extend("abc")
  3. print(li)
  4. [1, 2, 3, 'a', 'b', 'c']

迭代添加实现的原理;

  1. li = [1,2,3]
  2. for i in "abc":    #迭代添加开始
  3.     li.append(i)    #迭代添加结束
  4. print(li)
  5. [1, 2, 3, 'a', 'b', 'c']

整型int,布尔bool对象不能被迭代

  1. li = [1,2,3]        
  2. li.extend(123)
  3. print(li)
  4. #报错TypeError: 'int' object is not iterable

列表合并

  1. l1 = [1, 2, 3]
  2. l2 = ["a","b","c"]
  3. print(l1+l2)
  4. [1, 2, 3, 'a', 'b', 'c']

4.1.3 列表的删除

pop() 列表删除中唯独pop删除过程有返回值，返回的是被删除的内容，默认是删除在末尾元素。

语法：pop(index) 括号内指定被删除的索引(下标)。

  1. li = [1,2,3,"abc",True]
  2. li.pop(3)
  3. print(li)
  5. abc             # 被删除的内容
  6. [1, 2, 3, True]   #删除后的结果

remove() 指定删除的元素名字进行删除，如果元素名字不存在就会报错。

  1. li = [1,2,3,"abc",True]
  2. li.remove(1)
  3. print(li)

del 删除

标记删除，清除内存不用的资源，释放空间。

del是python的关键字，底层原理会计算所有元素出现的次数，在内存中进行分成统计，自动释放空间

li = [1,2,3,”abc”,True]
del li #del li 将整个容器都删掉
print(li)

del 支持索引，切片步长删除

  1. li = [1,2,3,"abc",True]
  2. del li[2]               #del支持索引删除
  3. del li[0:3]             #del支持切片删除
  4. del li[::2]             #del支持步长删除
  5. print(li)

clear() 清空

  1. li = [1,2,3,"abc",True]
  2. li.clear()                      #清空列表结果:[]
  3. print(li)

4.1.4 列表的修改

列表元素索引，切片，步长的修改。

列表的索引

  1. li = ["水杯",2,3,"abc",]
  2. li[1] = "奶瓶"                把二号元素替换成奶瓶
  3. print(li)
  4. ['水杯', '奶瓶', 3, 'abc']

列表的切片

  1. li = ["水杯",2,3,"abc",]
  2. i[1:3] = [1,2,3]   #在1到3范围添加列表[1,2,3]，1-3区间会展开放
  3. print(li)
  4. ['水杯', 1, 2, 3, 'abc']
  6. li = ["水杯",2,3,"abc",]
  7. li[1:3] = "abcd"
  8. print(li)
  9. ['水杯', 'a', 'b', 'c', 'd', 'abc']
  11. li = ["水杯",2,3,"abc",]
  12. l2 = [1,2,3,4,66,7]
  14. li[1:3] = l2[4:]       #l2[4:]从索引值4后面取出来的类型是列表[66,7]类型,迭代进去，可多可少。
  15. print(li)
  16. ['水杯', 66, 7, 'abc']
  18. li = ["水杯",2,3,"abc",]
  19. li[1:2] = []      #从1-2范围全部变成空,不包含2
  20. print(li)
  21. ['水杯', 3, 'abc']

题一：

  1. li = [1,2,3,4,"abc",5]
  2. li[0:2] = "ABCsadfsdf"    #li[0:2]出的结果[3,4,"abc",5]被"ABCsadfsdf"迭代添加
  3. print(li)
  4. ['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)

  1. li = ["水杯",2,3,"abc",]
  2. li[0:3:2] = [1,2,3],[1234]     #截取几个元素就放入几个元素
  3. print(li)
  4. [[1, 2, 3], 2, [1234], 'abc']

4.1.5 列表的查讯

列表是一个可迭代对象，可以进行for循环查

  1. #for循环
  2. li = ["水杯",2,3,"abc",]
  3. for em in li:
  4.     print(em)

一般查询

  1. li = [1,2,3,4]
  2. print(li)
  3. print(li[1])

列表的其他操作：统计，排序，反转，长度

  1. lst = ["太⽩", "太⿊",  "太⽩"] 
  2. c = lst.count("太⽩")                 # 查询太⽩出现的次数 
  3. print(c) 
  5. lst = [1, 11, 22, 2] 
  6. lst.sort()                              # 排序. 默认升序 
  7. print(lst) l
  8. st.sort(reverse=True)                   # 降序 
  9. print(lst)
  12. lst = ["太⽩白", "太⿊黑", "五⾊色", "银王", "⽇日天", "太⽩白"] 
  13. print(lst) 
  14. lst.reverse() 
  15. print(lst)
  17. l = len(lst)                             # 列列表的⻓长度 
  18. print(l)

4.3.6 列表的嵌套

采用降维度操作，一层一层的看就好

  1. lst = [1, "小白", "lisir", ["码农", ["可乐"], "王林林"]]
  2. print(lst[2])                       # 找到lisir
  3. print(lst[1:3])                     #找到'小白', 'lisir'
  4. print(lst[1][1])                     #找到小白中的白

lst = [1, “小白”, “lisir”, [“码农”, [“可乐”], “王林林”]] 将lisir拿到. 然后⾸首字⺟母⼤大写. 再扔回去

  1. lst = [1, "小白", "lisir", ["马疼", ["可乐"], "王林林"]]#将lisir拿到. 然后⾸首字⺟母⼤大写. 再扔回去
  2. s = lst[2]          #将lisir拿到
  3. s = s.capitalize()   #⾸首字⺟母⼤大写
  4. lst[2] = s
  5. print(lst)

简单写法：

  1. lst = [1, "小白", "lisir", ["码农", ["可乐"], "王林林"]]
  2. lst[2] = lst[2].capitalize()
  3. print(lst)

把小白变成小黑

  1. lst = [1, "小白", "lisir", ["码农", ["可乐"], "王林林"]]
  2. lst[1]= lst[1].replace("白", "黑")
  3. print(lst)

把码农换成码云

  1. lst = [1, "小白", "lisir", ["码农", ["可乐"], "王林林"]]
  2. lst[3][0] = lst[3][0].replace("农", "云")
  3. print(lst[3][0])

添加雪碧到列表

  1. lst[3][1].append("雪碧")
  2. print(lst)

4.3 元组tuple

元组: 俗称不可变的列列表.⼜又被成为只读列列表, 元组也是python的基本数据类型之⼀一, ⽤用⼩小括 号括起来, ⾥里里⾯面可以放任何数据类型的数据, 查询可以. 循环也可以. 切片也可以. 可以存一些任意类型的数据，但就是不能 改。存储一些不能修改的数据。

tu = (1) 括号中没有用逗号隔开就是元素本身不是元组。

tu = (1,) 小括号中的一个元素用逗号隔开的就是元组

tu = () 空的小括好就是元组

元组是有序的，索引，切片，步长，是不可变的数据类型

一般应用在配置文件程序中，为了防止误操作修改一些数据

4.3.1元组的查询

  1. tu = (1, 2, 3, "lisir", 6)
  2. print(tu)
  3. print(tu[1])            #索引
  4. print(tu[1:1000])       #切片 返回的是切片前的数据类型
  5. print(tu[::2])          #步长

元组的for循环

  1. tu = (1, 2, 3, "lisir", 6)
  2. # for循环遍历元组
  3. for el in tu:
  4.     print(el)

关于不可变, 注意: 这⾥里里元组的不可变的意思是⼦子元素不可变. ⽽而⼦子元素内部的⼦子元素是可 以变, 这取决于⼦子元素是否是可变对象

元素里面操作列表元素可以添加到元组的列表元素内

  1. tu = (1, 2, [],3, "lisir", 6)
  2. tu[2].append("hehe")     # 可以改了了. 没报错
  3. tu[2].append("你好")
  4. print(tu)

元组也有count(), index(), len()

4.3.2 元组嵌套

  1. tu = (1,2,3,(4,5,6,[6,7,8,(9,11,10),"abc"],"ABC"))
  2. print(tu[3][3][3][1])  # [6,7,8,(9,11,10),"abc"]
  3. print(tu[-1][-2][-1])

转载于:https://www.cnblogs.com/yueling314/p/10994401.html

发表评论

表情：
评论列表 （有 0 条评论，394人围观）

还没有评论，来说两句吧...

相关阅读