话说python也算是多年媳妇熬成婆的典范了。

1）3.6以后引入的f-格式化字符串，现在写代码更像写小作文了，而且折行顺眼多了。

print(f"""Hello,
{"World".upper()}""")

2）3.5以后引入的:和->类型注解，并且配套mypy 静态检查工具，可以减少很多莫名其妙的报错。

3）列表推导式（List Comprehensions）：

# 创建一个包含0到9的平方的列表
squares = [x**2 for x in range(10)]
print(squares)

# 与以下写法等同 - 
# squares = []
# for x in range(10):
#     squares.append(x**2)
# print(squares

# 创建一个包含偶数的列表
evens = [x for x in range(10) if x % 2 == 0]
print(evens)

# 与以下写法等同 - 
# evens = []
# for x in range(10):
#     if x % 2 == 0:
#         evens.append(x)
# print(evens)

# 创建一个包含字符串长度的列表
str_lengths = [len(s) for s in ['apple', 'banana', 'cherry']]
print(str_lengths)

# 与以下写法等同 - 
# str_lengths = []
# for s in ['apple', 'banana', 'cherry']:
#     str_lengths.append(len(s))
# print(str_lengths)

4）字典推导式（Dictionary Comprehensions）：

squares_dict = {x: x**2 for x in range(10)}
print(squares_dict)

# 与以下写法等同 - 
# squares_dict = {}
# for x in range(10):
#     squares_dict[x] = x**2
# print(squares_dict)

5）生成器表达式（Generator Expressions）：

squares_gen = (x**2 for x in range(10))  # 使用圆括号
# 生成器表达式是一个迭代器对象，而不是一个列表或者元组，所以直接打印squares_gen只会显示生成器对象的内存地址，而不是它生成的值。
print(squares_gen)

for x in squares_gen:
    print(x)

6）多重赋值（Multiple Assignments） or 解包赋值（Unpacking Assignment）：

# 交换变量a和b的值
a, b = 1, 2
print(a,"\n",b)
a, b = b, a
print(a,"\n",b)

# 从元组中解包元素
tup = (3, 4, 5)
x, y, z = tup
print(x,"\n",y,"\n",z)

# 从列表中解包元素
lst = [6, 7, 8]
j, k, l = lst
print(j,"\n",k,"\n",l)

7）with语句（Context Managers）：

with open('example.txt', 'w') as file:
    file.write('Hello, world!')
# 文件在这里已经自动关闭了

import sqlite3
with sqlite3.connect('example.db') as conn:
    cursor = conn.cursor()
    cursor.execute('CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, value TEXT)')
    cursor.execute('INSERT INTO test (value) VALUES (?)', ('Hello, world!',))
    conn.commit()
# 数据库连接在这里已经自动关闭了

from threading import Lock

lock = Lock()

with lock:
    # 临界区代码，这里可以安全地执行需要同步的操作
    print('Lock is acquired, performing critical section operations.')
# 锁在这里已经自动释放了

8）*args和**kwargs：

# 定义一个示例函数，它接受任意数量的位置参数和关键字参数
def outer_func(*args, **kwargs):
    print("Outer function received:")
    # 使用 print_args 函数打印所有位置参数
    print("Positional arguments:", args)
    # 使用 print_kwargs 函数打印所有关键字参数
    print("Keyword arguments:", kwargs)

# 使用位置参数调用函数
outer_func(1, 2, 3)

# 使用关键字参数调用函数
outer_func(name='Alice', age=25)

# 调用 outer_func 函数，传入任意数量的位置参数和关键字参数
outer_func(1, 2, 3, name='Alice', job='Engineer')

# 这里使用 * 来解包一个元组作为位置参数，使用 ** 来解包一个字典作为关键字参数
args_tuple = (4, 5, 6)
kwargs_dict = {'city': 'New York', 'country': 'USA'}
outer_func(*args_tuple, **kwargs_dict)

9）属性装饰器（Property Decorators）：

class MyClass:
    def __init__(self, value=0):
        self._value = value  # 使用一个私有变量来存储值

    @property
    def value(self):
        """getter：返回属性值"""
        print("Getting value")
        return self._value

    @value.setter
    def value(self, new_value):
        """setter：设置属性值前可以添加一些逻辑，比如类型检查或值的校验"""
        if not isinstance(new_value, (int, float)):
            raise ValueError("Value must be an int or float")
        print("Setting value to:", new_value)
        self._value = new_value

    @value.deleter
    def value(self):
        """deleter：删除属性时可以执行一些清理操作"""
        print("Deleting value")
        del self._value

# 使用示例
my_instance = MyClass()

# 访问属性，将调用 getter 方法
print(my_instance.value)  # 输出: Getting value 和 value

# 设置属性，将调用 setter 方法
my_instance.value = 10  # 输出: Setting value to: 10

# 再次访问属性，验证值是否设置成功
print(my_instance.value)  # 输出: value

# 删除属性，将调用 deleter 方法
del my_instance.value  # 输出: Deleting value

# 尝试再次访问属性，将抛出 AttributeError，因为属性已被删除
print(my_instance.value)  # 这将抛出错误

10）双下划线方法/魔术方法/特殊方法：

class MyDict:
    def __init__(self):
        self.data = {}  # 初始化一个空字典来存储数据

    def __getitem__(self, key):
        # 尝试返回字典中与键关联的值
        # 如果键不存在，将抛出 KeyError
        return self.data[key]

    def __setitem__(self, key, value):
        # 设置字典中键的值
        self.data[key] = value

    def __delitem__(self, key):
        # 删除字典中与键关联的项
        # 如果键不存在，将抛出 KeyError
        del self.data[key]

    def __iter__(self):
        # 返回字典键的迭代器
        return iter(self.data)

    def __len__(self):
        # 返回字典中项的数量
        return len(self.data)

    def __str__(self):
        # 返回字典的字符串表示，方便打印
        return str(self.data)

    def __repr__(self):
        # 返回字典的官方字符串表示，用于调试
        return f"MyDict({self.data!r})"

# 使用示例
my_dict = MyDict()
my_dict['apple'] = 1
my_dict['banana'] = 2

print(my_dict['apple'])  # 输出: 1
print(my_dict)            # 输出: {'apple': 1, 'banana': 2}
print(len(my_dict))      # 输出: 2

del my_dict['banana']
print(my_dict)            # 输出: {'apple': 1}

for key in my_dict:
    print(key)            # 依次输出: apple

print(repr(my_dict))      # 输出: MyDict({'apple': 1})

11）lambda函数：

numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared)  # 输出: [1, 4, 9, 16, 25]

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 输出: [2, 4, 6]

pairs = [(1, 'one'), (2, 'two'), (3, 'three')]
sorted_pairs = sorted(pairs, key=lambda pair: pair[1])
print(sorted_pairs)  # 输出: [(3, 'three'), (1, 'one'), (2, 'two')]

from functools import reduce

numbers = [1, 2, 3, 4, 5]
result = reduce(lambda x, y: x * y, numbers)
print(result)  # 输出: 120