白乐天

道阻且长，行则将至。

Python基础

发表于 更新于 分类于
本文字数： 17k 阅读时长 ≈ 16 分钟

bytes

bytes()

创建 bytes 对象

1
2
3
4
5
byte_data = bytes("hello", "utf-8")
print(byte_data)  # 输出: b'hello'

byte_data = bytes([65, 66, 67])
print(byte_data)  # 输出: b'ABC'

fromhex()

将十六进制字符串转换为字节序列。

1
2
3
4
hex_str = "48656c6c6f20576f726c64"  # "Hello World" 的十六进制表示
byte_data = bytes.fromhex(hex_str)

print(byte_data)  # 输出: b'Hello World'

hex()

将字节序列转换为十六进制字符串。

1
2
3
4
byte_data = b'Hello World'
hex_str = byte_data.hex()

print(hex_str)  # 输出: "48656c6c6f20576f726c64"

decode()

字节序列转字符串

1
2
3
byte_data = b'hello'
text = byte_data.decode("utf-8")
print(text)  # 输出: "hello"

int

to_bytes

from_byte

String

字符串拼接

使用+运算符可以将多个字符串拼接起来

1
2
3
4
5
6
str1 = "Hello"
str2 = " "
str3 = "World!"

result = str1 + str2 + str3
print(result)  # 输出: Hello World!

slice（切片）

1
2
3
4
5
str[start:end:step]

// start：子字符串的起始位置（包含）。如果省略，默认为 0。
// end：子字符串的结束位置（不包含）。如果省略，默认为字符串的末尾。
// step：步长，表示每次切片时跳过多少个字符。如果省略，默认为 1。

字符串方法

join

1
2
3
4
string.join(iterable)

# string：要连接的字符串，即连接其他元素的分隔符。
# iterable：一个可迭代对象，比如列表、元组等，其元素会被 str 连接。

示例

1
2
result = ', '.join(['Hello', 'World'])
print(result)  # 输出: Hello, World

lower

1
2
3
string.lower()

转换 string 中所有大写字符为小写

upper

1
2
3
string.upper()

转换 string 中的小写字母为大写

replace

用于替换字符串中的指定子字符串。

1
2
3
4
5
str.replace(old, new[, count])

# old：要被替换的子字符串。
# new：用于替换 old 的新字符串。
# count（可选）：指定替换的最大次数，默认为全部替换。

split()

用于将字符串分割成多个子字符串，返回一个列表。

1
2
3
4
str.split(sep=None, maxsplit=-1)

// sep（可选）：指定分隔符。默认值是 None，表示根据空格（包括多个连续空格）进行分割。如果指定了 sep，字符串会根据该分隔符来进行分割。
// maxsplit（可选）：指定分割的最大次数。默认为 -1，表示分割所有匹配的分隔符。如果指定了 maxsplit，那么返回的列表最多会包含 maxsplit + 1 个元素。

示例

1
2
3
4
5
text = "Hello world, welcome to Python."
result = text.split()
print(result) 
>>>
['Hello', 'world,', 'welcome', 'to', 'Python.']

encode()

decode()

format()

字符串格式化

%格式化

f-s

List

列表的方法

append()

添加元素，在末尾添加

extend()

合并列表

Dict

字典的创建方式

  • 直接定义

    1
    2
    3
    mydict = {} # 创建空字典
    my_dict = {'key1': 'value1', 'key2': 'value2'}
    print(my_dict)    # {'key1': 'value1', 'key2': 'value2'}

  • 使用dict()构造函数

    1
    2
    3
    mydict = dict() # 空字典
    my_dict = dict(key1='value1',key2='value2',key3='value3')
    print(my_dict) # {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

  • 键值对序列

    1
    2
    3
    4
    5
    6
    7
    8
    9
    tuple1 = ("key1","value1")
    tuple2 = ("key2","value2")
    tuple3 = ("key3","value3")
    my_list = list()
    my_list.append(tuple1)
    my_list.append(tuple2)
    my_list.append(tuple3)
    my_dict = dict(my_list)
    print(my_dict) # {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

