学习笔记Markdown 知识库

1. 列表（list）

1.1 基本用法

  1. 列表是Python中的一个对象；列表是用来存储对象的对象；
  2. 对象（object）就是内存中专门用来存储数据的一块区域；
  3. 列表中可以保存多个有序的数据；列表中的对象都会按照插入的顺序存储到列表中；
  4. 通过索引（index）来获取列表中的元素；索引是从0开始的整数，列表第一个位置索引为0；
  • 语法：my_list[索引]；如果使用的索引超出最大范围，会抛出异常；
  1. 可以通过len()函数获取列表的长度；获取到的长度的值，是列表的最大索引 + 1；

1.2 切片（slice）

  1. 切片指从现有列表中，获取一个子列表；
  2. 列表的索引可以是负数；如果索引是负数，则从后向前获取元素，-1表示倒数第一个，-2表示倒数第二个，以此类推；
  3. 基本语法：列表[起始:结束]；
  4. 通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素，即前闭后开区间；
  5. 做切片操作时，总会返回一个新的列表，但不会影响原来的列表；
  6. 起始和结束位置的索引都可以省略不写；如果省略结束位置，则会一直截取到最后；如果省略起始位置，则会从第一个元素开始截取；如果起始位置和结束位置全部省略，则相当于创建了一个列表的副本；
  7. 带步长的切片语法：列表[起始:结束:步长]；
  8. 步长表示每次获取元素的间隔，默认值是1；
  9. 如果步长是负数，则会从列表的后部向前边取元素；
  10. 例如：print(stus[::-1])会将返回列表的倒序排列；

1.3 通用操作

  1. + 将两个列表拼接为一个列表；例如： my_list = [1,2,3] + [4,5,6]；
  2. * 将列表重复指定的次数；例如：my_list = [1,2,3] * 5；
  3. in 用来检查指定元素是否存在于列表中；如果存在，返回True，否则返回False；
  4. not in 用来检查指定元素是否不在列表中；如果不在，返回True，否则返回False；
  5. len() 获取列表中的元素的个数；
  6. min() 获取列表中的最小值；
  7. max() 获取列表中的最大值；
  8. 方法（method）：方法和函数基本上是一样，只不过方法必须通过 对象.方法() 的形式调用；
  9. s.count() 统计指定元素在列表中出现的次数；
  10. 列表.index(元素) 获取指定元素在列表中的第一次出现时索引；
  11. index(元素,i,j) 中的第二个参数（可选）， i表示查找的起始位置 ， 第三个参数（可选）j，表示查找的结束位置；如果要获取列表中没有的元素，会抛出异常，ValueError: 'xxx' is not in list，看一个例子就很好理解了：

通用操作，👉官方文档：

1.4 序列（sequence）

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

1.5 修改元素

  1. 修改列表中的元素，直接通过索引来修改元素；例如：sixology_info[12] = '孙悟空扛着金箍棒正在赶来的路上'；

  2. 通过del来删除元素，例如：del sixology_info[4]，就把列表中索引为4的元素删除了，刚才的语句把 国际巨星 删除了；同样可以使用带步长的删除元素操作：del sixology_info[::2]，该语句将隔一个删除一个元素，为了保证六学的信息完整，因此我并没有运行该语句；

  3. 通过切片来修改列表；在给切片进行赋值时，只能使用序列；

  4. 当设置了步长时，序列中元素的个数必须和切片中元素的个数一致；

  5. 可以通过 list()函数将其他的序列转换为list；例如：six_young_boy_other_film = ‘《吴承恩与西游记》’，–> six_young_boy_other_film = list(six_young_boy_other_film) 可实现字符串到列表的转换；

1.6 列表（list）的方法

👉官方文档：

  1. .append() 向列表的最后添加一个元素；
  2. .insert(位置，元素) 向列表的指定位置插入一个元素；注意使用索引插入与该函数插入的区别：使用索引插入相当于改变索引位置的元素，而insert()函数，是插入一个元素，原来索引位置的元素后移，即索引+1；
  3. .extend() 使用新的序列来扩展当前序列，需要一个序列作为参数，它会将该序列中的元素添加到当前列表中；相当于 += 运算；
  4. .clear() 清空序列；
  5. .pop(索引) 根据索引删除，并且会返回被删除的元素；如果索引不写，默认删除最后一个；
  6. .remove(值) 删除指定值的元素，如果相同值的元素有多个，默认只会删除第一个；
  7. .reverse() 用来反转列表；
  8. .sort() 用来对列表中的元素进行排序，默认是升序排列； 如果需要降序排列，则需要传递一个 reverse=True作为参数；

