Python基础—16 个基础操作教程

介绍

本文中将分享一些 Python 使用技巧，这些技巧非常有用。通过学习和使用这些技巧，可以帮你节省时间和精力，并使你的代码更加优雅和高效。

1.三元运算符
Python中的三元运算符（也称为条件表达式）是一种简洁的编写条件语句的方式，它允许在一行代码中完成简单的if-else逻辑。三元运算符的基本语法如下：

result = value_if_true if condition else value_if_false

这里，condition 是要测试的条件，value_if_true 是当条件为真时返回的值，而 value_if_false 是当条件为假时返回的值。

下面是一个使用三元运算符的代码演示：

# 假设我们有一个分数
score = 85

# 使用三元运算符判断分数等级
grade = 'A' if score >= 90 else 'B' if score >= 80 else 'C'

# 注意：上面的三元运算符实际上是嵌套的，为了清晰起见，也可以写成多行
# 但Python的三元运算符不支持直接的多行写法，这里只是为了说明逻辑
# 实际上，更复杂的逻辑应该使用if-elif-else语句

# 另一种更清晰的方式是使用if-elif-else语句
# grade = 'A'
# if score < 90:
#     grade = 'B' if score >= 80 else 'C'
# 但为了演示三元运算符，我们保持上面的写法

print(grade)  # 输出: B

然而，需要注意的是，虽然上面的代码示例展示了如何使用嵌套的三元运算符来模拟更复杂的逻辑，但这种方式并不推荐用于非常复杂的条件判断，因为它可能会降低代码的可读性。对于更复杂的逻辑，应该使用if-elif-else语句。

2.枚举函数
在编程中，“枚举函数” 这个术语可能不是直接的标准术语，因为它不像某些内置函数（如 Python 中的 enumerate()）那样有一个明确定义的功能。不过，我们可以从几个角度来理解这个概念：

1. 枚举（Enumeration）: 在许多编程语言中，枚举是一种特殊的数据类型，它允许程序员为整数指定一个更易于理解的名字。这通常用于表示一组固定的常量，如星期、月份、颜色等。虽然枚举本身不是一个函数，但你可以使用枚举类型与函数结合来创建更清晰的代码。

2. 枚举函数（类似 enumerate()）: 在Python中，enumerate() 函数是一个内置函数，它用于将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，同时列出数据和数据下标，通常用在 for 循环当中。这可以被视为一种“枚举函数”，因为它在遍历过程中为每个元素提供了一个索引。

   示例：

   seasons = ['Spring', 'Summer', 'Autumn', 'Winter']
   for index, name in enumerate(seasons):
       print(f"{index}: {name}")
   

3. 自定义枚举函数: 如果你想模拟枚举类型或枚举行为，但你的编程语言不支持内置的枚举类型，你可以通过定义函数和类来实现类似的功能。例如，在Python中，虽然没有内置的枚举类型直到Python 3.4（引入了 Enum 类），但在此之前，你可以通过定义类和使用静态变量来模拟枚举。

   示例（使用Python的 Enum 类）:

   from enum import Enum
   
   class Color(Enum):
       RED = 1
       GREEN = 2
       BLUE = 3
   
   def get_color_name(color_value):
       for name, value in Color.__members__.items():
           if value == color_value:
               return name
       return None
   
   print(get_color_name(Color.RED))  # 输出: RED
   

在这个上下文中，get_color_name() 函数可以被视为一种“枚举函数”，因为它根据枚举值返回对应的枚举名称。然而，请注意，它实际上是在操作枚举类（Color）的静态成员，而不是传统意义上的枚举函数。

总之，“枚举函数” 这个概念可能因上下文而异，但通常它指的是与枚举类型或枚举行为相关的函数，这些函数可以帮助你在程序中更清晰地表示和操作一组固定的常量。

3. 压缩函数
在Python中，没有直接命名为“压缩函数”的内置函数，但我们可以根据需求实现数据的压缩功能。这通常意味着将一组数据转换为更紧凑或更高效的格式。Python中常见的压缩操作包括使用压缩库（如zlib、gzip或bz2）来压缩文件或数据流，以及使用更高级的编码技术（如pickle、json的压缩选项等）来序列化数据。

下面，我将展示几个不同场景下的“压缩”操作示例：

1. 使用zlib库压缩字符串

zlib是Python的一个标准库，用于数据的压缩和解压。以下是如何使用zlib来压缩和解压字符串的示例：

