【Python】序列类型①-列表

Love The Way You Lie 2023-09-27 17:56 133阅读 0赞

#### 文章目录 ####

*  1. 前言
 *  2. 列表的定义
 *  3. 列表的下标访问
 *   *  3.1 嵌套列表的下标
 *  4. 列表的切片操作
 *  5. 列表的遍历
 *   *  5.1 使用for循环进行遍历
     *  5.2 while循环进行遍历
 *  6.添加列表元素
 *   *  6.1 使用append方法添加元素
     *  6.2 使用insert方法添加元素
 *  7. 列表的拼接
 *   *  7.1 使用 + 进行拼接
     *  7.2 使用extend 进行拼接
     *  7.3 使用 += 进行拼接
 *  8. 列表的常用方法

## 1. 前言 ##

序列是一块用来存放多个值的内存空间.Python中常用的数据结构有列表,元组,字典,字符串,集合等. 本篇文章主要讲解列表的常见操作.

## 2. 列表的定义 ##

> 列表是python中内置的`可变序列`,是包含若干元素的有序连续内存空间  
> 所有的元素存放在 \[\] 中  
> 元素之间用逗号隔开

列表的定义有两种方式:

1.  `使用字面值创建列表`
2.  `使用list()创建列表`

实例：

# 使用使用字面值创建列表
    # []就代表一个空列别
    a = []
    print(type(a))
    
    # 使用list()创建列表
    b = list()
    print(type(b))
    
    # 输出的结果为：
    # <class 'list'>
    # <class 'list'>

**列表可以在定义时进行初始化**，但与C/Java等里面的数组不同的是，**数组只能放同一类型的变量**，例如整型数组就只能放整数类型的元素，而列表不同，列表可以存放不同数据类型的元素  
示例：

a = [1,2,3]
    print(a)
    # 输出[1, 2, 3]
    
    b = list((1,2,3))
    print(b)
    # 输出[1, 2, 3]
    
    c = [1,1.2,"ads",False,[1,2,3]];#也可以存放列表的数据
    print(c)
    # 输出[1, 1.2, 'ads', False, [1, 2, 3]]

## 3. 列表的下标访问 ##

对列表的元素，可以通过 列表名\[下标\] 这种形式进行访问  
`注意：这里的下标都是从0开始的 ，下标的有效范围是0到列表长度-1`  
如果超出下标的有效范围，那么就会出现异常  
`列表的长度可以直接使用内置函数len(列表名)获取`  
len()不止能求列表的长度，也可以求字符串、元组、字典等这个类型的长度

# 下标的范围[0,2]
    a = [1,2,3]
    print(len(a))
    # 输出结果：3
    print(a[1]) #对列表的元素进行访问
    # 输出结果：2
    a[2] = 5 #对列表的元素进行修改
    print(a)
    # 输出结果：[1, 2, 5]

python中的下标也可以写成**负数**的形式

a = [1,2,3]
    print(a[len(a)-1])
    # 输出结果：3
    print(a[-1])
    # 输出结果：3

对于**这里面的-1可以理解为len(列表名)-1把len(列表名)这个给省略了，也可以理解为是倒数第一个元素**，只要能记住，大家怎么理解都行  
如果是用**负数**表示下标，那么下标的有效范围就是\[-len(列表名)，-1\]

### 3.1 嵌套列表的下标 ###

在讲列表定义的时候说过列表的元素类型不限制,当然也就可以在列表中存放列表  
示例:

a = [[1, 2, 3], [4, 5, 6]]

对于这种列表里面是嵌套的列表,也是支持下标索引的  
例如:

a = [[1, 2, 3], [4, 5, 6]]
    print(a[0][1])
    # 输出结果:
    # 2

上面的代码可以分成两步进行理解:

1.  可以把\[1,2,3\]和\[4,5,6\]看出是a列表中的两个元素,a\[0\]就是得到\[1,2,3\]这个列表
2.  a\[0\]\[1\]就相当于访问了\[1,2,3\]这个列表的第二个元素,所以输出结果为2

## 4. 列表的切片操作 ##

切片操作使Python中有序序列的重要操作之一. 切片操作的本质上是截取一段子序列.

语法格式为: [start: stop: step]
     start: 切片的开始位置
     stop: 切片的结束位置(但不包含这个位置)
     step: 切片的步长,步长可以省略时默认是1,如果是省略可以顺便省略最后一个冒号

示例1:

a = [1, 2, 3, 4, 5, 6, 7]
    print(a[2:5])
    
    # 输出结果:
    [3, 4, 5]

列表的下标从0开始,因此下标为2的值为3,5下标的值是6,因为是不包含5这个下标的,且默认的步长为1,因此切片出来的值为\[3,4,5\].  
切片操作是很灵活的,除了步长可以省略,前面的两个表示范围的数字也是可以省略的

示例2:

a = [1, 2, 3, 4, 5, 6, 7]
    print(a[:])
    # [1, 2, 3, 4, 5, 6, 7]
    print(a[3:])
    # [4, 5, 6, 7]
    print(a[:3])
    # [1, 2, 3]
    print(a[:-1])
    # [1, 2, 3, 4, 5, 6]

*  当前面两个数都省略时,表示的就是整个列表.
 *  省略结束位置,就是从开始位置一直到列表结束
 *  省略开始位置,就是从0下标一直到结束位置(不包括结束位置)
 *  切片操作中的位置也可以写成负数形式

示例3:  
带有步长的切片

