```python```

注释规范

# Add commit for you codes.
# The proper addition of comments is so beautiful.from abc import abstractmethoddef add(a: int, b: int) -> int:# You can write some necessary notes here.# Such as the role of functions, the types and roles of parameters.## But what we recommend more is to know the meaning of the name when naming.# So you don't have to write too many comments.## It's important to remember to update your comments after you change the code.return a + b# The following comments are superfluous.a = 10  # Define a variable to be 10.
b = 90  # Define a variable to be 90.
res = add(a, b)  # Call the function and get the sum of the two.
print(res)  # Output calculation result

文档字符串规范

def execute():"""Execute the action to make the file saved."""passdef test(url: str):"""This is a test function for string document.Some description here.Another description here.Note: The key point to note.Args:url: A string where to fetch the content fromReturns:A string with UTF-8 encoded content provided by the site.Raises:ValueError: if url argument is not of the expected type (str)."""pass# Output Documentation String
print(execute.__doc__)
print(test.__doc__)

注解规范

class Circle:def __init__(self, radius):self.radius = radiusself.area = 0def area(radius: float) -> Circle:"""Compute area of a Circle with given radius."""pass# Show the annotation content of the function
print(area.__annotations__)  # {'radius': <class 'float'>, 'return': <class '__main__.Circle'>}

布局规范

# Different methods in a class should be separated by empty lines.
# This is more aesthetically pleasing, as in the following example.class People:def eat(self):passdef walk(self):pass

# Appropriate blank lines make the code more elegant.def calculate_the_number_of_rows_of_content_from(path: str) -> int:with open(path, 'r') as file:lines = file.readlines()count = 0for line in lines:if line.strip():count += 1return count

# A line of code should be limited to 75 characters.
# If you exceed that amount, you can use the "\" symbol to wrap the line.
# Or, if you use the () symbol, you can simply wrap the line.def some_too_long_method_for_demo_and_specified_usage(first_arg, second_arg, \third_arg, fourth_arg):passtoo_long_variable_for_demo_in_scenario_one = 1
too_long_variable_for_demo_in_scenario_two = 2
too_long_variable_for_demo_in_scenario_three = 3result = (too_long_variable_for_demo_in_scenario_one+ too_long_variable_for_demo_in_scenario_two+ too_long_variable_for_demo_in_scenario_three)

# Tabs and 4 Spaces are not equal.
# We recommend using 4 Spaces for indentation instead of tabs.num = int(input())
if num > 0:pass

# Here is our recommended format.mylist = [1, 2, 3,4, 5, 6
]

断言 assert

def divide(x: int, y: int) -> float:assert y != 0, "错误：除数不能为零！"  # 此行代码大意是：我断言y一定不等于0，如果我预判错误，抛出错误字符串return x / yprint(divide(2, 0))

符号 _

for _ in range(5):  # We only care about cycling five times.print("Hello World")my_dict = {'age': 18, 'name': 'Jack', 'hobby': 'code'}
for key, _ in my_dict.items():  # We are only concerned with its key.print(key)Tree = ('green', 'plentiful', 'leaf')
color, _, _ = Tree  # We only care about color.

列表推导式

class Weight:def __init__(self, weight: int):self.weight = weightdef __repr__(self):return f'weight: {self.weight}'weight_instances = [Weight(n) for n in range(10)]
print(weight_instances)

过滤与映射

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9]def is_odd_number(number: int) -> bool:  # 判断一个数是否为奇数return number % 2 == 1def multiply_by_two(number: int) -> int:  # 将一个数乘以2return number * 2odd_nums = filter(is_odd_number, nums)  # 过滤出奇数
map_nums = map(multiply_by_two, odd_nums)  # 将奇数乘以2result = list(map_nums)
print(result)# 上面代码可以用列表推导式完成nums = [1, 2, 3, 4, 5, 6, 7, 8, 9]
res_nums = [res * 2 for res in nums if res % 2 == 1]
print(res_nums)

灵活切片与*号