1.7 range

  1. range() 是一个函数，可以用来生成一个自然数的序列；
  2. 该函数需要三个参数：>1.起始位置（可以省略，默认是0）；>2.结束位置；>3.步长（可以省略，默认是1）；
  3. 通过range()可以创建一个执行指定次数的for循环，for()循环除了创建方式以外，其余的都和while一样，包括else、包括break continue都可以在for循环中使用，并且for循环使用也更加简单。

2. 元组（tuple）

2.1 元组

  1. 元组是一个不可变的序列，它的操作的方式基本上和列表是一致的；
  2. 一般当我们希望数据不改变时，就使用元组，其余情况都使用列表；
  3. 使用()来创建元组；例如my_tuple = () 创建了一个空元组；
  4. 元组是不可变对象，不能尝试为元组中的元素重新赋值；
  5. 例如：my_tuple[6] = '孙悟空' 出错：TypeError: 'tuple' object does not support item assignment；
  6. 当元组不是空元组时，括号可以省略；如果元组不是空元组，它里边至少要有一个，my_tuple = 10,20
  7. 元组的解包（解构）：解包指就是将元组当中每一个元素都赋值给一个变量；
  8. 交换a 和 b的值，这时我们就可以利用元组的解包：a , b = b , a；
  9. 在对一个元组进行解包时，变量的数量必须和元组中的元素的数量一致；也可以在变量前边添加一个*，这样变量将会获取元组中所有剩余的元素；a , b , *c = my_tuple；
  10. 不能同时出现两个或以上的*变量，例如：*a , *b , c = my_tuple报错：SyntaxError: two starred expressions in assignment；

2.2 可变对象

  1. 每个对象中都保存了三个数据： 1）id（标识）； 2）type（类型）； 3）value（值） ；

可变对象指的是值可变。

  1. 列表就是一个可变对象 a = [1,2,3]
  1. a[0] = 10（改对象）；
  2. 该操作是在通过变量去修改对象的值；
  3. 这种操作不会改变变量所指向的对象；
  4. 当我们去修改对象时，如果有其他变量也指向了该对象，则修改也会在其他的变量中体现； a = [4,5,6] （改变量）
  5. 该操作是在给变量重新赋值；
  6. 这种操作会改变变量所指向的对象；
  7. 为一个变量重新赋值时，不会影响其他的变量；
  8. 一般只有在为变量赋值时才是修改变量，其余的都是修改对象；

2.3 is 和 ==

  • == != 比较的是对象的值是否相等 ； is is not 比较的是对象的id是否相等（比较两个对象是否是同一个对象）；
a = [1,2,3]
b = [1,2,3]
print(a,b)
print(id(a),id(b))
print(a == b) # a和b的值相等，使用==会返回True
print(a is b) # a和b不是同一个对象，内存地址不同，使用is会返回False

3. 字典（dict）

  • 字典属于一种新的数据结构，称为映射（mapping）；
  • 字典的作用和列表类似，都是用来存储对象的容器；
  • 列表存储数据的性能很好，查询元素效率非常快，但是查询数据的性能的很差；
  • 字典中可以保存多个对象，每个对象都会有一个唯一的名字，称其为键（key），通过key可以快速的查询值（value）；即键值对（key-value）结构；每个字典中都可以有多个键值对，而每一个键值对我们称其为一项（item）；

3.1 基本用法

  1. 使用 {} 来创建字典，d = {} 创建了一个空字典；
  2. 字典的值可以是任意对象，字典的键可以是任意的不可变对象（int、str、bool、tuple …），但是一般我们都会使用str；
  3. 字典的键是不能重复的，如果出现重复的后边的会替换到前边的；
  4. 需要根据键来获取值；print(d['name'],d['age'],d['gender'])；
  5. 如果使用了字典中不存在的键，会报错：print(d['hello']) KeyError: 'hello'；
  • 也可以将一个包含有双值子序列的序列转换为字典；
  • 双值序列，序列中只有两个值，[1,2] ('a',3) 'ab'；
  • 子序列，如果序列中的元素也是序列，那么我们就称这个元素为子序列；d = dict([('name','孙悟空'),('age',18)])；

