可变序列——列表

列表

一、列表的定义与创建

（一）列表的定义

列表是Python中内置的有序、可变序列，列表的所有元素放在一对中括号 "[]" 中，并使用逗号隔开。列表的数据项不需要具有相同的数据类型。

ls1 = [1, 2, 3]
ls2 = [1, 2, 3.14]
ls3 = ['a', 2, 3.14]

（二）列表的创建

创建列表有多种方式，最常见的方式有两种：

  1. 直接建立

    # 直接建立列表
ls1 = [1, 2, 3, 4, 5]
print(ls1)
    image-20230711144117258

  2. 通过list()建立

    # 通过list()进行创建
str1 = "Hello"
ls2 = list(str1)
print(ls2)
    image-20230711144146281

二、序列的通用操作

所谓序列，就是一块可以存放多个值的连续内存空间，这些值按照一定顺序排列，可通过每个值所在位置的编号（索引）访问它们。

（一）序列的访问

在序列中，所有的元素都是有序号的，我们称序号为索引。

索引有两种表示方式，一种是从前往后的正方向索引，还有一种为从后往前的反方向索引。

正方向索引的第一个索引号为0，后面的索引号一次为1、2、...；反方向的第一个索引号为-1，接下来依次为 -2、-3、...。

image-20230711145332869

要访问列表中的值，使用 列表名[索引号] 即可。

ls = ["a", "b", "c"]

# 访问元素 "a"
print(ls[0])	# 也可以使用 print(ls[-3])
# 访问元素 "b"
print(ls[1])	# 也可以使用 print(ls[-2])
# 访问元素 "c"
print(ls[-1])	# 也可以使用 print(ls[2])

不仅是列表，访问元组、字符串等其他序列时，也可使用 序列名[索引] 的方法来访问其中的元素。

# 元组
t = ('a', 'b', 'c')
# 字符串
s = "abc"

# 访问元组t中的元素'c'
print(t[-1])

# 访问字符串s中元素'a'
print(s[0])

（二）序列的嵌套

序列里面可以再套序列，这叫作序列的嵌套。被嵌套的序列是作为一个整体看待的，所以其下标为一个。

ls = ['a', 'b', ['c','d'], 'e']
print(ls[2])		# 访问列表下标为2的元素
print(ls[2][0])		# 访问嵌套列表的元素
print(ls[2][1])		# 访问嵌套列表的元素
image-20230711150521078

在上边这个案例中，['c', 'd'] 是作为一个整体看待的，是列表ls的第3个元素，所以可以用 ls[2] 来访问。

如果要单独访问嵌套列表中的值，则需要进行列表下标的逐级分解。比如上边例子中使用 ls[2][0] 来访问 'c'，使用 ls[2][1] 来访问 'd'。

列表中不只可以嵌套列表，还可以嵌套其他的数据类型，比如：

ls = [1, 2, ('a', 'b'), {'1':'one', '2':'two'}]

（三）序列的截取

列表的截取又称作列表的切片，它需要使用两个索引下标来确定切片的起始位置和结束位置。

列表截取的格式为 列表名[头下标 : 尾下标 : 步长]；其中步长是可选参数，如果没有步长参数，则代表步长为1。

ls1 = ['a', 'b', 'c', 'd', 'e']
print(ls1[0 : 4])		
print(ls1[2 : 4])
print(ls1[0 : 4 : 2])
image-20230711151936101 image-20230711160709696

在上边的案例中，我们可以发现，列表截取的元素是从头下标的元素开始一直截到尾下标的前一个元素。也就是说列表的截取是 ”包头不包尾“ 的（从数学的角度来理解就是 左闭右开）。

步长参数默认为1，当步长参数改为2时，列表便会间隔1个元素进行截取。

如果切片是从头开始或者是到最后结束，头下标和尾下标也可以省略，如：

print(ls1[ : 4])	# 等价于 print(ls1[0 : 4])
print(ls1[2 : ])	# 等价于 print(ls1[2 : 5])
print(ls1[ : ])		# 等价于 print(ls1[0 : 5])  我们经常使用这个截取方法来复制列表
print(ls1[ : : 2])  # 等价于 print(ls1[0 : 5 : 2])
image-20230711152426836

列表截取的头下表和尾下标也可以使用负数，如：

print(ls1[-4 : -1])		# 等价于 print(ls1[1 : 5])
print(ls1[ : -1 : 2])	# 等价于 print(ls1[0 : -1 : 2])
image-20230711153429486

步长也可以使用负数，当步长为负数时，列表截取的方向从右边开始向左边截，如：

print(ls1[-1 : -4, -1])
print(ls1[-1 : -4 : -2])
image-20230711153701275

值得注意的是，列表在截取的过程中，一定要确保由 头下标和尾下标 构成的区间内有元素，否则截取的结果会为空表，如：

print(ls1[4 : 2])
print(ls1[0 : -1 : -1])
image-20230711153944816