访问字典

  • 通过key来获取value

    1
    2
    my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
    print(my_dict["key1"]) # value1

  • 添加元素

    1
    2
    3
    mydict = {}
    mydict["key1"]="value1"
    print(mydict) # {'key1': 'value1'}

  • 修改元素

    1
    2
    3
    4
    mydict = {}
    mydict["key1"]="value1"
    mydict["key1"]="new_value1"
    print(mydict) # {'key1': 'new_value1'}

  • 删除元素

    1
    2
    3
    4
    mydict = {}
    mydict["key1"]="value1"
    del mydict["key1"]
    print(mydict) # {}

  • 删除字典

    1
    2
    3
    mydict = {}
    mydict["key1"]="value1"
    del mydict

字典方法

clear()

清空字典，使之变成一个空字典。

1
dict.clear()

keys()

返回一个包含字典中所有键的对象

1
2
3
4
5
6
7
8
my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
print(my_dict.keys())
keyslist = list(my_dict.keys())
print(keyslist)

>>>
dict_keys(['key1', 'key2', 'key3'])
['key1', 'key2', 'key3']

values()

1
dict.values()

返回一个包含字典中所有值的对象

1
2
3
4
5
6
7
8
my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
print(my_dict.values())
valueslist = list(my_dict.values())
print(valueslist)

>>>
dict_values(['value1', 'value2', 'value3'])
['value1', 'value2', 'value3']

items()

1
dict.values()

返回一个包含字典中所以键值对的对象

1
2
3
4
5
6
7
8
my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
print(my_dict.items())
itemslist = list(my_dict.items())
print(ietmslist)

>>>
dict_items([('key1', 'value1'), ('key2', 'value2'), ('key3', 'value3')])
[('key1', 'value1'), ('key2', 'value2'), ('key3', 'value3')]

update()

将一个字典的键值对更新到另一个字典中。

1
2
3
dict.update([other])

# other:要更新到当前字典的键值对来源，可以是另一个字典、键值对列表或键值对元组序列。

示例

字典

1
2
3
4
5
6
7
8
9
dict1 = {"key1":"value1"}
dict2 = {"key2":"value2"}
dict1.update(dict2)
print("dict1",dict1)
print("dict2",dict2)

>>>
{'key1': 'value1', 'key2': 'value2'}
{'key2': 'value2'}

元组列表

1
2
3
4
5
6
7
dict1 = {"key1":"value1"}
list2= [("key2","value2")]
dict1.update(list2)
print("dict1",dict1)

>>>
dict1 {'key1': 'value1', 'key2': 'value2'}

键值对列表

1
2
3
4
5
6
7
8
dict1 = {"key1":"value1"}
list2= [["key2","value2"]]
dict1.update(list2)
print("dict1",dict1)

>>>
dict1 {'key1': 'value1', 'key2': 'value2'}

pop()

移除字典中的一个元素，并返回该元素的值。

1
dict.pop(key)

示例

1
2
3
4
5
6
7
8
my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
popvalue = my_dict.pop("key3")
print(popvalue)
print(my_dict)

>>>
value3
{'key1': 'value1', 'key2': 'value2'}

File I/O

open()

1
2
3
4
5
file = open(file, mode='r')

// file: 要打开的文件名（包含路径）
// mdoe: 打开文件的模式
// return: 返回一个文件对象

mode

模式 描述
r 以只读方式打开文件。文件的指针将会放在文件的开头。
w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
+ 打开一个文件进行更新(可读可写)。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
b 二进制模式。（与r、w、a组合使用）
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

close()

关闭文件。

1
file.close()
1
2
3
4
5
6
7
8
# 以只读模式 ("r") 打开名为 "example.txt" 的文件
file = open("example.txt", "r")  

