本篇博客为博主第一次学 Python 所做的笔记（希望读者能够少点浮躁，认真阅读，平心静气学习！）
补充：
- 列表、元组和字符串共同属性：
- 属于有序序列，其中的元素有严格的先后顺序
- 都支持双向索引，索引范围 [ -L, L-1 ] ，L -- 表示列表、元组和字符串的长度（分正向索引和反向索引）。
- 正向索引：0 表示第 1 个元素，1 表示第 2 个元素，2 表示第 3 个元素...
- 反向索引：-1 表示最后 1 个元素，-2 表示倒数第 2 个元素，-3 表示倒数第 3 个元素...
一、列表（关于列表的所有内容）：
放在一对方括号中，相邻元素之间使用逗号分隔。
- 同一个列表元素的数据类型可以各不相同。
- 列表包含：
- 整数、浮点数、复数、字符串 等 基本类型元素。
- 列表、元组、字典、集合、函数 或 其他任意对象。
创建列表：
- 使用方括号直接创建
- list() 函数把元组、range 对象、字符串、字典、集合，以及 map 对象、zip 对象、enumerate 对象或其他类似对象 转换 为列表。
- 内置函数（ sorted() ）、标准库函数（ random.sample() ）或扩展函数（ jieba.lcut() ）也会返回列表
函数：
1. 访问元素：
- 用户可以使用整数作为下标来随机访问其中任意位置上的元素
data = list(range())
# data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(data[1])
# 结果 1
print(data[-1])
# 结果 9
…… - 如果指定的下标不在有效范围内，代码会抛出异常提示下表越界
2. 其他常用方法：
lst - 表示列表对象
| 函数 | 解释 |
|---|---|
lst.append(x) |
将 x 追加至列表 lst 的尾部，不影响列表中已有元素的位置，也不影响列表在内存中的起始地址 |
lst.insert(index, x) |
在列表 lst 的 index 位置处插入 x，该位置之后的所有元素自动向后移动，索引加 1 |
extend(L) |
将列表 L 中所有元素追加至列表 lst 的尾部，不影响 lst 列表中已有元素的位置，也不影响 lst 列表在内存中的起始地址。 |
pop([index]) |
删除并返回列表 lst 中下标为 index 的元素，该位置后面的所有元素自动向前移动，索引减 1。index 默认为 -1，表示删除并返回列表中最后一个元素 |
remove(x) |
在列表 lst 中删除第一个值为 x 的元素，被删除元素位置之后的所有元素自动向前移动，索引减 1；如果列表中不存在 x 则抛出异常。 |
count(x) |
返回 x 在列表 lst 中的出现次数 |
index(x) |
返回列表 lst 中第一个值为 x 的元素的索引，若不存在值为 x 的元素则抛出异常。 |
sort( key = None , reverse = False) |
对列表 lst 的所有元素进行原地逆序，首尾交换 |
3. 推导式：
使用 非常简洁 的方式对列表或其他可迭代对象的元素进行遍历、过滤或再次计算，快速生成满足特定需求的新列表。
# 格式：
[expression for expr1 in sequence1 if condition
for expr2 in sequence2 if condition2
for expr3 in sequence3 if condition3
...
for exprN in sequenceN if conditionN
]
# 例子：
data = [num for num in range(20) if num%2==1]
# 等价于 =>
data = []
for num in range(20):
if num%2 == 1:
data.append(num)
二、元组（关于元组的所有内容）：
创建元组：
- 用圆括号放若干元素创建元组（如果只有一个元素，则需要多加一个逗号
(3,)） - 用
tuple()函数把 列表、字典、集合、字符串 以及 range 对象、map 对象、zip 对象 或 其他类似对象转换为元组
元组的好处（与列表对比）：
| 元组 | 列表 | |
|---|---|---|
| 修改元素值 | 不能直接修改 | 可以修改 |
| 访问速度 | 快 | 慢 |
| 开销 | 小 | 大 |
| 安全性 | 安全 | 不安全 |
| 是否可以用作字典的键 | 可以 | 不可以 |
| 是否可以作为集合的元素 | 可以 | 不可以 |
三、字典（关于字典的所有内容）：
- 属于容器对象，其中包含若干元素，每个元素包含 “键” 和 “值” 两部分，之间使用冒号分隔，表示一种对应关系。
- 不同元素之间使用逗号分隔，所有元素放在一对大括号中。
- “键”，可以是 Python 中任意不可变数据，例如整数、复数、字符串、元组等类型；不能是列表、集合、字典或其他可变类型，包含列表等可变数据的元组也不能作为字典的 “键”
函数：
1. 访问：
# 初始化
data = dict(name = "张三"， age = 8, sex = 'M')
- 把 “键” 最为下标可以返回对应的 “值”（不存在的话会抛出异常）
print(data('name'))
# 结果：张三
-
get()方法获取指定的 “键” 对应的 “值”（不存在返回空值或指定的值）
print(data.get('age'))
# 结果：18
- 支持元素迭代
- 可以将其转换为列表或元组
print(list(data))
# 结果：['name', 'age', 'sex'] - 可以使用 for 循环遍历其中的元素，默认情况下是遍历字典中的 “键”
for key, value in data.items():
print(key, value, sep='\t')
# 结果：name 张三
# 结果：age 18
# 结果：sex M - 遍历字典元素，必须使用字典对象的
items()方法明确说明print(list(data.items()))
# 结果：[('name', '张三'), ('age', '18'), ('sex', 'M')] - 遍历字典的 “值”，则必须使用字典对象的
values()方法明确说明print(list(data.values()))
# 结果：['张三', '18', 'M']
- 可以将其转换为列表或元组
2. 修改：
当以指定 “键” 为下标为字典元素赋值时：
- 若该 “键” 存在，表示修改该 “键” 对应的值：
soct = {'IP': '127.0.0.1', 'port': 80}
soct['port'] = 8080
print(soct)
# 结果：{'IP': '127.0.0.1', 'port': 8080}
- 若 “键” 不存在，表示添加一个新元素：
soct = {'IP': '127.0.0.1', 'port': 80}
soct['protocol'] = 'TCP'
print(soct)
# 结果：{'IP': '127.0.0.1', 'port': 80, 'protocol': 'TCP'}
3. 添加：
update() 方法可以将另一个字典的元素一次性全部添加到当前字典中，如果两个字典中存在相同的 “键”，则以另一个字典中的 “值” 为准对当前字典进行更新：
sock = {'IP': '127.0.0.1', 'port': 80}
sock.update({'IP': '192.168.9.62', 'protocol': 'TCP'})
print(sock)
# {'IP': '192.168.9.62', 'protocol': 'TCP', 'port': 80}
4. 删除：
sock = {'IP': '192.168.9.62', 'port': 80, 'protocol': 'TCP'}
-
pop()方法可以删除指定 “键” 对应的元素，同时返回对应的 “值”。
print(sock.pop('IP'))
# 结果：192.168.9.62
-
popitem()方法用于删除并返回一个包含两个元素的元组，其中的两个元素分别是字典元素的 “键” 和 “值”。
print(sock.popitem())
# 结果：('protocol', 'TCP')
-
del删除指定的 “键” 对应的元素。
del sock['port']
print(sock)
# 结果：{'IP': '192.168.9.62', 'protocol': 'TCP'}
四、集合（关于集合的所有内容）：
无序、可变的容器对象，所有元素放在一对大括号中，元素之间使用逗号分隔，同一个集合内的每个元素都是唯一的，不允许重复。
0. 创建：
- 所有元素放在一对大括号中，创建集合
data = {30, 40, 50}
- 使用
set()函数将列表、元组、字符串、range 对象等其他可迭代对象转换为集合。 - 使用集合推导式生成特定的集合，如果原来的数据中存在重复元素，在转换为集合的时候重复的元素只保留一个，自动除去重复元素。
- 如果原序列或迭代对象中有可变类型的数据，则无法转换成为集合，抛出异常。
特点：
- 集合内数据要求：
- 集合中只能包含数字、字符串、元组等不可变类型的数据
- 不包含列表、字典、集合等可变类型的数据，包含列表等可变类型数据的元组也不能作为集合的元素。
- 元素是无序的，元素储存顺序和添加顺序并不一致。
1. 访问：
- 集合不支持使用下标直接访问特定位置上的元素，也不支持使用
random中的choice()函数从集合中随机选取元素 - 支持使用
random模块中的sample()函数随机选取部分元素。
2. 修改：
| 函数 | 解释 |
|---|---|
add() |
添加新元素，如果存在则忽略该操作，不会抛出异常。 |
update() |
方法用户合并另一个集合中的元素到另一个集合中，并自动除去重复元素。 |
data = {30, 40, 50}
data.add(20)
print(data)
# 结果：{40, 50, 20, 30}
data = {30, 40, 50}
data.update({40, 60})
print(data)
# 结果：{50, 40, 60, 30}
3. 删除：
| 函数 | 解释 |
|---|---|
pop() |
用来随机删除并返回集合中的一个元素，如果集合为空则抛出异常。 |
remove() |
用于删除集合中的指定元素，如果指定元素不存在则抛出异常。 |
remove() |
用于从集合中删除一个指定元素，若指定的元素不在集合中则直接忽略该操作。 |
data = {30, 40, 50}
data.remove(30)
print(data)
# 结果：{40, 50}
data = {30, 40, 50}
data.discard(30)
print(data)
# 结果：{40, 50}
data = {30, 40, 50}
data.pop()
print(data)
# 结果：{50, 30}
五、字符串（关于字符串的所有内容）：
字符串属于不可变对象。
1. 编码与解码
| 函数 | 解释 |
|---|---|
encode() |
使用指定的编码格式把字符串编码为字符串，默认使用 UTF-8 编码格式。 |
decode() |
使用指定的编码格式把字节串解码为字符串，默认使用 UTF-8 编码格式。 |
2. 将数据格式转化为特定格式的字符串
| 函数 | 解释 |
|---|---|
format() |
用于把数据格式转化为特定格式的字符串，该方法通过格式字符串进行调用。 |
常用的格式：
- b（二进制格式）
- c（把整数转换成 Unicode 字符）
- d（十进制格式）
- o（八进制格式）
- x（小写十六进制格式）
- X（大写十六进制格式）
- e/E（科学计数法格式）
- f/F（固定长度的浮点数格式）
- %（使用固定长度浮点数显示百分数）
# 保留4位小数
# 0 表示参数下标，对应第一个参数
print('{0:.4f}'.format(10/3))
# 结果：3.3333
print('{0:.2%}'.format(1/3))
# 结果：33.33%
# 格式化为百分数字符串，总宽度为10，保留2位小数，> 表示右对齐
print('{0:>10.2%}'.format(1/3))
# 结果： 33.33%
# 逗号表示在数字字符串中插入逗号作为千分符，#x表示格式化为十六进制数
print("{0:,} in hex is: {0:#x}, in oct is {0:#o}".format(5555555))
# 结果：5,555,555 in hex is: 0x54c563, in oct is 0O25142543
# 可以先格式化下标为 1 的参数，再格式化下标为 0 的参数
print("{1} in hex is: {1: #x}, {0} in oct is {0:o}".format(6666, 66666))
# 结果：66666 in hex is: 0x1046a, 6666 in oct is 15012
# _表示在数字中插入下划线来为千分符
print('{0:_}, {0:#_x}'.format(10000000))
# 结果：10_000_000, 0x98_9680
3. 单个字符串在字符串中的相关函数
| 函数 | 解释 |
|---|---|
index() |
返回一个字符串在当前字符串中 首次出现 的位置，如果当前字符串中不存在此字符串，则抛出异常。 |
rindex() |
返回一个字符串在当前字符串中 最后一次 出现的位置，如果当前字符串中不存在此字符串，则抛出异常。 |
count() |
方法用来返回一个字符串在当前字符串中 出现的次数，如果当前字符串中不存在此字符串，则返回 0。 |
4. 字符串的编辑修改
| 函数 | 解释 |
|---|---|
replace() |
用来替换字符串中指定字符或子字符串的所有重复出现，每次只能替换一个字符或一个字符串，把指定的字符串参数作为一个整体对待，类似与 Word、WPS、记事本、写字板等文本编辑器的'全部替换'功能。该方法返回一个新字符串，并不修改原字符串。 |
maketrans() |
用来生成字符串映射表。 |
format() |
用于把数据格式转化为特定格式的字符串，该方法通过格式字符串进行调用。 |
translate() |
用来根据映射表中定义的对应关系转换字符串并替换其中的字符。 |
text = "python 是一门非常棒的编程语言。"
print(text.replace('棒', '优雅').replace('编程', '程序设计'))
# 结果：python 是一门非常优雅的程序设计语言。
table = ''.maketrans('0123456789', '零壹贰叁肆伍陆柒捌玖')
print('Tel:30647359'.translate(table))
# 结果：Tel:叁零陆肆柒叁伍玖
5. 字符串进行排版
| 函数 | 解释 |
|---|---|
ljust() |
居左 |
rjust() |
居右 |
center() |
居中 |
print('居左'.ljust(20)+'结束')
# 结果：居左 结束
print('居右'.rjust(20, '#'))
# 结果：####################居右
print('居中'.center(20, '='))
# 结果：==========居中==========
6. 自定义分隔符对字符串分隔
不指定默认为空格、换行符和制表符等空白字符）作为分隔符对原字符串进行分隔
| 函数 | 解释 |
|---|---|
split() |
从左向右 |
rsplit() |
从右向左 |
join() |
使用指定的字符串作为连接符对可迭代对象中的若干字符串进行连接。 |
text = 'Beautiful is better than ugly.'
print(text.split())
# 结果：['Beautiful', 'is', 'better', 'than', 'ugly.']
print(text.split(maxsplit=1))
# 结果：['Beautiful', 'is better than ugly.']
print('1,2,3,4'.split(','))
# 结果：['1', '2', '3', '4']
print(','.join(['1', '2', '3', '4']))
# 结果：1,2,3,4
print(':'.join(map(str, range(1, 5))))
# 结果：1:2:3:4
7. 大小写转换
| 函数 | 解释 |
|---|---|
lower() |
字符串中的英文字母全部转换为 小写 字母 |
upper() |
字符串中的英文字母全部转换为 大小 字母 |
capitalize() |
每个 句子 的 第一个字母 转换为 大写 字母 |
title() |
每个 单词 的 第一个 字母转换为 大写 字母 |
swapcase() |
小写 字母转换为 大写 字母并把 大写 字母转换为 小写 字母 |
text = 'Explicit is better than implicit.'
print(text.lower())
# 结果：explicit is better than implicit.
print(text.upper())
# 结果：EXPLICIT IS BETTER THAN IMPLICIT.
print(text.capitalize())
# 结果：Explicit is better than implicit.
print(text.title())
# 结果：Explicit Is Better Than Implicit.
print(text.swapcase())
# 结果：eXPLICIT iS bETTER tHAN iMPLICIT.
8. 判断字符串开始与结束单词
测试字符串是否以指定的一个或几个字符串（放在元组中）开始或结束
| 函数 | 解释 |
|---|---|
startswith() |
开始 |
endswith() |
结束 |
text = 'Simple is better than complex.'
print(text.startswith('simple'))
# 结果：False
print(text.startswith('Simple'))
# 结果：True
print(text.endswith(('.', '!', '?')))
# 结果：True
9. 删除字符串指定字符
删除字符串两侧、右侧和左侧的空白字符或指定的字符
| 函数 | 解释 |
|---|---|
strip() |
两侧 |
rstrip() |
右侧 |
lstrip() |
左侧 |
text = ' ======test===##### '
print(text.strip())
# 结果：======test===#####
print(text.strip('=# '))
# 结果：test