从上边这个例子我们不难看出，在截取列表时，为了防止截取的列表为空表，我们要遵循这样一个原则：当步长为正数时（即截取方向从左向右），头下表 ≤ 尾下标；当步长为负数时（即截取方向从右向左），头下表 ≥ 尾下标。

不仅是列表，元组和字符串也可以通过上述的方法来截取（序列名[头下标 : 尾下标 : 步长]）。

（四）len() 和 in

  1. len()：取一个序列的长度命令为len()，返回值为该序列的元素的个数。

    # 列表
l = [1, 2, 3, 4, 5]		
print(len(l))

# 元组
t = (1, 2, 3, 4, 5)		
print(len(t))

# 字符串
s = "12345"				
print(len(s))
    image-20230711154647403

  2. in：检查某一个元素是否在该序列中，需要使用in命令进行判断，其返回值是True或者False，所以往往该命令是结合条件语句使用的.

    # 列表
l = [1, 2, 3, ['a','b','c'], 4, 5, (10,9,8)]
print(8 in l)
print(['a','b','c'] in l)

# 元组
t = (1, 2, 3, ['a','b','c'], 4, 5, (10,9,8))
print(8 in t)
print(['a','b','c'] in t)

# 字符串
s = "123abc451098"

print('8' in s)
print('abc' in s)


<img src="C:\Users\听阴天说什么\AppData\Roaming\Typora\typora-user-images\image-20230711154948979.png" alt="image-20230711154948979" style="zoom:67%;" />

#### （五）max()、min()、sum()

1. max()：找出序列中的最大值；min()：找出序列中的最小值

需要注意的是，当序列均为数字类型时，max()将返回该序列中最大的数字；当序列均为字符串类型时，max()则是按照Unicode编码的顺序返回编码最大的元素；当序列内既有数字类型又有字符串类型时，会报错。min()也遵循这个原则。

```python
# 列表
l1 = [1, 3, 2, 4, 5]
print(max(l1))
l2 = ['c', 'a', 'b']
print(min(l2))

# 元组
t1 = (1, 3, 2, 4, 5)
print(max(t1))
t2 = ('c', 'a', 'b')
print(min(t2))

# 字符串
s1 = "13245"
print(max(s1))
s2 = "cab"
print(min(s2))
image-20230711155519900

  1. sum()：计算序列各个元素的和

    需要注意的是，只有序列内的元素全为数字类型才能进行求和，否则将报错。

    # 列表
l1 = [1, 3, 2, 4, 5]
print(sum(l1))

# 元组

t1 = (1, 3, 2, 4, 5)
print(sum(t1))


<img src="C:\Users\听阴天说什么\AppData\Roaming\Typora\typora-user-images\image-20230711155706112.png" alt="image-20230711155706112" style="zoom:67%;" />

#### （六）序列的加法和乘法

1. 序列的加法：同一类型的序列是可以进行加法运算的，序列的加法相当于将两个序列结合起来

```python
# 列表
l1 = [1, 2, 3]
l2 = [4, 5, 6]
print(l1 + l2)

# 元组
t1 = (1, 2, 3)
t2 = (4, 5, 6)
print(t1 + t2)

# 字符串
s1 = "123"
s2 = "456"
print(s1 + s2)
image-20230711160018818

  1. 序列的乘法：序列可以和正整数相乘，代表的是将该序列重复正整数次

    # 列表
l = [1, 2, 3]
print(l * 3)

# 元组
t = (1, 2, 3)
print(t * 3)

# 字符串
s = "123"
print(t * 3)
    image-20230711160133145

三、列表的专用操作

（一）更新列表中的值

列表值的更新又称作修改列表中的值，可以直接使用 列表名[下标] 的方式进行赋值。

ls = [1, 2, 3, 4, 5]
ls[0] = 0
print(ls)
image-20230711185527793

利用列表切片技术，列表的值也可以同时更新多个。

ls = ['a', 'b', 'c', 'd', 'e']
ls[1:4] = [1, 2, 3]
print(ls)
image-20230711185710694

（二）列表元素的添加

向列表里添加元素，主要有三种方法。

  1. append()

    • 格式：list_name.append(obj)
    • 参数：list_name代表列表名称；obj代表要插入的元素，元素可以是单个数据，也可以是列表、元素等
    • 作用：将元素添加到列表的末尾
    ls = [1,2,3,4]
ls.append(5)
print(ls)
ls.append([6,7])
print(ls)
    image-20230712121600476

  2. extend()

    • 格式：lsist_name.extend(seq)
    • 参数：list_name代表列表名称；seq代表要添加的列表元素
    • 作用：将多个元素添加到列表末尾
    ls = [1, 2, 3, 4]
ls.extend([5])
print(ls)
ls.extend([6,7])

print(ls)


<img src="C:\Users\听阴天说什么\AppData\Roaming\Typora\typora-user-images\image-20230712121634849.png" alt="image-20230712121634849" style="zoom:67%;" />

从执行结果可以看出，append无论后面是单个元素还是一个列表，都会把它当成一个新元素追加到原来的列表后面，而extend则会展开，把新列表拆开追加在原来的列表后面。

