Python序列类型及操作

文章目录

• ​​一. 序列类型定义（sequence）​​

• ​​1. 序列是具有先后关系的一组元素​​
• ​​2. 序列是一个基类类型，一般使用序列类型衍生出来的类型​​
• ​​3. 序号的定义​​

• ​​二. 序列处理函数及方法​​

• ​​1. 序列类型通用操作符​​
• ​​2. 序列类型通用函数和方法​​

• ​​三. 元组类型（tuple）​​

• ​​1. 定义元组​​
• ​​2. 创建元组​​

• ​​(1). 方式一：使用圆括号​​
• ​​(2). 方式二：不用括号​​
• ​​(3). 方式三：使用tuple()函数​​
• ​​(4). 举例​​

• ​​3. 操作元组​​

• ​​(1). 索引访问元组​​
• ​​(2). 对元组的组合​​
• ​​(3). 元组的内置函数​​

• ​​4. 元组与列表之间的转换​​

• ​​四. 列表类型（list）​​

• ​​1. 定义​​
• ​​2. 列表的表示​​
• ​​3. 列表的创建​​

• ​​(1). 使用方括号​​
• ​​(2). 使用list()函数​​

• ​​4. 列表元素的索引​​

• ​​(1). 通过索引访问列表元素方式​​
• ​​(2). 通过索引访问列表元素中的元素（这里是字符串，单个数据元素不用此操作）​​

• ​​5. 操作列表元素​​

• ​​(1). 修改元素（替换元素）​​
• ​​(2). 增加元素​​
• ​​(3). 删除元素​​
• ​​(4). 求列表元素个数​​
• ​​(5). 判断指定元素是否在列表中​​
• ​​(6). 在列表中查找指定的元素​​
• ​​(7). 返回列表中指定元素的个数​​

• ​​6. 操作列表​​

• ​​(1). 遍历列表​​
• ​​(2). 列表排序​​
• ​​(3). 列表切片​​
• ​​(4). 列表的扩充​​
• ​​(5). 列表的复制​​
• ​​(6). 列表的删除​​

• ​​7. 数值列表​​

• ​​(1). 创建数值列表​​
• ​​(2). 列表生成式​​
• ​​(3). 简单统计计算​​

• ​​8. 字符串与列表之间的转换​​

• ​​(1). 方式一：list()函数转换​​
• ​​(2). 方式二：split()方法​​

• ​​1. 定义​​
• ​​2. 语法​​

• ​​五. 序列类型应用场景​​

• ​​1. 数据表示：元组和列表​​
• ​​2. 元素遍历​​
• ​​3. 数据保护​​

一. 序列类型定义（sequence）

1. 序列是具有先后关系的一组元素

2. 序列是一个基类类型，一般使用序列类型衍生出来的类型

3. 序号的定义

二. 序列处理函数及方法

1. 序列类型通用操作符

2. 序列类型通用函数和方法

三. 元组类型（tuple）

1. 定义元组

元组是序列类型的一种扩展

用来存放一组相关的数据

元组使用（），一旦创建就不能修改

语法：

tuple = (字符串，元组，集合，字典， 列表，数字，布尔类型)

2. 创建元组

(1). 方式一：使用圆括号

将多个元素使用 ，隔开放在一对（）中

声明一个空元组
tp = ()

tup = ("张三", '李四', 88, (66, 90, "pudding"))

注：当定义的元组只有1个元素时，一定要在该元素的后面写一个，
否则系统会将其视为单个数据

tup = ("张三",)

(2). 方式二：不用括号

不带（）的多个数据用，隔开也可以定义元组

tup = 66,77,88,"张三"

(3). 方式三：使用tuple()函数

使用tuple()函数创建

声明一个空元组
tp = tuple()

(4). 举例

3. 操作元组

元组继承序列类型的全部通用操作

元组因为创建后不能修改，因此没有特殊操作

(1). 索引访问元组