3.2 字典的使用

  1. len(字典) 获取字典中键值对的个数；
  2. in 检查字典中是否包含指定的键；not in 检查字典中是否不包含指定的键；
  3. 获取字典中的值，根据键来获取值；语法：d[key]；通过[ ]来获取值时，如果键不存在，会抛出异常 KeyError；
  4. .get(key[, default]) 方法用来根据键来获取字典中的值；如果获取的键在字典中不存在，会返回None；也可以指定一个默认值，来作为第二个参数，这样获取不到值时将会返回默认值；print(d.get('name'))；
  5. 修改字典：d[key] = value 如果key存在则覆盖，不存在则添加；
  6. setdefault(key[, default])可以用来向字典中添加key-value；如果key已经存在于字典中，则返回key的值，不会对字典做任何操作；如果key不存在，则向字典中添加这个key，并设置value；
  7. .update([other])；将其他的字典中的key-value添加到当前字典中；如果有重复的key，则后边的会替换到当前的；
  8. 删除，可以使用 del 来删除字典中的 key-value；
  9. .popitem()随机删除字典中的一个键值对，一般都会删除最后一个键值对；删除之后，它会将删除的key-value作为返回值返回；返回的是一个元组，元组中有两个元素，第一个元素是删除的key，第二个是删除的value；当使用.popitem()删除一个空字典时，会抛出异常 KeyError: 'popitem(): dictionary is empty'；
  10. .clear() 方法用来清空字典；
  11. .copy()方法用于对字典进行浅复制；复制以后的对象，和原对象是独立，修改一个不会影响另一个；注意，浅复制会简单复制对象内部的值，如果值也是一个可变对象，这个可变对象不会被复制；

3.3 遍历字典

  1. .keys() 方法会返回字典的所有的key；该方法会返回一个序列，序列中保存有字典的所有的键；
  2. 通过遍历.keys()来获取所有的键：
for k in d.keys() :
 print(k , d[k])
  1. .values() 方法会返回一个序列，序列中保存有字典的左右的值；
for v in d.values():
 print(v)
  1. .items() 方法会返回字典中所有的项，它会返回一个序列，序列中包含有双值子序列；双值分别是，字典中的key和value；

4.集合（set）

  • 集合和列表非常相似
  • 不同点： 1.集合中只能存储不可变对象； 2.集合中存储的对象是无序（不是按照元素的插入顺序保存）； 3.集合中不能出现重复的元素；

4.1 基本使用

  1. 使用 {}来创建集合；
s = {10,3,5,1,2,1,2,3,1,1,1,1} # <class 'set'>
# s = {[1,2,3],[4,6,7]} TypeError: unhashable type: 'list'
  1. 使用 set() 函数来创建集合；s = set() 创建了一个空集合；
  2. 可以通过 set() 来将序列和字典转换为集合：
s = set([1,2,3,4,5,1,1,2,3,4,5])
s = set('hello')
s = set({'a':1,'b':2,'c':3}) # 使用set()将字典转换为集合时，只会包含字典中的键
  1. 使用 in 和 not in 来检查集合中的元素；
  2. 使用 len() 获取集合中元素的数量；
  3. .update() 方法将一个集合中的元素添加到当前集合中；.update() 可以传递序列或字典作为参数，字典只会使用键；
  4. .pop() 方法随机删除并返回一个集合中的元素；
  5. .remove() 方法删除集合中的指定元素；
  6. .clear() 方法清空集合；
  7. .copy() 方法对集合进行浅复制；

4.2 集合的运算

  • 在对集合做运算时，不会影响原来的集合，而是返回一个运算结果；
# 创建两个集合
s = {1,2,3,4,5}
s2 = {3,4,5,6,7}

# & 交集运算
result = s & s2 # {3, 4, 5}

# | 并集运算
result = s | s2 # {1,2,3,4,5,6,7}

# - 差集
result = s - s2 # {1, 2}

# ^ 异或集 获取只在一个集合中出现的元素
result = s ^ s2 # {1, 2, 6, 7}

# <= 检查一个集合是否是另一个集合的子集
# 如果a集合中的元素全部都在b集合中出现，那么a集合就是b集合的子集，b集合是a集合超集
a = {1,2,3}
b = {1,2,3,4,5}

result = a <= b # True
result = {1,2,3} <= {1,2,3} # True
result = {1,2,3,4,5} <= {1,2,3} # False

# < 检查一个集合是否是另一个集合的真子集
# 如果超集b中含有子集a中所有元素，并且b中还有a中没有的元素，则b就是a的真超集，a是b的真子集
result = {1,2,3} < {1,2,3} # False
result = {1,2,3} < {1,2,3,4,5} # True

# >= 检查一个集合是否是另一个的超集
# > 检查一个集合是否是另一个的真超集
print('result =',result)