3. insert()

- 格式：```list_name.insert(index, obj)```
- 参数：list_name代表列表名称；index代表列表的下标，该参数只能为整数；obj代表要插入的元素，元素可以是单个数据，也可以是列表、元素等
- 作用：将元素插入指定的位置

```python
ls = [1,2,3,4]
ls.insert(1,'python')
print(ls)
image-20230711190150403

（三）列表元素的删除

删除列表的值有多重方法，主要的有以下4种方法。

  1. del()

    • 格式：del list_name(index)
    • 参数：list_name代表列表名，index代表下标（可省略）
    • 作用：删除列表中的指定下标的值，如果没有指定下标，则是删除整个变量
    ls = [1, 2, 3, 4]
del ls[0]
print(ls)
del ls
print(ls)
    image-20230711190534346

  2. pop()

    • 格式：list_name.pop(index)
    • 参数：list_name代表列表名；index代表下标（可省略）
    • 作用：删除指定下标的元素，如果没有指定下标，则默认删除最后一个元素
    ls = [1, 2, 3, 4]
ls.pop(0)
print(ls)
ls.pop()
print(ls)
    image-20230711190720313

  3. remove()

    • 格式：list_name.remove(obj)
    • 参数：list_name代表列表名；obj代表需要移除的元素的值，但是需要注意的是，一定要确保obj在列表里，否则会报错
    • 作用：移除列表里面第一次出现的指定值的元素
    ls = [1, 2, 3, 4]
ls.remove(1)
print(ls)
    image-20230711191004521

  4. clear()

    • 格式：list_name.clear()
    • 参数：list_name代表列表名
    • 作用：清除列表所有的元素，但是不删除列表，知识列表为空
    ls = [1, 2, 3, 4]
ls.clear()
print(ls)
    image-20230711191130925

（四）查找元素

  1. index()

    • 格式：list_name.index(obj, start, end)
    • 参数：list_name代表列表名；obj代表要查找的元素的值；start代表开始查找的位置，end代表结束查找的位置，start、end都是非必要选项，如果没有，则代表在整个列表里进行查找（这里的 start,end 也是包头包尾的）
    • 作用：查找元素在列表中的位置，返回值为该元素在列表中第一次出现的下标
    ls = ['H','e','l','l','o','!']
print(ls.index('l'))
print(ls.index('l', 3))
    image-20230711191535106

  2. count()

    • 格式：list_name.count(obj)
    • 参数：list_name代表列表名；obj代表要统计的元素，如果obj不在列表中，则返回0
    • 作用：统计某个元素在列表中出现的次数，返回值为该元素的个数
    ls = ['H','e','l','l','o','!']
print(ls.count('l'))
    image-20230711191903344

（五）列表的排序

  1. sort()

    • 格式：list_name.sort(cmp=None, key=None, reverse=False)
    • 参数：list_name代表列表名；cmp和key参数本章暂不作详细解释，有兴趣的同学可以自行查询；reverse代表是否翻转，默认为不翻转；cmp、key、reverse都是可选参数
    • 作用：对原列表进行排序，不返回新列表。如果指定参数，则使用指定的比较函数进行排序
    • 注意事项：
      • sort()函数是在原内存地址上进行排序，所以sort()函数排序后会直接和原列表进行绑定，会改变原列表的值
      • sort()函数和求最值函数max()、min函数一样，要求带排列对象必须为同一类型，常见就是数字类型和字符串类型（按Unicode码排序）
      • 如果sort()加入了reverse参数（list_name.sort(reverse=True)），其工作原理是首先将列表按照从小到大的顺序进行排序，然后再进行翻转
    ls = [1,2,5,4,3]
ls.sort()
print(ls)

ls.sort(reverse = True)
print(ls)
    image-20230711193002081

  2. sorted()

    • 格式：sorted(iterable, cmp=None, key=None, reverse=False)
    • 参数：iterable为可迭代对象（在列表中即为列表名）；cmp和key参数本章暂不作详细解释，有兴趣的同学可以自行查询；reverse代表是否翻转，默认为不翻转；cmp、key、reverse都是可选参数
    • 作用：对可迭代的对象进行排序操作，会生成新的列表
    • 注意事项：
      • sorted()和sort()一样，对待排序的对象有相同的要求
      • sorted()不是在原内存地址进行排序，是新建一个列表，所以不改变原来的列表值
    ls = [1,2,5,4,3]
new_ls = sorted(ls)
print(ls)
print(new_ls)

new_ls = sorted(ls, reverse = True)
print(new_ls)
    image-20230711193716720

  3. reverse()

    • 格式：list_name.reverse()
    • 参数：list_name 代表列表名
    • 作用：用于翻转列表中的元素
    • 注意事项：
      • reverse()并不进行排序，而是将列表里的元素进行顺序上的前后颠倒
      • reverse()和sort()一样，都是在原列表中进行操作，所以没有返回值，但是会改变原列表的值
posted @ 2023-10-16 11:49  离渊灬  阅读(112)  评论(0)    收藏  举报