import zlib

# 要压缩的字符串
original_data = b'This is the data to compress.'

# 压缩数据
compressed_data = zlib.compress(original_data)

# 解压数据
decompressed_data = zlib.decompress(compressed_data)

print("Original:", original_data)
print("Compressed:", compressed_data)
print("Decompressed:", decompressed_data)

注意：zlib.compress() 和 zlib.decompress() 函数处理的数据类型是字节串（bytes），而不是字符串（str）。

2. 使用gzip库压缩文件

gzip模块提供了对GZIP格式文件的支持，允许你读写GZIP格式的文件。以下是如何使用gzip来压缩和解压文件的示例：

import gzip

# 压缩文件
with open('example.txt', 'rb') as f_in:
    with gzip.open('example.txt.gz', 'wb') as f_out:
        f_out.writelines(f_in)

# 解压文件
with gzip.open('example.txt.gz', 'rb') as f_in:
    with open('example_decompressed.txt', 'wb') as f_out:
        f_out.writelines(f_in)

3. 使用pickle序列化并压缩对象

pickle模块用于Python对象的序列化和反序列化。虽然它本身不直接提供压缩功能，但可以通过与gzip等模块结合使用来压缩序列化后的数据。

import pickle
import gzip

# 假设我们有一个要序列化的对象
data = {'a': [1, 2.0, 3, 4+6j],
        'b': ("character string", b"byte string"),
        'c': None}

# 序列化并压缩对象
with gzip.open('data.pkl.gz', 'wb') as f:
    pickle.dump(data, f, pickle.HIGHEST_PROTOCOL)

# 反序列化并解压对象
with gzip.open('data.pkl.gz', 'rb') as f:
    data_loaded = pickle.load(f)

print(data_loaded)

在这些示例中，我们看到了如何在Python中执行不同类型的“压缩”操作。根据你的具体需求（如文件压缩、数据流压缩或对象序列化），你可以选择最适合你的方法。

4. 列表生成式

列表生成式是一种从现有列表或任何可迭代对象创建列表的简洁方法。这是一种可以替代 for 循环的单行代码，使你的代码更加高效，并使代码的可读性更强。

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

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

5. 匿名函数

Lambda 函数是使用lambda关键字定义的匿名函数。当你需要编写一次性的小函数并且不想使用关键字def来定义命名函数时，它们很有用。

add = lambda x, y: x + y 

result = add(3, 4)

print(result)
# 7

6.any()和all()函数

any()函数和all()函数返回True或False基于 iterable 中元素的真实性。如果 iterable 中的任何元素为真，则函数any()返回True，如果 iterable 中的所有元素都为真，则函数all()返回True。

numbers = [1, 2, 3, 0, 4] 
result = any(numbers) # True 
result = all(numbers) # False。0使结果为False

7. 迭代模块

itertools模块提供了一组函数来处理迭代器。该模块中的函数包括chain、product和permutations。

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


# 输出所有排列组合 
# [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]

8. 生成器

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

# 使用yield关键字创建生成器 
def fibonacci_series(n):
    a, b = 0, 1
    for i in range(n):
        yield a
        a, b = b, a + b

# 输出迭代器中的值 
for number in fibonacci_series(10):
    print(number)

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

9.装饰器

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

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))

# 运行add函数，返回值为12

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}

11. 动态导入

当你想根据用户输入或配置导入模块时，可以使用模块动态导入模块importlib。

import importlib

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

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}

13. 可调用对象

在 Python 中，任何可以称为函数的对象都称为可调用对象，包括函数、方法、类，甚至是定义__call__方法的对象。

class Adder:
    def __call__(self, x, y):
        return x + y

adder = Adder()
result = adder(3, 4)

print(result)
#7

14.用下划线分隔大数字/字符

大数字很难一眼看出来是多大，在 Python 中可以用下划线来使数字更易读。

num_test = 100_345_405 # 一个大数字

print(num_test)
# 100345405

15.快速合并两个字典

在Python中，如果你想要合并两个字典，即将一个字典的键值对添加到另一个字典中，有几种快速的方法可以做到这一点。下面是一些常见的合并字典的代码演示：

方法1：使用update()方法

update()方法会用一个字典的项更新另一个字典，将给定字典（dict2）的键-值对添加到当前字典（dict1）中。如果dict2中的键在dict1中也存在，则dict1中对应键的值会被dict2中的值替换。

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