a = [1, 2, 3, 4, 5, 6, 7]
    print(a[::2])
    #[1, 3, 5, 7]

步长除了取整数,也可以是负数.如果步长为负数则代表是从后往前取.

a = [1, 2, 3, 4, 5, 6, 7]
    print(a[::-1])
    # [7, 6, 5, 4, 3, 2, 1]

需要注意的是与下标访问列表元素不同,切片操作不会因为下标越界而抛出异常.而是尽可能地获取到所需要的元素  
示例4:

a = [1, 2, 3, 4, 5, 6, 7]
    print(a[:100])
    # [1, 2, 3, 4, 5, 6, 7]

虽然上面我想要获取的列表元素是a列表下标从0开始到100位置(不包括100)之间的元素,但a列表的长度是远远不够100的,所以在进行切片时,在a列表的尾部时就进行截断了.因此使用切片操作可以使代码具有更强的健壮性

## 5. 列表的遍历 ##

### 5.1 使用for循环进行遍历 ###

使用for循环遍历列表有两种方式  
方法1:

a = [1, 2, 3]
    for elem in a:
        print(elem)
    
    # 1
    # 2
    # 3

上述代码中,elem相当于使一个临时变量,值就是a列表中的每一个元素  
方法2:

a = [1, 2, 3]
    
    for i in range(len(a)):
        print(a[i])
    
    # 1
    # 2
    # 3

### 5.2 while循环进行遍历 ###

a = [1, 2, 3]
    i = 0
    while i < len(a):
        print(a[i])
        i += 1
    
    # 1
    # 2
    # 3

## 6.添加列表元素 ##

在列表中新增元素有两种方式,一种是 使用append方法,另一种是使用insert方法

### 6.1 使用append方法添加元素 ###

append方法是往列表的末尾新增元素,使用的方法很简单

> 语法: 列表名.append(新增元素)

a = [1, 2, 3]
    a.append(4)
    print(a)
    # [1, 2, 3, 4]

### 6.2 使用insert方法添加元素 ###

与append方法不同,insert方法可以往指定位置新增元素.

a = [1, 2, 3]
    a.insert(1, 'insert')
    print(a)
    # [1, 'insert', 2, 3]

需要注意的是,如果指定的位置超过了列表的长度,只会插入列表的末尾

a = [1, 2, 3]
    a.insert(100, 'insert')
    print(a)
    # [1, 2, 3, 'insert']

## 7. 列表的拼接 ##

### 7.1 使用 + 进行拼接 ###

a = [1, 2, 3]
    b = [4, 5, 6]
    c = a + b
    print(c)
    # [1, 2, 3, 4, 5, 6]

使用 + 拼接本质上是产生了一个更大的列表,不会修改原来的列表

### 7.2 使用extend 进行拼接 ###

extend 是在原有的列表基础上将另外一个列表进行拼接. 这个方法会修改原来的列表

a = [1, 2, 3]
    b = [4, 5, 6]
    a.extend(b)
    print(a)
    # [1, 2, 3, 4, 5, 6]

### 7.3 使用 += 进行拼接 ###

a = [1, 2, 3]
    b = [4, 5, 6]
    a += b
    print(a)
    # [1, 2, 3, 4, 5, 6]

## 8. 列表的常用方法 ##

以下是列表中一些常用的内置函数:

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>列表名.append(x)</td> 
   <td>将元素x添加到列表的最后位置</td> 
  </tr> 
  <tr> 
   <td>列表名.extend(L)</td> 
   <td>将列表L中的所有元素添加到列表的尾部</td> 
  </tr> 
  <tr> 
   <td>列表名.insert(index,x)</td> 
   <td>在列表的index位置插入元素x</td> 
  </tr> 
  <tr> 
   <td>列表名.remove(x)</td> 
   <td>在列表中删除首次出现的元素x</td> 
  </tr> 
  <tr> 
   <td>列表名.pop([index])</td> 
   <td>删除并返回列表对象的指定位置的元素,默认为最后一个元素</td> 
  </tr> 
  <tr> 
   <td>列表名.clear()</td> 
   <td>删除列表中所有元素,但保留列表对象</td> 
  </tr> 
  <tr> 
   <td>列表名.index(x)</td> 
   <td>返回第一个值为x的元素下标,做不存在x,则抛出异常</td> 
  </tr> 
  <tr> 
   <td>列表名.count(x)</td> 
   <td>返回指定元素x在列表中的个数</td> 
  </tr> 
  <tr> 
   <td>列表名.reverse()</td> 
   <td>对列表元素进行原地翻转</td> 
  </tr> 
  <tr> 
   <td>列表名.sort(key=None,reverse=False)</td> 
   <td>对列表元素进行原地排序</td> 
  </tr> 
  <tr> 
   <td>列表名.copy()</td> 
   <td>对列表元素进行浅拷贝</td> 
  </tr> 
  <tr> 
   <td>len(列表名)</td> 
   <td>统计列表中元素的个数</td> 
  </tr> 
 </tbody> 
</table>

> 感谢你的观看!希望这篇文章能帮到你!  
> [python专栏][python]在不断更新中,欢迎订阅!  
> “愿与君共勉,携手共进!”  
> ![在这里插入图片描述][8fbf2a7f2d0e4db782e58035677a303d.png_pic_center]

[python]: https://blog.csdn.net/m0_63463510/category_12243628.html
[8fbf2a7f2d0e4db782e58035677a303d.png_pic_center]: https://img-blog.csdnimg.cn/8fbf2a7f2d0e4db782e58035677a303d.png#pic_center