与列表一样，元组可以使用索引位置来访问元组中的值

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print("tup1[0]: ", tup1[0])
print("tup2[-1]: ",tup2[-1])

结果：
tup1[0]:  physics
tup2[-1]: 7

嵌套的元组，访问元素与列表一样，通过在后面添加中括号的形式实现。

tup = (1,2,3,"abc",(10,20,30))
print("tup[3][1]: ",tup[3][1])
print("tup[4][0]: ",tup[4][0])

输出结果：
tup[3][1]: b
tup[4][0]: 10

(2). 对元组的组合

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
tup3 = tup1 + tup2
print(tup3)

输出结果：
(12, 34.56, 'abc', 'xyz')

(3). 元组的内置函数

注：其中比较最大值和最小值，若元组里面全是字母的时候，比较他们的首字母的编码值大小

4. 元组与列表之间的转换

Python提供了两个转换函数

tuple()函数用来将列表转换为元组
list()函数用来将元组转换为列表

tupPlay = ("张三", "男", 98)
listPlay = list(tupPlay)
>>>listPlay
["张三", "男", 98]

listScore = [66, 77, 88, 99]
tupScore = tuple(listScore)
>>>tupScore
(66, 77, 88, 99)

四. 列表类型（list）

由0个或多个数据组成的有序序列

1. 定义

列表是序列类型的一种扩展，十分常用

用来有序存放一组相关数据，以便进行统一的处理

2. 列表的表示

Python语言中，列表（list）使用[ ]表示，采用逗号，分隔各元素

['F', 'f']表示两个元素'F'和'f'

元素的个数表示列表的长度

3. 列表的创建

使用方括号[ ] 或list()函数创建列表，元素之间使用逗号分隔

列表是一种序列类型，创建后可以随意被修改

列表中个元素类型可以不同，无长度限制

(1). 使用方括号

语法：

list = [字符串，元组， 集合，字典，列表，数字，布尔类型]

声明一个空列表
ls = []

举例
play = ["阿布", 98, ["阿伟", 60], ("张三", 88)]

注：元组可以充当列表的元素，但是不能修改元组中的元素，可以通过一个新的元组来替换列表中的元组

(2). 使用list()函数

声明一个空列表
ls = list()

>>> lst = list("hello")
>>> lst
['h', 'e', 'l', 'l', 'o']

4. 列表元素的索引

列表中每一个元素都对应一个位置编号，这个位置编号称为元素的索引，列表通过索引来访问元素的

语法格式：

列表名[索引值]

注：列表和字符串一样也有正向和反向索引方式

列表的反向索引方式可以方便程序更加快捷访问列表尾元素

(1). 通过索引访问列表元素方式

举例：

间接访问
>>> list = ['physics', 'chemistry', 1997, 2000]
>>> print(list[0])
physics

直接访问
>>> print(['physics', 'chemistry', 1997, 2000][0])
physics

(2). 通过索引访问列表元素中的元素（这里是字符串，单个数据元素不用此操作）

>>> a = ['physics', 'chemistry'] #此时变为列表   
>>> print(a[0])    #打印第一个元素（这里为字符串）
physics
>>> print(a[0][1])    #打印第一个元素的第二个位置上的字符
h

5. 操作列表元素

列表的特性：

列表的元素是有序存放的，可以通过索引直接来访问列表元素

列表的元素值可以修改，元素个数可以改变

(1). 修改元素（替换元素）

定义：直接将列表中要修改的元素索引指出，然后为其指定新值

语法格式：

列表名[索引] = 值

>>> list = ['Google', 'Runoob']
>>> list[0] = "Baidu"
>>> print(list)
['Baidu', 'Runoob']

(2). 增加元素

1. 方法一：append()方法
   用来指定在列表尾部添加元素
   语法：

列表名.append(新元素)

1. 方法二：insert()方法
   允许为新增的元素指定插入的位置，位置使用索引表示
   语法：

