转载说明：原创不易，未经授权，谢绝任何形式的转载

Python是一种通用且广泛使用的编程语言，具有广泛的库和框架。但是，有一些不太知名的Python编程技巧和库可以使开发人员的生活更轻松，代码更高效。

在这篇博客中，我们将探讨一些不太常用的Python技巧，这些技巧非常有用，但并不广为人知。通过学习和实施这些技巧，您可以节省编码的时间和精力，并使您的代码更加优雅和高效。因此，让我们深入了解Python语言的这些隐藏技巧！

1. 三元运算符

三元运算符是if-else语句的简写。其语法为value_if_true if condition else value_if_false，它是一种可以代替多行if-else语句的一行代码，使得你的代码更加简洁。

例如，以下代码使用了三元运算符来判断'a'是否大于'b'，如果是则返回'a'，否则返回'b'：

a = 5 
b = 10 
max = a if a > b else b  

##value_if_true if condition else value_if_false

print(max)
#10

2. Enumerate函数

enumerate() 函数将一个可迭代对象转换为枚举对象，并返回一个由 (index, value) 二元组组成的迭代器。该函数常用于需要遍历列表并显示索引的情况下。

例如，给定一个列表 fruits = ['apple', 'banana', 'mango']，我们希望遍历该列表并打印出每个水果的索引和名称。我们可以使用 enumerate() 函数来实现这个功能：

fruits = ['apple', 'banana', 'mango'] 
for index, fruit in enumerate(fruits): 
    print(index, fruit)

#0 apple
#1 banana
#2 mango

3. Zip函数

zip()函数可以将一个或多个可迭代对象中对应的元素打包成一个元组，并返回一个由这些元组组成的迭代器。这个迭代器可以生成一个或多个元组，每个元组包含每个可迭代对象中相应位置的元素。如果传入的可迭代对象长度不等，则返回的迭代器长度和最短的可迭代对象相同。示例代码如下：

list1 = [1, 2, 3] 
list2 = ['a', 'b', 'c'] 
for x, y in zip(list1, list2):
    print(x, y)

#1 a
#2 b
#3 c

在上述示例中，zip()函数将list1和list2打包成元组的形式，返回一个迭代器。在循环时，迭代器会生成每个元组，每个元组包含list1和list2在相同位置的元素。这种方法可以同时迭代多个列表，并对它们执行相同的操作，非常方便。

4. 列表推导式

列表推导式是一种从现有列表或任何可迭代对象创建列表的简洁方式。它是一种可以替换for循环的一行代码，使您的代码更有效和可读。

列表推导式的语法如下：[expression for item in iterable]

其中，expression是要执行的操作，item是可迭代对象中的元素，iterable是一个可以迭代的对象，如列表、元组、字符串等。下面是一个简单的示例，用于生成1到5的平方数列表：

squared_numbers = [x**2 for x in range(1, 6)]

print(squared_numbers)
#[1, 4, 9, 16, 25]

在上面的代码中，我们使用range(1,6)生成数字1到5的迭代器对象。然后，我们使用列表推导式将每个数字的平方添加到一个新的列表中。这样，我们就得到了一个包含1到5的平方数的列表。

列表推导式还可以包含条件语句，以生成符合特定条件的元素。例如，下面的代码生成一个包含1到10之间的偶数的列表：

even_numbers = [x for x in range(1, 11) if x % 2 == 0]

print(even_numbers)
#[2, 4, 6, 8, 10]

在上面的代码中，我们使用range(1,11)生成数字1到10的迭代器对象。然后，我们使用列表推导式将每个偶数添加到一个新的列表中。这里的if语句检查每个数字是否是偶数，如果是，则将其添加到列表中。

使用列表推导式可以使代码更简洁、更可读，并且可以大大减少for循环的使用。

5. Lambda函数

Lambda函数是使用lambda关键字定义的匿名函数。它们在需要编写简单的函数时非常有用，可以不使用def关键字定义命名函数。

例如，以下代码使用lambda函数定义一个将两个数字相加的函数。使用lambda函数的语法是lambda arguments: expression，其中arguments是函数的参数，expression是函数要求返回的结果。

add = lambda x, y: x + y 

result = add(3, 4)

print(result)
#7

6. any和all函数

any()和all()函数根据可迭代对象中元素的真值返回True或False。any()函数在可迭代对象中有任何一个元素为True时返回True，而all()函数在可迭代对象中所有元素为True时返回True。

以下示例演示了如何使用any()和all()函数检查列表中的元素是否为真值：

numbers = [1, 2, 3, 0, 4] 
result = any(numbers) #True 
result = all(numbers) # False. 0 is making it false 

在此示例中，any()函数返回True，因为列表中有至少一个元素为True（即数字1、2、3和4）。相反，all()函数返回False，因为列表中有一个元素（即数字0）为False。

