盘点Python那些甜甜的语法糖（30个，含示例）

本文详细介绍了Python中30个甜美的语法糖，包括列表推导式、条件表达式、Lambda函数、Map、Filter、Zip等，还有解包、原地交换、多重返回值等实用技巧，深入浅出地展示了Python的简洁之美。

1. List Comprehension（列表推导式）

# 传统方式
my_list = []
for i in range(10):
    if i % 2 == 0:
        my_list.append(i)

# 使用列表推导式
my_list = [i for i in range(10) if i % 2 == 0]

2. Conditional Expression（条件表达式）

# 传统方式
x = 5
if x > 0:
    y = 1
else:
    y = 0

# 使用条件表达式
x = 5
y = 1 if x > 0 else 0

3. Lambda Function（Lambda函数）

# 传统方式
def square(x):
    return x*x

# 使用Lambda函数
square = lambda x: x*x

4. Map Function（Map函数）

# 传统方式
my_list = [1, 2, 3]
new_list = []
for i in my_list:
    new_list.append(i*2)

# 使用Map函数
my_list = [1, 2, 3]
new_list = list(map(lambda x: x*2, my_list))

5. Filter Function（Filter函数）

# 传统方式
my_list = [1, 2, 3, 4, 5]
new_list = []
for i in my_list:
    if i % 2 == 0:
        new_list.append(i)

# 使用Filter函数
my_list = [1, 2, 3, 4, 5]
new_list = list(filter(lambda x: x % 2 == 0, my_list))

6. Zip Function（Zip函数）

# 传统方式
my_list1 = [1, 2, 3]
my_list2 = [4, 5, 6]
new_list = []
for i in range(len(my_list1)):
    new_list.append((my_list1[i], my_list2[i]))

# 使用Zip函数
my_list1 = [1, 2, 3]
my_list2 = [4, 5, 6]
new_list = list(zip(my_list1, my_list2))

7. Iterable Unpacking（可迭代对象解包）

# 传统方式
my_list = [1, 2, 3]
x = my_list[0]
y = my_list[1]
z = my_list[2]

# 使用可迭代对象解包
my_list = [1, 2, 3]
x, y, z = my_list

8. Extended Iterable Unpacking（扩展的可迭代对象解包）

# 传统方式
my_list = [1, 2, 3, 4, 5]
x = my_list[0]
y = my_list[1:]
z = my_list[-1]

# 使用扩展的可迭代对象解包
my_list = [1, 2, 3, 4, 5]
x, *y, z = my_list

9. In-place Swapping（原地交换）

# 传统方式
a = 1
b = 2
temp = a
a = b
b = temp

# 使用原地交换
a = 1
b = 2
a, b = b, a

10. Multiple Return Values（多重返回值）

# 传统方式
def my_function(x, y):
    return x+y, x-y

result = my_function(3, 2)
sum = result[0]
diff = result[1]

# 使用多重返回值
def my_function(x, y):
    return x+y, x-y

sum, diff = my_function(3, 2)

11. Named Arguments（命名参数）

# 传统方式
def my_function(x, y):
    print(x, y)

my_function(1, 2)

# 使用命名参数
def my_function(x, y):
    print(x, y)

my_function(x=1, y=2)

12. Function Annotations（函数注解）

# 传统方式
def my_function(x: int, y: int) -> int:
    return x+y

# 使用函数注解
def my_function(x: int, y: int) -> int:
    return x+y

13. Default Arguments（默认参数）

# 传统方式
def my_function(x, y=0):
    print(x, y)

my_function(1)
my_function(1, 2)

# 使用默认参数
def my_function(x, y=0):
    print(x, y)

my_function(1)
my_function(1, y=2)

14. Variable Number of Arguments（可变数量的参数）

# 传统方式
def my_function(*args):
    for arg in args:
        print(arg)

my_function(1, 2, 3)

# 使用可变数量的参数
def my_function(*args):
    for arg in args:
        print(arg)

my_function(1, 2, 3)

15. Keyword Arguments（关键字参数）

# 传统方式
def my_function(x, y):
    print(x, y)

my_function(1, 2)

# 使用关键字参数
def my_function(x, y):
    print(x, y)

my_function(x=1, y=2)

16. List Slicing（列表切片）

# 传统方式
my_list = [1, 2, 3, 4, 5]
new_list = my_list[1:4]

# 使用列表切片
my_list = [1, 2, 3, 4, 5]
new_list = my_list[1:4]

17. List Concatenation（列表合并）

# 传统方式
my_list1 = [1, 2, 3]
my_list2 = [4, 5, 6]
new_list = my_list1 + my_list2

# 使用列表合并
my_list1 = [1, 2, 3]
my_list2 = [4, 5, 6]
new_list = [*my_list1, *my_list2]

18. List Packing and Unpacking（列表打包和解包）