my_list = ['a', 'b', 'c', 'd', 'e']# 灵活切片法:(ele_1, ele_2, remain) = my_list[0], my_list[1], my_list[2:]
print(remain)  # ['c', 'd', 'e'](ele_1, middle, ele_2) = my_list[0], my_list[1:-1], my_list[-1]
print(middle)  # ['b', 'c', 'd'](front, ele_1, ele_2) = my_list[0:-2], my_list[-2], my_list[-1]
print(front)  # ['a', 'b', 'c']# 使用 * 号的方法(ele_1, ele_2, *remain) = my_list
print(remain)  # ['c', 'd', 'e'](ele_1, *middle, ele_2) = my_list
print(middle)  # ['b', 'c', 'd'](*front, ele_1, ele_2) = my_list
print(front)  # ['a', 'b', 'c']

模拟 switch-case

import operator  # 内置模块def calculator(var1, var2, symbol):operator_dict = {'+': operator.add,  # operator 模块里面的 加法函数'-': operator.sub,  # operator 模块里面的 减法函数'*': operator.mul,  # operator 模块里面的 乘法函数'/': operator.truediv  # operator 模块里面的 除法函数}return operator_dict.get(symbol)(var1, var2)  # 函数地址 + 括号 => 调用print(calculator(10, 20, '*'))  # 200

温馨提示：在 Python 3.10 推出了 match-case，其功能比其他语言的 switch-case 更强大

推荐阅读：https://blog.csdn.net/wuShiJingZuo/article/details/134589275

装饰器 @dataclass

推荐阅读：https://www.cnblogs.com/wang_yb/p/18077397

from dataclasses import dataclass@dataclass
class People:pass

字典推导式

from dataclasses import dataclass@dataclass
class User:name: stremail: strlist_of_users = [User('Bob', '168@qq.com'), User('Jack', '195@qq.com')]# 普通的写法
emails_for_user = {}
for user in list_of_users:if user.email:emails_for_user[user.name] = user.emailprint(emails_for_user)# 字典推导的写法
emails_for_user = {user.name: user.emailfor user in list_of_users if user.email}
print(emails_for_user)

字典的排序

d = {'a': 400, 'c': 200, 'b': 300, 'd': 100}
print(d.items())  # dict_items([('a', 400), ('c', 200), ('b', 300), ('d', 100)])# 按照键进行排序（升序）
d_list = sorted(d.items())
print(d_list)  # [('a', 400), ('b', 300), ('c', 200), ('d', 100)]# 按照值进行排序（升序）
rule = lambda x: x[1]
d_list = sorted(d.items(), key=rule)  # 这里的key的意思不是字典中的key，而是sorted()函数的一个参数，用来说明以哪个东西进行排序
print(d_list)  # [('d', 100), ('c', 200), ('b', 300), ('a', 400)]# 按照值进行排序（降序）
d_list = sorted(d.items(), key=lambda x: x[1], reverse=True)
print(d_list)  # [('a', 400), ('b', 300), ('c', 200), ('d', 100)]

字典的组合

fruits_price_1 = {'apple': 10.5, 'orange': 8.8}
fruits_price_2 = {'banana': 2.8, 'orange': 9.5}
fruits_price_3 = {'watermelon': 5.5, 'orange': 10.8}# 通过更新将字典组合起来
lastest_fruit_price = {}
lastest_fruit_price.update(fruits_price_1)
lastest_fruit_price.update(fruits_price_2)
lastest_fruit_price.update(fruits_price_3)
print(lastest_fruit_price)  # {'apple': 10.5, 'orange': 10.8, 'banana': 2.8, 'watermelon': 5.5}# 使用星星符号**将字典组合起来（速度会更快，因为它背后做了优化）
lastest_fruit_price = {}
lastest_fruit_price = {**fruits_price_1,**fruits_price_2,**fruits_price_3
}
print(lastest_fruit_price)  # {'apple': 10.5, 'orange': 10.8, 'banana': 2.8, 'watermelon': 5.5}

优美的打印字典

