详细介绍Python函数③（日常使用）

详细介绍Python常用函数和方法③（日常使用）

列表（数组）操作

在 Python 中，可以使用列表（List）来实现数组的功能，并对其进行各种操作。列表在 Python 中非常灵活，可以存储任意类型的数据，并且支持动态大小和各种操作。

定义一个数组（列表）：

python复制代码# 定义一个空列表
my_list = []

# 定义带有初始元素的列表
my_list = [1, 2, 3, 4, 5]

# 定义包含不同数据类型的列表
mixed_list = [1, 'hello', 3.14, True]

# 列表也可以包含其他列表（嵌套列表）
nested_list = [[1, 2], [3, 4, 5], [6, 7, 8, 9]]

对列表进行操作：

1. 访问列表元素：

python复制代码my_list = [1, 2, 3, 4, 5]

# 访问单个元素
print(my_list[0])  # 输出: 1

# 切片操作（获取子列表）
print(my_list[1:3])  # 输出: [2, 3]

# 访问最后一个元素
print(my_list[-1])  # 输出: 5

2. 修改列表元素：

python复制代码my_list = [1, 2, 3, 4, 5]

# 修改单个元素
my_list[2] = 10
print(my_list)  # 输出: [1, 2, 10, 4, 5]

# 使用切片进行批量修改
my_list[1:4] = [20, 30, 40]
print(my_list)  # 输出: [1, 20, 30, 40, 5]

3. 添加元素：

python复制代码my_list = [1, 2, 3]

# 在末尾添加一个元素
my_list.append(4)
print(my_list)  # 输出: [1, 2, 3, 4]

# 在指定位置插入元素
my_list.insert(1, 5)
print(my_list)  # 输出: [1, 5, 2, 3, 4]

4. 删除元素：

python复制代码my_list = [1, 2, 3, 4, 5]

# 删除指定位置的元素
del my_list[2]
print(my_list)  # 输出: [1, 2, 4, 5]

# 移除第一个匹配的元素
my_list.remove(4)
print(my_list)  # 输出: [1, 2, 5]

# 弹出（删除并返回）指定位置的元素
popped_element = my_list.pop(1)
print(popped_element)  # 输出: 2
print(my_list)  # 输出: [1, 5]

5. 其他常见操作：

python复制代码my_list = [1, 2, 3, 4, 5]

# 获取列表长度
print(len(my_list))  # 输出: 5

# 判断元素是否在列表中
print(3 in my_list)  # 输出: True

# 迭代列表元素
for item in my_list:
    print(item)

# 清空列表
my_list.clear()
print(my_list)  # 输出: []

交换两个变量值

在Python中，可以使用这种方式交换两个变量的值：

Copy CodecurA = 10
curB = 20
curA, curB = curB, curA

在执行这段代码之后，curA的值将变为20，curB的值将变为10。这种方式简洁而高效，可以避免使用额外的临时变量。

异常处理机制

在Python中，异常处理机制用于捕获和处理程序运行过程中出现的异常情况，以便程序能够更好地处理这些异常而不会崩溃。

Python提供了try-except语句来实现异常处理。try语句块用于包含可能引发异常的代码，而except语句块用于定义处理异常的逻辑。

以下是一个异常处理的基本结构：

try:
    # 可能引发异常的代码
    # ...
except ExceptionType1:
    # 处理 ExceptionType1 异常的逻辑
except ExceptionType2:
    # 处理 ExceptionType2 异常的逻辑
else:
    # 如果没有异常发生时执行的逻辑
finally:
    # 无论是否发生异常都会执行的逻辑

在上述代码中，try语句块中的代码是可能引发异常的部分。如果在这个代码块中发生了异常，那么程序会跳转到与其类型匹配的except语句块，并执行相应的逻辑。如果异常的类型没有在except语句中被捕获到，则该异常会向上层调用栈传播，直到遇到能够处理它的except语句或者到达最顶层，此时程序会终止并打印异常信息。

可以使用多个except语句来捕获不同类型的异常。在except语句中，可以使用具体的异常类型（如ZeroDivisionError、FileNotFoundError等）或者使用基类Exception来捕获所有的异常。同时，也可以通过给except语句添加as关键字来获取异常对象的引用，以便进一步处理。

在except语句块之后，可以使用else语句块来定义在没有发生异常时执行的逻辑。finally语句块则用于定义无论是否发生异常都会执行的逻辑，如资源释放等操作。

举例

try:
    file = open("nonexistent_file.txt", "r")
except FileNotFoundError:
    print("文件不存在！")

在上述代码中，我们尝试以只读模式打开一个名为nonexistent_file.txt的文件。但由于该文件不存在，Python会引发一个FileNotFoundError异常。在except FileNotFoundError语句块中，我们打印了一条自定义的错误信息"文件不存在！"。