# 读取文件的全部内容，并存入变量 content
content = file.read()  

# 关闭文件，释放系统资源（必须手动关闭，否则可能会占用文件资源）
file.close()

read

read()

读取整个文件

1
2
3
4
content = file.read(size)

// size=-1（默认）：读取整个文件
// size=n：读取前 n 个字节（字符），适用于大文件逐步读取

readline()

读取一行

1
2
3
4
file.readline()

// 每次调用 readline() 读取一行（包含换行符 \n）。
// 若到达文件末尾，则返回 ""（空字符串）。

readlines()

读取所有行，返回列表

1
2
3
4
file.readlines()

// 一次性读取所有行，返回列表
// 每行作为一个字符串元素，保留换行符 \n

write

write()

1
2
3
4
5
file.write(string)

// 只能写入字符串，不能直接写入数字、列表等（需转换）
// 不会自动换行，需要手动加 \n
// 写入完成后必须关闭文件（推荐 with open 方式）

writelines()

1
2
3
4
file.writelines(lines)

// 一次性写入多行，参数需为列表或可迭代对象
// 不会自动换行，需确保列表中的字符串带有 \n

flush()

刷新缓冲区

1
file.flush()

tell()

返回文件指针当前位置。

1
fileObject.tell()

seek()

移动文件读取指针到指定位置。

1
file.seek(offset, whence)

  • offset

    开始的偏移量，也就是代表需要移动偏移的字节数

  • whence

    可选，默认值为 0。给offset参数一个定义，表示要从哪个位置开始偏移；0代表从文件开头开始算起，1代表从当前位置开始算起，2代表从文件末尾算起。

random

seed()

random.seed() 用于初始化随机数生成器的种子（Seed）。它的主要作用是让伪随机数的生成过程可预测，从而在不同的运行环境下产生相同的随机序列。

1
2
3
4
5
import random

random.seed(42)  # 设置随机种子
print(random.random())  # 0.6394267984578837
print(random.randint(1, 100))  # 82

random.seed(42) 设定了随机数种子为 42。

之后调用 random.random() 和 random.randint() 会得到固定的值。

只要种子值相同，每次运行时生成的随机序列也相同。

1
2
3
4
5
6
7
8
random.seed(a=None, version=2)

// a（可选）：用于初始化随机数生成器的种子，可以是：
	// int 类型（最常见）
	// float 类型
	// str、bytes、bytearray 等
	//None（默认），会使用系统时间或其他随机源进行初始化
// version（可选）：默认为 2，表示使用 hash(a) % 2**32 作为种子；如果 version=1，则直接使用 a 作为种子（但只支持整数类型）。

random()

random.random()用于生成一个 [0.0, 1.0) 之间的浮点数（包括 0.0，但不包括 1.0）。

1
2
3
4
import random

print(random.random())  # 生成一个随机浮点数，例如 0.3745401188473625
print(random.random())  # 可能是 0.9507143064099162

randint()

random.randint(a, b) 用于生成一个在 [a, b] 之间的随机整数，**包括 a 和 b**。

1
2
3
4
import random

print(random.randint(1, 10))  # 可能输出 1 到 10 之间的整数
print(random.randint(1, 10))  # 可能输出 7

uniform()

random.uniform(a, b) 用于生成一个在 [a, b] 或 [b, a] 之间的随机浮点数，包括 a 和 b（即闭区间）。

1
2
3
4
import random

print(random.uniform(1, 10))  # 可能输出 3.758382659073293
print(random.uniform(-5, 5))  # 可能输出 -2.134985731

randbytes()

random.randbytes() 用于生成指定长度的随机字节序列（bytes 对象）。这是 Python 3.9 版本引入的功能。

1
2
3
4
random.randbytes(n)

// n：要生成的随机字节数（必须是正整数）。
// return：一个长度为 n 的 bytes 对象，每个字节的值范围为 0-255。

choice()