7. Itertools

itertools是一个Python的标准库，提供了一系列处理迭代器的函数，其中一些函数包括chain、product和permutations等等。以下是一些itertools函数的介绍：

• chain(iter1, iter2, ...)：将多个迭代器连接在一起，返回一个迭代器。
• product(iter1, iter2, ..., repeat=n)：返回迭代器的笛卡尔积，其中n指定重复次数。
• permutations(iterable, r=None)：返回迭代器中指定长度的所有排列，如果未指定长度，则返回迭代器的所有排列。
• combinations(iterable, r)：返回迭代器中指定长度的所有组合。

这些函数可以帮助你更轻松地处理迭代器，例如创建排列和组合，或者将多个迭代器连接在一起。

这段代码使用了itertools.permutations()函数来计算给定列表的所有排列组合。permutations()函数返回一个迭代器，该迭代器包含给定列表的所有排列组合。

import itertools 
numbers = [1, 2, 3] 
result = list(itertools.permutations(numbers)) 


#output all the permutations 
#[(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]

8. 生成器

生成器是一种可迭代的类型，可以动态生成值，而不是将它们存储在内存中。它们使用yield关键字定义，并可用于创建自定义迭代器。

例如，以下代码定义了一个生成斐波那契数列的生成器函数。生成器函数返回迭代器，该迭代器生成斐波那契数列的值。

### Generators created using yield keyword 
def fibonacci_series(n):
    a, b = 0, 1
    for i in range(n):
        yield a
        a, b = b, a + b

# Driver code to check above generator function 
for number in fibonacci_series(10):
    print(number)

#0
#1
#1
#2
#3
#5
#8
#13
#21
#34

在上面的代码中，fibonacci_series()函数使用yield关键字定义，这使得它成为一个生成器函数。该函数返回一个迭代器，该迭代器生成斐波那契数列的值。可以使用for循环来迭代生成器并获取每个值。

由于生成器在运行时动态生成值，因此它们可以帮助您在处理大型数据集时节省内存。生成器还可用于创建自定义迭代器，这使得您可以将它们用于特定的编程问题。

9. Decorators

装饰器是一种修改函数或类行为的方法。它们使用@符号定义，并可用于向函数添加功能，例如日志记录、计时或身份验证。

以下是一个装饰器的例子，它会在函数调用前后打印一些信息：

def log_function(func):
    def wrapper(*args, **kwargs):
        print(f'Running {func.__name__}')
        result = func(*args, **kwargs)
        print(f'{func.__name__} returned {result}')
        return result
    return wrapper

@log_function
def add(x, y):
    return x + y


print(add(5,7))

#Running add
#add returned 12
#12

在上面的代码中，log_function()函数定义了一个装饰器，该装饰器在函数调用前后打印一些信息。@log_function语法用于将装饰器应用于函数add()。当add()函数被调用时，它将首先打印一些信息，然后返回函数的结果并打印另一些信息。

装饰器是Python中非常强大的工具，可以用于各种编程任务，例如日志记录、缓存、验证等等。

10. 多个函数参数

在Python中，您可以使用*和**运算符来处理多个函数参数。*运算符用于将参数列表作为单独的位置参数传递，**运算符用于将参数作为字典关键字参数传递。

以下是一个使用多个参数的函数的示例：

def print_arguments(*args, **kwargs):
    print(args)
    print(kwargs)

print_arguments(1, 2, 3, name='John', age=30)

#(1, 2, 3)
#{'name': 'John', 'age': 30}

在上面的代码中，print_arguments()函数使用*args和**kwargs参数来处理任意数量的位置参数和关键字参数。函数打印位置参数和关键字参数，这使您可以轻松地处理任意数量和类型的参数。

使用多个参数的函数在Python中非常常见，因此了解如何使用*和**运算符是非常重要的。

11. 动态导入

你可以使用importlib模块动态地导入一个模块。当你想要根据用户输入或配置导入一个模块时，这非常有用。

以下是一个导入模块的例子：

import importlib

module_name = 'math'
module = importlib.import_module(module_name)
result = module.sqrt(9)

这段代码使用了importlib.import_module()函数来动态地导入math模块。result变量将包含math.sqrt()函数返回的结果。这种方法使您能够根据需要动态导入模块，从而使您的代码更加灵活和可配置。

12. 字典推导式

字典推导式是一种从现有字典或任何可迭代对象创建新字典的简洁方式。它是一个一行代码，可以代替for循环，使您的代码更加有效和可读。

以下是一个使用字典推导式创建字典的示例：

squared_numbers = {x: x**2 for x in range(1, 6)}
print(squared_numbers)

#{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

