1、Python 基础知识
1、输入输出
是与用户进行交互的重要部分。
# 控制台输入
-------------------------------------------------------
# 从控制台读取输入
name = input("Enter your name: ")
print(f"Hello, {name}!")
'''
Enter your name: 小宏运维有点菜
Hello, 小宏运维有点菜!
'''
# 读取整数输入
age = int(input("Enter your age: "))
print(f"You are {age} years old.")
'''
Enter your age: 18
You are 18 years old.
'''
# 读取整数输入
age = int(input("Enter your age: "))
print(f"You are {age} years old.")
'''
Enter your age: 18
You are 18 years old.
'''
# 控制台输出
-------------------------------------------------------
# 打印字符串
print("Hello, World!")
'''
Hello, World!
'''
# 打印多个值
a = 10
b = 20
print("The values are:", a, b)
'''
The values are: 10 20
'''
# 格式化字符串
name = "小宏运维有点菜"
age = 18
print(f"My name is {name} and I am {age} years old.")
'''
My name is 小宏运维有点菜 and I am 18 years old.
'''
# 使用字符串格式化方法
print("My name is {} and I am {} years old.".format(name, age))
'''
My name is 小宏运维有点菜 and I am 18 years old.
'''2、注释
注释是用来解释代码的文本，对于代码的理解和维护非常重要。
Python支持两种类型的注释：单行注释和多行注释。
# 这是一个单行注释
# x = 5
------------------------------------------------------------
'''''' 这是多行注释
'''
这是一个多行注释示例。
它可以跨越多行，用于详细解释函数或类的功能。
'''
3、pass
pass是一个空语句，它不执行任何操作。它通常用作占位符，用于语法上需要语句但又不需要实际操作的情况。pass的存在使得代码结构更加完整。
my_list = [1, 2, 3, 4, 5]
for item in my_list:
if item % 2 == 0:
# TODO: 处理偶数
pass
else:
# TODO: 处理奇数
pass4、运算符
运算符用于执行各种操作，例如算术运算、比较运算、逻辑运算等。
# 算数运算法
a = 10
b = 3
# 依次：加、减、乘、除、整除（商）、取余数、幂运算
print(a + b) # 输出: 13
print(a - b) # 输出: 7
print(a * b) # 输出: 30
print(a / b) # 输出: 3.3333333333333335
print(a // b) # 输出: 3
print(a % b) # 输出: 1
print(a ** b) # 输出: 1000
-------------------------------------------------------------------------------
# 比较运算法
x = 10
y = 5
# 依次：等于、不等于、大于、小于、大于等于、小于等于
print(x == y) # 输出: False
print(x != y) # 输出: True
print(x > y) # 输出: True
print(x < y) # 输出: False
print(x >= y) # 输出: True
print(x <= y) # 输出: False
-------------------------------------------------------------------------------
# 逻辑运算符
a = True
b = False
# 依次：与，所有条件为真时结果为真、 或，任意条件为真时结果为真、 非，反转条件的真假
print(a and b) # 输出: False
print(a or b) # 输出: True
print(not a) # 输出: False
5、字符串
字符串格式化是将变量值、表达式或其他字符串插入到字符串中的一种方法，以便动态地生成字符串。
# 格式化字符串 %
name = "小宏运维有点菜"
age = 18
formatted_string = "Name: %s, Age: %d" % (name, age)
print(formatted_string)
'''
Name: 小宏运维有点菜, Age: 30
'''
-----------------------------------------------------------------------------
# 使用 () 格式化字符串
name = "小宏运维有点菜"
age = 18
formatted_string = "Name: {}, Age: {}".format(name, age)
print(formatted_string)
'''
Name: 小宏运维有点菜, Age: 25
'''
----------------------------------------------------------------------------
# 使用 f-strings 格式化字符串
name = "小宏运维有点菜"
age = 18
formatted_string = f"Name: {name}, Age: {age}"
print(formatted_string)
'''
Name: 小宏运维有点菜, Age: 20
'''
---------------------------------------------------------------------------
# 使用字典格式化字符串
person = {'name': 'xiaohong', 'age': 18}
formatted_string = "Name: {name}, Age: {age}".format(**person)
print(formatted_string)
'''
Name: xiaohong, Age: 28
'''
6、range
range()是一个用于生成整数序列的内置函数。它常用于循环结构中，例如for循环，可以生成一系列按指定步长递增或递减的整数。
# 解释
range(start, stop, step)
start：序列的起始值，默认为 0。
stop：序列的结束值（不包含），必须指定。
step：序列的步长，默认为 1。
-------------------------------------------------------------------------
# 使用 range() 进行迭代：
for i in range(5):
print(i)
'''
0
1
2
3
4
'''
--------------------------------------------------------------------------
# 指定步长
for i in range(1, 10, 2):
print(i)
'''
1
3
5
7
9
'''2、数据类型
1、列表：list
列表（list）是一种有序、可变的数据集合，用于存储一组任意类型的元素。列表是非常常用的数据结构，它支持增删改查等多种操作。
1. 使用 [] 创建列表,最常见的方法是使用方括号 [] 来创建一个空列表或包含元素的列表
# 创建一个空列表
empty_list = []
# 创建一个包含元素的列表
fruits = ['apple', 'banana', 'cherry']
----------------------------------------------------------------------------------
2.使用 list() 函数,可以使用 list() 函数将其他可迭代对象（如字符串、元组、集合等）转换为列表
# 使用 list() 函数从字符串创建列表
chars = list("hello")
print(chars) # 输出: ['h', 'e', 'l', 'l', 'o']
# 使用 list() 函数从元组创建列表
numbers = list((1, 2, 3, 4))
print(numbers) # 输出: [1, 2, 3, 4]
---------------------------------------------------------------------------------
3.访问列表元素,可以使用索引（从0开始）访问列表中的元素，也可以使用负索引从列表末尾开始计数
fruits = ['apple', 'banana', 'cherry']
print(fruits[0]) # 输出: 'apple'
print(fruits[-1]) # 输出: 'cherry'
---------------------------------------------------------------------------------
4.添加元素,使用 append() 方法在列表末尾添加元素：
fruits = ['apple', 'banana', 'cherry']
('orange')
print(fruits) # 输出: ['apple', 'banana', 'cherry', 'orange']
4.1 使用 insert() 方法在指定位置插入元素
(1, 'grape')
print(fruits) # 输出: ['apple', 'grape', 'banana', 'cherry', 'orange']
-------------------------------------------------------------------------------
5.删除元素,使用 remove() 方法删除指定值的元素
('banana')
print(fruits) # 输出: ['apple', 'grape', 'cherry', 'orange']
5.1 使用 pop() 方法删除指定索引的元素（默认删除最后一个元素）
removed_fruit = (1)
print(fruits) # 输出: ['apple', 'cherry', 'orange']
print(removed_fruit) # 输出: 'grape'
-------------------------------------------------------------------------------
6.修改元素,可以直接通过索引对列表元素进行赋值修改
fruits[1] = 'pear'
print(fruits) # 输出: ['apple', 'pear', 'cherry', 'orange']
6.1 列表切片,使用切片操作可以获取列表的子集
numbers = [1, 2, 3, 4, 5]
subset = numbers[1:4]
print(subset) # 输出: [2, 3, 4]2、字符串：string
字符串（string）是一种有序的字符序列，用于存储和表示文本信息。Python提供了丰富的字符串操作方法，包括创建字符串、访问字符串中的字符、字符串的拼接和切片、字符串方法以及格式化字符串等功能。
1.创建字符串
# 使用单引号创建字符串
single_quoted_string = 'Hello, Python!'
# 使用双引号创建字符串
double_quoted_string = "Hello, Python!"
-------------------------------------------------------------------
2.使用三引号创建多行字符串
multi_line_string = """
This is a multi-line
string in Python.
"""
-------------------------------------------------------------------
3.访问字符串中的字符,可以使用索引访问字符串中的单个字符，索引从0开始
my_string = "Hello"
print(my_string[0]) # 输出: 'H'
print(my_string[1]) # 输出: 'e'
-------------------------------------------------------------------
4.字符串切片（Slicing）,使用切片操作可以获取字符串的子串
my_string = "Hello, Python!"
print(my_string[7:13]) # 输出: 'Python'
-------------------------------------------------------------------
5.字符串拼接,使用 + 号将两个字符串拼接起来
str1 = "Hello"
str2 = "Python"
concatenated_string = str1 + ", " + str2
print(concatenated_string) # 输出: 'Hello, Python'
-------------------------------------------------------------------
6.字符串常用方法
upper()：将字符串转换为大写字母。
text = "hello"
print(()) # 输出: HELLO
lower()：将字符串转换为小写字母。
text = "HELLO"
print(()) # 输出: hello
strip()：去除字符串两端的空格或指定字符。
text = " hello "
print(()) # 输出: hello
replace(old, new)：将字符串中的指定子字符串替换为新的子字符串。
text = "Hello, World!"
print(("World", "Python")) # 输出: Hello, Python!
split(separator)：将字符串按指定分隔符拆分为列表。
text = "Hello, World!"
words = (", ")
print(words) # 输出: ['Hello', 'World!']
find(substring)：返回子字符串在字符串中首次出现的索引，如果未找到则返回 -1。
text = "Hello, World!"
print(("World")) # 输出: 7
startswith(prefix)：判断字符串是否以指定前缀开头。
text = "Hello, World!"
print(("Hello")) # 输出: True
endswith(suffix)：判断字符串是否以指定后缀结尾。
text = "Hello, World!"
print(("World!")) # 输出: True3、浮点型：float
浮点型（float）用于表示带小数点的实数。浮点数是不可变的，这意味着它们的值在创建后不能被改变。
import math # 导入模块（要使用这个模块，必须先导入）
a = -3.14
b = 3.14
print(abs(a)) # 输出: 3.14 浮点数 x 的绝对值
print(round(b, 1)) # 输出: 3.1 浮点数 x 四舍五入到 n 位小数
print((b)) # 输出: 4 返回大于或等于 x 的最小整数
print((b)) # 输出: 3 返回小于或等于 x 的最大整数
print((16)) # 输出: 4.0 返回 x 的平方根
4、字典：Dictionary
字典是一种无序的数据集合，用
{}来表示，每个元素是由键（key）和值（value）对组成的。字典中的键必须是唯一的，但值可以不唯一。
1.创建字典
# 使用 {} 创建字典
my_dict = {'name': '小宏运维有点菜', 'age': 18, 'city': 'New York'}
# 使用 dict() 函数创建字典
another_dict = dict(name='小宏运维有点菜', age=18, city='San Francisco')
------------------------------------------------------------------------
2.访问和操作字典
# 访问字典中的值
print(my_dict['name']) # 输出: 小宏运维有点菜
# 添加新的键值对
my_dict['email'] = 'alice@'
# 修改键值对
my_dict['age'] = 31
# 删除键值对
del my_dict['city']
# 检查键是否存在
if 'email' in my_dict:
print("Email found:", my_dict['email'])
# 遍历字典
for key, value in my_dict.items():
print(key, ":", value)5、集合：Set
集合是一种无序且元素唯一的数据结构，用
{}来表示。集合中通常用来存储不重复的元素，支持基本的集合操作，如并集、交集、差集等。
1.创建集合
# 使用 {} 创建集合
my_set = {1, 2, 3, 4, 5}
# 使用 set() 函数创建集合
another_set = set([4, 5, 6, 7])
--------------------------------------------------------------------------------
2.集合操作
# 添加元素
my_set.add(6)
# 删除元素
my_set.remove(3)
# 检查元素是否存在
if 4 in my_set:
print("4 is in the set")
# 遍历集合
for item in my_set:
print(item)6、元组：Tuple
元组是一种有序且不可变的数据结构，用
()来表示。元组中的元素可以是不同的数据类型，一旦创建后就不能修改。
1.创建元组
# 使用 () 创建元组
my_tuple = (1, 2, 3, 'a', 'b', 'c')
--------------------------------------------------------
2.访问和操作元组
# 访问元素
print(my_tuple[0]) # 输出: 1
# 元组的切片
print(my_tuple[1:4]) # 输出: (2, 3, 'a')
# 元组是不可变的，不能修改元素
# my_tuple[0] = 10 # 这会引发 TypeError 错误
# 遍历元组
for item in my_tuple:
print(item)7、布尔类型：Bool
布尔类型只有两个值：
True和False，用于表示逻辑真和逻辑假。
1.创建布尔值
is_true = True
is_false = False
----------------------------------------------------------------------
2.布尔类型支持逻辑运算，如与、或、非：
a = True
b = False
print(a and b) # 输出: False
print(a or b) # 输出: True
print(not a) # 输出: False8、整形：int
整数（integer）是一种基本的数据类型，用于表示整数值。
1.创建整数
x = 5
y = -10
---------------------------------------------------------------
2.基本运算
a = 10
b = 3
print(a + b) # 输出: 13
print(a - b) # 输出: 7
print(a * b) # 输出: 30
print(a / b) # 输出: 3.3333333333333335 (除法总是返回浮点数)
print(a // b) # 输出: 3 (整除，返回整数部分)
print(a % b) # 输出: 1 (取余数)
print(a ** b) # 输出: 1000 (幂运算)
---------------------------------------------------------------
3.类型转换：可以使用内置函数进行类型转换，将其他类型转换为整数
x = int(3.14) # 将浮点数转换为整数，结果是 3
y = int("123") # 将字符串转换为整数，结果是 123
9、空值：None
None是一个特殊的常量，用于表示空值或不存在的值。它通常用于变量未赋值或函数没有返回值的情况。
3、推导式
推导式（comprehensions）是一种用简洁的语法从一个数据序列构建另一个数据序列的方法。推导式包括列表推导式、集合推导式、字典推导式和生成器表达式，它们可以在很大程度上简化代码并提高可读性。
1. 列表推导式（List Comprehensions），列表推导式提供了一种从一个列表中生成另一个列表的简洁方式。
numbers = [1, 2, 3, 4, 5]
# 获取所有偶数的平方
squares = [x**2 for x in numbers if x % 2 == 0]
print(squares) # 输出: [4, 16]
-----------------------------------------------------------------------
2. 集合推导式（Set Comprehensions），集合推导式类似于列表推导式，但是生成的结果是一个集合。
numbers = [1, 2, 3, 4, 5]
# 获取所有偶数的平方
squares_set = {x**2 for x in numbers if x % 2 == 0}
print(squares_set) # 输出: {16, 4}
-----------------------------------------------------------------------
3. 字典推导式（Dictionary Comprehensions），字典推导式允许从任意可迭代对象创建一个字典。
numbers = [1, 2, 3, 4, 5]
# 创建一个字典，键为数字，值为数字的平方
square_dict = {x: x**2 for x in numbers}
print(square_dict) # 输出: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
-----------------------------------------------------------------------
4. 生成器表达式（Generator Expressions），生成器表达式与列表推导式类似，但是返回的是一个生成器对象，而不是一个列表。
numbers = [1, 2, 3, 4, 5]
# 创建一个生成器，用于迭代获取所有偶数的平方
squares_gen = (x**2 for x in numbers if x % 2 == 0)
print(squares_gen) # 输出: <generator object <genexpr> at 0x7fc5a3e0b200>
# 使用生成器迭代获取结果
for square in squares_gen:
print(square) # 输出: 4 164、函数
4.1、内置函数
提供了一系列内置函数，这些函数在 Python 解释器启动时自动加载，不需要额外导入模块即可使用。
1. 数学相关函数
abs(x): 返回数字 x 的绝对值。
print(abs(-7)) # 输出: 7
max(iterable, *[, key, default]): 返回可迭代对象中的最大值。
print(max(1, 5, 2, 4)) # 输出: 5
min(iterable, *[, key, default]): 返回可迭代对象中的最小值。
print(min(1, 5, 2, 4)) # 输出: 1
sum(iterable, /, start=0): 返回可迭代对象的元素之和。
print(sum([1, 2, 3, 4])) # 输出: 10
round(number, ndigits=None): 返回四舍五入后的值，ndigits是表示小数点后几位。
print(round(3.14159, 2)) # 输出: 3.14
-------------------------------------------------------------------------------------
2. 类型转换函数
int(x): 将 x 转换为整数。
print(int('10')) # 输出: 10
float(x): 将 x 转换为浮点数。
print(float('3.14')) # 输出: 3.14
str(x): 将 x 转换为字符串。
print(str(10)) # 输出: '10'
list(iterable): 将 iterable 转换为列表。
print(list('hello')) # 输出: ['h', 'e', 'l', 'l', 'o']
dict(): 创建字典。
print(dict(a=1, b=2)) # 输出: {'a': 1, 'b': 2}
set(iterable): 将 iterable 转换为集合。
print(set([1, 2, 2, 3])) # 输出: {1, 2, 3}
tuple(iterable): 将 iterable 转换为元组。
print(tuple('hello')) # 输出: ('h', 'e', 'l', 'l', 'o')
---------------------------------------------------------------------------------
3. 序列相关函数
len(s): 返回对象的长度（元素个数）。
print(len('hello')) # 输出: 5
sorted(iterable, *, key=None, reverse=False): 返回排序后的列表。
print(sorted([3, 1, 4, 2])) # 输出: [1, 2, 3, 4]
reversed(seq): 返回序列的反转迭代器。
print(list(reversed([1, 2, 3]))) # 输出: [3, 2, 1]
enumerate(iterable, start=0): 返回枚举对象。
for index, value in enumerate(['a', 'b', 'c']):
print(index, value) # 输出: 0 a, 1 b, 2 c
zip(*iterables): 将多个可迭代对象压缩成元组组成的迭代器。
for item in zip([1, 2, 3], ['a', 'b', 'c']):
print(item) # 输出: (1, 'a'), (2, 'b'), (3, 'c')
---------------------------------------------------------------------------------
4. 其他常用函数
type(object): 返回对象的类型。
print(type(10)) # 输出: <class 'int'>
isinstance(object, classinfo): 判断对象是否是指定类或其子类的实例。
print(isinstance(10, int)) # 输出: True
id(object): 返回对象的唯一标识符。
x = 10
print(id(x)) # 输出: 对象 x 的唯一标识符
callable(object): 判断对象是否可调用。
def func():
pass
print(callable(func)) # 输出: True4.2、自定义函数
自定义函数可以帮助组织代码、提高代码的重用性和可读性。函数是一段执行特定任务的代码，可以通过函数名调用执行这段代码。
1.函数的定义与使用
1.定义函数：使用 def 关键字来定义函数，语法如下
def function_name(parameters):
"""
Optional docstring
"""
# Function body
return result
'''
function_name 是函数的名称，命名应遵循标识符规则。
parameters 是函数的参数（也可以没有参数）。
函数体是执行的代码块，可以包含多条语句。
return 语句用于返回结果（可选）。
'''2.使用函数
1. 无参数无返回值的函数
def greet():
print("Hello, World!")
greet() # 输出: Hello, World!
2. 带参数的函数
def greet(name):
print(f"Hello, {name}!")
greet("Alice") # 输出: Hello, Alice!
3. 带返回值的函数
def add(a, b):
return a + b
result = add(5, 3)
print(result) # 输出: 8
4. 带默认参数的函数
def greet(name="Guest"):
print(f"Hello, {name}!")
greet() # 输出: Hello, Guest!
greet("Alice") # 输出: Hello, Alice!
5. 带可变数量参数的函数，使用 *args 和 **kwargs 可以定义可变数量的参数。
# *args 用于接收任意数量的位置参数
def greet(*names):
for name in names:
print(f"Hello, {name}!")
greet("Alice", "Bob", "Charlie") # 输出: Hello, Alice! Hello, Bob! Hello, Charlie!
# **kwargs 用于接收任意数量的关键字参数
def describe_person(**person):
for key, value in ():
print(f"{key}: {value}")
describe_person(name="Alice", age=30, city="New York")
# 输出:
# name: Alice
# age: 30
# city: New York2、函数的作用域
局部变量：在函数内部定义的变量，只能在函数内部访问。
全局变量：在函数外部定义的变量，可以在函数内部访问。
x = 10 # 全局变量
def modify():
global x
x = 20 # 修改全局变量
y = 5 # 局部变量
print(y)
modify()
print(x) # 输出: 20
# print(y) # 这会引发 NameError，因为 y 是局部变量3、Lambda 函数
Lambda 函数是一个匿名函数，用于定义简短的、一次性使用的函数。
add = lambda a, b: a + b
print(add(3, 5)) # 输出: 8
4、递归函数
递归函数是一个调用自身的函数，适用于分而治之的问题。
def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n - 1)
print(factorial(5)) # 输出: 120
# 这个看不懂可以私信我哈，用到了一个阶乘。5、函数的嵌套
函数可以嵌套定义，也就是在一个函数的内部定义另一个函数。这种嵌套函数的用法可以用于封装逻辑、创建闭包和避免命名冲突。
def outer_function(msg):
# 这是外部函数定义的地方
def inner_function():
# 这是内部函数定义的地方
print(msg) # 内部函数可以访问外部函数的变量
# 调用内部函数
inner_function()
# 调用外部函数
outer_function("Hello, from the inner function!")
6、闭包函数
闭包是指一个函数定义在另一个函数的内部，并且可以访问外部函数的变量，即使外部函数已经执行完毕。
def outer_function(x):
def inner_function(y):
return x + y
return inner_function
add_five = outer_function(5)
print(add_five(3)) # 输出: 8
print(add_five(10)) # 输出: 15
7、装饰器
不修改函数代码的前提下，给函数添加功能。装饰器本质上是一个函数，它接受一个函数作为输入并返回一个新的函数。
def outer(origin):
def inner(*args, **kwargs):
print("before 110")
res = origin(*args, **kwargs) # 调用原来的func函数
print("after")
return res
return inner
@outer # func1 = outer(func1)
def func1(a1):
print("我是func1函数")
# value = (11, 22, 33, 44)
# return value
func1(1)5、模块
1、自定义模块
自定义模块是由用户自己编写的模块，通常用来封装特定功能或逻辑。一个自定义模块本质上就是一个Python文件（后缀为
.py），其中包含了变量、函数、类等定义。
# 创建自定义模板
# my_module.py
def greet(name):
return f"Hello, {name}!"
def add(a, b):
return a + b
---------------------------------------------------------------------------
#使用自定义模板
#
import my_module
print(my_module.greet("小宏运维有点菜")) # 输出: Hello, 小宏运维有点菜!
print(my_module.add(3, 5)) # 输出: 8
#或者只导入特定函数
#
from my_module import greet, add
print(greet("小宏运维有点菜")) # 输出: Hello, 小宏运维有点菜!
print(add(2, 7)) # 输出: 9
2、第三方模块
第三方模块是由社区或公司开发并发布的模块，通常通过Python的包管理工具
pip进行安装。这些模块可以提供各种各样的功能，如数据处理、网络请求、机器学习等。
使用 pip 安装第三方模块：
pip install requests
-----------------------------------------------------------------------
安装后，我们可以在Python代码中导入并使用第三方模块。例如，使用 requests 模块发送HTTP请求：
import requests
response = ("")
print(response.status_code) # 输出: 200
print(()) # 输出: GitHub API的响应内容
3、内置模块
内置模块是Python标准库的一部分，这些模块随Python解释器一起发布，默认安装在Python环境中。内置模块涵盖了文件操作、系统调用、数学运算、数据处理等各方面的功能。
我们可以直接导入并使用内置模块。例如，使用 math 模块进行数学运算：
import math
print((16)) # 输出: 4.0
print() # 输出: 3.141592653589793
print((5)) # 输出: 120
---------------------------------------------------------------------------
os 模块进行操作系统相关操作：
import os
print(()) # 输出当前工作目录
('test_dir') # 创建目录
print(('.')) # 列出当前目录下的所有文件和目录
---------------------------------------------------------------------------
sys 模块提供了一些与Python解释器交互的函数和变量。
import sys
print() # 输出Python版本信息
print() # 输出模块的搜索路径
() # 退出Python程序
---------------------------------------------------------------------------
datetime 模块提供了处理日期和时间的类。
import datetime
now = ()
print(now) # 当前日期和时间
today = ()
print(today) # 当前日期
one_day = (days=1)
yesterday = today - one_day
print(yesterday) # 昨天的日期
---------------------------------------------------------------------------
re 模块提供了正则表达式的支持，用于字符串匹配和操作。
import re
pattern = r'\d+'
text = 'There are 123 apples and 456 oranges.'
matches = (pattern, text)
print(matches) # 输出: ['123', '456']6、开发规范
一套被称为 PEP 8 的官方编码风格指南，它提供了一系列关于如何编写清晰、易读和一致的Python代码的建议。遵循这些规范可以使你的代码更加容易被他人理解和维护。
1. 缩进
使用4个空格进行缩进。不要使用制表符（tab），因为不同编辑器中制表符的显示宽度不同，会导致代码在不同环境下显示不一致。
# Good
if x > 5:
print("x is greater than 5")
# Bad - 使用了制表符
if x > 5:
print("x is greater than 5")
-------------------------------------------------------------------------------------
2. 行长
每行代码建议不超过79个字符，可以有一些例外情况，比如长的导入语句或URL。
# Good
def long_function_name(
var_one, var_two, var_three,
var_four):
print(var_one)
-------------------------------------------------------------------------------------
3. 空行
使用空行来分隔函数和类定义，以及不同功能段落之间的代码块，使代码结构更清晰。
# Good
def function_a():
# Function body
def function_b():
# Function body
-------------------------------------------------------------------------------------
4. 注释
使用注释解释代码的目的和关键步骤，使得代码更易于理解。
# Good
# Calculate the sum of two numbers
def add_numbers(a, b):
return a + b
-------------------------------------------------------------------------------------
5. 命名规范
变量名、函数名使用小写字母，单词间使用下划线 _ 分隔。
类名使用驼峰命名法（首字母大写）。
# Good
def calculate_sum(num_list):
total_sum = 0
for num in num_list:
total_sum += num
return total_sum
class MyClass:
def __init__(self, name):
= name
-------------------------------------------------------------------------------------
6. . 导入规范
每个 import 语句应该单独占一行。
标准库导入放在文件顶部，第三方库导入次之，最后是本地库导入。
不推荐使用通配符导入 (from module import *)，除非是导入常用模块，如 from math import *。
# Good
import os
import sys
from datetime import datetime
import requests7、深浅拷贝
拷贝（copy）是指创建一个新对象，其中包含原始对象的所有内容。
浅拷贝（Shallow Copy）
浅拷贝会创建一个新的对象，然后将原始对象中的元素（如果是可变对象）或者引用（如果是不可变对象）复制到新对象中。新对象与原始对象中的元素是共享的，即修改新对象中的元素也会影响原始对象中的元素。
在Python中，可以使用 copy 模块的 copy() 方法或者对象的 copy() 方法进行浅拷贝。
使用 copy 模块的 copy() 方法进行浅拷贝：
import copy
original_list = [1, 2, [3, 4]]
copied_list = (original_list)
# 修改浅拷贝后的列表
copied_list[2][0] = 100
print(original_list) # 输出: [1, 2, [100, 4]]
print(copied_list) # 输出: [1, 2, [100, 4]]
-------------------------------------------------------------------------------------
深拷贝会创建一个新的对象，并递归地将原始对象中的所有元素（包括嵌套对象）复制到新对象中。因此，新对象与原始对象完全独立，修改新对象不会影响原始对象。
在Python中，可以使用 copy 模块的 deepcopy() 方法进行深拷贝。
使用 copy 模块的 deepcopy() 方法进行深拷贝：
import copy
original_list = [1, 2, [3, 4]]
deep_copied_list = (original_list)
# 修改深拷贝后的列表
deep_copied_list[2][0] = 100
print(original_list) # 输出: [1, 2, [3, 4]]
print(deep_copied_list) # 输出: [1, 2, [100, 4]]8、面向对象
面向对象编程（OOP），这是一个强大的编程范式，它将程序视为对象的集合，每个对象都是类的实例。对象是具有属性（数据）和方法（行为）的实体，类是对象的蓝图或模板。
- 类（Class）：类是创建对象的模板。它定义了对象的属性和方法。
- 对象（Object）：对象是类的实例。每个对象都有属于自己的属性和方法。
- 属性（Attributes）：属性是对象的数据，通常用变量表示。
- 方法（Methods）：方法是对象的行为，通常是函数。
1、定义类
class Dog:
# 类变量
species = "Canis familiaris"
# 初始化方法（构造函数）
def __init__(self, name, age):
# 实例变量
= name
= age
# 实例方法
def description(self):
return f"{} is {} years old"
# 实例方法
def speak(self, sound):
return f"{} says {sound}"
# 创建Dog类的实例
my_dog = Dog("Buddy", 3)
# 访问实例变量和方法
print(my_dog.name) # 输出: Buddy
print(my_dog.age) # 输出: 3
print(my_dog.description()) # 输出: Buddy is 3 years old
print(my_dog.speak("Woof Woof")) # 输出: Buddy says Woof Woof
2、面向对象三大特性
1、封装
封装是指将数据（属性）和行为（方法）包装在一个类中，并通过控制访问来保护数据的完整性。使用双下划线
__开头的变量或方法来表示私有（不可访问）。
class Car:
def __init__(self, model, year):
= model
self.__year = year # 私有变量
def get_year(self):
return self.__year # 通过方法访问私有变量
my_car = Car("Toyota", 2019)
print(my_car.model) # 输出: Toyota
print(my_car.get_year()) # 输出: 2019
# print(my_car.__year) # 会引发错误，不能直接访问私有变量
2、继承
继承是面向对象编程中的一个重要概念，它允许一个类继承另一个类的属性和方法，从而实现代码的重用。
# 我这个列子，没有用到父类（upper）
定义一个基类（父类）
class Animal:
def __init__(self, name):
= name
def speak(self):
raise NotImplementedError("Subclass must implement abstract method")
定义一个子类
class Dog(Animal):
def speak(self):
return f"{} says Woof!"
class Cat(Animal):
def speak(self):
return f"{} says Meow!"
使用子类
my_dog = Dog("Buddy")
my_cat = Cat("Whiskers")
print(my_dog.speak()) # 输出: Buddy says Woof!
print(my_cat.speak()) # 输出: Whiskers says Meow!
3、多态
多态是指不同的类可以提供相同的方法或属性接口，即使这些方法的具体实现不同。
def make_animal_speak(animal):
print(())
make_animal_speak(my_dog) # 输出: Buddy says Woof!
make_animal_speak(my_cat) # 输出: Whiskers says Meow!
3、成员
成员用于定义类的属性和行为。
属性（Attributes）
属性是类的数据成员，用于存储对象的状态或特征。在Python中，属性可以分为类属性（类变量）和实例属性（实例变量）两种。
------------------------------------------------------------------------------------
类属性（Class Attributes）：属于整个类的变量，所有实例共享。通常在类的内部定义，在所有实例之间保持一致。
class Dog:
species = "Canis familiaris" # 类属性
def __init__(self, name, age):
= name # 实例属性
= age # 实例属性
-----------------------------------------------------------------------------------
实例属性（Instance Attributes）：属于特定实例的变量，每个实例都有独立的值。通常在 __init__ 构造方法中定义。
class Dog:
def __init__(self, name, age):
= name # 实例属性
= age # 实例属性方法（Methods）
方法是类中定义的函数，用于实现类的行为和操作。在Python中，方法分为实例方法、类方法和静态方法三种类型。
-------------------------------------------------------------------------------------
实例方法（Instance Methods）：第一个参数通常是 self，表示调用该方法的实例。
class Dog:
def __init__(self, name):
= name
def bark(self):
return f"{} is barking"
-------------------------------------------------------------------------------------
类方法（Class Methods）：使用 @classmethod 装饰器定义，第一个参数通常是 cls，表示调用该方法的类。
class Dog:
species = "Canis familiaris"
@classmethod
def get_species(cls):
return
-------------------------------------------------------------------------------------
静态方法（Static Methods）：使用 @staticmethod 装饰器定义，不接受特定的实例或类参数，通常用于实现与类相关但又不依赖于类或实例的功能。
class Dog:
@staticmethod
def info():
return "This is a Dog class"特殊成员
有一些特殊的成员方法（也称为魔术方法或特殊方法），它们的命名以双下划线开头和结尾（例如 __init__）。这些特殊方法提供了一种让对象与Python的内置功能集成的方式，使得对象可以表现得像内置类型一样，比如支持迭代、比较、运算符重载等。
1. __init__: 构造方法，在创建对象时调用，用于初始化对象的状态。
class Dog:
def __init__(self, name):
= name
-------------------------------------------------------------------------------------
2. __str__: 字符串表示方法，返回对象的描述字符串，通常用于 print 函数输出。
class Dog:
def __init__(self, name):
= name
def __str__(self):
return f"Dog: {}"
my_dog = Dog("Buddy")
print(my_dog) # 输出: Dog: Buddy
-------------------------------------------------------------------------------------
3. __len__: 长度方法，返回对象的长度，通常与内置函数 len() 结合使用。
class MyList:
def __init__(self, data):
= data
def __len__(self):
return len()
my_list = MyList([1, 2, 3, 4])
print(len(my_list)) # 输出: 4
-------------------------------------------------------------------------------------
4. __getitem__ 和 __setitem__: 索引访问方法，允许对象像序列一样使用索引访问元素。
class MyList:
def __init__(self, data):
= data
def __getitem__(self, index):
return [index]
def __setitem__(self, index, value):
[index] = value
my_list = MyList([1, 2, 3, 4])
print(my_list[2]) # 输出: 3
my_list[2] = 10
print(my_list[2]) # 输出: 10
-------------------------------------------------------------------------------------
5. __iter__ 和 __next__: 迭代方法，允许对象支持迭代器协议，实现迭代访问元素。
class Countdown:
def __init__(self, start):
= start
def __iter__(self):
return self
def __next__(self):
if <= 0:
raise StopIteration
result =
-= 1
return result
countdown = Countdown(5)
for num in countdown:
print(num) # 逐行输出: 5, 4, 3, 2, 14、迭代器、生成器、可迭代对象
1、可迭代对象（Iterable）
可迭代对象是实现了
__iter__方法的对象，__iter__方法返回一个迭代器。可以用for循环来遍历可迭代对象中的元素。
my_list = [1, 2, 3]
for item in my_list:
print(item) # 输出: 1, 2, 3
2、迭代器（Iterator）
迭代器是实现了
__iter__和__next__方法的对象。__iter__方法返回迭代器本身，__next__方法返回下一个元素。如果没有更多的元素可返回，__next__方法会引发StopIteration异常。
class MyIterator:
def __init__(self, start, end):
= start
= end
def __iter__(self):
return self
def __next__(self):
if >= :
raise StopIteration
else:
+= 1
return - 1
iterator = MyIterator(1, 4)
for item in iterator:
print(item) # 输出: 1, 2, 3
3、生成器（Generator）
生成器是一种特殊的迭代器，使用
yield关键字定义。生成器函数每次被调用时会暂停并保存当前的执行状态（包括局部变量、指令指针等），并返回一个值。下一次调用生成器函数时，会从上次暂停的地方继续执行。
def my_generator(start, end):
current = start
while current < end:
yield current
current += 1
gen = my_generator(1, 4)
for item in gen:
print(item) # 输出: 1, 2, 3
4、关系与区别
- 可迭代对象 是实现了
__iter__方法的对象。调用__iter__方法返回一个迭代器。- 迭代器 是实现了
__iter__和__next__方法的对象。__next__方法返回下一个元素，并在没有更多元素时引发StopIteration异常。- 生成器 是一种特殊的迭代器，通过生成器函数和
yield关键字创建。生成器函数每次调用时会返回一个生成器对象，该对象自动实现了迭代器协议（__iter__和__next__方法）。
5、异常处理
异常处理是一种机制，用于处理程序运行时可能发生的错误或异常情况，例如除零错误、索引错误等。异常处理通过
try-except语句块来实现。
try:
result = 10 / 0 # 除零错误
except ZeroDivisionError:
print("除零错误发生")
--------------------------------------------------------------------------------
try:
# 可能会抛出异常的代码块
pass
except ExceptionType1:
# 如果抛出 ExceptionType1 异常，则执行此处的代码块
pass
except ExceptionType2 as e:
# 如果抛出 ExceptionType2 异常，并将异常对象保存到变量 e 中，则执行此处的代码块
pass
else:
# 如果没有发生异常，则执行此处的代码块
pass
finally:
# 无论是否发生异常，都会执行此处的代码块
pass
6、反射
射是一种在运行时检查类或对象的能力，并且可以在运行时修改类或对象的能力。在Python中，可以通过内置的函数如
getattr()、hasattr()、setattr()和delattr()等来实现反射。
class MyClass:
def __init__(self, x):
= x
def my_method(self):
print("调用了 my_method")
obj = MyClass(10)
# 使用 getattr 获取属性值
print(getattr(obj, 'x')) # 输出: 10
# 使用 hasattr 检查属性是否存在
print(hasattr(obj, 'my_method')) # 输出: True
# 使用 setattr 设置属性值
setattr(obj, 'y', 20)
print() # 输出: 20
# 使用 delattr 删除属性
delattr(obj, 'x')
print(obj.__dict__) # 输出: {'y': 20}
写的不好，请多多指教