列表名.insert(索引，新元素)

(3). 删除元素

1. 方法一：使用del命令
   定义：删除指定索引位置的元素
   语法：

del 列表名[索引]

1. 方法二：使用pop()方法
   定义：指定索引从列表中删除对应的元素，并返回该元素
   语法格式：

列表名.pop(索引)

注：

当没有指定索引来删除元素时，默认删除列表的最后一个元素

1. 方法三：使用remove()方法
   定义：可以直接指定待删除元素的值
   语法格式：

列表.remove(元素值)

注：当列表元素有多个相同的取值时，需要删除时怎么办？

remove()方法删除的是列表中排在最前面的待删除的元素

(4). 求列表元素个数

语法格式：

len(列表)

返回列表的长度

(5). 判断指定元素是否在列表中

使用in和not in成员运算符

使用保留字in判断一个元素是否在列表中，如果元素在列表中则返回True，否则返回False

语法：

元素 in 列表
元素 not in 列表

举例：

TemStr[-1] in ['C', 'c']判断前者是否与列表中某个元素相同

(6). 在列表中查找指定的元素

定义：index()方法在列表中查找指定的元素，如果存在则返回指定元素在列表中的索引
如果存在多个指定元素，则返回最小的索引值。如果不存在，会直接报错

语法：

列表.index(元素)

(7). 返回列表中指定元素的个数

定义：count()方法统计并返回列表中指定元素的个数

语法：

列表.count(元素)

注：当统计列表中没有的元素，返回值是0

6. 操作列表

(1). 遍历列表

1. 方式一：通过索引号进行遍历
2. 方式二：使用range()函数
   语法：

for i in range(n)：
  print(列表[i])

索引从0到n-1的变化来实现元素的遍历

1. 方式三：直接的元素遍历
   定义：直接依次访问列表中的每一个元素
   语法：

for 元素 in 列表：
  print(元素)

举例：

谁是小偷

suspects=['A', 'B', 'C', 'D']
for x in suspects:
  if (x!='A') + (x=='C') + (x=='D') + (x!='D')==3
    print("小偷是：",x)
    break

(2). 列表排序

1. 方式一：sort()方法
   语法格式：

列表.sort()   <==>    列表.sort(reverse=False)
  表示：列表元素从小到大排列

 列表.sort(reverse=True)
  表示：列表元素从大到小排序

注：

Python中排序是基于ord()函数得到的编码值来进行的，
 对于数字和英文字符排序，结果是确定的，
 但是对于中文，中文通常拼音和笔画两种排序，
 不同字符集可能采用不同的方式，所以sort()方法排序可能结果不同

1. 方式二：sorted()方法
   语法格式：

sorted(列表，reverse = True/False)
  False：表示升序排列(默认)
  True：表示降序排列

sort()方法和sorted()方法区别

sort()方法直接改变原来的列表顺序，
 而sorted()函数只生成排序后的列表副本，不改变原来的列表顺序

1. 方式三：reverse()方法
   定义：将列表中的元素反向排列
   注：首先需要对列表中的元素进行排列
   语法：

list1 = [1,2,3,4,5]
list1.reverse()
print(list1)

结果：
[5, 4, 3, 2, 1]

(3). 列表切片

定义：直接指定切片的起始索引和终止索引可以从列表中提取切片，和字符串切片操作类似

语法：

列表[起始索引：终止索引]
  表示：从起始索引对应元素到终止索引前的那个元素作为切片

列表[起始索引：终止索引：n]
  表示：从起始索引到终止索引前的元素每隔n个元素提取一个元素的方式进行切片

(4). 列表的扩充

1. 方式一：+ 元素
   定义：和字符串类似，将两个列表连接起来
   语法：

新列表 = 列表一 + 列表二

注：

连接之后的新列表，但是原来的列表一和列表二都没有变化