在上面的代码中，{x: x**2 for x in range(1, 6)}使用字典推导式定义了一个新字典，该字典包含1到5之间的数字的平方。可以使用类似for循环的语法来创建字典，这使得代码更加简洁和可读。

13. 可调用对象

Callable Objects 是Python中的一个概念，它指的是可以像函数一样被调用的对象。这些对象可以是函数、方法、类以及定义了__call__()方法的对象。使用callable()函数可以检查一个对象是否可调用。

以下是一个使用callable()函数检查对象是否可调用的示例：

def add(x, y):
    return x + y

class Calculator:
    def __init__(self, base):
        self.base = base
    def add(self, x):
        return self.base + x

calculator = Calculator(10)

print(callable(add)) #True
print(callable(calculator.add)) #True
print(callable(calculator)) #False

在上面的代码中，add()函数和Calculator.add()方法都是可调用的，因为它们都是函数和方法。相反，Calculator类本身不是可调用的，因为它没有定义__call__()方法。

使用可调用对象可以帮助您编写更灵活的代码，因为它们可以像函数一样使用，但具有更多的自定义选项和功能。

14. 你可以用下划线分隔大数字或字符

在 Python 中，你可以使用下划线来增强大数字或字符串的可读性。这在处理长而复杂的数字或字符串时特别有用。

例如，你可以使用下划线来分隔大数字的每个数字，如下所示：

big_number = 1_000_000_000

这样可以使数字更易于阅读和理解。

你还可以使用下划线来分隔字符串中的字符，如下所示：

long_string = 'This_is_a_long_string'

同样，这可以使字符串更易于阅读和理解，特别是在处理长而复杂的字符串时。

使用下划线的这种方式不仅更易于阅读，而且可以使你的代码更高效、更易于维护。

15. 快速合并2个字典

在Python中，有多种方法可以合并两个字典。其中一种方法是使用**运算符将两个字典合并为一个字典。

以下是一个合并两个字典的例子：

dictionary_one = {"a": 1, "b": 2}
dictionary_two = {"c": 3, "d": 4}

merged = {**dictionary_one, **dictionary_two}

print(merged)  
# {'a': 1, 'b': 2, 'c': 3, 'd': 4}

在上面的代码中，**运算符用于将dict1和dict2合并为一个字典。合并后的字典包含dict1和dict2中的所有键值对。

这种方法在合并两个字典时非常有用，因为它非常简单、快速，并且可以处理任意数量的字典。

16. 列表（list）、集合（set）和字典（dictionary）是可变的数据类型。

在Python中，列表（list）、集合（set）和字典（dictionary）是可变的数据类型。这意味着您可以更改列表、集合或字典中的元素或键值对。

列表是一个有序的集合，其中每个元素都有一个唯一的索引。列表可以通过索引和切片访问，也可以使用各种内置方法进行操作，例如添加、删除和排序。

集合是一个无序的集合，其中每个元素都是唯一的。集合可以用于检查元素是否存在，并且可以进行各种集合操作，例如交集、并集和差集。

字典是一种无序的键值对集合。每个键必须是唯一的，但值可以重复。字典可以用于存储和检索数据，例如将姓名映射到电话号码或电子邮件地址。

由于这些数据类型是可变的，因此您可以随意更改它们中的元素或键值对。这使得它们非常灵活，并且可以用于各种编程任务。但是，这也意味着您需要小心，以免意外更改数据结构中的元素或键值对，从而导致错误或问题。

可变意味着我们可以更改或更新对象（列表，集合或字典），而不更改内存中的对象指针。让我们看看它的实际操作。

在下面的示例中，我们通过附加新城市来更新城市列表。我们可以看到ID（对象指针）保持不变。对于集合和字典也是如此。

cities = ["Munich", "Zurich", "London"]
print(id(cities)) # 2797174365184
cities.append("Berlin")
print(id(cities)) # 2797174365184

####Sets 

my_set = {1, 2, 3}
print(id(my_set))  # 2797172976992
my_set.add(4)
print(id(my_set))  # 2797172976992

###Dictionary 

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
print(id(thisdict))  #2797174128256
thisdict["engine"] = "2500cc"
print(id(thisdict))  #2797174128256

结束

今天的介绍就到这里，Python是一种非常强大且灵活的编程语言，有许多有用的技巧和库可以帮助你更高效地编写代码。本文介绍了一些非常有用的Python技巧，通过学习和实现这些技巧，你可以在编码过程中节省时间和精力，并使你的代码更加高效和优雅。

希望今天的分享对你有所帮助，感谢你的阅读，文章创作不易，如果你喜欢我的分享，别忘了点赞转发，让更多有需要的人看到，最后别忘记关注「前端达人」，你的支持将是我分享最大的动力，后续我会持续输出更多内容，敬请期待。