三、容器类型
（一）容器通用操作
1.运算
| 类型 | |
|---|---|
| 拼接 | x+y 连接两个容器 累加x +=y |
| 复制 | x * n , x *= n 将容器x复制n遍 |
| 比较 | 对容器里的内容先转为对应的编码，再依次比较 |
| 成员运算符 | in, not in 判断一个成员是否在容器内 |
2.索引
#语法：<变量>[ ]
lists = [1,2,3]
lists[0]
"""
字符串的序号
-3 -2 -1 反向
刘 亦 菲
0 1 2 正向
"""注： ( <>[ ] = 可以修改容器内内容，字符串是不可变的数据类型，因此不可修改)
3.切片
"""语法：<变量>[login:end] 返回一段内容，范围[login,end)"""
lists = [1,2,2]
lists = [0:1] # 1
"""高级切片 <变量>[m:n:step] 根据步长切片，步长的正负需与mn保持一致。可以省略m或n，表示至开头或结尾。[ : : -1]=>逆序"""4.函数、方法
| 名称 | |
|---|---|
| len() | 返回序列 的长度 |
| max() | 返回序列的最大值元素 |
| min() | 返回序列的最小值元素 |
| sum() | 对数值求和 |
（二）字符串 str
1.定义
由一列字符组成的不可变序列容器，存储的是字符的编码值
2.表示
‘ ’，“ ”，""" """ 三引号可以所见即所得 str()
3.字符串格式化
对 ‘\’ 后面的字符进行转义
| 转义字符 | |
|---|---|
| \ ' | 显示一个普通的单引号 |
| \ " | 显示一个的双引号 |
| \n | 表示一个换行 |
| \t | 表示一个tab键 |
| \ (r"") | 表示一个普通的反斜线\ |
注
取消转义
url = " c: \ \nlr\aode"
url = r" c:\nlr\aode"
4.字符串格式化
-
使用%占位符
占位符 %s 表示字符串的占位符 %% 输出百分数 50% %d 表示整数的占位符 %f 表示浮点数的占位符 %.nd 显示n位数字，不足空格补齐 %.0nd 不足0补齐 %.-nd 表示在后面补齐 %.nf 保留n位小数 %x 表示以十六进制输出 print("名字:%s,性别:%s"%("张飞","男")) print("名字:%(name)s,性别:%(sex)s"%{"name":"张飞","sex":"男"}) #以字典的形式 -
format格式
#"{:<填充>|<对齐>|<宽度>|<,>|<精度>|<类型>}".format() "{}:计算机{}的CPU功率{}".format("2018","1","2") "我是{name}，我今年{age}".format(age=18,name="") "我是{name}，我今年{age}".format({“age”:18,"name":""})： 引号符号 <填充> 用于填充的字符(宽度不足) <对齐> “<” 左对齐 "^" 居中 ">" 右对 <宽度> 设定输出字符串的宽度 <,> 数字的千分位分隔符 <精度> 浮点数精度 <类型> 整数 b二进制, d(10) o(8) x X(16) 浮点数 e E f % -
f格式(3.6版以后)
#语法：f"{}" age=18 name="" f"我是{name}，我今年{age}" #2.具有eval功能,将字符串当成表达式运行 f'{print("")}' result = f'{3+5}'
5.编码
\1. 字节byte：计算机最小存储单位，等于8 位bit.
\2. 字符：单个的数字，文字与符号。
\3. 字符集(码表)：存储字符与二进制序列的对应关系。
\4. 编码：将字符转换为对应的二进制序列的过程。
\5. 解码：将二进制序列转换为对应的字符的过程。
\6. 编码方式：
--ASCII编码：包含英文、数字等字符，每个字符1个字节。
--GBK编码：兼容ASCII编码，包含21003个中文；英文1个字节，汉字2个字节。
--Unicode字符集：国际统一编码，旧字符集每个字符2字节，新字符集4字节。
-- UTF-8编码：Unicode的存储与传输方式，英文1字节，中文3字节。
6.函数
| 类型 | 函数/方法("".) | |
|---|---|---|
| 其他 | ord(字符串） | 返回该字符串的unicode码 |
| chr(unicode码) | 返回相应的字符串 | |
| 判断 | .isspace() | 如果字符串中只包含空白，则返回 True，否则返回 False. |
| .lower() | 判断字符串是否是小写 | |
| .upper() | 判断字符串是否是大写 | |
| .istitle() | 判断字符串每个单词首字母是否大写 | |
| .isalnum() | 判断字符串是否由字母或数字组成 | |
| .isspace() | 字符串由字母组成结果为True | |
| .startswith(substr, beg=0,end=len(string)) | 检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。 | |
| .endswith(suffix, beg=0, end=len(string)) | 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. | |
| .isdigit() | 判断字符串是否由数字组成 | |
| 查找 | .find(str, beg=0 end=len(string)) | 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1 |
| .rfind(str, beg=0,end=len(string)) | 从右边开始查找. | |
| .count(str, beg= 0,end=len(string)) | 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 | |
| 修改 | .replace(old, new [, max]) | 把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。 |
| .lstrip() | 截掉字符串左边的空格或指定字符。 | |
| .rstrip() | 删除字符串字符串末尾的空格. | |
| .strip([chars]) | 在字符串上执行 lstrip()和 rstrip() | |
| .lower() | 转换字符串中所有大写字符为小写. | |
| upper() | 转换字符串中的小写字母为大写 | |
| swapcase() | 将字符串中大写转换为小写，小写转换为大写 |
（三）列表 list
1.定义
由一系列变量组成的可变序列容器
列表内存图
2.表示
[<对象>,] 或 list([<其他容器>])
3.操作
-
获取元素
#索引 lists = [1,2,3] lists[0] #切片 通过切片获取元素，会创建新列表，仅仅拷贝第一层 ----浅拷贝 list[0:1]
-
修改
#语法: list.[index/切片] = lists = ["刘亦菲","貂蝉"] lists[1] = "杨幂" lists[1] =["杨幂","刘诗诗"] #L.sort(reverse=False) | 将列表中的元素进行排序，默认顺序按值的小到大的顺序排列 #L.reverse() | 列表的反转，用来改变原列表的先后顺序 进行排序，容器内的元素必须是同种类型
-
增加
方法 .append(object) 在列表末尾添加 .insert(index,object) 在index位置添加 -
合并列表
#语法：list_a.extend(list_b) 把b追加到a里
-
删除
方法 .pop([index]) / del a[index] 默认(没有index)，删除末尾元素 .remove(objext) 删除列表里的内容，若不存在，则报错。 .clean() 清楚列表
注：
删除实质：在内存中，后一个替换前一个
---------------------------------
可以从后往前删
for i in range (-(len(a),-1,-1):
4.遍历列表
#语法：for item in list:
lists = ["1","2",1]
for item in lists:
print(item)
#倒叙
#1）for i in list02[::-1]:
#list02[::-1] 通过切片拿元素，会重新创建新列表。浪费内存,不建议
#（2）0 1 2 3 => 3 2 1 0 或 -1 -2 -3 -4
for i in range( len(lists)-1, -1 , -1) :
print( lisrs[i])
for i in range (-1,-len(lists)-1,-1):
print( lisrs[i])5.拷贝
浅拷贝
通过切片，[ 4,[ a,b]]只拷贝一层,内面容器的内容不拷贝
a.copy()
深拷贝
将所有内容拷贝，使用copy模块， a=copy.deepcopy(b)
注：
不过是浅拷贝还是深拷贝，都无法拷贝不可变的容器
6.列表推导式
-
定义
使用简易方法，将可迭代对象转换成列表
-
语法
#变量 = [ 表达式 for 变量 in 可迭代对象] #变量 = [ 表达式 for 变量 in 可迭代对象 for 变量 in 可迭代对象] 双for结构 #变量 = [ 表达式 for 变量 in 可迭代对象 if 条件]
7.列表扩容
1.列表在创建时都会预留空间
2.当预留空间不足时，都会在创建新列表（更大的空间）
3.将原有数据拷贝到新列表中
4.替换引用
（四）元组 tuple
1.定义
由一系列变量组成的不可变序列容器，一旦创建，里面的变量不可操作（按需分配）
2.操作
-
创建
#空元组 a= () a = tuple() #默认值 a = (1,2) #元组只有一个元组 a = (1,) -
获取元素
同列表，索引、切片
（五）字典
1.定义
由一系列键值对组成的可变映射容器
映射：一对一的对应关系
键必须唯一且不可变（字符串/数字/元组），值没有限制
2.操作
-
创建
#空字典 dict0 = {} dict0 = dict() #默认值 dict01 ={"1":1} dict01 ={x=1,y=1} dict01 = dict(<容器>) #dict( [("a","1"),["age",12]] ) keys = ["name","age"] value = None dict01 ={}.formkeys(keys,values<默认值>) -
查找
dict01 = {" name":"杨幂","sex":"女"} #1.dict[key] dict01["name"] #杨幂 #2.dict.get(key,value) print(dict01.get("name","刘亦菲")) #若字典中不存在，则返回"刘亦菲" -
修改/添加
#dict[key] = 若字典中存在，则修改，否则是增加 dict01["name"] = "张飞" #dict01 = {" name":"张飞","sex":"女"} -
删除
#语法：del dict01[ ]
-
遍历
""" for key,value in dict01.items(): 得到key,value for i in dict01.items(): 以元组形式得到键值 for i in dict01: 得到key for i in dict01.values(): 得到value """
3.列表与字典的嵌套
-
字典内嵌列表 { <>: [ ] }
-
字典内嵌字典 { <>: {} }
-
列表内嵌字典 [ { : } ]
-
列表内嵌列表
#1. exercise05字典内嵌列表:
{
"张无忌":[28,100,"男"],
}
#2. exercise06字典内嵌字典:
{
"张无忌":{"age":28,"score":100,"sex":"男"},
}
#3. exercise07列表内嵌字典:
[
{"name":"张无忌","age":28,"score":100,"sex":"男"},
]
#4. 列表内嵌列表
[
["张无忌",28,100男],
]
"""
选择策略：根据具体需求，结合优缺点，综合考虑(两害相权取其轻).
字典：
优点：根据键获取值，读取速度快；
代码可读性相对列表更高(根据键获取与根据索引获取).
缺点：内存占用大；
获取值只能根据键,不灵活.
列表：
优点：根据索引/切片，获取元素更灵活.
相比字典占内存更小。
缺点：通过索引获取，如果信息较多，可读性不高.
"""
4.推导式
#语法：{ item:item ** 2 for item in range(1,11) if item >5}
5.函数
-
查找
函数/方法 .get(key, default=None) 返回指定键的值，如果值不在字典中返回default值 .setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default .popitem() 随机返回并删除字典中的一对键和值(一般删除末尾对)。 .items() 以列表返回可遍历的(键, 值) 元组数组 .keys() 返回一个迭代器，可以使用 list() 来转换为列表 values() 返回一个迭代器，可以使用 list() 来转换为列表 -
修改
方法 update(dict2) 字典记录累加 clear() 删除字典内所有元素
6.键值互换
#语法
dic = { value:key for key ,value in dict01.items()}
#value重复时
li = [(value,key) for key,value in dict01.items()]（六）集合 set
1.定义
由一系列不重复的不可变类型变量组成的可变映射容器，相当于有键无值的字典
2.操作
-
创建
#空值 set0 = set() set1 =set(可迭代对象) #默认值 set2 = {1,2,3} -
添加 .add( <元素>)
-
删除 .discard( <元素>)
-
遍历 for item in set0:
3.函数
update() 给集合添加元素
clear() 移除集合中的所有元素
copy() 拷贝一个集合
pop() 随机移除元素
4.运算
交集 &
并集 |
补集 (两边不同) ^
补集 (一边不同) -
子集 <
超集 >
5.固定集合
不可变集合 -frozenset()
运算同集合
（七）容器转换
| 列表 =>字符串 | result=" 连接符".join(<list>) 注：列表内的元素须是字符串 |
| 字符串 => 列表 | result="a-b-c".split(<分隔符>) |
| 列表 => 元组 | tuple( [ ] ) |
| 元组 => 列表 | list( <tuple>) |
| 集合=>字符串 | 先转为列表，再转 |
416
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
