# Python
- Python是解释型语言，使用它需要安装的 python 解释器（用于运行 python 程序），与编译型语言不同，要运行 python 程序并不需要把 python 代码编译成目标代码（机器码），而是在解释器上逐行执行。
- Python是跨平台的，它可以运行在 Windows、Mac 和各种 Linux/Unix 系统上。在 Windows 上写 Python 程序，放到 Linux 上也是能够运行的，这是因为Python 是一种解释型语言，只要有解释器就可以运行 python 代码，在Windows、Mac 和各种 Linux/Unix 系统上都可以安装 python解释器。
优点：
- 高级语言 使用时无需考虑内存管理之类的底层细节。
- 免费开源 你可以自由地阅读它的源代码、发布这个软件的拷贝、对它进行修改、把它的一部分用于自己的软件中。
- 可移植性 因为它是开源的，所以只需亿点点改动就能使它工作在不同平台上。现在 Python 已经被移植在许多平台上。
- 有丰富的库 许多功能不需要自己写，可以直接用别人写的库解决问题
- 可扩展性 如果你需要你的一段关键代码运行得更快或者希望某些算法不公开，你可以把你的部分程序用 C 或 C++ 编写，然后在你的 Python 程序中调用它们
缺点：
- 运行速度慢，非常消耗内存，为了提高速度，一般使用 C++ 写关键部分，然后用 Python 调用 C++
版本说明
目前 Python 有 Python2 和 Python3 两个版本，这两个版本不能相互兼容，该笔记的编写以 Python3 为准
Python 提供了将 Python2 转化为 Python3 的功能，这需要安装 2to3 ，在命令行工具中使用Python 3 的包管理器 pip 来安装
pip install 2to3
参考：2to3 的使用方法 (opens new window)
# 安装python
- 在 MacOS 上安装 Python：下载地址 (opens new window)
- 在 Windows 上安装 Python：下载地址 (opens new window)
# 输入和输出
# 输出
用 print() 可以向屏幕上输出指定的文字。例如输出hello, world，用代码实现如下：
print('hello, world')
运行结果：
hello, world
输出变量值
一般输出一个变量只要需要把变量写入 print 函数中即可
x = 0
print(x)
但如果要和字符串一起输出，就需要用连接符 + 将字符串和变量连接起来
year = input()
month = input()
date = input()
print(year + "年" + month + "月"+ date +"日")
运行结果：
2024年9月22日
# 分隔符
当需要使用一个 print 函数输出多个数据时就要用到分隔符 , 把这些数据分隔开
print("Hello", "world")
输出结果：
Hello world
由于是两个数据，输出结果会用空格将这两个数据隔开
如果想要将这个空格替换成其他符号 就要用到 sep 参数了
# 参数
- sep
该参数用于设置分隔多个输出项之间的分隔符，默认为一个空格
print("Hello", "world", sep="!")
输出结果：
Hello!world
- end
用于设置输出结束后的字符，默认为换行符 \n
print("Hello", "world", end="!")
输出结果：
Hello world!
提示
print 可以同时使用多个参数，就像这样：
print("Hello", "world", sep="_", end="!")
其中 "Hello"， "world"， sep="_"， end="!" 都是参数
# 格式化输出
字符串格式化有多种方式
# 使用str.format()方法
语法
"str".format()
用法
方法一：
name = "Alice"
age = 25
print("{} is {} years old.".format(name, age))
方法二：
name = "Alice"
age = 25
# 指定位置参数
print("{1} plays {0}".format("football", "Tom"))
方法三：
name = "Alice"
age = 25
# 关键字参数
print("{name} likes to play {game}".format(name="Jerry", game="chess"))
示例
示例一：
year = input()
month = input()
date = input()
print("{}年{}月{}日".format(year,month, date))
输入：
2024
9
22
输出：
2024年9月22日
示例二：
year = input()
month = input()
date = input()
#指定位置参数
print("{2}年{1}月{0}日".format(year,month, date))
输入：
2024
9
11
输出：
11年9月2024日
# 使用 f-string
非常推荐使用 f-string 进行格式化输出
- 输出时不需要考虑变量的数据类型，f-string 会将其他数据类型转换为适合输出的字符串类型
- 输出时用
{}括住变量就行，不需要使用+这样的连接符，不易出错且表达更直观 - 方便使用格式化指令，可以很快的实现保留小数点后几位之类的功能
- 性能相较于其他更加优异
f-string 是一种从 Python 3.6 开始引入的一种格式化字符串的方式，相较于 format 方法表达更加直观，性能更加优异。
使用时需要在字符串前加一个 f ，表示使用 f-string 进行字符串格式化，变量用 {变量名} 的形式表达
使用示例
name = "Alice"
age = 25
print(f"My name is {name} and I am {age} years old.")
输出：
My name is Alice and I am 25 years old.
使用 f-string 实现保留小数点后几位
pi= 3.141592653589793238462643383279 # 保留小数点后30位的 π 值
print(f"{pi:.2f}") # 输出保留小数点后两位的 π 值
f"{pi:.2f}" 中，字符串前的 f 表示使用 f-string 进行格式化输出，pi 是变量，: 表示使用格式化命令，.2 表示保留小数点后4位，随后的 f 表示这是一个浮点数
# 使用 string.Template 类
string.Template 的优势在于可以做一个字符串模板，使用时只需要替换这个模板中需要更改的部分
使用示例
from string import Template # 从 string 模块中导入 Template 类
# 设置变量
a = "Alice"
b = 25
t = Template("My name is $name and I am $age years old.")
# 输出结果
print(t.substitute(name=a, age=b))
输出：
My name is Alice and I am 25 years old.
# 使用占位符
示例
name = "Alice"
age = 25
print("My name is %s and I am %d years old." % (name, age))
输出：
My name is Alice and I am 25 years old.
代码中的 %s 和 %d 都是占位符，从 % (name, age) 中按照顺序依次替换占位符。
占位符会表达其所代替对象的数据类型，例如 %s 代表字符串类型 %d 十进制整数类型
更多内容参考 Python_printf-style String Formatting (opens new window)
# 字符串切片
字符串切片的基本语法是
<string>[<start>:<end>:<step>]
<start>开始索引（默认为0）<end>结束索引<step>步长（默认为1）
输出第 5 个字符之前的所有字符
s = "Hello, world!"
print(s[:5])
输出：
Hello
输出第 6 到第 10 个字符
s = "Hello, world!"
print(s[5:10])
输出：
, wor
输出第 5 个字符之后的所有字符
s = "Hello, world!"
print(s[5:])
输出：
, world!
输出整个字符串
s = "Hello, world!"
print(s[:])
输出：
Hello, world!
从第一个字符开始，以步长为 2 依次输出
s = "abcdefgh"
print(s[::2])
输出：
aceg
步长就类似人类走路，步长越长跨过的字符越多，实际输出的字符就会变少，以上述为例，Hello, world! 从第一个字符 a 开始，由于步长为 2 ，所以每经过2个字符输出一次，所以第二次输出 c ，第三次输出 e 以此类推
# 多重切片
s = "abcdefghijklmn"
print(s[:5],s[5:10]) # 输出 abcde fghij
print(s[:5]+s[5:10]) # 输出 abcdefghij
# 反转字符串
步长为负时表示从后往前取值， -1 则表示从后往前逐个字符取值
s = "abcdefgh"
print(s[::-1])
输出：
hgfedcba
注意
:: 并不是一个特殊的运算符，而是因为在语法 <string>[<start>:<end>:<step>] 中 这里的代码并没有设定 <start> 和<end>
所以变成了 : :<step>，写紧凑点就成了 ::-1
# 转义符
当我们想要输出一些特殊符号例如 " 或者空格等因为语法原因导致内容无法被识别为要输出的字符串时就可以使用转义符 \ 它可以将该符号转义为与语法不冲突的符号，成功以字符串的形式输出
在需要转义的符号前加上 \ 即可，空格的转义符为 \n
# 输入
用 input() 可以向计算机输入数据，当计算机执行到 input() 代码时，计算机会等待用户进行输入，当用户输入完成后就会继续执行下一行代码
一般我们会设置一个变量用于保存计算机所输入的值，例如 x=input()，当计算机执行到 x=input() 时，计算机会让用户进行输入，并把输入的内容赋值给变量 x（这里的 = 表示赋值），这时 x 就等于刚才用户输入的值。
注意
默认情况下 input() 输入的内容会被存储为一个字符串类型的数据
x=input()
可以在 input() 括号中写一下提示性的话，来提示用户需要输入什么内容，例如：
name = input("请输入你的姓名：")
运行效果：
请输入你的姓名：
这时计算机就会输出 请输入你的姓名： 并等待用户的输入内容
# 数据类型
以下是 Python 的基本数据类型：
- 整数 (int)：如
42 - 浮点数 (float)：如
3.14 - 字符串 (str)：如
"Hello"（字符串类型的数据要用"符号括起来） - 布尔值 (bool)：如
True和False
除此之外还有一些更加高级的容器类型：
- 列表（List）：可变、有序，可以包含任意类型的元素
- 元组（Tuple）：不可变、有序，可以包含任意类型的元素
- 集合（Set）：无序、不重复，可变
- 字典（Dictionary）：键值对形式，可变，无序
什么是容器类型？
容器可以存储多个元素，每个元素可以是任何类型的数据，所有的容器类型都具有可迭代性，说人话就是可以通过循环进行遍历，来访问容器中的每一个元素。
字符串不是容器类型！
字符串虽有容器类型的一些性质，例如支持切片和索引，但它并不是容器类型。因为字符串中的每个字符都只是单一的字符并不是独立的对象
# 列表
序列是一种存储有序数据的基本数据结构，它由多个元素或数据按照顺序排列而成。列表，元组，字符串都是序列
索引
# 创建列表
Python 中列表类型一般用 [] 表示
list = []
这样就创建了一个空列表，列表中可以添加元素，这些元素用 , 隔开
list = [1, 2, 3]
# 访问列表元素
一般用索引的方式来访问列表中的某个元素，索引一般从 0 开始，list[0] 表示索引列表第一个元素，list[1] 自然就是索引列表中的第二个元素了
a = list[0]
像这样就是索引列表中的第一个元素，并把它赋值给变量 a
示例：
list = [1, 2, 3]
a = list[0]
print(a)
输出结果
1
如果在索引值前加一个负号 - 表示从后往前索引，例如 list[-1] 就表示从后往前索引列表 list
示例:
list = [1, 2, 3]
a = list[-1]
print(a)
输出结果
3
# 访问列表中多个元素
Python 可以索引某个范围的多个元素，索引值之间要用 : 隔开，例如 list[1:4] 表示从第二个元素开始到第四个元素
list = [1, 2, 3, 4, 5]
a = list[1:4]
print(a)
输出结果
[2, 3, 4]
这样输出的是结果是带 [] 的列表类型的数据，如果要输出这个列表中单一的值就要用到 解包（Unpacking）
list = [1, 2, 3, 4, 5]
a,b,c = list[1:4] # 使用解包赋值
print(a)
print(b)
print(c)
输出结果
2
3
4
- 访问列表中某个元素之后的所有元素
list = [1, 2, 3, 4, 5]
a = list[1:] # 访问索引值为 1 的元素及其之后的所有元素
print(a)
输出结果
[2, 3, 4, 5]
list[:1] 表示访问索引为 1 的元素前的所有元素，list[:-1] 表示访问从后往前数索引为 1 的元素之前的所有的元素
# 修改列表
- 修改列表中的元素
修改列表 list 的第一个元素为 new value
list[0] = 'new value'
以下是用于测试效果的完整代码
list = [1, 2, 3, 4, 5]
list[0] = 'new value'
a = list[0]
print(a)
输出结果
new value
- 在列表中添加元素
这个方法可以在列表中添加新的元素，但添加的新元素会按照顺序依次排列，排在之前元素的后面
list.append('new item')
示例
list = [1, 3, 3, 3, 5]
list.append('new item')
print(list)
输出结果
[1, 3, 3, 3, 5, 'new item']
- 在列表中插入元素
前面的 append 方法只能在列表的后面添加元素，而 insert 方法可以在列表中的特定位置插入元素
例如这段代码 是在列表 list 中的第 4 个元素前插入元素 "x"
list.insert(3, "x")
示例
list = [1, 2, 3, 4, 5]
list.insert(3, "x")
print(list)
输出结果
[1, 2, 3, 'x', 4, 5]
- 删除元素
list.remove(3)
这个方法可以删除列表里对应的元素，例如这个例子是删除列表 list 中值为3的元素。但这个方法有个问题是只能删除一次，若列表里有多个 3 时，并不会删除所有的 3 而是从左往右遍历，当检测到 3 时删除这个元素，然后就结束了，之后的 3 就不管了，所以要删除一个列表中的所有 3 时就要使用使用 while 循环，遍历列表里的所有元素，并删除列表中的3，就像这样
list = [1, 3, 3, 3, 5]
while 3 in list:
list.remove(3)
print(list)
- 删除列表中指定位置的元素
例如这个例子是删除列表 list 中索引到的的第一个元素
del list[0]
- 清空列表
list.clear()
# 列表拼接
通过运算符 += 把列表 a 和列表 b 拼接起来
a = [1, 2, 3, 4, 5]
b = [6, 7, 8, 9, 10]
a += b
print(a)
输出结果
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 列表嵌套
a = [1, 2, 3, 4, 5]
b = [6, 7, 8, 9, 10]
c = [a, b]
print(c)
输出结果
[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]
# 列表比较
- 比较列表是否完全相等
if a == b:
- 比较列表内容是否相同（忽略顺序），思路是把列表转换成集合类型来比较
if set(a) == set(b):
- 比较列表的长度
if len(a) == len(b):
# 查看元素索引
index 方法可以帮助我们查看列表中某个元素的索引值
示例
list = [1, 2, 3, 4, 5]
a = list.index(4)
print(a)
输出结果
3
输出结果为 3 说明元素 4 的索引值为 3。这个方法也是一次性的，当列表中有多个相同的元素时它输出的索引值是第一个遍历到指定元素的索引值
如果要输出列表中所有的指定元素时，可以使用 enumerate 函数
list = [1, 2, 3, 3, 5]
indices = [i for i, value in enumerate(list) if value == 3]
print(indices)
输出结果
[2, 3]
# 获取列表长度
使用 len 函数可以获取数据的长度，它可以可以应用于多种数据类型，包括列表、元组、字符串、字典、集合等，这里以列表为例
list = [1, 2, 3, 3, 5]
length = len(list) # 获取列表长度
print(length)
输出结果
5
# 关于列表的函数&方法
函数
| 函数 | 说明 |
|---|---|
len(list) | 列表元素个数，list 表示要计算元素个数的列表 |
max(list) | 返回列表元素最大值，list 表示要返回最大值的列表 |
min(list) | 返回列表元素最小值，list 表示要返回最小值的列表 |
list(seq) | 将元组转换为列表，seq 表示要转换为列表的元组或字符串 |
方法
| 方法 | 说明 |
|---|---|
list.append(obj) | 在列表末尾添加新的对象，obj 为添加到列表末尾的对象 |
list.count(obj) | 统计某个元素在列表中出现的次数，obj 为列表中被统计的对象 |
list.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值，seq 为追加的序列，例如列表、元组、集合、字典 |
list.index(obj) | 从列表中查找某个值第一个匹配项的索引位置，obj 为被查找的对象 |
list.insert(index, obj) | 将对象插入列表，index表示要插入的位置的索引值，obj要插入列表中的对象 |
list.remove(obj) | 移除列表中某个值的第一个匹配项，obj 是列表中要移除的对象 |
list.reverse() | 反向列表中的元素，使用时列表中的元素会从后往前的方向访问 |
list.clear() | 清空列表 |
list.copy() | 复制列表 |
# 元组
# 集合
# 字典
在 Python 3.7 之前，字典（dict）是无序的，也就是说，当你访问字典的键或值时，它们的顺序可能是随机的，不保证按照插入顺序排列。然而，从 Python 3.7 开始，字典开始保持插入顺序，这意味着元素会按照插入的顺序进行排序。
# 转换数据类型
int()将其他数据类型转换为整数float()将其他数据类型转换为浮点数str()将其他数据类型转换为字符串bool()将其他数据类型转换为布尔值list()将其他数据类型转换为列表tuple()将其他数据类型转换为元组dict()将其他数据类型转换为字典set()将其他数据类型转换为集合eval()可以将字符串动态转化为其他数据类型，例如当数据需要作为浮点数进行计算时，它就会将该字符串转化为字符串类型的数据
提示
当你需要转换数据类型，但又不确定将数据转换成什么类型时就可以使用eval()，他会自动将数据转换为合适的类型
# int()
将字符串转换为整数
num_str = "123"
num_int = int(num_str)
print(num_int)
输出：
123
将浮点数转换为整数
num_float = 123.45
num_isnt = int(num_float)
print(num_isnt)
输出：
123
# float()
将字符串转换为浮点数
num_str = "123.45"
num_float = float(num_str)
print(num_float)
输出：
123.45
将整数转换为浮点数
num_int = 123
num_float = float(num_int)
print(num_float)
输出：
123.0
# str()
将整数转换为字符串
num_int = 123
num_str = str(num_int)
print(num_str)
输出：
123
注意
虽然输出的还是 123 但是经过 str() 函数的处理后，数据类型已经从整数类型变为了字符串类型，这时的 123 并不能像整数一样进行算数运算
将浮点数转换为字符串
num_float = 123.45
num_str = str(num_float) # 结果: "123.45"
# bool()
# 将整数转换为布尔值
num_int = 0
num_bool = bool(num_int) # 结果: False
num_int = 1
num_bool = bool(num_int) # 结果: True
# 将字符串转换为布尔值
num_str = ""
num_bool = bool(num_str) # 结果: False
num_str = "hello"
num_bool = bool(num_str) # 结果: True
大部分编程语言中非零的值被视为真值（True）如下：
当把整数 5 转换为布尔类型后输出的值是 True
num_int = 5
num_bool = bool(num_int)
print(num_bool)
输出：
True
这里如果把 5 换作 0 就会输出 False
# list()
将字符串转换为列表
str_data = "hello"
list_data = list(str_data)
print(list_data)
输出：
['h', 'e', 'l', 'l', 'o']
将元组转换为列表
tuple_data = (1, 2, 3)
list_data = list(tuple_data)
print(list_data)
输出：
[1, 2, 3]
# tuple()
将列表转换为元组
list_data = [1, 2, 3]
tuple_data = tuple(list_data)
print(tuple_data)
输出：
(1, 2, 3)
将字符串转换为元组
str_data = "hello"
tuple_data = tuple(str_data)
print(tuple_data)
输出：
('h', 'e', 'l', 'l', 'o')
# dict()
# 将列表转换为字典
list_data = [("a", 1), ("b", 2)]
dict_data = dict(list_data) # 结果: {'a': 1, 'b': 2}
# 使用关键字参数创建字典
dict_data = dict(a=1, b=2) # 结果: {'a': 1, 'b': 2}
# set()
# 将列表转换为集合
list_data = [1, 2, 2, 3, 4]
set_data = set(list_data) # 结果: {1, 2, 3, 4}
# 将字符串转换为集合
str_data = "hello"
set_data = set(str_data) # 结果: {'h', 'e', 'l', 'o'}
# 注释
注释一般用于解释代码的作用，并不会执行
# 这是一个单行注释，用于对此行代码进行说明
多行注释
多行注释不能使用 # 表示，要用 """ 括起来表示
"""
这是一个多行注释
可以跨越多行
"""
# 声明
注释除了以上用法外，还有另一种特殊的用法。一般注释是不会执行的，除了代码开头的两行特殊注释，以下代码就是开头的前两行注释，第一行叫做（Shebang Line）用于指定执行代码的解释器，可以用它来指定所安装的不同版本的 Python 解释器来执行该文件中的代码，第二行用于指定代码所用的字符编码格式，Python 一般默认使用 UTF-8，它们的使用一般在 Linux 和 macOS 上比较常见
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#!/ 表示这是一个可执行脚本文件，后面跟着的是解释器的路径。例如 /usr/bin/python3，env 可以帮助找到正确的解释器路径
# 变量
设置变量的过程其实是向计算机申请内存空间的过程，给变量赋的值会存储在计算机的内存中，当使用这个变量时计算机就会从内存里找到这个变量的值
- 变量的首字符不能是数字
- 变量名中间不能出现空格（空格用
_代替） - 变量名只能包含字母、数字和下划线 _（理论上可以使用中文作为变量名，但不建议）
- 变量名区分大小写，例如 x 和 X 是不同的变量
- 建议使用有意义的变量名，以便代码更具可读性
- 不建议使用中文作为变量名
- 不要将 Python 关键词（保留字）作为变量名 查看指定字符是否为关键词 (opens new window)
示例
设置一个变量 x 并给这个 x 赋值为 0
x = 0
# 变量赋值
给变量赋值不同类型的数据
x = 10 #整数类型
pi = 3.14159 #浮点数类型
name = "Alice" #字符串类型
# 变量的作用域
全局变量：
写在公共部分的变量，并不属于某个函数，全局变量可以在程序中的任何地方使用
x = 10
def function():
print(x) # 输出 10
function()
print(x) # 输出 10
这段代码会输出两个 10，说明在函数内和函数外都可以使用这个全局变量 x
局部变量：
在函数内部定义的变量，只在该函数内部有效
def function():
x = 10
print(x) # 输出 10
function()
print(x) # 报错：NameError: name 'x' is not defined
这段代码会输出一个 10 并报错，这是因为最后一行代码的print() 无法获取x 的值，因为变量 x 是写在
# 重新赋值
x = 10
x = 20
print(x) # 输出 20
输出结果：
20
代码逐行执行，第二行代码覆盖了第一行，所以输出的是第二次赋的值
# 多变量赋值
一次性给变量 a, b, c 分别赋值 1, 2, 3
a, b, c = 1, 2, 3
print(a, b, c) # 输出 1 2 3
输出结果：
1 2 3
# 变量交换
通过多变量赋值的方法可以将两个变量的值进行互换
x=1
y=0
x,y=y,x #交换两个变量的值
print(x,y)
输出结果：
0 1
# 将多个变量同时赋相同的值
x=y=z=1
print(x,y,z)
输出结果：
1 1 1
# 运算符
Python 语言支持以下类型的运算符：
算术运算符 ，比较运算符 ，赋值运算符 ，逻辑运算符 ，位运算符 ，成员运算符 ，身份运算符
# 算术运算符
| 运算符 | 说明 | 实例 |
|---|---|---|
+ | 加法运算（返回两数之和） | 1 + 2返回3 |
- | 减法运算（返回两级之差） | 3 - 2返回1 |
* | 乘法运算（返回两数之积） | 2 * 3返回6 |
/ | 除法运算（返回两数之比） | 2 / 6返回3 |
** | 幂运算（返回该数的n次方） | 2 ** 3返回8 |
% | 模运算（返回除法的余数部分） | 10 % 3返回1 |
// | 整除（返回除法的整数部分） | 10 // 3返回3 |
注意
//是往数值小的方向取整数，例如-10 // 3返回-4
使用示例：
# 输出运算结果 x
x = 1 + 2
print(x) # 输出结果3
# 运算并直接输出
print(2 * 3) # 输出结果6
# 比较运算符
| 运算符 | 说明 | 示例 |
|---|---|---|
== | 等于（若两数相等则返回 True 否则返回 False） | a == b |
!= | 不等于（若两数不相等则返回 True 否则返回 False） | a != b |
> | 小于（若 a 大于 b 则返回 True 否则返回 False） | a > b |
< | 大于（若 a 小于 b 则返回 True 否则返回 False） | a < b |
<= | 小于等于（若 a 小于或等于 b 则返回 True 否则返回 False） | a <= b |
>= | 大于等于（若 a 大于或等于 b 则返回 True 否则返回 False） | a >= b |
比较运算符常用于条件判断（if语句）或者循环条件（while 和 for）
使用示例
示例1：
x = 3
print(x == 3)
输出：
True
示例2：
age = 18
if age >= 18:
print("成年人")
else:
print("未成年人")
输出：
成年人
示例3：
i = 0
while i < 5:
print(i)
i += 1
输出：
0
1
2
3
4
# 赋值运算符
| 运算符 | 说明 | 示例 |
|---|---|---|
= | 赋值 | c = a + b 将 a + b 的运算结果赋值为 c |
+= | 加法赋值 | c += a 等效于 c = c + a |
-= | 减法赋值 | c -= a 等效于 c = c - a |
*= | 乘法赋值 | c *= a 等效于 c = c * a |
/= | 除法赋值 | c /= a 等效于 c = c / a |
//= | 整除赋值 | c %= a 等效于 c = c % a |
%= | 取模赋值 | c %= a 等效于 c = c % a |
**= | 幂赋值 | c **= a 等效于 c = c ** a |
使用示例
c = 2
c += 1 # 相当于c=c+1
print(c)
输出：
3
# 逻辑运算符
| 运算符 | 说明 | 示例 |
|---|---|---|
and | 与 | 两个操作数的值都为 True（真），则结果为 True（真）；否则为 False（假） |
or | 或 | 至少有一个操作数为 True（真），则结果为 True（真）；否则为 False（假） |
not | 非 | 对操作数的布尔值取反，若原值为 True（真）则结果为 False（假），若原值为 False（假）则结果为 True（真） |
逻辑运算符常用于条件判断（if语句）或者循环条件（while 和 for）
# 位运算
| 运算符 | 说明 | 示例 |
|---|---|---|
& | 与（位运算） | (a & b)两个对应的位都为 1 ,则该位的结果为 1 ,否则为 0 |
| | 或（位运算） | (a | b)对应的二个位有一个为 1 时，结果位就为 1 |
^ | 异或 | (a ^ b)两个对应的位不同时为 1 ，否则为 0 |
~ | 取反 | (~a) 把 1 变为 0 ,把 0 变为 1 |
<< | 左移 | (a << 2)二进制位整体向左移动（高位丢弃，低位补0） |
>> | 右移 | (a >> 2)二进制位整体向右移动（高位丢弃，低位补0） |
示例
---- 分割线上是 a，b以及它们对应的值，分割线下是经过不同位运算后的结果
a 0011 1100
b 0000 1101
---------------------
a&b 0000 1100
a|b 0011 1101
a^b 0011 0001
~a 1100 0011
a<<2 1111 0000
a>>2 0000 1111
# 成员运算符
成员运算符用于检查序列中是否包含某个特定的元素
| 运算符 | 说明 |
|---|---|
in | 若序列中包含该元素则返回 True，否则返回 False |
not in | 若序列中不包含该元素则返回 True，否则返回 False |
使用示例
# 判断元素是否在列表中
list = [1, 2, 3, 4, 5]
if 3 in list:
print("3 在列表中")
# 判断元素是否不在字串中
str = "Hello, world!"
if "x" not in str:
print("'x' 不在字符串中")
# 身份运算符
身份运算符用于比较两个对象的是否是同一个对象，即具有相同的内存地址
| 运算符 | 说明 | 示例 |
|---|---|---|
is | 两个对象的内存地址相同则返回 True ，否则返回 False | a is b |
is not | 两个对象的内存地址不同则返回 True ，否则返回 False | a is not b |
# 优先级
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
() | ****= | +x-x~x | *///% | +- | <<>> | & | ^ | | | ==!=<<=>>= | not | and | or |
提示
括号()可以用来改变表达式中运算符的优先级，例如2 + 3 * 4和(2 + 3) * 4，前者优先运算3*4，而后者优先运算2+3
# 层级关系
提示
在编写 Python 时，一般用 4 个空格表示一次缩进
在 Python 中通过缩进来表达层级关系，以下面的代码为例
age = 17
if age >= 18:
print("abc")
print("123")
这段代码中使用了一个条件语句，当满足条件时就会执行之后的代码，如果条件不满足就会跳过后面这段代码，很明显条件中需要 age 大于等于 18 ，所以条件并不满足。代码中有两个 print 函数，print("abc") 有缩进，所以属于 if 语句， print("123") 没有缩进，与 if 层级并列（不属于 if 语句）
输出结果：
123
print("abc") 属于 if 语句，所以当条件满足时就会执行该代码，如果条件不满足则不执行，由于该程序条件不满足，所以这里并不能输出 abc ，而 print("123") 并不属于 if 语句，所以不受 if 条件的影响 ，可以直接输出 123。
def compare(a, b):
if a > b:
return a
else:
return b
print(compare(4, 5))
这段代码中 def compare(a, b): 和 print(compare(4, 5)) 是第一层级，
if a > b 和 else 是第二层级，return a 和 return b 第三层级，层级间是包含关系，第一层级包含第二层级，第二层级包含第三层级
# 条件语句
条件语句用关键词 if 表示，if 后面是需要进行判断的条件，当满足条件时就执行下一行，如果不满足条件则跳过（这里的跳过并不是跳过下一行，而是跳出 if 语句，进入和 if 语句并列的层级，如果 if 语句中有多行代码，都会一并跳过，不会执行）
if age >= 18:
print("yes")
这是一个 if 语句，age >= 18 是它的条件，print("yes") 是条件满足后执行的代码（必须用缩进表示它的所属于 if 语句）
前面只说了满足条件时执行的情况，可以用 else 编写在条件不满足时所要执行的代码
if age >= 18:
print("yes")
else:
print("no")
这段代码的意思是，如果变量 age 的值大于等于 18 则输出 yes ，否则输出 no
# 多条件语句
如果要进行筛选，就需要用到多条件语句 elif，当第一个 if 条件不成立时，程序会继续检查 elif 后面的条件，直到找到一个条件满足的情况。例如
if score > 90:
print("A")
elif score > 80:
print("B")
elif score > 60:
print("C")
else:
print("D")
这里假设 score = 75，执行程序后检查 score 是否大于 90，条件不满足则继续检查 score 是否大于 80，条件也不满足，继续检查 score 是否大于 60，条件满足，则输出 C
# 并列条件语句
现在需要实现一个程序，输入月份，输出这个月有多少天。如何实现这个程序？ 1、3、5、7、8、10、12 月有 31 天；4、6、9、11 月有 30 天。只需要判断月份再输出对应的天数就行了，通常我们会想到用语句嵌套来一个月一个月判断
# 获取用户输入的月份
month = int(input("请输入月份（1-12）："))
# 判断月份并输出对应的天数
if month == 1:
print(f"{month}月有31天")
else:
if month == 2:
print(f"{month}月有28天或29天（闰年时为29天）")
else:
if month == 3:
print(f"{month}月有31天")
else:
if month == 4:
print(f"{month}月有30天")
else:
if month == 5:
print(f"{month}月有31天")
else:
if month == 6:
print(f"{month}月有30天")
else:
if month == 7:
print(f"{month}月有31天")
else:
if month == 8:
print(f"{month}月有31天")
else:
if month == 9:
print(f"{month}月有30天")
else:
if month == 10:
print(f"{month}月有31天")
else:
if month == 11:
print(f"{month}月有30天")
else:
if month == 12:
print(f"{month}月有31天")
else:
print("输入的月份无效，请输入1到12之间的数字")
的确这种方法可以实现，但这样的代码存在几个缺点：
- 代码冗长难以阅读和维护。
- 扩展性差，如需增加新的条件或者修改现有条件，需要手动添加或修改多个 if-else 语句，容易出错。
- 性能下降，复杂的条件判断中，嵌套的 if-else 语句可能会导致性能下降。
为了解决这些问题，我们可以使用逻辑运算符帮忙
# 获取用户输入的月份
month = int(input("请输入月份（1-12）："))
# 判断月份并输出对应的天数
if month == 1 or month == 3 or month == 5 or month == 7 or month == 8 or month == 10 or month == 12:
print(f"{month}月有31天")
elif month == 4 or month == 6 or month == 9 or month == 11:
print(f"{month}月有30天")
elif month == 2:
print(f"{month}月有28天或29天（闰年时为29天）")
else:
print("输入的月份无效，请输入1到12之间的数字")
这样一来代码就精简了许多，但我还是不满意，这个判断条件也太长了吧，这是我就想到了另一种方法来替代这些流水线式的判断条件，可以使用容器！我们可以把这些月份放在容器里，让 if 检查这个容器中的月份，根据月份来输出天数
if m in [1, 3, 5, 7, 8, 10, 12]:
print("31")
elif m in [4,6,9,11]:
print("30")
elif m == 2:
print("28 or 29")
这里我使用列表作为容器，也可以使用字典等其他容器类型
再举一个例子，比如判断闰年，闰年分以下两种
- 普通闰年：年份是 4 的倍数，且不是 100 的倍数；
- 世纪闰年：年份是 400 的倍数。
def LeapYear(year):
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
return True
return False
# 语句嵌套
Python 支持语句的嵌套，就是可以把一个语句结构放在另一个语句结构之中。例如下面这段代码，在一个条件语句里嵌套了另一个条件语句，当条件 1 满足时就会执行里面的判断语句，判断条件 2 是否满足，如果条件 1 不满足就会进入执行 else: 语句后的代码
if condition1:
# 条件1成立时执行的代码
if condition2:
# 条件2成立时执行的代码
else:
# 条件2不成立时执行的代码
else:
# 条件1不成立时执行的代码
# 条件表达式
# 循环语句
Python 提供了两种循环语句，分别是 for 循环和 while 循环
# while
while 循环语句会根据条件进行循环，如果条件满足则结束循环，条件不满足则继续循环，直至满足条件
a=0
while a < 5:
print(a)
a+=1
输出结果
0
1
2
3
4
这段代码有一个 while 循环语句，while 后面是判断的条件，如果条件满足就跳出 while 语句，如果条件不满足就执行 while 语句中的代码，执行完后在回到 while 所在的那行代码重新判断条件是否满足，如果不满足则继续，直到满足为止
# for
for 循环语句常用于遍历对象中的元素
使用 for 循环语句遍历字符串
word = "yoseya"
for x in word:
print(x)
也可以这样
for x in "yoseya":
print(x)
输出结果
y
o
s
e
y
a
这段代码中的 x 是循环变量，跟在 in 后面的是要进行遍历的对象，这个对象可以是变量，也可以是字典，元组，列表，字符串这样类型的数据（它们都有一个共同的特点：一个对象包含多个元素。所以它们具有可迭代性）
提示
x 是一个临时申请的变量，用于存储当前迭代中的元素，在每次迭代后，x 的值会被更新为下一个元素
# break
break 语句用于提前终止循环
for i in range(10):
if i == 5:
break
print(i)
解析：range 函数可以从 0 开始生成一个整数序列，例如 range(10) 就是生成序列 1,2,3,4,5,6,7,8,9,10，for 循环语句会按照这个序列依次给变量 i赋值，for 语句中嵌套到了一个 if 判断语句，当变量 i 等于 5 时进入 if 语句，随后执行 break 语句，跳出 for 循环语句
输出结果
0
1
2
3
4
由于在变量 i 等于 5 时就执行 break 语句 跳出了循环，所以就不会再输出变量 i 的值了
# continue
continue 语句用于跳过当前循环的剩余部分，继续执行下一次循环，与break 语句不同的是 continue 语句不会跳出循环，而是跳过 continue 语句之后的代码，继续进行循环。通过这个语句可以实现一个对于奇偶数的筛选，如下
for i in range(10):
if i % 2 == 0:
continue
print(i)
解析：range 函数生成了序列 1,2,3,4,5,6,7,8,9,10 for 循环语句按照序列依次给变量 i 赋值，当变量 i 被2整除时进入 if 执行 continue 语句，跳过之后的代码（for循环语句内）继续进行下一次循环
输出结果
1
3
5
7
9
参考：如何判断奇偶数？
# else
for 循环中的 else 语句会在循环正常结束（未被 break 终止）时执行
for i in range(10):
if i == 5:
break
print(i)
else:
print("循环正常结束")
这段代码中 break 会正常执行所以不会执行 else 语句中的代码，我们可以创造一个情况让 break 不执行，例如把 if i == 5: 改为 if i == 11:，由于 变量 i 永远不可能为11，所以 break 语句永远不会执行，这时再试试结果会不会输出 循环正常结束
# 函数
函数是什么？
函数是一堆被封装起来的代码。当我们需要实现一个功能，这个功能在之后不同的场景中可能会多次用到，为了避免重复编写这一功能，所以我们把实现这个功能的代码封装起来，当再用到时就可以用语句调用这段代码，不用重复编写
函数的优点
- 代码复用：通过定义函数，可以在程序的不同部分多次调用它，避免重复编写相同的代码。
- 模块化：函数使得程序结构更加清晰，易于理解和维护。
- 易于调试：函数将程序分解成小的独立部分，便于定位和修复错误。
- 封装性：函数内部的具体实现细节对外部是隐藏的，只暴露必要的接口
定义函数
函数使用关键词 def 定义，后面跟着函数名和参数，参数写在括号 () 里
# 定义函数
def greet(name):
print(f"Hello, {name}!")
# 调用函数
greet("yoseya")
这段代码中 greet 是函数名，name 是参数，参数可以是一个也可以是多个，多个参数间要用 , 隔开
输出结果
Hello, yoseya!
返回值
使用 return 语句可以使函数返回一个值
def add(a, b): # 定义函数及参数
c = a + b # 进行运算
return c # 返回值 x
x = add(3, 4) # 获取返回值（把函数返回的值赋值给 x）
print(x) # 输出 x
# 参数
- 传递参数
一般情况下调用函数时参数填写的顺序和函数定义时参数的位置一一对应，例如
def add(a, b):
add(3, 4)
调用函数时要向函数内传递参数（在括号中填写参数），参数填写的顺序和函数定义时的顺序一致，这里的 3 对应 a，4 对应 b
如果参数太多不想一一对应的填写参数，也可以通过参数名传递参数，这样的方式不需要考虑参数的顺序
def add(a, b):
add(b=3, a=4)
# 可变参数
# Lambda 函数
# 闭包
# 装饰器
# 递归函数
# 模块
# 导入模块
# 数学运算
在 Python 中进行高级的数学运算时需要使用 Python 自带的数学函数库 math，它提供了许多标准数学函数，如 sin, cos, log, exp 等可用于普通的数学运算
参考：math 函数库使用文档 (opens new window)
使用前需要先引入 math 数学函数库
import math
如果有更高级的数学运算需求可以使用 NumPy，它支持多种随机数生成方法，可用于多维数组操作，支持矢量化运算，广泛应用于科学计算、数据分析和机器学习等领域
参考：NumPy 用户指南 (opens new window)
NumPy 是一个第三方库，需要单独安装
pip install numpy
引入 NumPy 科学计算库
import numpy as np
如果你需要处理大规模数值数据并进行高效操作，建议使用 NumPy，如果你只需要简单的数学计算，可以使用 math
# 图表绘制
在 Python 中绘制图表需要引入专门的绘图库， Matplotlib 就是一个主流的绘图库，支持绘制静态，动态，可交互式的多种类型的图表
安装
pip install matplotlib
参考： Matplotlib 使用文档 (opens new window)
使用示例
假设一架飞机要在空中投掷炸弹，条件如下
列出计算公式：
求投掷炸弹后，
# 引入所需的库
import matplotlib.pyplot as plt
import numpy as np
# 设置参数
h = 3000
v0 = 200
g = 9.8
t = np.arange(0.0, 3.5, 0.01) # 设置时间(0 ~ 3.5s)
x = v0 * t # 计算横坐标
y = h - (1 / 2) * g * t**2 # 计算纵坐标
plt.plot(x, y) # 绘制点
plt.grid(True) # 显示网格
plt.xlabel("range (m)") # 设置x轴标签
plt.ylabel("height (m)") # 设置y轴标签
plt.title("Flight path of the bomb") # 设置标题
plt.savefig("pic.svg") # 保存文件
plt.show() # 显示图像
输出结果：
# 其他
这里存放的是一些我在学习中遇到的不好分类的内容
# venv
venv 是 Python 自带的一个模块，用于创建虚拟环境。虚拟环境是一个独立的 Python 环境，其中包含了一个独立的 Python 解释器及其相关的库和包。这样可以避免不同项目之间的依赖冲突
venv 文件夹通常包含以下几个主要部分:
bin包含了一些可执行脚本，如 activate（激活虚拟环境的脚本）、pip（包管理工具）等include包含了一些头文件，用于编译 C 扩展等lib包含了 Python 标准库和其他安装的第三方库pyvenv.cfg包含了虚拟环境的一些配置信息，如 Python 版本等