from pprint import pprintbooks_map = {'name': 'Python编程指南', 'author': 'Jack','stars': 5, 'release-time': '2024-5-20','info': {'content': 'Guide to Programming ', 'user': 1000}}pprint(books_map)"""
运行结果：{'author': 'Jack','info': {'content': 'Guide to Programming ', 'user': 1000},'name': 'Python编程指南','release-time': '2024-5-20','stars': 5}"""

集合的运算

# 定义两个集合
programming_languages = {'C#', 'Go', 'Java', 'Python', 'Ruby'}
dynamic_languages = {'Ruby', 'Python', 'JavasScript', 'Lua'}# 集合的
print(programming_languages | dynamic_languages)  # 并集
print(programming_languages & dynamic_languages)  # 交集
print(programming_languages - dynamic_languages)  # 差集1
print(dynamic_languages - programming_languages)  # 差集2
print(programming_languages ^ dynamic_languages)  # 对称差集"""
运行结果：{'Python', 'Lua', 'Ruby', 'Java', 'Go', 'C#', 'JavasScript'}
{'Ruby', 'Python'}
{'Go', 'C#', 'Java'}
{'JavasScript', 'Lua'}
{'Lua', 'Java', 'Go', 'C#', 'JavasScript'}"""# -------------- 案例演示 --------------backend_developers = ['John', 'Rose', 'Jane', 'Steven']  # 前端人员
frontend_developers = ['Jack', 'Rose', 'Jane', 'Tom']  # 后端人员
full_stack_developers = []  # 全栈人员# 筛选出全栈人员：# 原始方法：
for developer in backend_developers:if developer in frontend_developers:full_stack_developers.append(developer)# 利用集合的运算性质
full_stack_developers = list(set(backend_developers) & set(frontend_developers))

集合推导式

class Person:def __init__(self, name):self.name = nameperson_list = [Person('Jack'), Person(None), Person('Tom'), Person('John'), Person(None)]
name_set = {person.name for person in person_list if person.name}
print(type(name_set), name_set)  # <class 'set'> {'Tom', 'Jack', 'John'}

集合处理 Counter

from collections import Counterc = Counter("你好，世界！你好，编程")print(c)
print(c.most_common(3))  # 出现最多共同点中的前3个
print(c.keys())
print(c.values())
print(list(c.elements()))"""
运行结果：Counter({'你': 2, '好': 2, '，': 2, '世': 1, '界': 1, '！': 1, '编': 1, '程': 1})
[('你', 2), ('好', 2), ('，', 2)]
dict_keys(['你', '好', '，', '世', '界', '！', '编', '程'])
dict_values([2, 2, 2, 1, 1, 1, 1, 1])
['你', '你', '好', '好', '，', '，', '世', '界', '！', '编', '程']
"""

元组解包数据

# 使用元组解包数据
csv_file_row = ['Jack', '168@qq.com', 35]
(name, email, age) = csv_file_row
print(name, email, age)  # Jack 168@qq.com 35# 使用 *元组 解包数据
group1 = ('Cat', 'Dog')
group2 = ('Eagle', 'Geese')
new_group = (*group1, *group2, 'Snake')
print(new_group)  # ('Cat', 'Dog', 'Eagle', 'Geese', 'Snake')# 使用 *元组 解包数据
def display_users(*users):print(type(users))for user in users:print(user)display_users('Dany', 'Bobby', 'Jacky')# 运行结果：
# <class 'tuple'>
# Dany
# Bobby
# Jacky

元组与占位符_

# 巧用占位符
animal = ('Cat', 'Dog', 'Eagle', 'Geese', 'Tiger')(first, second, _, _, _,) = animal
print(first, second)  # Cat Dog(first, second, *_) = animal
print(first, second)  # Cat Dog

高效拼接字符串

list_of_str = ['Syntax Error', 'Network Error', 'File not found']# 普通方法
concat_string = ''
for substring in list_of_str:concat_string += substring# 高效方法
concat_string = ''.join(list_of_str)