这一部分大纲围绕着，字符串、列表、元组、字典这四大可迭代序列来描述。
列表
1. 介绍
- 利用range()创建列表
temp = list(range(10, 1, -2))
# 从10到1的，间隔2数的列表
empty = []
# 空列表
- 利用推导式创建列表
x = [0] * 5
print(x, type(x))
# [0,0,0,0,0] <class list>
# 注意这是一个列表哦,而且类似于extend，而不是append
# 不是这样[[0],[0],[0],[0],[0]]
a = [0] * 3 # [0,0,0]
x = [a] * 4 # [[0,0,0]] * 4
print(x, type(x))
# x =[[0,0,0],[0,0,0],[0,0,0],[0,0,0]] <class list>
print(8* [0,0,0]) #相当于空列表 []append 8个列表
# [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
注意：
-
由于list的元素可以是任何对象，因此列表中所保存的是对象的指针。即使保存一个简单的
[1,2,3]，也有3个指针和3个整数对象。 -
x = [a] * 4操作中，只是创建4个指向list的引用，所以一旦a改变，x中4个a也会随之改变。 -
列表的元素是可变的
2. 基本方法
已知：
x = [‘Monday’, ‘Tuesday’, ‘Wednesday’, ‘Thursday’, ‘Friday’]
| 方法名 | 含义 | 举例 | 结果 |
|---|---|---|---|
| append | 添加单个元素 | x.append([‘123’,’456’]) | [‘Monday’, ‘Tuesday’, ‘Wednesday’, ‘Thursday’, ‘Friday’, [‘123’,’456’]] |
| extend | 将另一个序列的所有值加入(类似于Java的addAll) | x.extend([‘123’,’456’]) | [‘Monday’, ‘Tuesday’, ‘Wednesday’, ‘Thursday’, ‘Friday’, ‘123’,’456’] |
| insert | 将元素插入到指定位置 | x.insert(2,’123’) | [‘Monday’, ‘Tuesday’, ‘123’, ‘Wednesday’, ‘Thursday’, ‘Friday’] |
| remove | 移除列表中某个值的第一个匹配项 | x.remove(‘Monday’) | [‘Tuesday’, ‘Wednesday’, ‘Thursday’, ‘Friday’] |
| pop | list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
y = x.pop(0) | print(y) # Monday |
删除多个元素使用:
del x[0:2]
print(x) # 剩下的元素 x[2:]
获取元素
print(x[0])
print(x[2:])
print(x[-1])
print(x[:3:1])
# 切片的通用写法是 start : stop : step
注意：
append是追加，把一个东西整体添加在列表后，而extend是扩展，把一个东西里的所有元素添加在列表后。- remove和pop的区别：
remove和pop都可以删除元素，前者是指定具体要删除的元素，后者是指定一个索引。
【举例】请将列表x=[‘Monday’, ‘Tuesday’, ‘Wednesday’, ‘Thursday’, ‘Friday’],按照倒叙排列
print(x[::-1]) # 即x[0:len(x):-1]
# 切片的通用写法是 start : stop : step
# 如果start是0，stop是最后一个，可以省略，所以变成了x[:]
# 步长为-1，即从最后一个数开始往回找
3. 浅拷贝和深拷贝
list1 = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
list2 = list1 # 浅拷贝,如果list1的元素发生改变，那么list2也会跟着变动
list3 = list1[:] # 深拷贝，不会发生变动
# 当我们希望改变列表中的元素，而不影响原列表的时候，就使用深拷贝
4. 列表中的常用操作符
- 等号操作符：
== - 连接操作符
+# extend() - 重复操作符
*# x = a * 3 - 成员关系操作符
in、not in
注意：
append, extend, insert可对列表增加元素，它们没有返回值，是直接修改了原数据对象
而将两个list相加，需要创建新的 list 对象，从而需要消耗额外的内存;所以建议使用extend
5. 额外方法
list.count(obj) # 统计某个元素在列表中的次数
list.index(obj,0) # 返回元素出现的第一个位置,0是start开始位置
list.index(obj,3, 7) # 返回元素出现的第一个位置，从下标3到7
list.reverse() # 反向列表中元素 [::-1]
list.sort(key=None, reverse=False) # 对原列表进行排序。默认为False，升序
【例题】马上分寝室了，请根据姓名进行正序排列来分寝室；请根据年龄排序来查看年龄分布情况。
# list=[(名称，年龄)，..]
list1 = [('张三',23),('李四',24),('王五',25),('赵六',26),('孙七',27),('周八',28),('吴九',29),('郑十',30)]
# 根据姓名进行排序，第一种：自己写一个方法
# list1中每一个元素都是一个元组
def get_elem_one(name_age_tuple):
return name_age_tuple[0]
# 分寝室
list1.sort(key=get_elem_one,reverse=True)
print(list1)
# 查看年龄分布
list1.sort(key=lambda x:x[1])
print(list1)
元组
元组一旦创建，就不允许进行修改了，就像str
t1 = (1, 10.31, 'python')
t2 = 1, 10.31, 'python'
# 以上两个都是元组哦！！！
获取元素的用法和列表完全相同，也可以进行切片
注意：
- 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。
x = (1)
# print(type(x)) <class 'int'>
x = ()
# print(type(x)) <class 'tuple'>
x = (1,)
# print(type(x)) <class 'tuple'>
print(8 * (8)) # 64
print(8 * (8,)) # (8, 8, 8, 8, 8, 8, 8, 8)
print(4 * (8,6)) # (8, 6, 8, 6, 8, 6, 8, 6)
print(4 * ((8,6))) # (8, 6, 8, 6, 8, 6, 8, 6)
print(4 * [[8,6]]) # [[8, 6], [8, 6], [8, 6], [8, 6]]
# 列表和元组这里是有区别的哦
元组是不可更改的,但是元组的元素如果是可变的，那么该元素就可变
同时，可以以深拷贝的方式重新创建一个新的元组
week = ('Monday', 'Tuesday', 'Thursday', ['Friday','Saturday', 'Sunday'])
week[2] = 'Wednesday'
# TypeError: 'tuple' object does not support item assignment
week[3][0] = '123' # 正常执行
week = week[:2] + ('Wednesday',) + week[2:]
# 注意哦，因为前后都是元组，+的自然也是元组，所以必须要打括号，而且因为是一个元素，必须加上逗号
1. 基本方法：
t = (1, 10.31, 'python')
print(t.count('python')) # 1
print(t.index(10.31)) # 1
2. 解压元组
# 一个function的函数，有三个返回值，比如姓名，年龄，电话
def function():
# 方法体
# return name,age,tel_num
t = '张三', 29, '23453451'
return t
(name,age,tel_num) = function()
# 当然，更常见的写法是 name,age,tel_num = function()
# 元素多了怎么办，比如我利用select * 返回的所有列表，但是只想取其中几个元素
# function返回的列表假设为t = 1, 2, 3, 4, 5
# 只关注前两个数
(name,age, *rest) = function() # 把多个元素丢给了 `rest` 变量。
# 或者：
name, age, *_ = t
# 如果我们不关心rest变量，那么都不用取变量名，直接使用下划线代替
字符串
字符串和元组相同，都是不可变的
| 转义字符 | 描述 |
| :——: | ————— |
| \\ | 反斜杠符号 |
| \' | 单引号 |
| \" | 双引号 |
| \n | 换行 |
| \t | 横向制表符(TAB) |
| \r | 回车 |
【例子】原始字符串只需要在字符串前边加一个英文字母 r 即可。
print(r'C:\Program Files\Intel\Wifi\Help')
# C:\Program Files\Intel\Wifi\Help
1. 常用方法
capitalize()将字符串的第一个字符转换为大写。lower()转换字符串中所有大写字符为小写。upper()转换字符串中的小写字母为大写。swapcase()将字符串中大写转换为小写，小写转换为大写。count(str, beg= 0,end=len(string))返回str在 string 里面出现的次数，如果beg或者end指定则返回指定范围内str出现的次数。endswith(suffix, beg=0, end=len(string))startswith(substr, beg=0,end=len(string))find(str, beg=0, end=len(string))rfind(str, beg=0,end=len(string))isnumeric()如果字符串中只包含数字字符，则返回 True，否则返回 False。ljust(width[, fillchar])返回一个原字符串左对齐，并使用fillchar（默认空格）填充至长度width的新字符串。rjust(width[, fillchar])返回一个原字符串右对齐，并使用fillchar（默认空格）填充至长度width的新字符串。(这两个方法常用于设置日标，比如20240430 + 0001，凑足12位)lstrip([chars])截掉字符串左边的空格或指定字符。rstrip([chars])删除字符串末尾的空格或指定字符。strip([chars])在字符串上执行lstrip()和rstrip()。partition(sub)找到子字符串sub，把字符串分为一个三元组(pre_sub,sub,fol_sub)，如果字符串中不包含sub则返回('原字符串','','')。rpartition(sub)类似于partition()方法，不过是从右边开始查找。replace(old, new [, max])把 将字符串中的old替换成new，如果max指定，则替换不超过max次。split(str="", num)不带参数默认是以空格为分隔符切片字符串，如果num参数有设置，则仅分隔num个子字符串，返回切片后的子字符串拼接的列表。splitlines([keepends])按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数keepends为 False，不包含换行符，如果为 True，则保留换行符。
注意：这些方法是在使用中去进行运用的，不用去记忆
2. 字符串格式化
str8 = "{0} Love {1}".format('I', 'Lsgogroup') # 位置参数
str8 = "{a} Love {b}".format(a='I', b='Lsgogroup') # 关键字参数
# 注意，不建议两个混着用，只使用其中一个
str8 = '{0:.2f}{1}'.format(27.658, 'GB') # 保留小数点后两位
# '{0:.2f}'表示含义： 0表示第一个元素， :表示对第一个元素进行额外操作 .2f保留两位小数
print("我叫 %s 今年 %d 岁!" % ('小明', 10)) # 我叫 小明 今年 10 岁!
字典
1. 释义
-
dict查找和插入的速度极快，不会随着key的增加而增加，但是需要占用大量的内存。 - 序列是以连续的整数为索引，与此不同的是，字典以”关键字”为索引，关键字可以是任意不可变类型，通常用字符串或数值。
- 字典是 Python 唯一的一个 映射类型，字符串、元组、列表属于序列类型。
如何快速判断一个数据类型 X 是不是可变类型的呢？两种方法：
- 麻烦方法：用
id(X)函数，对 X 进行某种操作，比较操作前后的id，如果不一样，则X不可变，如果一样，则X可变。 - 便捷方法：用
hash(X)，只要不报错，证明X可被哈希，即不可变，反过来不可被哈希，即可变。
2. id与hash
id()函数返回10进制地址，如果存储的地址都改变了，那说明已经不是之前的对象了。
哈希值是一个固定长度的整数，用于唯一标识对象。具有相同内容的对象将具有相同的哈希值，不同内容的对象将具有不同的哈希值。如果是可变类型，比如list,dict,set等，会报错
TypeError: unhashable type: 'dict'
【例子】
i = 1
print(id(i)) # 140732167000896
i = i + 2
print(id(i)) # 140732167000960
l = [1, 2]
print(id(l)) # 4300825160
l.append('Python')
print(id(l)) # 4300825160
- 数值、字符和元组 都能被哈希，因此它们是不可变类型。
- 列表、集合、字典不能被哈希，因此它是可变类型。
3. 字典的创建和访问
注意：如果我们取的键在字典中不存在，会直接报错KeyError。
seq = {'name': 10, 'age': 10, 'sex': 10}
print(seq['sdf']) # 会报错
# 可以使用dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回默认值。
print(seq.get('sdf')) # 会报错
# 1. 可以使用enumerate创建字典
nums = [-1,0,1,2,-1,-4]
print(dict(enumerate(nums)))
# 2. dict() 创建一个空的字典。
dic = dict()
dic['a'] = 1
dic['b'] = 2
dic['c'] = 3
# 3. 通过列表来创建一个字典
dic1 = dict([('apple', 4139), ('peach', 4127), ('cherry', 4098)])
print(dic1) # {'cherry': 4098, 'apple': 4139, 'peach': 4127}
# 4. 通过元组来创建一个字典
dic2 = dict((('apple', 4139), ('peach', 4127), ('cherry', 4098)))
print(dic2) # {'peach': 4127, 'cherry': 4098, 'apple': 4139}
# 5. dict(**kwargs) 这种情况下，键只能为字符串类型，并且创建的时候字符串不能加引号，加上就会直接报语法错误。
dic = dict(name='Tom', age=10)
print(dic) # {'name': 'Tom', 'age': 10}
4. 字典的内置方法
dict.fromkeys(seq[, value])
用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
seq = ('name', 'age', 'sex')
dic1 = dict.fromkeys(seq) # {'name': None, 'age': None, 'sex': None}
dic2 = dict.fromkeys(seq, 10)
print(dic2) # {'name': 10, 'age': 10, 'sex': 10}
dic3 = dict.fromkeys(seq, ('小马', '8', '男'))
print(dic3) # {'name': ('小马', '8', '男'), 'age': ('小马', '8', '男'), 'sex': ('小马', '8', '男')}
dict.keys()返回一个可迭代对象，可以使用list()来转换为列表，列表为字典中的所有键。dict.values()返回一个迭代器，可以使用list()来转换为列表，列表为字典中的所有值。dict.items()以列表返回可遍历的 (键, 值) 元组数组。dict.get(key, default=None)返回指定键的值，如果值不在字典中返回默认值。
seq = {'name': 10, 'age': 10, 'sex': 10}
lst = list(seq.keys()) # 转换为列表
print(list(dic.values()))
print(lst) # ['name', 'age', 'sex']
print(list(seq.items()))
print(seq.get('name'))
dict.setdefault(key, default=None)和get()方法 类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
seq = {'name': 10, 'age': 10, 'sex': 10}
value = seq.setdefault('tel', "1245436")
print("Age 键的值为 : %s" % dic.setdefault('age', None)) # Age 键的值为 : 7
print(value)
print(seq)
-
dict.pop(key[,default])删除字典给定键key所对应的值，返回值为被删除的值。key值必须给出。若key不存在，则返回default值。 -
del dict[key]删除字典给定键key所对应的值。 -
dict.clear()用于删除字典内所有元素。 -
dict.update(dict2)把字典参数dict2的key:value对 更新到字典dict里。
dic = {'Name': 'Lsgogroup', 'Age': 7}
dic2 = {'Sex': 'female', 'Age': 8}
dic.update(dic2)
print(dic) # {'Sex': 'female', 'Age': 8, 'Name': 'Lsgogroup'}
集合
Python 中set与dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
注意，key为不可变类型，即可哈希的值。
num = {}
print(type(num)) # <class 'dict'>
num = {1, 2, 3, 4}
print(type(num)) # <class 'set'>
1. 集合的创建
- 先创建对象再加入元素。
- 在创建空集合的时候只能使用
s = set()，因为s = {}创建的是空字典。 - 重复元素在
set中会被自动被过滤。
basket = set()
basket.add('apple')
basket.add('banana')
集合的两个特点：无序 (unordered) 和唯一 (unique)。
2. 集合的内置函数
-
set.update(set)用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。 -
set.remove(item)用于移除集合中的指定元素。如果元素不存在，则会发生错误。 -
set.discard(value)用于移除指定的集合元素。remove()方法在移除一个不存在的元素时会发生错误，而discard()方法不会。(推荐使用该方式) -
set.pop()用于随机移除一个元素。（因为set是没有下标的）
3. 不可变集合
a = frozenset(range(10)) # 生成一个新的不可变集合,返回一个冻结的集合，冻结后集合不能再添加或删除任何元素
print(a)
b = frozenset('lsgogroup')
print(b)
序列
序列类型包括字符串、列表、元组、集合和字典，这些序列支持一些通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。
1. 针对序列的内置函数
list(sub)把一个可迭代对象转换为列表。
a = list()
print(a) # []
b = 'I Love LsgoGroup'
print(list(b))
c = (1, 1, 2, 3, 5, 8)
print(list(c))
-
tuple(sub)把一个可迭代对象转换为元组。 -
str(obj)把obj对象转换为字符串
a = 123
print(str(a)) # 123
max(sub)返回序列或者参数集合中的最大值sum(iterable[, start=0])返回序列iterable与可选参数start的总和。
for i, element in a:
print('{0},{1}'.format(i, element))