# 传统方式
my_list = [1, 2, 3]
x, y, z = my_list

# 使用列表打包和解包
my_list = [1, 2, 3]
x, y, z = [*my_list]

19. Dictionary Packing and Unpacking（字典打包和解包）

# 传统方式
my_dict = {
            'a': 1, 'b': 2, 'c': 3}
new_dict = {
            'a': my_dict['a'], 'b': my_dict['b'], 'c': my_dict['c']}

# 使用字典打包和解包
my_dict = {
            'a': 1, 'b': 2, 'c': 3}
new_dict = {
            **my_dict}

20. Set Comprehension（集合推导式）

# 传统方式
my_list = [1, 2, 3, 4, 5]
my_set = set()
for i in my_list:
    if i % 2 == 0:
        my_set.add(i)

# 使用集合推导式
my_list = [1, 2, 3, 4, 5]
my_set = {
            i for i in my_list if i % 2 == 0}

21. Dictionary Comprehension（字典推导式）

# 传统方式
my_list = [1, 2, 3, 4, 5]
my_dict = {
            }
for i in my_list:
    my_dict[i] = i * i

# 使用字典推导式
my_list = [1, 2, 3, 4, 5]
my_dict = {
            i: i * i for i in my_list}

22. Generator Expression（生成器表达式）

# 传统方式
my_list = [1, 2, 3, 4, 5]
my_generator = (i for i in my_list)
for i in my_generator:
    print(i)

# 使用生成器表达式
my_list = [1, 2, 3, 4, 5]
for i in (i for i in my_list):
    print(i)

23. String Formatting（字符串格式化）

# 传统方式
name = "Alice"
age = 25
print("My name is " + name + " and I am " + str(age) + " years old.")

# 使用字符串格式化
name = "Alice"
age = 25
print("My name is {} and I am {} years old.".format(name, age))

24. F-Strings（格式化字符串）

# 传统方式
name = "Alice"
age = 25
print("My name is {} and I am {} years old.".format(name, age))

# 使用格式化字符串
name = "Alice"
age = 25
print(f"My name is {
              name} and I am {
              age} years old.")

25. Decorators（装饰器）

# 传统方式
def my_function():
    print("Hello, world!")

def my_decorator(func):
    def wrapper():
        print("Before function")
        func()
        print("After function")
    return wrapper

my_function = my_decorator(my_function)
my_function()

# 使用装饰器
def my_decorator(func):
    def wrapper():
        print("Before function")
        func()
        print("After function")
    return wrapper

@my_decorator
def my_function():
    print("Hello, world!")

my_function()

26. Class Decorators（类装饰器）

# 传统方式
class MyClass:
    def my_method(self):
        print("Hello, world!")

def my_decorator(cls):
    class Wrapper:
        def __init__(self, *args, **kwargs):
            self.wrapped = cls(*args, **kwargs)

        def my_method(self):
            print("Before method")
            self.wrapped.my_method()
            print("After method")

    return Wrapper

MyClass = my_decorator(MyClass)

my_object = MyClass()
my_object.my_method()

# 使用类装饰器
def my_decorator(cls):
    class Wrapper:
        def __init__(self, *args, **kwargs):
            self.wrapped = cls(*args, **kwargs)

        def my_method(self):
            print("Before method")
            self.wrapped.my_method()
            print("After method")

    return Wrapper

@my_decorator
class MyClass:
    def my_method(self):
        print("Hello, world!")

my_object = MyClass()
my_object.my_method()

27. Property Decorator（属性装饰器）

# 传统方式
class MyClass:
    def __init__(self, x):
        self._x = x

    def get_x(self):
        return self._x

    def set_x(self, value):
        self._x = value

    def del_x(self):
        del self._x

    x = property(get_x, set_x, del_x)

my_object = MyClass(5)
print(my_object.x)
my_object.x = 10
print(my_object.x)

# 使用属性装饰器
class MyClass:
    def __init__(self, x):
        self._x = x

    @property
    def x(self):
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

my_object = MyClass(5)
print(my_object.x)
my_object.x = 10
print(my_object.x)

28. Try-Except-Else Blocks（异常处理）

# 传统方式
try:
    x = 1 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")
else:
    print("No exception occurred")

# 使用异常处理
try:
    x = 1 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")
else:
    print("No exception occurred")
finally:
    print("Finally block executed")

29. With Statement（上下文管理器）

# 传统方式
file = open("myfile.txt", "r")
try:
    contents = file.read()
finally:
    file.close()

# 使用上下文管理器
with open("myfile.txt", "r") as file:
    contents = file.read()

30. Enumerate Function（枚举函数）

# 传统方式
my_list = ["apple", "banana", "orange"]
for i in range(len(my_list)):
    print(i, my_list[i])

# 使用枚举函数
my_list = ["apple", "banana", "orange"]
for i, item in enumerate(my_list):
    print(i, item)