用于从非空序列中随机选择一个元素，序列可以是任何可迭代的对象（如列表、元组、字符串等）。

1
2
3
4
random.choice(seq)

// seq：一个非空的序列（如列表、元组、字符串、range 等）。
// return：返回 序列 seq 中的一个随机元素。

shuffle()

random.shuffle(seq)用于 随机打乱可变序列（如列表）中的元素顺序。该方法会直接修改原始序列，而不是返回一个新的序列。

1
2
3
random.shuffle(seq)

// seq：seq：一个可变序列（通常是列表）。shuffle() 会对该序列中的元素进行随机排序。

示例用法

1
2
3
4
5
6
7
import random

# 打乱列表顺序
numbers = [1, 2, 3, 4, 5]
random.shuffle(numbers)
print(numbers)  # 可能输出 [3, 1, 5, 4, 2]

sample()

random.sample(seq, k) 用于 从序列 seq 中随机选择 k 个不重复的元素，并返回一个新列表。这个方法不会修改原始序列。

1
2
3
4
5
random.sample(seq, k)

// seq：一个序列（如列表、元组、字符串、range 等）。
// k：要选择的元素个数，必须小于或等于 seq 中元素的数量。
// return：返回一个包含 k 个从 seq 中随机选出的不重复元素的列表。

示例用法

1
2
3
4
5
6
import random

# 从列表中随机选择 3 个元素
fruits = ["苹果", "香蕉", "橙子", "葡萄", "草莓"]
sampled_fruits = random.sample(fruits, 3)
print(sampled_fruits)  # 可能输出 ['草莓', '香蕉', '橙子']

binascii

urllib

parse

quote()

用于对字符串进行 URL 编码。

1
2
3
4
5
6
urllib.parse.quote(string, safe='/', encoding=None, errors=None)

// string: 要进行 URL 编码的字符串。
// safe: 指定哪些字符不需要进行编码。默认情况下，safe='/'，表示 / 字符不会被编码。
// encoding: 字符串编码的方式。默认使用 utf-8 编码。
// errors: 处理编码错误的方式。通常情况下，不需要设置此参数，默认值为 None。

unquote()

用于 对字符串进行URL 解码。

1
2
3
4
5
urllib.parse.unquote(string, encoding='utf-8', errors='replace')

// string:要解码的 URL 编码字符串。该字符串中包含百分号编码的部分，需要被转换回对应的字符。
// encoding (可选):指定用于解码的字符编码。默认使用 utf-8 编码。
// errors (可选):指定在解码过程中遇到错误时的处理方式。默认值是 'replace'，即遇到无法解码的字节时用一个替代字符（通常是 �）代替。

requests

request()

requests.request() 是 requests 库中最底层、最通用的 HTTP 请求方法。它允许你通过传入不同的 HTTP 方法（如 GET、POST、PUT、DELETE 等）来构造请求，内部所有的专用方法（如 requests.get()、requests.post() 等）其实都是对 requests.request() 的简单封装。

1
2
3
4
5
requests.request(method, url, **kwargs)

# method：请求方法的名称，字符串形式，如 "GET"、"POST"、"PUT"、"DELETE"、"HEAD"、"OPTIONS"、"PATCH" 等。
# url：请求的 URL 地址。
# kwargs：其他可选参数，用于控制请求的各个方面。

get()

requests.get() 用于向指定 URL 发送 GET 请求，从服务器获取数据。

1
2
3
4
5
6
response = requests.get(url, params=None, **kwargs)

# url：必需参数，表示请求的目标 URL。
# params：可选参数，一般以字典、元组列表或字节流的形式传入，用于构造 URL 的查询字符串。传递的参数会自动编码并附加到 URL 后面。
# kwargs：其他可选参数，用于定制请求行为。
	# 常见的有：headers,cookies,timeout等

示例

