Python序列复习

不念不忘少年蓝@ 2023-01-10 11:46 91阅读 0赞

### 目录 ###

*  列表 List
 *   *  切片
 *  序列(sequence)
 *   *  序列的基本操作
     *  可变对象
     *  不可变对象
     *   *  元组 tuple
 *  字典（dict）
 *  集合（set）

# 列表 List #

列表是Python中的一个对象

*  对象（object）就是内存中专门用来存储数据的一块区域
 *  之前我们学习的对象，像数值，它只能保存一个单一的数据
 *  列表中可以保存多个有序的数据
 *  列表是用来存储对象的对象
 *  列表的使用：  
    1.列表的创建  
    2.操作列表中的数据

## 切片 ##

1.  如果索引是负数，则从后向前获取元素，-1表示倒数第一个，-2表示倒数第二个 以此类推
2.  列表\[起始:结束\]

*  通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素
 *  做切片操作时，总会返回一个新的列表，不会影响原来的列表
 *  起始和结束位置的索引都可以省略不写
 *  如果省略结束位置，则会一直截取到最后
 *  如果省略起始位置，则会从第一个元素开始截取
 *  如果起始位置和结束位置全部省略，则相当于创建了一个列表的副本

1.  语法：列表\[起始:结束:步长\]

*  步长表示，每次获取元素的间隔，默认值是1
 *  步长不能是0，但是可以是负数，从列表的后部向前边取元素

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUxMTIzNg_size_16_color_FFFFFF_t_70]

# 序列(sequence) #

*  序列是Python中最基本的一种数据结构
 *  数据结构指计算机中数据存储的方式
 *  序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引）  
    并且序列中的数据会按照添加的顺序来分配索引
 *  序列的分类：  
    可变序列（序列中的元素可以改变）：  
    > 列表（list）  
    不可变序列（序列中的元素不能改变）：  
    > 字符串（str）  
    > 元组（tuple）

## 序列的基本操作 ##

<table> 
 <thead> 
  <tr> 
   <th>操作符</th> 
   <th>用法</th> 
   <th>eg</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>+</td> 
   <td>可以将两个列表拼接为一个列表</td> 
   <td>my_list = [1,2,3] + [4,5,6]</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>可以将列表重复指定的次数</td> 
   <td>my_list = [1,2,3] * 5</td> 
  </tr> 
  <tr> 
   <td>in 和 not in</td> 
   <td>用来检查指定元素是否存在于列表中</td> 
   <td>print(‘22’ in stus)</td> 
  </tr> 
  <tr> 
   <td>len()</td> 
   <td>获取列表中的元素的个数</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>min()</td> 
   <td>获取列表中的最小值</td> 
   <td>arr = [10,1,2,5,100,77] print(min(arr) )</td> 
  </tr> 
  <tr> 
   <td>max()</td> 
   <td>获取列表中的最大值</td> 
   <td>arr = [10,1,2,5,100,77] print(max(arr)）</td> 
  </tr> 
  <tr> 
   <td>s.index()</td> 
   <td>获取指定元素在列表中的第一次出现时索引 ,第二个参数，表示查找的起始位置 ， 第三个参数，表示查找的结束位置</td> 
   <td>print(stus.index(‘黄’,3,7))</td> 
  </tr> 
  <tr> 
   <td>s.count()</td> 
   <td>统计指定元素在列表中出现的次数</td> 
   <td>print(stus.count(‘王’))</td> 
  </tr> 
 </tbody> 
</table>

## 可变对象 ##

*  每个对象中都保存了三个数据：  
    id（标识）  
    type（类型）  
    value（值）
 *  列表就是一个可变对象  
    a = \[1,2,3\]
 *  a\[0\] = 10 （改对象）  
    \- 这个操作是在通过变量去修改对象的值  
    \- 这种操作不会改变变量所指向的对象  
    \- 当我们去修改对象时，如果有其他变量也指向了该对象，则修改也会在其他的变量中体现
 *  a = \[4,5,6\] （改变量）  
    \- 在给变量重新赋值  
    \- 会改变变量**所指向的对象**  
    \- 为一个变量重新赋值时，不会影响其他的变量

一般只有在为变量赋值时才是修改变量，其余的都是修改对象

## 不可变对象 ##

### 元组 tuple ###

1.  使用()来创建元组
2.  当元组不是空元组时，括号可以省略；
3.  如果元组不是空元组，它里边至少要有一个,

my_tuple1 = ()
    my_tuple1 = (1,2,3,4)
    my_tuple2 = 1,2,3,4
    my_tuple3 = 1,

1.  在对一个元组进行解包时，变量的数量必须和元组中的元素的数量一致  
    也可以在变量前边添加一个\*，这样变量将会获取元组中所有剩余的元素,**不能同时出现两个或以上的\*变量**

a , b , *c = my_tuple
    a , *b , c = my_tuple
    *a , b , c = my_tuple
    print(a,b,c)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUxMTIzNg_size_16_color_FFFFFF_t_70 1]

# 字典（dict） #

*  字典属于一种新的数据结构，称为映射（mapping） 字典的作用和列表类似，都是用来存储对象的容器
 *  在字典中每一个元素都有一个唯一的名字，通过这个唯一的名字可以快速的查找到指定的元素，键值对（key-value）结构
 *  每个字典中都可以有多个键值对，而每一个键值对我们称其为一项（item）