dict1.update(dict2)

print(dict1)  # 输出: {'a': 1, 'b': 3, 'c': 4}

注意，如果dict2中的键在dict1中已存在（如这里的'b'键），则dict1中该键的值会被dict2中的值覆盖。

方法2：使用{**dict1, **dict2}（Python 3.5+）

从Python 3.5开始，你可以使用字典解包（unpacking）的语法来合并两个字典。这种方法不会修改任何原始字典，而是创建一个新的字典。

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

merged_dict = {**dict1, **dict2}

print(merged_dict)  # 输出: {'a': 1, 'b': 3, 'c': 4}
# 注意：与update()不同，这里'b'的值来自dict2

同样地，如果两个字典中有相同的键，则后一个字典（这里是dict2）中的值会覆盖前一个字典（dict1）中的值。

方法3：使用collections.ChainMap（不推荐用于合并）

虽然collections.ChainMap可以用来创建一个看似合并了多个字典的视图，但它实际上并没有创建一个新的字典或修改原始字典。它只是提供了一种方便的方式来按顺序查找键值对。因此，它可能不适用于需要真正合并字典的场景。但在这里提一下以供参考。

from collections import ChainMap

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

merged = ChainMap(dict1, dict2)

# 注意：这不是一个真正的合并后的字典，而是一个视图
# 当你访问一个键时，它会按顺序查找第一个匹配的项
print(merged['b'])  # 输出: 3，来自dict2

# 如果你想转换成真正的字典，可以使用dict()
real_merged = dict(merged)
print(real_merged)  # 输出: {'a': 1, 'b': 3, 'c': 4}

对于大多数需要合并字典的场景，推荐使用{**dict1, **dict2}或dict1.update(dict2)（如果你不介意修改原始字典）。

16. 列表、集合和字典是可变的
在Python中，列表（list）、集合（set）和字典（dict）都是可变的（mutable）数据结构，这意味着你可以在创建它们之后修改它们。下面是这些数据结构可变性的代码演示：

列表（List）

列表是可变的，你可以添加、删除或修改元素。

# 创建一个列表
my_list = [1, 2, 3]

# 修改列表中的元素
my_list[1] = 'a'  # 将索引为1的元素从2修改为'a'
print(my_list)  # 输出: [1, 'a', 3]

# 在列表末尾添加元素
my_list.append(4)
print(my_list)  # 输出: [1, 'a', 3, 4]

# 在列表开头添加元素
my_list.insert(0, 0)
print(my_list)  # 输出: [0, 1, 'a', 3, 4]

# 删除列表中的元素
my_list.remove('a')  # 删除列表中第一个出现的'a'
print(my_list)  # 输出: [0, 1, 3, 4]

# 通过索引删除元素
del my_list[0]
print(my_list)  # 输出: [1, 3, 4]

集合（Set）

集合也是可变的，你可以添加或删除元素，但集合中的元素是无序且唯一的。

# 创建一个集合
my_set = {1, 2, 3}

# 向集合中添加元素
my_set.add(4)
print(my_set)  # 输出可能是: {1, 2, 3, 4}（集合是无序的）

# 从集合中删除元素
my_set.remove(2)
print(my_set)  # 输出可能是: {1, 3, 4}

# 也可以使用discard方法删除元素，如果元素不存在则不会抛出错误
my_set.discard(5)  # 尝试删除不存在的元素5，不会有任何影响
print(my_set)  # 输出仍然可能是: {1, 3, 4}

# 清空集合
my_set.clear()
print(my_set)  # 输出: set()

字典（Dict）

字典是可变的，你可以添加、删除或修改键值对。

# 创建一个字典
my_dict = {'name': 'John', 'age': 30}

# 修改字典中的键值对
my_dict['age'] = 31
print(my_dict)  # 输出: {'name': 'John', 'age': 31}

# 向字典中添加新的键值对
my_dict['city'] = 'New York'
print(my_dict)  # 输出: {'name': 'John', 'age': 31, 'city': 'New York'}

# 删除字典中的键值对
del my_dict['age']
print(my_dict)  # 输出: {'name': 'John', 'city': 'New York'}

# 也可以使用pop方法删除键值对，并返回该键对应的值
age = my_dict.pop('city')
print(age)  # 输出: New York
print(my_dict)  # 输出: {'name': 'John'}

# 清空字典
my_dict.clear()
print(my_dict)  # 输出: {}