这样，即使文件不存在，我们的程序也不会崩溃，而是能够正常地输出错误提示信息。

除了捕获特定类型的异常，我们还可以使用except Exception来捕获所有类型的异常，并在处理时输出通用的错误信息。

try:
    # 可能引发异常的代码
    # ...
except Exception as e:
    print("发生了异常：", str(e))

在上述代码中，我们使用Exception作为异常类型，这将捕获所有类型的异常。在except Exception as e语句块中，我们打印了异常的描述信息。

除了try-except语句外，还可以使用raise语句来手动引发异常，并使用assert语句来进行断言和异常触发。

当我们需要在程序运行过程中手动引发异常时，可以使用raise语句来实现。

例如，我们希望在函数中检查输入参数是否满足一定的条件，如果不满足则引发一个ValueError异常。

def divide(a, b):
    if b == 0:
        raise ValueError("除数不能为0！")
    return a / b

在上述代码中，我们定义了一个函数divide，它接受两个参数a和b，并返回它们之间的除法运算结果。如果参数b等于0，则会引发一个ValueError异常，并输出自定义的错误信息"除数不能为0！"。

这样，在调用函数divide时，如果参数b等于0，就会引发一个异常，并终止程序的执行。

除了raise语句外，还可以使用assert语句来进行断言和异常触发。

例如，我们希望在程序中检查输入的参数是否满足一定的条件，如果不满足则引发一个AssertionError异常。

def square(x):
    assert x > 0, "参数必须大于0！"
    return x * x

在上述代码中，我们定义了一个函数square，它接受一个参数x，并返回它的平方。在函数内部，我们使用assert语句来检查参数x是否大于0，如果不满足，则引发一个AssertionError异常，并输出自定义的错误信息"参数必须大于0！"。

这样，在调用函数square时，如果参数x不大于0，就会引发一个异常，并终止程序的执行。

随机数生成random

import random

i = random.randint(1, 10)
print("Random number between 1 and 10:", i)

在上述代码中，我们导入了 random 模块。然后，使用 random.randint(1, 10) 生成一个1到10之间的随机整数，并将其赋值给变量 i。最后，使用 print() 函数打印出生成的随机数。

print函数

为什么要写print函数呢，因为在某些时候不仅仅是简单的打印操作，而涉及到几个想要同时打印时，我发现我忘记了该如何写，所以记录下来。

name = "Alice"
age = 25
print("Name:", name, "Age:", age, sep=" | ")  # 使用自定义的分隔符

字典方法调用—赋值

        freq = {}
        for num in nums:
            freq[num] = freq.get(num, 0) + 1

freq.get(num, 0): 这一部分是一个字典方法调用，用来获取字典 freq 中键为 num 的值。如果字典中不存在键 num，则返回默认值 0。

freq[num] = freq.get(num, 0) + 1: 将 freq[num] 的值设置为当前 num 的计数值加一。如果 num 已经存在于 freq 中，则将其对应的计数值加一；如果 num 不在 freq 中，则将 num 加入 freq，并设置初始计数值为 1。

这段代码的效果是统计 nums 列表中每个元素出现的次数，最终得到一个字典 freq，其中键是 nums 中的元素，对应的值是该元素在 nums 中出现的次数。

哈希表

在 Python 中，可以使用字典（dictionary）来实现哈希表的功能。字典是一种无序的数据集合，它由键值对（key-value pairs）组成，其中每个键都是唯一的，并且与一个值相关联。

以下是在 Python 中使用字典来实现哈希表的基本操作示例：

创建一个空字典

my_dict = {}

添加键值对

my_dict['apple'] = 3
my_dict['banana'] = 6
my_dict['orange'] = 9

访问元素

print(my_dict['banana'])  # 输出 6

检查键是否存在

if 'apple' in my_dict:
    print("苹果的数量是：" + str(my_dict['apple']))
else:
    print("找不到苹果")

删除键值对

del my_dict['orange']

通过上述操作，可以看出在 Python 中使用字典就相当于使用了哈希表的功能。字典提供了快速的键值查找和插入操作，适用于许多实际的编程场景。

注意：

在python中，如果刚开始访问的键的值不存在的话，需要先赋值，否则会报错，而c++中则会直接给你创建一个。

defaultdict类的用法

collections.defaultdict 是 Python 标准库中的一个数据结构，它是 dict 的一个子类，提供了一种方便的方式来处理字典中缺失键的情况。与普通的字典不同，defaultdict 允许指定一个默认的数值类型，在访问不存在的键时会自动为其创建一个默认值。

下面是一个简单的示例，演示了 defaultdict 的基本用法：

from collections import defaultdict

# 创建一个 int 类型的 defaultdict
my_dict = defaultdict(int)

# 访问不存在的键，会自动创建并初始化为默认值 0
print(my_dict['key1'])  # 输出 0

# 可以直接对不存在的键进行操作
my_dict['key2'] += 1
print(my_dict['key2'])  # 输出 1