fruit = ["苹果","梨子","菠萝","香蕉"]
vegetable = ["土豆","萝卜","茄子","白菜","黄瓜"]
food = []
food = fruit + vegetable
print(food)

结果：
['苹果', '梨子', '菠萝', '香蕉', '土豆', '萝卜', '茄子', '白菜', '黄瓜']

1. 方式二：extend()方法
   定义：列表调用extend()方法直接将新列表添加到列表的后面
   语法：

列表.extend(新列表)

1. 方式三：* 运算
   定义：和字符串一样，将列表中的元素重复多遍
   语法格式：

列表 * n

注：如果不用赋值语句将结果保存下来，*运算结果仅回显一次

(5). 列表的复制

1. 方式一：利用切片实现
   语法：

新列表 = 列表[:]

1. copy()方法
   语法：

新列表 = 列表.copy()

注：列表的copy()方法会生成原列表的备份，并将该备份赋值给新列表，这被称为深拷贝

1. 列表之间的赋值
   语法：

新列表 = 列表

注：直接列表赋值，仅仅是让原列表多了一个新名字，但是和原列表内容相同，被称为浅拷贝

(6). 列表的删除

1. 方式一：列表整体删除
   语法：

del 列表名
 
 再次输出列表会报错

1. 方式二：列表的清空
   语法：

通过del 列表[:]

 是表示清空列表，此时列表还在，是一个没有元素的空列表

7. 数值列表

(1). 创建数值列表

1. 方式一：通过input()函数输入
   定义：输入列表的时候要带有[ ]一起输入
   语法：

lst = eval（input("请输入一个数值列表：\n"))

输入：[1, 2, 3, 4]

注：输入的时候一定要带有[ ]，这样才被看做是列表

1. 方式二：通过list()函数转换
   语法：

lst = list(range(1, 11))

注：list函数可将range对象转换为列表

1. 方式三：基于range()函数创建数字列表
   定义：通过range()函数，利用 Python 列表提供的append()插入功能创建一个列表
   语法：

# 声明一个列表变量
numbers = []
# 利用append()函数和range()函数向列表插入目标元素
for i in range(10):
    number = i**2
    numbers.append(number)
print(numbers)

输出结果：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

1. 方式四：使用list()函数和range()函数创建数字列表
   语法：

data_list = list(range(lower_limit,upper_limit,step))

举例：

data_list = list(range(1,6))
print(data_list)

输出结果：[1,2,3,4,5]

(2). 列表生成式

定义：

列表生成式将range()函数生成的若干数
按照指定的表达式运算符后的结果作为元素创建了数值列表

语法：

列表 = [循环变量相关表达式 for 循环变量 in range()]

举例：

>>> lnum = []
>>> for i in range(1, 11):
  lnum.append(i**2) 
>>> lnum
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

等价于
>>> lnum = [i**2 for i in range(1, 11)]
>>> lnum
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

(3). 简单统计计算

Python语言针对数值列表提供了几个内置函数

1. 求最小值min()函数
2. 求最大值的max()函数
3. 求和的sum()函数

举例：

numbers = [2,4,11,1,21,32,5,8]
print('The min number is',min(numbers))
print('The max number is',max(numbers))
print('The sum is',sum(numbers))

输出结果：
The min number is 1
The max number is 32
The sum is 84

8. 字符串与列表之间的转换

(1). 方式一：list()函数转换

转换后的字符串中单个字符依次成为列表元素

name = "张三， 李四"
guests = list(name)
>>> guests
['张', '三', '，', '李', '四']

(2). 方式二：split()方法

1. 定义

split()是处理字符串的方法，根据指定的分隔符拆分字符串，并生成列表

2. 语法

列表 = 字符串.split(分隔符)

当分隔符缺省，默认按照空格拆分字符串

sentence = "I am pudding"
sentenceList = sentence.split()
>>>sentenceList
['I', 'am', 'pudding']

五. 序列类型应用场景

1. 数据表示：元组和列表

2. 元素遍历

3. 数据保护