1
2
3
4
params = {"q": "python教程", "page": 1}
response = requests.get("https://www.example.com/search", params=params)
print(response.url)
# 输出类似：https://www.example.com/search?q=python%E6%95%99%E7%A8%8B&page=1

post()

requests.post() 方法用于向服务器发送 HTTP POST 请求。与 GET 请求不同，POST 请求通常用于向服务器提交数据（如表单数据、JSON 数据、文件上传等），数据内容被放在请求体（body）中。

1
2
3
4
5
6
7
8
response = requests.post(url, data=None, json=None, headers=None, params=None, files=None, auth=None, timeout=None, **kwargs)

# url：必需参数，目标请求地址。
# data：常用于提交表单数据，可为字典、字节序列或文件对象。当传入字典时，默认以 application/x-www-form-urlencoded 编码；也可以传入字符串，此时默认为 text/plain。
# json：用于提交 JSON 数据。当使用该参数时，requests 会自动将数据序列化为 JSON 字符串，并设置请求头 Content-Type: application/json。如果同时传入了 data 和 json，通常后者优先。
# headers：字典，设置请求头，可以用来自定义 User-Agent、Content-Type 等信息。
# params：用于 URL 查询参数，类似于 GET 请求，但在 POST 请求中有时也会用到。
# files：用于上传文件，支持多种格式。

使用 data 参数提交表单数据时，数据会以 URL 编码格式发送；使用 json 参数提交数据时，数据会自动转换为 JSON 字符串，并设置 Content-Type: application/json。

Response对象

Response 对象是 Python requests 库中用来表示服务器响应的核心对象。每当你使用 requests.get()、requests.post() 等方法发送 HTTP 请求时，返回的就是一个 Response 对象，它包含了服务器返回的所有信息，例如状态码、响应头、响应体、Cookies 以及请求相关的信息等。

status_code

表示 HTTP 响应的状态，如 200（成功）、404（资源未找到）、500（服务器错误）等。

headers

是一个字典，存储了服务器返回的所有 HTTP 响应头信息，如 Content-Type、Content-Encoding 等。

响应体

有两种常用形式

  • text：

    经过编码（通常基于响应头中指定的 charset 或通过 apparent_encoding 计算）解码后的字符串数据，适合处理文本内容。

  • content：

    原始的二进制数据

Cookies

Response 对象的 cookies 属性是一个 RequestsCookieJar 对象，用于存储服务器返回的 Cookie。

json()

用于将响应体内容解析为 JSON 格式并返回对应的 Python 对象（通常是字典或列表）。如果响应内容不是合法的 JSON，则会抛出异常。

close()

用于关闭响应连接，尤其在使用流式请求（stream=True）时显得尤为重要。

re

正则表达式

常用匹配规则

元字符

模式 描述
. 匹配任意单个字符（除换行符）。
^ 匹配字符串的开头。
$ 匹配字符串的结尾。
* 匹配前一个字符0次或多次。
+ 匹配前一个字符1次或多次。
? 匹配前一个字符0次或1次。
{n} 精确匹配前一个字符 n 次。
{n,} 匹配前一个字符至少 n 次。
{n,m} 匹配前一个字符 n 到 m 次。

字符类

模式 描述
[abc] 匹配字符 “a”、”b” 或 “c”。
[a-z] 匹配所有小写字母。
[^abc] 匹配除 “a”、”b” 和 “c” 之外的任意字符。

预定义字符类

模式 描述
\d 匹配任意数字，等价于 [0-9]。
\D 匹配任意非数字。
\w 匹配字母、数字或下划线，等价于 [a-zA-Z0-9_]。
\W 匹配非字母、数字和下划线。
\s 匹配空白字符，包括空格、制表符等。
\S 匹配非空白字符。

分组和引用

模式 描述
() 用于分组，可以将一部分模式看作一个整体
| 匹配左边或右边的表达式。
\1, \2,… 反向引用，用于引用分组匹配的内容。

match object（匹配对象）