# 自定义默认值
my_dict = defaultdict(lambda: 'N/A')
print(my_dict['key3'])  # 输出 'N/A'

# 使用 defaultdict 处理列表
my_list_dict = defaultdict(list)
my_list_dict['list1'].append(1)
my_list_dict['list1'].append(2)
print(my_list_dict['list1'])  # 输出 [1, 2]

在上述示例中，我们首先导入了 defaultdict 类，然后创建了几个不同类型的 defaultdict。我们可以看到，当访问不存在的键时，defaultdict 会根据指定的默认值类型自动创建并初始化该键。这样可以方便地处理字典中不存在的键的情况，避免了 KeyError 错误。

除了使用内置的类型作为默认值外，你还可以使用 lambda 函数来自定义默认值逻辑。此外，defaultdict 也非常适合用来处理值为列表、集合等可变类型的情况，可以直接对列表进行操作而无需担心键不存在的问题。

counter函数用法

Counter 是 Python 标准库 collections 模块中的一个数据结构，用于快速、简便地统计可迭代对象中元素的出现次数。Counter 可以接受任何可迭代对象作为输入，包括字符串、列表、元组等。

下面是一些常见的使用方法和示例：

1. 创建 Counter 对象：

   from collections import Counter
   
   # 从可迭代对象创建 Counter 对象
   counter1 = Counter([1, 2, 3, 3, 4, 4, 4])
   
   # 从字符串创建 Counter 对象
   counter2 = Counter("hello")
   

2. 访问计数结果：

   print(counter1)  # Counter({4: 3, 3: 2, 1: 1, 2: 1})
   print(counter2)  # Counter({'l': 2, 'h': 1, 'e': 1, 'o': 1})
   

3. 获取元素的计数：

   print(counter1[4])  # 3
   print(counter2['l'])  # 2
   

4. 统计整个 Counter 中不同元素的个数：

   print(len(counter1))  # 4
   print(len(counter2))  # 4
   

5. 获取所有元素及其对应的计数：

   print(counter1.items())  # dict_items([(1, 1), (2, 1), (3, 2), (4, 3)])
   print(counter2.items())  # dict_items([('h', 1), ('e', 1), ('l', 2), ('o', 1)])
   

6. 获取计数最多的元素及其计数：

   print(counter1.most_common(1))  # [(4, 3)]
   print(counter2.most_common(2))  # [('l', 2), ('h', 1)]
   

get函数

在 Python 中，get 函数是字典（dictionary）对象的一个方法，用于获取指定键对应的值。get 方法接受一个键作为参数，并返回该键对应的值。如果字典中不存在指定的键，则可以提供一个默认值作为第二个参数，以便在键不存在时返回默认值。

下面是 get 函数的基本使用方法和示例：

# 创建一个字典
my_dict = {'a': 1, 'b': 2, 'c': 3}

# 获取指定键对应的值
value_a = my_dict.get('a')  # 返回 1
value_d = my_dict.get('d')  # 返回 None，因为'd'不在字典中

# 提供默认值参数
value_d_default = my_dict.get('d', 0)  # 返回 0，因为'd'不在字典中，使用默认值 0

# 不提供默认值参数
value_d_no_default = my_dict.get('d')  # 返回 None，因为'd'不在字典中，且没有提供默认值

可以看到，get 函数的基本形式是 my_dict.get(key, default=None)，其中 key 是要查找的键，default 是可选的默认值，如果提供了默认值，则当键不存在时会返回默认值，否则会返回 None。

使用 get 函数可以避免因为字典中不存在指定的键而导致的 KeyError 异常，非常适合在需要获取字典中键对应值的场景中使用。

str函数

在 Python 中，str() 函数用于将一个对象转换为字符串。无论是数字、列表、元组、字典还是其他类型的对象，都可以使用 str() 函数将其转换为对应的字符串表示形式。

下面是一些示例，演示了如何使用 str() 函数：

1. 将整数转换为字符串：

num = 42
str_num = str(num)
print(str_num)  # 输出：'42'

1. 将浮点数转换为字符串：

pi = 3.14159
str_pi = str(pi)
print(str_pi)  # 输出：'3.14159'

1. 将列表转换为字符串：

my_list = [1, 2, 3, 4, 5]
str_list = str(my_list)
print(str_list)  # 输出：'[1, 2, 3, 4, 5]'

1. 将字典转换为字符串：

my_dict = {'name': 'Alice', 'age': 30}
str_dict = str(my_dict)
print(str_dict)  # 输出："{'name': 'Alice', 'age': 30}"

总之，str() 函数是一个非常方便的工具，可以帮助你将各种类型的对象转换为字符串，以便进行输出、拼接等操作。

not操作

在 Python 中，not 操作符会将任何非空对象转换为 False，如果对象为空则转换为 True。