<table> 
 <thead> 
  <tr> 
   <th>API</th> 
   <th>用法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>{}</td> 
   <td>d1={‘a’:69,‘v’:88} 或者 dict ={}</td> 
  </tr> 
  <tr> 
   <td>dict()</td> 
   <td>d2 = dict(name=“haha”,age=“gg”)</td> 
  </tr> 
  <tr> 
   <td>[双值子序列]</td> 
   <td>print(‘双值’,‘ab’,’[c,d]’,(‘a’,3) ,print(‘子序列’,[(1,2),(23,5,3),‘ab’,[1,2]] ,print(‘双值子序列’,[(1,2),(2,3),‘ab’,[1,2] ) , d3 = dict([(“text”,2),(‘a’,‘b’),‘gb’,<a rel="nofollow">1,22</a>]) print(d3[‘g’])</td> 
  </tr> 
  <tr> 
   <td>len()</td> 
   <td>获取字典中的值，根据键来获取值</td> 
  </tr> 
  <tr> 
   <td>d[key]</td> 
   <td>d[‘age’]) ,如果键不存在，会抛出异常 KeyError</td> 
  </tr> 
  <tr> 
   <td>not in ,in</td> 
   <td>检查字典中是否不包含指定的键,是否包含指定的键</td> 
  </tr> 
  <tr> 
   <td>get(key[, default])</td> 
   <td>如果获取的键在字典中不存在，会返回None ; 也可以指定一个默认值，来作为第二个参数，这样获取不到值时将返回默认值</td> 
  </tr> 
  <tr> 
   <td>d[key] = value</td> 
   <td>如果key存在则覆盖，不存在则添加</td> 
  </tr> 
  <tr> 
   <td>setdefault(key[, default])</td> 
   <td>如果key已经存在于字典中，则返回key的值，不会对字典做任何操作 ; 如果key不存在，则向字典中添加这个key，并设置value</td> 
  </tr> 
  <tr> 
   <td>update([other])</td> 
   <td>d = {‘a’:1,‘b’:2,‘c’:3} d2 = {‘d’:4,‘e’:5,‘f’:6, ‘a’:7 d.update(d2)</td> 
  </tr> 
  <tr> 
   <td>del d[‘a’]</td> 
   <td>删除，可以使用 del 来删除字典中的 key-value</td> 
  </tr> 
  <tr> 
   <td>popitem()</td> 
   <td>随机删除字典中的一个键值对，一般都会删除最后一个键值对 ,会将删除的key-value(一个元组)作为返回值返result=d.popitem()</td> 
  </tr> 
  <tr> 
   <td>pop(key[, default])</td> 
   <td>如果删除不存在的key，会抛出异常,result = d.pop(‘d’) ;如果指定了默认值，再删除不存在的key时，不会报错，而是直接返回默认值</td> 
  </tr> 
  <tr> 
   <td>clear()</td> 
   <td>用来清空字典</td> 
  </tr> 
  <tr> 
   <td>copy()</td> 
   <td>法用于对字典进行浅复制,浅复制会简单复制对象内部的值，如果值也是一个可变对象，这个可变对象不会被复制</td> 
  </tr> 
  <tr> 
   <td>values()</td> 
   <td>for value in d10.values(): print(value,end=’-----’)</td> 
  </tr> 
  <tr> 
   <td>keys()</td> 
   <td>for key in d10.keys(): print(key,end=’-----’)</td> 
  </tr> 
  <tr> 
   <td>items()</td> 
   <td>for k,v in d10.items():print(k,’-----’,v)</td> 
  </tr> 
 </tbody> 
</table>

# 集合（set） #

<table> 
 <thead> 
  <tr> 
   <th>API</th> 
   <th>用法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>set()</td> 
   <td>空集合，将序列和字典转换为集合(只会包含字典中的键)</td> 
  </tr> 
  <tr> 
   <td>{…}</td> 
   <td>s = {10,3,5,1,2,1,2,3,1,1,1,1}</td> 
  </tr> 
  <tr> 
   <td>in和not in</td> 
   <td>检查集合中的元素</td> 
  </tr> 
  <tr> 
   <td>len()</td> 
   <td>获取集合中元素的数量</td> 
  </tr> 
  <tr> 
   <td>add()</td> 
   <td>s.add(10)</td> 
  </tr> 
  <tr> 
   <td>update()</td> 
   <td>将一个集合中的元素添加到当前集合中</td> 
  </tr> 
  <tr> 
   <td>pop()</td> 
   <td>随机删除并返回一个集合中的元素</td> 
  </tr> 
  <tr> 
   <td>remove()</td> 
   <td>删除集合中的指定元素</td> 
  </tr> 
  <tr> 
   <td>clear()</td> 
   <td>清空集合</td> 
  </tr> 
  <tr> 
   <td>copy()</td> 
   <td>对集合进行浅复制</td> 
  </tr> 
  <tr> 
   <td>&amp;</td> 
   <td>交集运算</td> 
  </tr> 
  <tr> 
   <td><code>|</code></td> 
   <td>并集运算</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>差集</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>异或集 获取只在一个集合中出现的元素</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>检查一个集合是否是另一个集合的子集</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>检查一个集合是否是另一个集合的真子集</td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>检查一个集合是否是另一个的超集</td> 
  </tr> 
  <tr> 
   <td>&gt;</td> 
   <td>检查一个集合是否是另一个的真超集</td> 
  </tr> 
 </tbody> 
</table>

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUxMTIzNg_size_16_color_FFFFFF_t_70]: /images/20221119/a6b6e90909dd4def91ffc349feba4e83.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUxMTIzNg_size_16_color_FFFFFF_t_70 1]: /images/20221119/69f629ee0d4743fbb944a54a96d3b47b.png