匹配对象是 re.Match 类型的实例，可以通过该对象访问有关匹配的信息。

属性

lastindex

返回正则表达式中最后一个分组的索引。如果没有分组，则返回 None。

lastgroup

返回最后一个匹配的分组名称（如果正则表达式使用了命名分组）。如果没有使用命名分组，则返回 None。

方法

group()

  • 返回整个匹配的字符串（即正则表达式匹配到的内容）。
  • 如果正则表达式包含分组（用圆括号 () 包围的部分），可以通过 group() 方法传入一个数字来返回特定分组的匹配内容。

start()

返回匹配的起始位置（索引），即匹配字符串的第一个字符在原始字符串中的位置。

end()

返回匹配的结束位置（索引），即匹配字符串的最后一个字符后面的索引。注意，这个位置是匹配的结束位置的下一个位置。

span()

返回一个元组 (start, end)，分别表示匹配的起始位置和结束位置。

groups()

返回所有分组的元组（不包括整个匹配的字符串），如果正则表达式没有分组，则返回一个空元组 ()。

groupdict()

如果正则表达式使用了命名分组，groupdict() 会返回一个字典，键为分组名称，值为对应分组的匹配内容。否则，返回一个空字典。

match()

从字符串的起始位置开始匹配正则表达式 pattern，如果匹配成功，返回一个匹配对象；如果不匹配，返回 None。

1
re.match(pattern, string)

在整个字符串中搜索匹配正则表达式 pattern 的部分，只要找到了第一个匹配项就返回匹配对象，否则返回 None。

1
re.search(pattern, string)

findall()

查找所有匹配 pattern 的部分，并返回一个列表。如果没有匹配项，则返回空列表。

1
re.findall(pattern, string)

finditer()

与 findall 类似，但是返回的是一个迭代器，每个元素是一个匹配对象。

1
re.finditer(pattern, string)

sub()

用 repl 替换字符串中所有匹配 pattern 的部分，返回替换后的新字符串。

1
re.sub(pattern, repl, string)

split()

根据正则表达式 pattern 将字符串分割成多个部分，返回一个列表。

1
re.split(pattern, string)

struct

unpack()

将 二进制数据 解析为 Python 数据类型

1
struct.unpack(format, buffer)
  • **format**：格式字符串，定义二进制数据的解析规则（如数据类型、字节序）。
  • **buffer**：包含二进制数据的字节对象（如 bytes, bytearray）。
  • 返回值：返回一个 元组，包含解析后的数据。

格式字符串

字节序指令（可选，默认按系统原生顺序）：

符号 说明
@ 原生字节序 + 原生对齐（默认）
= 原生字节序 + 标准大小
< 小端序（低位在前）
> 大端序（高位在前）
! 网络序（大端序）

数据类型指令：

符号 C 类型 Python 类型 字节数
b char int 1
B unsigned char int 1
h short int 2
H unsigned short int 2
i int int 4
I unsigned int int 4
q long long int 8
Q unsigned long long int 8
f float float 4
d double float 8
s char[] bytes 1 per char

time

time()

返回当前时间的时间戳。时间戳是从1970年1月1日00:00:00 UTC开始的秒数。

1
time.time()

调用示例

1
2
3
4
5
6
import time

print(time.time())

>>>
1738742885.6218357

json

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，易于人和机器阅读和解析。它基于JavaScript的对象表示法，但被广泛用于多种编程语言。

JSON中的数据类型

  • 字符串（String）：用双引号包围，如 “Hello, World!”。
  • 数字（Number）：如 123、3.14，无引号。
  • 布尔值（Boolean）：true 或 false。
  • 数组（Array）：如 [1, 2, “abc”, true]。
  • 对象（Object）：如 {“name”: “Alice”, “age”: 30}。
  • 空值（Null）：表示空，如 null。

