本篇博客为博主第一次学 Python 所做的笔记（希望读者能够少点浮躁，认真阅读，平心静气学习！）

补充：

• 列表、元组和字符串共同属性：
  • 属于有序序列，其中的元素有严格的先后顺序
  • 都支持双向索引，索引范围 [ -L, L-1 ] ，L — 表示列表、元组和字符串的长度（分正向索引和反向索引）。
    • 正向索引：0 表示第 1 个元素，1 表示第 2 个元素，2 表示第 3 个元素…
    • 反向索引：-1 表示最后 1 个元素，-2 表示倒数第 2 个元素，-3 表示倒数第 3 个元素…

一、列表（关于列表的所有内容）：

放在一对方括号中，相邻元素之间使用逗号分隔。

• 同一个列表元素的数据类型可以各不相同。
• 列表包含：
  1. 整数、浮点数、复数、字符串 等 基本类型元素。
  2. 列表、元组、字典、集合、函数 或 其他任意对象。

创建列表：

• 使用方括号直接创建
• 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 – 表示列表对象

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="	")
    # 结果：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. 修改：

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. 删除：

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. 编码与解码

2. 将数据格式转化为特定格式的字符串

常用的格式：

• 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. 单个字符串在字符串中的相关函数

4. 字符串的编辑修改

text = "python 是一门非常棒的编程语言。"
print(text.replace("棒", "优雅").replace("编程", "程序设计"))
# 结果：python 是一门非常优雅的程序设计语言。

table = "".maketrans("0123456789", "零壹贰叁肆伍陆柒捌玖")
print("Tel:30647359".translate(table))
# 结果：Tel:叁零陆肆柒叁伍玖

5. 字符串进行排版

print("居左".ljust(20)+"结束")
# 结果：居左				结束
print("居右".rjust(20, "#"))
# 结果：####################居右
print("居中".center(20, "="))
# 结果：==========居中==========

6. 自定义分隔符对字符串分隔

不指定默认为空格、换行符和制表符等空白字符）作为分隔符对原字符串进行分隔

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. 大小写转换

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. 判断字符串开始与结束单词

测试字符串是否以指定的一个或几个字符串（放在元组中）开始或结束

text = "Simple is better than complex."
print(text.startswith("simple"))
# 结果：False

print(text.startswith("Simple"))
# 结果：True

print(text.endswith((".", "!", "?")))
# 结果：True

9. 删除字符串指定字符

删除字符串两侧、右侧和左侧的空白字符或指定的字符

text = "     ======test===#####     "
print(text.strip())
# 结果：======test===#####

print(text.strip("=# "))
# 结果：test