JSON的基本语法

  • 数据在键值对中：每个键值对由键和值组成，格式为 “key”: value。
  • 数据由逗号分隔：多个键值对之间使用逗号分隔。
  • 对象由花括号 {} 包围：表示一个无序的键值对集合。
  • 数组由方括号 [] 包围：表示一个有序的值的集合。
  • 键 必须是字符串（用双引号包裹），值 可以是字符串、数字、布尔值、数组、对象或 null。

JSON示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
{
    "args": {},
    "headers": {
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
        "Accept-Encoding": "gzip, deflate, br, zstd",
        "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6",
        "Host": "www.httpbin.org",
        "Priority": "u=0, i",
        "Sec-Ch-Ua": "\"Chromium\";v=\"130\", \"Microsoft Edge\";v=\"130\", \"Not?A_Brand\";v=\"99\"",
        "Sec-Ch-Ua-Mobile": "?0",
        "Sec-Ch-Ua-Platform": "\"Windows\"",
        "Sec-Fetch-Dest": "document",
        "Sec-Fetch-Mode": "navigate",
        "Sec-Fetch-Site": "none",
        "Sec-Fetch-User": "?1",
        "Upgrade-Insecure-Requests": "1",
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36 Edg/130.0.0.0",
        "X-Amzn-Trace-Id": "Root=1-672db183-55e0183d3ee3822d699e15c5"
    },
    "origin": "45.32.145.117",
    "url": "https://www.httpbin.org/get"
}

load()

  • 从文件对象读取 JSON 格式的数据并将其解析为 Python 对象。
  • 用于直接从文件中加载 JSON 数据。
1
2
3
4
import json
with open('data.json', 'r') as file:
    data = json.load(file)
print(data)

loads()

  • 从字符串中解析 JSON 格式的数据并将其转换为 Python 对象。
  • 用于从 JSON 字符串中加载数据。
1
2
3
4
import json
json_string = '{"name": "Alice", "age": 25}'
data = json.loads(json_string)
print(data)

dump()

  • 将 Python 对象转换为 JSON 格式，并将其写入到文件中。
  • 用于将 JSON 数据保存到文件。
1
2
3
4
5
6
7
8
import json
data = {
    "name": "Bob",
    "age": 30,
    "isStudent": True
}
with open('output.json', 'w') as file:
    json.dump(data, file, indent=4)  # 使用 indent 参数使输出美观

dumps()

  • 将 Python 对象转换为 JSON 格式的字符串。
  • 用于在程序中将 Python 对象转换为 JSON 字符串以便于传输或输出。
1
2
3
4
5
6
7
8
import json
data = {
    "name": "Charlie",
    "age": 22,
    "isStudent": False
}
json_string = json.dumps(data, indent=4)  # 使用 indent 参数格式化输出
print(json_string)

uuid

uuid 库用于生成通用唯一标识符（UUID）。UUID 是 128 位的唯一标识符，通常用于标记对象、数据或会话，以确保唯一性。

uuid1

基于时间戳和主机 MAC 地址生成。

示例

1
2
3
import uuid
u1 = uuid.uuid1()
print(u1)  # 输出类似: 123e4567-e89b-12d3-a456-426614174000

uuid4

完全基于随机数生成。

示例

1
2
u4 = uuid.uuid4()
print(u4)  # 输出完全随机的 UUID，如：e30d81fe-d831-4867-804b-da6c476fa270

Crypto

Problem

No module named “Crypto”

安装pycryptodome

1
pip install pycryptodome

pycryptodome是crypto的延伸版本，用法和crypto是一模一样的，可以完全替代crypto。

如果上述方法仍不能解决问题，可以找到 python 下面的\Lib\site-packages，手动将crypto改为Crypto。

Jupyter notebook

安装与启动

在终端执行如下命令进行安装

1
pip install notebook

在终端输入如下命令进行启动

1
jupyter notebook

会在浏览器打开Jupyter，选择一个目录新建文件，编写代码

在终端执行Ctrl + C命令停止服务