python编程基础

@

目录

Python 是一种广泛使用的高级编程语言，它以其清晰的语法和代码可读性而闻名。Python 支持多种编程范式，包括面向对象、命令式、函数式和过程式编程。它由 Guido van Rossum 创建，并于1991年首次发布。本文将详细介绍python编程语法。

1.python中的变量和数据类型

1.1变量

在Python中，变量是用来存储数据的容器。你可以将变量视为一个有标签的盒子，这个标签就是变量名，盒子里面可以放入数据。Python中的变量不需要显式声明类型，解释器会根据赋给变量的值自动确定类型。

以下是一些关于Python变量的基本规则和特点：

  1. 命名规则：

    • 变量名必须以字母或下划线开头，不能以数字开头。
    • 变量名只能包含字母、数字和下划线（A-z, 0-9, 和 _ ）。
    • 变量名是区分大小写的，这意味着Variable和variable是两个不同的变量。

  2. 动态类型：

    • Python是动态类型语言，变量可以在运行时改变类型。例如：
      x = 10      # x是整数
x = "Hello" # x现在是字符串

  3. 无需声明：

    • 在Python中，你不需要声明变量的类型，直接赋值即可。

  4. 全局变量和局部变量：

    • 如果在函数内部赋值给一个变量，那么这个变量是局部变量，仅在函数内部有效。
    • 如果在函数外部赋值给一个变量，那么这个变量是全局变量，可以在程序的任何地方访问。

  5. 变量作用域：

    • Python中有LEGB规则，即Local（局部），Enclosing（封闭），Global（全局），Built-in（内置）。

  6. 可变类型与不可变类型：

    • 变量可以指向可变类型（如列表、字典）或不可变类型（如整数、字符串、元组）。
    • 对于不可变类型，赋值操作实际上是创建了一个新的对象，并更新了变量的引用。
    • 对于可变类型，赋值操作只是改变了变量的引用，指向了一个新的对象。

  7. 垃圾回收：

    • Python有自动垃圾回收机制，当一个变量不再被引用时，它会被自动回收。

  8. 关键字：

    • 一些单词在Python中有特殊的意义，被称为关键字，不能用作变量名。

这里有一个简单的Python变量示例：

# 定义一个变量并赋值
my_variable = 42

# 打印变量的值
print(my_variable)

# 改变变量的类型
my_variable = "Now I'm a string"

# 再次打印变量的值
print(my_variable)

在这段代码中，我们首先定义了一个名为my_variable的变量，并赋值为整数42。然后我们打印了这个变量的值。接着我们将变量的值改为字符串"Now I'm a string"，并再次打印了变量的值。这展示了Python变量的动态类型特性。

1.2python基本数据类型

Python中有几种基本数据类型，用于存储不同类型的数据。以下是Python中常见的基本数据类型：

  1. 整数（Integers）：

    • 用于存储整数，没有小数点。
    • 示例：42, -7, 0, 1024

  2. 浮点数（Floats）：

    • 用于存储小数点后的数字。
    • 示例：3.14, -0.01, 2.0

  3. 字符串（Strings）：

    • 用于存储文本数据。
    • 可以用单引号'、双引号"或三引号'''或"""来定义字符串。
    • 示例：'hello', "world", ```"""multiline
      text"""`

  4. 布尔值（Booleans）：

    • 只有两个值：True和False。
    • 用于逻辑判断。
    • 示例：True, False

  5. 复数（Complex Numbers）：

    • 用于存储复数。
    • 示例：3+4j, 1.2-3.4j

  6. 列表（Lists）：

    • 有序的元素集合，可以包含不同类型的元素。
    • 元素可以重复。
    • 可变类型，可以修改。
    • 示例：[1, 'a', 3.14], [True, False, True]

  7. 元组（Tuples）：

    • 有序的元素集合，可以包含不同类型的元素。
    • 元素不可重复。
    • 不可变类型，一旦创建不能修改。
    • 示例：(1, 'a', 3.14), (1, 2, 3)

  8. 字典（Dictionaries）：

    • 无序的键值对集合。
    • 键必须是不可变类型，如字符串、整数。
    • 值可以是任何数据类型。
    • 可变类型，可以修改。
    • 示例：{'name': 'John', 'age': 30}

  9. 集合（Sets）：

    • 无序的元素集合。
    • 元素必须是可哈希的，不可重复。
    • 可变类型，可以修改。
    • 示例：{1, 2, 3}, {'a', 'b', 'c'}

  10. 冻结集合（Frozen Sets）：

    • 和集合类似，但是不可变类型。
    • 示例：frozenset([1, 2, 3])

这些基本数据类型构成了Python编程的基础，并且可以用于创建更复杂的数据结构和对象。在Python中，除了这些基本数据类型，还有用于处理日期和时间的datetime类型，用于处理二进制数据的bytes和bytearray类型等。此外，Python还支持自定义数据类型，通常通过类来实现。

1.3基本输入与输出

在Python中，输入和输出是编程中的基本操作，用于与用户交互或处理数据。以下是Python中基本的输入和输出方法：

输入（Input）

Python使用input()函数来接收用户的输入。这个函数会暂停程序的执行，等待用户在控制台输入文本，并按下回车键。输入的文本默认为字符串类型。

# 请求用户输入并存储到变量中
user_input = input("请输入一些内容: ")

# 打印用户输入的内容
print("你输入的内容是: " + user_input)

如果你需要用户输入一个特定的数据类型，比如整数或浮点数，你可能需要使用int()或float()函数来转换输入的字符串。

# 请求用户输入一个整数
user_number = int(input("请输入一个整数: "))

# 使用输入的整数
print("你输入的整数是: " + str(user_number))

输出（Output）

Python使用print()函数来输出内容到控制台。这个函数可以接受多个参数，并且可以格式化输出。

基本输出

# 打印简单的文本
print("Hello, World!")

打印多个参数

# 打印多个参数，用空格分隔
print("Hello", "World", "!")

格式化输出

Python支持多种字符串格式化方法，包括传统的%操作符、str.format()方法和f-string（Python 3.6+）。

使用%操作符：

name = "Kimi"
age = 30
print("我的名字是%s, 我的年龄是%d" % (name, age))

使用str.format()方法：

name = "Kimi"
age = 30
print("我的名字是{name}, 我的年龄是{age}".format(name=name, age=age))

使用f-string：

name = "Kimi"
age = 30
print(f"我的名字是{name}, 我的年龄是{age}")

f-string是格式化字符串的现代方法，它简洁且易于阅读。在f-string中，你只需在字符串前加上f，然后将变量放在花括号{}中即可。

打印到文件

除了打印到控制台，Python也可以将输出重定向到文件。

# 打开一个文件用于写入
with open('output.txt', 'w') as file:
    file.write("这是文件中的内容。\n")

# 追加内容到文件
with open('output.txt', 'a') as file:
    file.write("这是追加的内容。\n")

在这个例子中，with语句用于打开文件，确保在操作完成后自动关闭文件。'w'模式表示写入模式，如果文件已存在，它会被覆盖；'a'模式表示追加模式，内容会被添加到文件末尾。

这些是Python中进行基本输入和输出操作的方法。通过这些方法，你可以与用户交互，处理数据，并将结果输出到屏幕或文件中。

1.4python中的运算符

Python提供了丰富的运算符来执行各种数学和逻辑运算。以下是Python中常用的运算符：

算术运算符

用于执行基本的数学运算。

  • 加法（+）：5 + 3 结果为 8
  • 减法（-）：5 - 3 结果为 2
  • 乘法（*）：5 * 3 结果为 15
  • 除法（/）：5 / 3 结果为 1.6666666666666667
  • 整除（//）：5 // 3 结果为 1（返回商的整数部分）
  • 模运算（%）：5 % 3 结果为 2（返回余数）
  • 指数运算（**）：5 ** 3 结果为 125（5的3次方）

比较运算符

用于比较两个值，并返回布尔值（True 或 False）。

  • 等于（==）：5 == 3 结果为 False
  • 不等于（!=）：5 != 3 结果为 True
  • 大于（>）：5 > 3 结果为 True
  • 小于（<）：5 < 3 结果为 False
  • 大于等于（>=）：5 >= 3 结果为 True
  • 小于等于（<=）：5 <= 3 结果为 False

赋值运算符

用于给变量赋值。

  • 简单赋值（=）：x = 5
  • 复合赋值（+=, -=, *=, /=, //=, %=, **=）：
    • x += 3 等同于 x = x + 3
    • x -= 3 等同于 x = x - 3
    • x *= 3 等同于 x = x * 3
    • x /= 3 等同于 x = x / 3
    • x //= 3 等同于 x = x // 3
    • x %= 3 等同于 x = x % 3
    • x **= 3 等同于 x = x ** 3

逻辑运算符

用于执行布尔逻辑运算。

  • 逻辑与（and）：True and False 结果为 False
  • 逻辑或（or）：True or False 结果为 True
  • 逻辑非（not）：not True 结果为 False

位运算符

用于对二进制位进行操作。

  • 按位与（&）：0b101 & 0b110 结果为 0b100
  • 按位或（|）：0b101 | 0b110 结果为 0b111
  • 按位异或（^）：0b101 ^ 0b110 结果为 0b011
  • 按位非（~）：~0b101 结果为 -0b110（注意：Python中没有无符号整数类型）
  • 左移（<<）：0b101 << 1 结果为 0b110
  • 右移（>>）：0b101 >> 1 结果为 0b001

成员运算符

用于检查某个值是否存在于序列中。

  • 属于（in）：'a' in 'abc' 结果为 True
  • 不属于（not in）：'b' not in 'abc' 结果为 False

身份运算符

用于比较两个对象的内存身份。

  • 身份相等（is）：x is y 检查 x 和 y 是否为同一个对象
  • 身份不等（is not）：x is not y 检查 x 和 y 是否不是同一个对象

这些运算符在Python编程中非常常用，它们使得代码更加简洁和强大。

2.python中的列表、元组、字典、集合

2.1列表

在Python中，列表（List）是一种内置的数据结构，它是一个有序的元素集合，可以包含不同类型的元素，并且元素可以重复。列表是可变的，这意味着你可以在列表中随时添加、删除或更改元素。

以下是Python列表的一些关键特性：

  1. 有序：列表中的元素有明确的顺序，这个顺序是按照元素被添加到列表的顺序确定的。

  2. 可变：你可以修改列表的内容，比如添加、删除或替换元素。

  3. 异构：列表可以包含不同类型的元素，例如整数、浮点数、字符串，甚至是其他列表。

  4. 动态大小：列表的大小可以根据需要动态变化。

  5. 索引：列表中的每个元素都有一个索引，这是它在列表中的位置，索引从0开始。

  6. 切片：你可以使用切片操作来获取列表的一部分。

  7. 方法丰富：列表提供了大量的方法来操作列表，比如append()、extend()、insert()、remove()、pop()、sort()等。

以下是一些使用列表的示例：

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

# 访问列表中的元素
print(my_list[0])  # 输出第一个元素，索引为0

# 修改列表中的元素
my_list[1] = 20

# 添加元素到列表末尾
my_list.append(6)

# 插入元素到指定位置
my_list.insert(1, 'a')

# 删除列表末尾的元素
last_item = my_list.pop()

# 删除指定位置的元素
del my_list[1]

# 列表切片
sub_list = my_list[1:3]  # 获取索引1到2的元素

# 列表长度
print(len(my_list))  # 输出列表中的元素数量

# 检查元素是否在列表中
print(2 in my_list)  # 输出 True 或 False

# 列表排序
my_list.sort()

# 列表反转
my_list.reverse()

# 列表复制
new_list = my_list.copy()

列表是Python中非常灵活和强大的数据结构，它在编程中有着广泛的应用，比如存储数据集合、处理序列化数据等。

2.2元组

在Python中，元组（Tuple）是一种内置的数据结构，它与列表类似，也是有序的元素集合。然而，与列表的主要区别在于元组是不可变的，这意味着一旦元组被创建，你就不能修改它的元素。

以下是Python元组的一些关键特性：

  1. 有序：元组中的元素有明确的顺序。

  2. 不可变：元组一旦创建，其内容就不能被修改。这意味着你不能添加、删除或更改元组中的元素。

  3. 异构：元组可以包含不同类型的元素。

  4. 索引：元组中的每个元素都有一个索引，索引从0开始。

  5. 切片：与列表一样，你可以使用切片操作来获取元组的一部分。

  6. 方法较少：与列表相比，元组提供的方法较少，因为元组不支持修改操作。

  7. 不可变性带来的优势：由于元组的不可变性，它们在多线程环境中更安全，可以作为字典的键，而列表则不能。

以下是一些使用元组的示例：

# 创建一个元组
my_tuple = (1, 2, 3, 4, 5)

# 访问元组中的元素
print(my_tuple[0])  # 输出第一个元素

# 修改元组元素的尝试将导致错误
# my_tuple[1] = 20  # 这将抛出 TypeError

# 元组切片
sub_tuple = my_tuple[1:3]  # 获取索引1到2的元素

# 元组长度
print(len(my_tuple))  # 输出元组中的元素数量

# 检查元素是否在元组中
print(2 in my_tuple)  # 输出 True 或 False

# 元组复制
new_tuple = my_tuple.copy()

由于元组的不可变性，它们通常用于保护数据不被更改，或者在函数中返回多个值。例如：

def get_user_info():
    # 假设我们从数据库获取了用户信息
    user_id = 1
    username = "Kimi"
    email = "kimi@example.com"
    return user_id, username, email  # 返回一个元组

# 使用返回的元组
user_id, username, email = get_user_info()
print(f"User ID: {user_id}, Username: {username}, Email: {email}")

在这个例子中，函数get_user_info返回了一个包含三个元素的元组，分别代表用户的ID、用户和电子邮件。由于元组的不可变性，这些返回的值在函数外部是安全的，不会被意外修改。

2.3字典

在Python中，字典（Dictionary）是一种内置的数据结构，它存储键值对（key-value pairs）。字典是可变的，这意味着你可以在运行时添加、删除或更改键值对。

以下是Python字典的一些关键特性：

  1. 无序：在Python 3.6之前，字典是无序的，即键值对的顺序是不确定的。从Python 3.7开始，字典保持插入顺序，即键值对按照插入的顺序存储。

  2. 可变：你可以修改字典的内容，比如添加、删除或更改键值对。

  3. 键必须是不可变类型：字典的键必须是不可变类型，如字符串、整数或元组。这是因为不可变类型可以被哈希，而哈希值用于快速检索字典中的键值对。

  4. 值可以是任何类型：字典的值可以是任何数据类型，包括可变类型和不可变类型。

  5. 键唯一：字典中的键必须是唯一的，不能有重复的键。

  6. 索引：字典不是通过索引访问的，而是通过键来检索对应的值。

  7. 方法丰富：字典提供了大量的方法来操作字典，比如get()、keys()、values()、items()、update()、pop()、popitem()等。

以下是一些使用字典的示例：

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

# 访问字典中的值
print(my_dict['name'])  # 输出 'Kimi'

# 添加新的键值对
my_dict['email'] = 'kimi@example.com'

# 修改已有的键值对
my_dict['age'] = 31

# 删除键值对
del my_dict['city']

# 使用pop方法删除并返回值
removed_value = my_dict.pop('age', None)

# 获取字典中的所有键
keys = my_dict.keys()

# 获取字典中的所有值
values = my_dict.values()

# 获取字典中的所有键值对
items = my_dict.items()

# 检查键是否存在于字典中
print('name' in my_dict)  # 输出 True 或 False

# 获取字典的长度
print(len(my_dict))  # 输出字典中的键值对数量

# 遍历字典
for key, value in my_dict.items():
    print(f"{key}: {value}")

字典在Python中非常灵活和强大，它在编程中有着广泛的应用，比如存储配置信息、缓存数据、实现关联数组等。由于字典的键值对结构，它特别适合用于存储和管理具有映射关系的数据。

2.4集合

在Python中，集合（Set）是一种内置的数据结构，它存储唯一元素的无序集合。集合中的元素必须是可哈希的，这意味着它们必须是不可变类型，如整数、浮点数、字符串或元组。集合是可变的，这意味着你可以在集合中随时添加或删除元素。

以下是Python集合的一些关键特性：

  1. 无序：集合中的元素没有固定的顺序，每次迭代集合时元素的顺序可能不同。

  2. 元素唯一：集合自动去除重复的元素，只保留唯一的元素。

  3. 可变：你可以修改集合的内容，比如添加或删除元素。

  4. 无重复元素：集合不允许有重复的元素。如果你尝试添加一个已经存在于集合中的元素，该元素不会被添加。

  5. 方法丰富：集合提供了大量的方法来操作集合，比如add()、remove()、discard()、clear()、union()、intersection()、difference()、symmetric_difference()等。

以下是一些使用集合的示例：

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

# 添加元素到集合
my_set.add(6)

# 尝试添加重复元素
my_set.add(3)  # 没有效果，因为3已经在集合中了

# 删除元素
my_set.remove(2)

# 删除元素时不抛出错误（如果元素不存在）
my_set.discard(7)

# 清空集合
my_set.clear()

# 创建另一个集合
another_set = {4, 5, 6, 7}

# 集合的并集
union_set = my_set.union(another_set)

# 集合的交集
intersection_set = my_set.intersection(another_set)

# 集合的差集
difference_set = my_set.difference(another_set)

# 集合的对称差集
symmetric_difference_set = my_set.symmetric_difference(another_set)

# 检查元素是否在集合中
print(3 in my_set)  # 输出 True 或 False

# 获取集合的长度
print(len(my_set))  # 输出集合中的元素数量

# 遍历集合
for element in my_set:
    print(element)

集合在Python中非常有用，特别是当你需要处理一组唯一的元素时。集合还常用于数学集合操作，如并集、交集、差集等。由于集合中的元素是无序的，所以它们不适合用作索引或需要有序元素的情况。

3.range、zip、enumerate

3.1range函数

Python 中的 range() 函数用于生成一个整数序列。这个函数非常灵活，可以根据你提供的参数生成不同的序列。range() 函数可以接收一到三个参数，具体如下：

  1. 不带参数：当你不传递任何参数给 range() 时，它会生成一个从 0 开始到停止值默认为 100000 的序列。这通常不是你想要的，因此很少单独使用 range()。

  2. 一个参数：如果你只传递一个参数 n 给 range()，它会生成一个从 0 到 n-1 的序列。

    list(range(5))  # [0, 1, 2, 3, 4]

  3. 两个参数：你可以传递两个参数 start 和 stop 给 range()，它会生成一个从 start 到 stop-1 的序列。

    list(range(2, 5))  # [2, 3, 4]

  4. 三个参数：range() 也可以接收三个参数 start、stop 和 step，它会生成一个从 start 开始，每次增加 step，直到 stop-1 的序列。

    list(range(2, 10, 2))  # [2, 4, 6, 8]

range() 生成的是一个“范围对象”（range object），这是一个可迭代的对象，可以在循环中直接使用，或者使用 list() 函数转换成列表。转换成列表后，你就可以使用列表的所有方法。

range() 也可以生成负数序列，只需将 step 参数设置为负数即可。

list(range(-5, 5, 1))  # [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]

range() 函数在循环中非常有用，尤其是在需要迭代一系列连续整数时。它比手动创建列表更加高效和简洁。

3.2zip函数

Python 中的 zip() 函数是一个非常有用的内置函数，它用于将多个可迭代对象（如列表、元组、集合等）中对应的元素打包成一个个元组，然后返回由这些元组组成的对象。zip() 可以接收任意数量的可迭代参数，并且返回一个迭代器。

以下是 zip() 函数的一些基本用法：

  1. 合并两个或多个列表：
    你可以使用 zip() 来合并两个或多个列表，将它们的元素配对成元组。

    list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
zipped = zip(list1, list2)
print(list(zipped))  # 输出：[(1, 'a'), (2, 'b'), (3, 'c')]

  2. 与 * 运算符一起使用：
    在 Python 3 中，你可以使用 * 运算符来解包参数。

    *args = [1, 2, 3]
zipped = zip(*args)
print(list(zipped))  # 输出：[(1,), (2,), (3,)]

  3. 处理不同长度的可迭代对象：
    如果传入的可迭代对象长度不同，zip() 会以最短的可迭代对象为界，停止合并。

    list1 = [1, 2, 3]
list2 = ['a', 'b']
zipped = zip(list1, list2)
print(list(zipped))  # 输出：[(1, 'a'), (2, 'b')]

  4. 与 map() 函数结合使用：
    你可以将 zip() 与 map() 函数结合使用，对配对的元素执行操作。

    list1 = [1, 2, 3]
list2 = [4, 5, 6]
zipped = zip(list1, list2)
summed = map(lambda x, y: x + y, *zipped)
print(list(summed))  # 输出：[5, 7, 9]

  5. 使用 zip() 函数生成字典：
    zip() 可以与 dict() 函数结合使用，快速生成字典。

    keys = ['name', 'age', 'city']
values = ['Alice', 30, 'New York']
dictionary = dict(zip(keys, values))
print(dictionary)  # 输出：{'name': 'Alice', 'age': 30, 'city': 'New York'}

  6. 使用 itertools.zip_longest() 处理不同长度的可迭代对象：
    如果你需要在可迭代对象长度不同时填充缺失值，可以使用 itertools.zip_longest()。

    from itertools import zip_longest
list1 = [1, 2, 3]
list2 = ['a', 'b']
zipped = zip_longest(list1, list2, fillvalue='None')
print(list(zipped))  # 输出：[(1, 'a'), (2, 'b'), (3, 'None')]

zip() 函数是处理多个列表或序列时的强大工具，它可以帮助你轻松地将数据配对和组合。

3.3enumerate函数

Python 中的 enumerate() 函数是一个非常实用的内置函数，它用于将一个可迭代对象（如列表、元组、字符串等）组合为一个索引序列，同时列出数据和数据下标。这在循环遍历可迭代对象时非常有用，尤其是当你需要知道元素的索引时。

基本用法

enumerate() 函数的基本用法是提供一个可迭代对象，它返回一个枚举对象，该对象生成包含索引和值的元组。

my_list = ['apple', 'banana', 'cherry']
for index, value in enumerate(my_list):
    print(index, value)

这将输出：

0 apple
1 banana
2 cherry

自定义起始索引

enumerate() 还允许你指定起始索引，这在索引不是从0开始的情况下非常有用。

my_list = ['apple', 'banana', 'cherry']
for index, value in enumerate(my_list, start=1):
    print(index, value)

这将输出：

1 apple
2 banana
3 cherry

在 enumerate() 中使用列表推导式

你也可以在列表推导式中使用 enumerate()，这样可以创建一个包含索引和值的新列表。

my_list = ['apple', 'banana', 'cherry']
enumerated_list = [(index, value) for index, value in enumerate(my_list)]
print(enumerated_list)

这将输出：

[(0, 'apple'), (1, 'banana'), (2, 'cherry')]

使用 enumerate() 与字典

enumerate() 也可以用来创建字典，尤其是当你需要将列表转换为字典，并且列表的元素作为值，索引作为键时。

my_list = ['apple', 'banana', 'cherry']
my_dict = {index: value for index, value in enumerate(my_list)}
print(my_dict)

这将输出：

{0: 'apple', 1: 'banana', 2: 'cherry'}

enumerate() 函数是 Python 编程中常用的工具之一，它使得在循环中处理索引和值变得简单直观。通过使用 enumerate()，你可以避免使用传统的 for 循环计数器，从而使代码更加清晰和易于维护。

4.序列、推导式、生成器与迭代器

4.1序列的切片

在Python中，序列的切片（Slicing）是一种强大的操作，它允许你从序列类型（如列表、元组、字符串等）中提取出一部分元素，创建一个新的序列。切片操作通过指定起始索引、结束索引和步长来完成。

切片的基本语法如下：

sequence[start:end:step]
  • start：切片开始的索引（包含该索引处的元素）。
  • end：切片结束的索引（不包含该索引处的元素）。
  • step：步长，表示取元素的间隔。

如果省略某个参数，Python会使用默认值：

  • 如果省略 start，它默认为0。
  • 如果省略 end，它默认为序列的长度。
  • 如果省略 step，它默认为1。

以下是一些切片操作的例子：

  1. 提取序列的一部分：

    my_list = [0, 1, 2, 3, 4, 5]
print(my_list[1:4])  # 输出 [1, 2, 3]

  2. 从头开始切片：

    print(my_list[:3])  # 输出 [0, 1, 2]

  3. 从末尾切片到特定位置：

    print(my_list[2:])  # 输出 [2, 3, 4, 5]

  4. 切片到序列的末尾：

    print(my_list[4:])  # 输出 [4, 5]

  5. 使用负索引进行切片：
    负索引表示从序列的末尾开始计数。

    print(my_list[-3:-1])  # 输出 [2, 3]

  6. 使用步长进行切片：
    步长可以是正数或负数。

    print(my_list[::2])  # 输出 [0, 2, 4]，从开始到结束，步长为2
print(my_list[1::2])  # 输出 [1, 3, 5]，从索引1开始到结束，步长为2
print(my_list[::-1])  # 输出 [5, 4, 3, 2, 1, 0]，从末尾到开始，步长为-1（反转序列）

  7. 切片赋值：
    你可以对切片的结果进行赋值，这会修改原始序列。

    my_list[1:3] = [10, 20]
print(my_list)  # 输出 [0, 10, 20, 3, 4, 5]

切片是处理序列数据时非常有用的工具，它允许你快速访问和修改序列的一部分，而不需要编写复杂的循环结构。

4.2序列的基本操作

Python 中的序列类型（如列表和元组）提供了许多有用的方法来进行常见操作。以下是一些序列类型的常用操作：

列表特有操作

  1. append(x)：在列表末尾添加一个元素 x。

    lst = [1, 2, 3]
lst.append(4)
print(lst)  # 输出：[1, 2, 3, 4]

  2. extend(iterable)：将一个可迭代对象 iterable 的所有元素添加到列表末尾。

    lst = [1, 2, 3]
lst.extend([4, 5])
print(lst)  # 输出：[1, 2, 3, 4, 5]

  3. insert(i, x)：在指定位置 i 添加一个元素 x。

    lst = [1, 2, 4]
lst.insert(2, 3)
print(lst)  # 输出：[1, 2, 3, 4]

  4. remove(x)：移除列表中第一个值为 x 的元素。

    lst = [1, 2, 3, 2, 4]
lst.remove(2)
print(lst)  # 输出：[1, 3, 2, 4]

  5. pop([i])：移除列表中位置 i 的元素，并返回该元素。如果不指定 i，默认移除并返回列表的最后一个元素。

    lst = [1, 2, 3, 4]
item = lst.pop(1)
print(item)  # 输出：2
print(lst)  # 输出：[1, 3, 4]

  6. clear()：清空列表中的所有元素。

    lst = [1, 2, 3]
lst.clear()
print(lst)  # 输出：[]

  7. index(x[, start[, end]])：返回列表中第一个值为 x 的元素的索引，可以指定搜索的起始和结束位置。

    lst = [1, 2, 3, 2, 4]
print(lst.index(2))  # 输出：1

  8. count(x)：返回元素 x 在列表中出现的次数。

    lst = [1, 2, 3, 2, 4]
print(lst.count(2))  # 输出：2

  9. sort(key=None, reverse=False)：对列表中的元素进行排序。

    lst = [4, 1, 3, 2]
lst.sort()
print(lst)  # 输出：[1, 2, 3, 4]

  10. reverse()：反转列表中的元素顺序。

    lst = [1, 2, 3, 4]
lst.reverse()
print(lst)  # 输出：[4, 3, 2, 1]

元组特有操作

元组是不可变的，所以没有像列表那样的修改操作，如 append()、extend()、insert()、remove()、pop() 等。但是，元组支持以下操作：

  1. count(x)：返回元素 x 在元组中出现的次数。

    tup = (1, 2, 3, 2, 4)
print(tup.count(2))  # 输出：2

  2. index(x[, start[, end]])：返回元组中第一个值为 x 的元素的索引，可以指定搜索的起始和结束位置。

    tup = (1, 2, 3, 2, 4)
print(tup.index(2))  # 输出：1

通用操作

  1. 切片：获取序列的一部分。

    seq = [0, 1, 2, 3, 4, 5]
print(seq[1:4])  # 输出：[1, 2, 3]

  2. len(seq)：获取序列的长度。

    seq = [0, 1, 2, 3, 4, 5]
print(len(seq))  # 输出：6

  3. 成员检查：

    • x in seq：检查 x 是否是序列的元素。
    • x not in seq：检查 x 是否不是序列的元素。
    seq = [0, 1, 2, 3, 4, 5]
print(2 in seq)  # 输出：True
print(6 in seq)  # 输出：False

  4. max(seq) 和 min(seq)：获取序列中的最大值和最小值。

    seq = [3, 1, 4, 1, 5, 9, 2]
print(max(seq))  # 输出：9
print(min(seq))  # 输出：1

  5. sum(seq)：计算序列中所有元素的总和。

    seq = [1, 2, 3, 4, 5]
print(sum(seq))  # 输出：15

这些操作是处理Python序列时的基础工具，它们使得数据操作变得简单而高效。

4.3列表推导式

列表推导式（List Comprehension）是Python中创建列表的一种简洁而强大的工具。它允许你通过一个现有的列表或任何可迭代对象来创建一个新的列表，同时可以应用条件过滤和复杂的表达式。

基本语法

列表推导式的基本语法如下：

[expression for item in iterable if condition]
  • expression：对每个元素进行的操作或计算。
  • item：来自 iterable 的每个元素的变量名。
  • iterable：一个可迭代对象，如列表、元组、字符串等。
  • condition：（可选）一个布尔表达式，用于过滤结果。

示例

  1. 基本列表推导式：

    squares = [x**2 for x in range(10)]
print(squares)  # 输出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

  2. 带有条件的列表推导式：

    even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)  # 输出：[0, 4, 16, 36, 64]

  3. 使用多个循环的列表推导式：

    matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
print(flattened)  # 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9]

  4. 对字典的键或值进行列表推导式：

    dict = {'a': 1, 'b': 2, 'c': 3}
keys = [key for key in dict]
values = [value for value in dict.values()]
print(keys)      # 输出：['a', 'b', 'c']
print(values)    # 输出：[1, 2, 3]

  5. 对字典的键值对进行列表推导式：

    dict = {'a': 1, 'b': 2, 'c': 3}
items = [(key, value) for key, value in dict.items()]
print(items)    # 输出：[('a', 1), ('b', 2), ('c', 3)]

  6. 使用条件和表达式的组合：

    numbers = [1, 2, 3, 4, 5, 6]
multiples_of_three = [num for num in numbers if num % 3 == 0]
print(multiples_of_three)  # 输出：[3, 6]

列表推导式不仅使代码更加简洁，而且通常比等效的 for 循环执行得更快。它们是处理列表和可迭代对象的强大工具，能够使代码更加Pythonic。

4.4生成器与迭代器

在Python中，迭代器（Iterator）和生成器（Generator）是处理数据集合时非常有用的抽象概念，它们允许我们逐个处理数据集中的元素，而不必一次性将整个数据集合加载到内存中。

迭代器（Iterator）

迭代器是一个实现了迭代器协议的对象，这意味着它有两个方法：__iter__() 和 __next__()。迭代器从集合的开始到结束进行遍历，并且你可以随时检查迭代器是否还有更多的元素。

迭代器的特点：

  1. 一次遍历：迭代器只能遍历一次，一旦遍历完成，它就会变得无效。
  2. 惰性计算：迭代器不会立即加载所有元素，而是在需要的时候才生成下一个元素。

创建迭代器的示例：

class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index < len(self.data):
            result = self.data[self.index]
            self.index += 1
            return result
        else:
            raise StopIteration

# 使用迭代器
my_iter = MyIterator([1, 2, 3, 4])
for value in my_iter:
    print(value)

生成器（Generator）

生成器是一种特殊的迭代器，它通过使用 yield 语句来产生值。每次迭代时，生成器会返回 yield 表达式的值，并且会在下一次迭代时从它离开的地方继续执行。

生成器的特点：

  1. 惰性计算：生成器只在需要的时候计算下一个值，这使得它们在处理大型数据集时非常高效。
  2. 状态保存：生成器保存了迭代的状态，包括变量值和执行位置，使得它们可以在每次 yield 之后恢复执行。

创建生成器的示例：

def my_generator(data):
    for value in data:
        yield value  # 生成器通过 yield 返回值

# 使用生成器
my_gen = my_generator([1, 2, 3, 4])
for value in my_gen:
    print(value)

生成器还可以使用 yield from 来从一个生成器中委托给另一个生成器：

def nested_generator():
    yield from [1, 2, 3, 4]

# 使用嵌套生成器
for value in nested_generator():
    print(value)

生成器和迭代器是Python中强大的工具，它们允许你以一种高效且内存友好的方式来处理数据集合。生成器特别适用于数据流和大型数据集，因为它们不需要一次性将所有数据加载到内存中。

5.程序流程控制

5.1分支结构

Python中的分支结构主要通过if、elif和else语句来实现。这些语句允许程序根据条件判断来执行不同的代码块。下面是Python中分支结构的基本用法：

单分支 if

if 条件:
    # 条件为真时执行的代码块

双分支 if-else

if 条件:
    # 条件为真时执行的代码块
else:
    # 条件为假时执行的代码块

多分支 if-elif-else

if 条件1:
    # 条件1为真时执行的代码块
elif 条件2:
    # 条件1为假且条件2为真时执行的代码块
else:
    # 所有条件都为假时执行的代码块

示例

x = 20
if x < 10:
    print("x is less than 10")
elif x < 20:
    print("x is less than 20 but not less than 10")
else:
    print("x is 20 or more")

在这个例子中，x 的值为 20，所以程序会检查每个条件，直到找到满足条件的分支。由于 x 不小于 10，第一个 if 分支被跳过。然后，由于 x 小于 20 的条件也不成立，程序执行 else 分支。

使用 in 和 not in

你还可以在 if 语句中使用 in 和 not in 来检查某个元素是否存在于序列中。

my_list = [1, 2, 3, 4]
if 2 in my_list:
    print("2 is in the list")
if "Kimi" not in my_list:
    print("Kimi is not in the list")

嵌套 if 语句

if 语句可以嵌套在其他 if 语句内部，这允许你创建复杂的逻辑。

x = 10
y = 5
if x > y:
    if x > 10:
        print("x is greater than 10")
    else:
        print("x is greater than y but less than or equal to 10")
else:
    print("x is not greater than y")

分支结构是控制流语言中的基础，它允许程序根据条件执行不同的代码路径。在Python中，分支结构通常用于决策制定，例如在函数中根据输入参数的不同执行不同的逻辑，或者在程序中根据用户的选择来执行不同的操作。

5.2循环结构

Python中的循环结构允许你重复执行一段代码，直到满足特定的条件。主要有两种类型的循环结构：for 循环和 while 循环。

for 循环

for 循环通常用于遍历序列（如列表、元组、字符串等）或其他可迭代对象。

基本语法：

for 变量 in 可迭代对象:
    # 循环体，对每个元素执行的操作

示例：

fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)

for 循环也可以使用 range() 函数生成一系列数字：

for i in range(5):
    print(i)  # 输出：0 1 2 3 4

while 循环

while 循环会一直执行，直到指定的条件不再为真。

基本语法：

while 条件:
    # 循环体，只要条件为真就执行

示例：

count = 0
while count < 5:
    print(count)
    count += 1  # 递增计数器

循环控制语句

在循环中，你可能需要提前退出循环或者跳过某些迭代。Python提供了两个这样的语句：break 和 continue。

  • break：立即终止循环。
  • continue：跳过当前迭代，继续执行下一次迭代。

示例使用 break：

for num in range(10):
    if num == 5:
        break
    print(num)
# 输出：0 1 2 3 4

示例使用 continue：

for num in range(10):
    if num % 2 == 0:
        continue
    print(num)
# 输出：1 3 5 7 9

else 子句与循环

Python的循环还支持 else 子句。如果循环正常结束（即不是因为 break 语句退出的），则执行 else 块。

示例：

for i in range(3):
    print(i)
else:
    print("循环结束")
# 输出：
# 0
# 1
# 2
# 循环结束

如果循环中包含 break 语句，且 break 被执行，则 else 块不会被执行。

for i in range(3):
    print(i)
    if i == 1:
        break
else:
    print("循环结束")
# 输出：
# 0
# 1
# 循环不会执行 "循环结束" 的输出

循环结构是编程中处理重复任务的基本工具，它们使得代码更加简洁，减少了重复代码的编写。在Python中，for 循环和 while 循环各有适用场景，可以根据需要选择使用。

6.函数

6.1python函数的定义

在Python中定义函数是一个将重复使用的代码块封装起来的过程，使其可以被多次调用。以下是定义函数的基本步骤：

  1. 使用 def 关键字开始定义函数。
  2. 指定函数的名称，这应该描述函数的功能。
  3. 在圆括号 () 内，可以定义零个或多个参数，这些参数是函数调用时接收的输入值。
  4. 函数的第一行代码之后是一个冒号 :。
  5. 缩进的代码块构成了函数体，即当函数被调用时将执行的代码。
  6. 函数可以通过 return 语句返回值。

下面是一个定义函数的示例：

def say_hello(name):
    ""“这是一个简单的函数，用于打印欢迎信息。”""
    print(f"Hello, {name}!")

在这个例子中，say_hello 是函数的名称，name 是函数的参数，花括号 {} 中的字符串是函数的文档字符串（docstring），它是一个字符串文字，用来描述函数的功能。文档字符串是可选的，但它是一个很好的编程习惯，因为它可以让阅读代码的人更容易理解函数的用途和行为。

函数定义后，可以通过提供必要的参数来调用它：

say_hello("Chengfu")  # 输出：Hello, Chengfu!

在定义函数时，还可以为参数设置默认值，使其成为可选参数：

def say_hello(name, message="Hello"):
    print(f"{message}, {name}!")

say_hello("Chengfu")          # 使用默认消息
say_hello("Chengfu", "Hi")   # 使用自定义消息

此外，Python允许使用可变数量的参数，这使得函数可以接收任意数量的参数：

def sum_numbers(*args):
    total = 0
    for num in args:
        total += num
    return total

# 可以传递任意数量的数值参数
print(sum_numbers(1, 2, 3, 4, 5))  # 输出：15

在定义函数时，你可以使用 * 来收集所有未命名的额外参数到一个元组中，使用 ** 来收集命名参数到一个字典中：

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Chengfu", country="Moonshot", job="AI Assistant")

这将输出：

name: Chengfu
country: Moonshot
job: AI Assistant

定义函数是Python编程的基础，它有助于代码的模块化和重用。通过定义函数，你可以创建更清晰、更易于维护的代码。

6.2形参与实参

我们来重新看一下形参（Parameter）和实参（Argument）的概念，。

形参（Parameter）

形参是在函数定义中声明的变量名，用于在函数调用时接收传递进来的值。这些变量在函数体内部被视为局部变量。

示例：

def introduce(title, name):
    print(f"{title}, {name}!")

在这个例子中，title 和 name 是形参。

实参（Argument）

实参是在调用函数时实际传递给函数的具体值。实参可以是字面量、变量、表达式或任何可产生值的实体。

示例：

introduce("Mr", "John")

在这里，"Mr" 和 "John" 是实参。

形参与实参的关系

函数调用时，实参会按照函数定义中形参的顺序传递给形参。如果函数定义中某个参数有默认值，那么在调用时可以省略该参数对应的实参，此时形参会被赋予默认值。

示例：

# 定义函数时，title 和 name 是形参
def introduce(title, name="Smith"):
    print(f"{title}, {name}!")

# 调用函数时，"Mr" 是实参，对应形参 title
# 由于没有传递 name 的实参，形参 name 使用默认值 "Smith"
introduce("Mr")

输出：

Mr, Smith!

如果调用函数时传递的实参数量多于形参，那么多余部分的实参将会被忽略，除非函数使用了 *args 或 **kwargs 来收集多余的参数。

示例：

def greet(name):
    print(f"Hello, {name}!")

# 调用函数时传递了两个实参，但函数定义中只有一个形参
greet("Alice", "Bob")  # "Bob" 会被忽略

输出：

Hello, Alice!

理解形参和实参的概念对于掌握函数的使用和调用至关重要。希望这些例子有助于你更好地理解这些概念。

6.3变量的作用域

在Python中，变量的作用域（Scope）决定了变量在程序中的可见性和生命周期。变量的作用域主要分为以下几种：

  1. 局部作用域（Local Scope）：

    • 局部变量是在函数内部定义的变量，它们只能在该函数内部被访问。
    • 例子：
      def my_function():
    x = 5  # x是局部变量
    print(x)

my_function()
# print(x)  # 这将引发错误，因为x不在局部作用域之外可见

  2. 全局作用域（Global Scope）：

    • 全局变量是在所有函数之外定义的变量，它们可以在整个程序中被访问。
    • 例子：
      y = 10  # y是全局变量

def my_function():
    print(y)

my_function()
print(y)

  3. 内置作用域（Built-in Scope）：

    • 内置变量是Python解释器内置的变量，它们属于Python的内置命名空间。
    • 例子：
      print(len("Hello World"))  # len是内置函数

  4. 封装作用域（Enclosing Scope）：

    • 如果一个函数嵌套在另一个函数内部，那么内部函数可以访问外部函数的局部变量。
    • 例子：
      def outer_function():
    z = 15
    def inner_function():
        print(z)  # z在外部函数的局部作用域中
    inner_function()

outer_function()

  5. 类作用域（Class Scope）：

    • 类变量是属于类的变量，它们在类的内部定义，可以被类的所有实例访问。
    • 例子：
      class MyClass:
    class_var = 20

print(MyClass.class_var)

  6. 命名空间（Namespace）：

    • Python使用命名空间来存储对象引用，每个变量名都与一个命名空间相关联。
    • 命名空间分为：__builtins__（内置命名空间）、__main__（全局命名空间）和模块命名空间。

理解变量的作用域对于编写清晰的程序非常重要。它决定了变量的生命周期，以及变量在程序中不同部分的可见性。正确地管理作用域可以避免命名冲突，并提高代码的模块化和可维护性。

6.4函数的类型

在Python中，函数本身也是一种对象，因此可以像任何其他对象一样被处理。函数对象可以被分配给变量，可以作为参数传递给其他函数，也可以作为函数的返回值。以下是一些与函数类型相关的要点：

  1. 普通函数：
    这是最常用的函数类型，使用 def 关键字定义。

    def my_function():
    pass

  2. 匿名函数（Lambda函数）：
    使用 lambda 关键字定义的匿名函数，常用于创建简单的、一次性使用的函数。

    square = lambda x: x * x
print(square(4))  # 输出：16

  3. 嵌套函数：
    在另一个函数内部定义的函数，可以访问外部函数的局部变量（除了参数）。

    def outer_function():
    def inner_function():
        print("Hello from inner function")
    return inner_function
my_function = outer_function()
my_function()  # 输出：Hello from inner function

  4. 递归函数：
    调用自身的函数称为递归函数，通常用于处理重复的任务。

    def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)
print(factorial(5))  # 输出：120

  5. 高阶函数：
    高阶函数是接受函数作为参数或返回函数作为结果的函数。

    def greet(name):
    def say_hello():
        print(f"Hello, {name}!")
    return say_hello
my_greet = greet("Alice")
my_greet()  # 输出：Hello, Alice!

  6. 生成器函数：
    使用 yield 关键字定义的函数，用于创建迭代器。

    def count_up_to(max):
    n = 1
    while n <= max:
        yield n
        n += 1
counter = count_up_to(5)
for number in counter:
    print(number)  # 输出：1 2 3 4 5

  7. 静态函数（在类定义中）：
    使用 @staticmethod 装饰器定义的函数，它不接收类或实例的引用。

    class MyClass:
    @staticmethod
    def my_static_function():
        print("This is a static method.")
MyClass.my_static_function()  # 输出：This is a static method.

  8. 类方法（在类定义中）：
    使用 @classmethod 装饰器定义的函数，它接收类作为第一个参数。

    class MyClass:
    @classmethod
    def my_class_method(cls):
        print(f"This is a class method of {cls}")
MyClass.my_class_method()  # 输出：This is a class method of <class '__main__.MyClass'>

  9. 实例方法（在类定义中）：
    在类中定义但不使用 @staticmethod 或 @classmethod 装饰器的函数，它们接收实例作为第一个参数。

    class MyClass:
    def my_instance_method(self):
        print("This is an instance method.")
instance = MyClass()
instance.my_instance_method()  # 输出：This is an instance method.

这些不同类型的函数提供了灵活性，允许你根据需要选择最合适的函数类型来实现特定的功能。

7.python的常用内置函数

7.1python主要的内置函数

函数名 描述 示例
abs() 返回数的绝对值 abs(-10) 返回 10
all() 所有元素为真时返回True all([True, True, False]) 返回 False
any() 任一元素为真时返回True any([False, False, True]) 返回 True
ascii() 返回对象的ASCII表达式 ascii(123) 返回 '123'
bin() 将整数转换为二进制字符串 bin(10) 返回 '0b1010'
bool() 将值转换为布尔类型 bool([]) 返回 False
bytearray() 创建一个可变的字节数组 bytearray([1, 2, 3])
bytes() 创建一个不可变的字节对象 bytes([72, 101, 108, 108, 111]) 返回 b'Hello'
chr() 将ASCII码转换为对应的字符 chr(65) 返回 'A'
complex() 创建一个复数 complex(1, 2) 返回 (1+2j)
dict() 创建一个字典 dict([['one', 1], ['two', 2]]) 返回 {'one': 1, 'two': 2}
divmod() 同时得到除法的商和余数 divmod(10, 3) 返回 (3, 1)
enumerate() 将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标 list(enumerate(['a', 'b', 'c'])) 返回 [(0, 'a'), (1, 'b'), (2, 'c')]
eval() 计算表达式的值，并返回结果 eval('1 + 2') 返回 3
exec() 执行动态Python代码 exec('print("Hello World")') 打印 Hello World
filter() 使用函数过滤序列，过滤掉不符合条件的元素，返回一个迭代器 list(filter(lambda x: x > 1, [1, 2, 3, 4])) 返回 [2, 3, 4]
float() 将值转换为浮点数 float('3.14') 返回 3.14
format() 格式化对象 format(12.34, '.2f') 返回 '12.34'
frozenset() 创建一个不可变集合 frozenset([1, 2, 3])
getattr() 获取对象属性 getattr(math, 'sin') 返回 <function sin>
globals() 返回当前全局符号表的字典 globals()
hasattr() 检查对象是否包含某个属性 hasattr(math, 'sin') 返回 True
hash() 返回对象的哈希值 hash((1, 2))
help() 获取对象的帮助信息 help(print)
hex() 将整数转换为十六进制字符串 hex(255) 返回 '0xff'
id() 返回对象的内存地址 id([1, 2, 3])
input() 获取用户输入的字符串 input("Enter something: ")
int() 将值转换为整数 int('123') 返回 123
isinstance() 检查实例是否是类或派生类的实例 isinstance(3, int) 返回 True
issubclass() 检查一个类是否是另一个类的子类 issubclass(int, float) 返回 False
iter() 返回对象的迭代器 iter([1, 2, 3])
len() 获取对象的长度 len([1, 2, 3]) 返回 3
list() 将对象转换为列表 list((1, 2, 3)) 返回 [1, 2, 3]
locals() 返回当前局部符号表的字典 locals()
map() 使用给定函数映射序列的每个元素 list(map(lambda x: x + 1, [1, 2, 3])) 返回 [2, 3, 4]
max() 获取可迭代对象中的最大值 max([1, 2, 3]) 返回 3
memoryview() 创建对象的内存视图 memoryview(b'Hello')
min() 获取可迭代对象中的最小值 min([1, 2, 3]) 返回 1
next() 返回迭代器的下一个项目 next(iter([1, 2, 3])) 返回 1
object() 创建一个新对象 object()
oct() 将整数转换为八进制字符串 oct(10) 返回 '0o12'
open() 打开一个文件，并返回文件对象 open('file.txt', 'r')
ord() 返回字符的ASCII码 ord('A') 返回 65
pow() 返回x的n次幂 pow(2, 3) 返回 8
print() 打印对象 print("Hello World")
property() 创建属性 property()
range() 创建一个整数序列 range(3) 返回 range(0, 3)
repr() 获取对象的官方字符串表示 repr(True) 返回 'True'
reversed() 反转序列 list(reversed([1, 2, 3])) 返回 [3, 2, 1]
round() 四舍五入 round(3.14) 返回 3
set() 创建一个可变集合 set([1, 2, 3])
setattr() 设置对象属性 setattr(math, 'sqrt', lambda x: x**0.5)
slice() 创建一个切片对象 slice(1, 3, 1)
sorted() 排序可迭代对象 sorted([3, 1, 2]) 返回 [1, 2, 3]
staticmethod() 创建静态方法 staticmethod()
str() 将对象转换为字符串 str(123) 返回 '123'
sum() 计算可迭代对象的总和 sum([1, 2, 3]) 返回 6
super() 返回对象的超级代理 super()
tuple() 将对象转换为元组 tuple([1, 2, 3]) 返回 (1, 2, 3)
type() 获取对象的类型 type(123) 返回 <class 'int'>
vars() 以字典的形式返回对象的属性 vars(123)
zip() 将多个迭代器的对应元素打包为元组 list(zip([1, 2], ['a', 'b'])) 返回 [(1, 'a'), (2, 'b')]

7.2eval函数

Python 中的 eval() 函数是一个内置函数，它用于计算字符串表达式的值。当传给 eval() 的字符串参数是一个有效的 Python 表达式时，eval() 会计算该表达式并返回结果。

基本用法

result = eval(expression)

这里的 expression 是一个字符串，它包含了一个有效的 Python 表达式。eval() 函数会计算这个表达式并返回结果。

示例

# 计算简单的算术表达式
print(eval('1 + 2'))  # 输出：3

# 计算更复杂的表达式
print(eval('10 * (2 + 3)'))  # 输出：50

# 使用变量名
x = 5
print(eval('x + 1'))  # 输出：6，因为 eval() 可以访问外部变量 x

# 调用函数
print(eval('len("Hello World")'))  # 输出：11

7.3filter函数

Python 中的 filter() 函数是一个内置函数，用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器。filter() 函数把一个函数和一个序列作为参数，返回一个迭代器，该迭代器包含所有使得函数返回值为True的元素。

基本语法

filter(function, iterable)
  • function：这是一个函数，它接收一个参数，返回一个布尔值（True或False）。
  • iterable：这是一个序列，它的每个元素都将传给function函数进行判断。

示例

# 定义一个简单的过滤函数
def is_even(num):
    return num % 2 == 0

# 使用 filter() 函数过滤列表
numbers = [1, 2, 3, 4, 5, 6]
even_numbers = filter(is_even, numbers)

# 将 filter() 对象转换为列表
print(list(even_numbers))  # 输出：[2, 4, 6]

你也可以使用 lambda 表达式来简化这个过程：

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

使用场景

filter() 函数常用于从序列中提取符合条件的元素。例如，从一个列表中提取所有偶数，或者从一个字符串列表中提取所有以特定字母开头的字符串。

注意事项

  • filter() 返回的是一个迭代器，如果你需要一个列表，可以使用 list() 函数进行转换。
  • filter() 函数不会修改原始序列，它返回一个新的迭代器。
  • 如果序列很大，使用 filter() 可以节省内存，因为它是惰性计算的，即它只有在需要的时候才会计算下一个元素。

与列表推导式比较

虽然 filter() 函数很有用，但在Python中，列表推导式通常更受欢迎，因为它们更简洁，更易于阅读：

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = [x for x in numbers if x % 2 == 0]
print(even_numbers)  # 输出：[2, 4, 6]

尽管如此，filter() 函数在某些情况下仍然很有用，特别是在你需要一个迭代器而不是列表时，或者当你需要将过滤逻辑与函数分离时。

7.4map函数

Python 中的 map() 函数是一个内置函数，它允许你将一个给定的函数应用于一个序列（或多个序列）的所有项目，并返回一个包含结果的迭代器。

基本语法

map(function, iterable, ...)
  • function：这是要应用于每个元素的函数。
  • iterable：这是一个或多个序列（如列表、元组、字符串等），函数将依次应用于这些序列的每个元素。

示例

# 定义一个简单的函数，用于加倍数值
def double_number(num):
    return num * 2

# 使用 map() 函数将 double_number 函数应用于数字列表
numbers = [1, 2, 3, 4]
doubled_numbers = map(double_number, numbers)

# 将 map 对象转换为列表
print(list(doubled_numbers))  # 输出：[2, 4, 6, 8]

如果你不想定义一个函数，你可以使用 lambda 表达式：

numbers = [1, 2, 3, 4]
doubled_numbers = map(lambda x: x * 2, numbers)
print(list(doubled_numbers))  # 输出：[2, 4, 6, 8]

多个序列

map() 也可以接受多个序列参数，但你必须提供对应的函数，该函数接受的参数数量应该与序列数量相同：

# 使用 map() 函数将两个列表的对应元素相加
list1 = [1, 2, 3]
list2 = [4, 5, 6]
added_pairs = map(lambda x, y: x + y, list1, list2)

print(list(added_pairs))  # 输出：[5, 7, 9]

使用场景

map() 函数通常用于对序列中的每个元素执行相同的操作。它特别适合于简单的、不需要额外状态的操作。

注意事项

  • map() 返回的是一个迭代器，如果你需要一个列表，可以使用 list() 函数进行转换。
  • map() 函数不会修改原始序列，它返回一个新的迭代器。
  • 如果序列很大，使用 map() 可以节省内存，因为它是惰性计算的，即它只有在需要的时候才会计算下一个元素。

与列表推导式比较

与 filter() 类似，列表推导式通常比 map() 更简洁，更易于阅读，并且在处理复杂的转换时更加灵活：

numbers = [1, 2, 3, 4]
doubled_numbers = [x * 2 for x in numbers]
print(doubled_numbers)  # 输出：[2, 4, 6, 8]

尽管如此，map() 在某些情况下仍然很有用，特别是在你需要一个迭代器而不是列表时，或者当你需要将操作逻辑与函数分离时。此外，map() 在函数应用于多个序列的元素时，可以非常清晰地表达意图。

7.5lamdba函数

Python 中的 lambda 关键字用于创建匿名函数，这些函数没有名称，定义后只能使用一次。lambda 函数通常用于编写简单的、临时的函数，它们在需要一个函数对象但不想费神命名并定义一个完整函数时非常有用。

基本语法

lambda arguments: expression
  • arguments：这是传递给 lambda 函数的参数，可以有一个或多个。
  • expression：这是 lambda 函数返回的表达式。

示例

# 创建一个 lambda 函数，计算两个数的和
add = lambda x, y: x + y

# 使用 lambda 函数
print(add(3, 4))  # 输出：7

lambda 函数可以包含任意复杂的表达式，但它们通常用于简单的操作：

# 创建一个 lambda 函数，返回数字的平方
square = lambda num: num ** 2

# 使用 lambda 函数
print(square(5))  # 输出：25

使用 lambda 与 map()、filter()、sorted() 等

lambda 函数经常与 map()、filter() 和 sorted() 等函数配合使用，为这些函数提供所需的函数逻辑。

# 使用 lambda 函数和 map() 来将列表中的每个元素乘以 2
numbers = [1, 2, 3, 4]
doubled = list(map(lambda x: x * 2, numbers))
print(doubled)  # 输出：[2, 4, 6, 8]

# 使用 lambda 函数和 filter() 来过滤出列表中的偶数
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 输出：[2, 4]

# 使用 lambda 函数和 sorted() 来根据元素的第二个项对元组列表进行排序
tuples_list = [(1, 'one'), (3, 'three'), (2, 'two')]
sorted_list = sorted(tuples_list, key=lambda item: item[1])
print(sorted_list)  # 输出：[(1, 'one'), (2, 'two'), (3, 'three')]

注意事项

  • lambda 函数只能包含单个表达式，因此它们不能包含多个语句或复杂的逻辑。
  • lambda 函数没有自己的局部作用域，它们只能访问外部作用域中的变量。
  • lambda 函数通常用于简短的、一次性的函数定义，对于更复杂的函数，最好使用 def 关键字定义一个完整的函数。

尽管 lambda 函数在某些情况下非常有用，但过度使用会使代码难以阅读和维护。因此，应当在适当的时候选择使用 lambda 函数。

7.6sorted函数

Python 中的 sorted() 函数是一个内置函数，用于对可迭代对象的元素进行排序，并返回一个新的排好序的列表。原始的可迭代对象不会被 sorted() 改变。

基本语法

sorted(iterable, key=None, reverse=False)
  • iterable：要排序的可迭代对象，例如列表、元组或字符串。
  • key：一个函数，它会被用来在进行比较之前从每个列表元素中提取一个比较键（比如通过一个函数指定排序的依据）。
  • reverse：一个布尔值。如果设置为 True，则列表元素将被逆序排列，默认为 False。

示例

默认排序

numbers = [3, 1, 4, 1, 5, 9, 2]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出：[1, 1, 2, 3, 4, 5, 9]

字符串排序

words = ['banana', 'apple', 'cherry']
sorted_words = sorted(words)
print(sorted_words)  # 输出：['apple', 'banana', 'cherry']

逆序排序

sorted_numbers_desc = sorted(numbers, reverse=True)
print(sorted_numbers_desc)  # 输出：[9, 5, 4, 3, 2, 1, 1]

使用 key 参数

# 根据字符串的长度进行排序
sorted_words_by_length = sorted(words, key=len)
print(sorted_words_by_length)  # 输出：['apple', 'banana', 'cherry']

# 使用 lambda 表达式作为 key 函数
sorted_words_custom = sorted(words, key=lambda x: (len(x), x))
print(sorted_words_custom)  # 输出：['apple', 'cherry', 'banana']

对象列表排序

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"Person({self.name}, {self.age})"

people = [Person("John", 45), Person("Diana", 32), Person("Tom", 42)]
# 根据年龄排序
sorted_people = sorted(people, key=lambda person: person.age)
print(sorted_people)  # 输出：[Person(Diana, 32), Person(Tom, 42), Person(John, 45)]

注意事项

  • sorted() 总是返回一个新的列表，它不会修改原始的可迭代对象。
  • 如果要对原始列表进行排序，可以使用列表的 list.sort() 方法，这将对列表进行就地排序。
  • key 参数接受的函数可以是内置函数或者自定义函数，它定义了排序的具体行为。

sorted() 函数是一个非常强大的工具，它提供了灵活的排序功能，可以用于各种数据类型的排序，并且可以通过 key 参数定制排序逻辑。

8.字符串

8.1字符串的格式化

在Python中，字符串格式化是一种将数据嵌入到字符串中的方法。Python提供了多种字符串格式化的方式，包括传统的 % 格式化、str.format() 方法，以及Python 3.6+中引入的 f-string（格式化字符串字面量）。

  1. % 格式化

这是较早的字符串格式化方法，通过在字符串中使用 % 操作符来嵌入变量。

name = "Alice"
age = 30
sentence = "Hello, %s. You are %d years old." % (name, age)
print(sentence)  # 输出：Hello, Alice. You are 30 years old.

你还可以使用字典来解构键值对：

data = {'name': 'Alice', 'age': 30}
sentence = "Hello, %(name)s. You are %(age)d years old." % data
print(sentence)  # 输出：Hello, Alice. You are 30 years old.
  1. str.format() 方法

str.format() 方法提供了一个新的字符串格式化方法，它允许你使用花括号 {} 作为占位符。

name = "Alice"
age = 30
sentence = "Hello, {}. You are {} years old.".format(name, age)
print(sentence)  # 输出：Hello, Alice. You are 30 years old.

你同样可以使用索引和关键字来引用传递给 format() 的参数：

sentence = "Hello, {0[name]}. You are {0[age]} years old.".format(data)
print(sentence)  # 输出：Hello, Alice. You are 30 years old.
  1. f-string（格式化字符串字面量）

从Python 3.6开始，引入了f-string，它提供了一种更简洁和直观的方式来格式化字符串。

name = "Alice"
age = 30
sentence = f"Hello, {name}. You are {age} years old."
print(sentence)  # 输出：Hello, Alice. You are 30 years old.

f-string还支持表达式内的计算和更复杂的表达式：

sentence = f"Hello, {name}. You are {age + 10} years old in 10 years."
print(sentence)  # 输出：Hello, Alice. You are 40 years old in 10 years.

注意事项

  • f-string 是最快的字符串格式化方法，推荐在性能要求较高的场景下使用。
  • % 格式化和 str.format() 方法在多种情况下都很有用，尤其是在需要与旧代码兼容时。
  • 使用 str.format() 或 f-string 时，如果参数数量多于占位符，Python会抛出 IndexError 或 ValueError。如果参数数量少于占位符，剩余的占位符将被替换为 None。

字符串格式化是Python编程中的一个基本技能，它使得数据的展示更加灵活和动态。f-string因其简洁和性能优势而成为现代Python代码的首选格式化方法。

8.2字符串的常用方法

在Python中，字符串提供了多种方法来查找子字符串或字符，以下是 find(), rfind(), index(), rindex(), count()、‘ spilt’、rspilt、partation、rpartation join、replace这些方法的详细说明和示例：

以下是字符串查找和操作相关函数的详细说明和示例：

查找函数
find()
返回子字符串首次出现的最低索引，如果找不到子字符串则返回 -1。

s = "hello world"
print(s.find("world"))  # 输出：6
print(s.find("Python"))  # 输出：-1

rfind()
返回子字符串最后一次出现的最低索引，如果找不到子字符串则返回 -1。

s = "hello world world"
print(s.rfind("world"))  # 输出：12
print(s.rfind("Python"))  # 输出：-1

index()
返回子字符串首次出现的最低索引，如果找不到子字符串则抛出 ValueError。

s = "hello world"
print(s.index("world"))  # 输出：6
# print(s.index("Python"))  # 将抛出 ValueError

rindex()
返回子字符串最后一次出现的最低索引，如果找不到子字符串则抛出 ValueError。

s = "hello world world"
print(s.rindex("world"))  # 输出：12
# print(s.rindex("Python"))  # 将抛出 ValueError

count()
返回子字符串在字符串中出现的次数。

s = "hello world world"
print(s.count("world"))  # 输出：2
print(s.count("Python"))  # 输出：0

分割函数

split()
按照指定的分隔符（默认为空格）分割字符串，返回一个包含所有分割结果的列表。

s = "hello world"
print(s.split())  # 输出：['hello', 'world']

rsplit()
与 split() 类似，但是从字符串的末尾开始分割。

s = "hello world world"
print(s.rsplit())  # 输出：['hello', 'world', 'world']

partition()
将字符串按照第一个出现的分隔符进行分割，并返回一个包含分割结果的元组（分割符前的部分，分隔符本身，分隔符后的部分）。

s = "hello-world"
print(s.partition("-"))  # 输出：('hello', '-', 'world')

rpartition()
与 partition() 类似，但是从字符串的末尾开始分割。

s = "hello-world-again"
print(s.rpartition("-"))  # 输出：('hello-world', '-', 'again')

连接和替换函数

join()
将序列中的元素连接成一个字符串，元素之间用指定的分隔符连接。

words = ["hello", "world"]
print(" ".join(words))  # 输出：hello world

replace()
将字符串中的部分内容替换为另一个字符串，返回新的字符串。

s = "hello world"
print(s.replace("world", "Python"))  # 输出：hello Python

这些函数在处理字符串时非常有用，可以帮助你完成各种字符串的查找、分割、连接和替换操作。

9.面向对象编程

面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它使用对象和类来模拟现实世界中的实体和它们之间的关系。

9.1面向对象的概念

面向对象编程的核心思想是将数据和处理数据的方法封装在对象中。对象是具有状态和行为的实体，状态由对象的属性（数据）表示，行为由对象的方法（函数）表示。

9.2类的定义与实例化

类是对象的蓝图或模板，定义了对象的属性和方法。实例化是创建类的一个具体对象的过程。

class Dog:
    def __init__(self, name, age):  # 初始化方法
        self.name = name  # 实例变量
        self.age = age

    def bark(self):  # 实例方法
        print("Woof!")

# 实例化
my_dog = Dog("Buddy", 3)
my_dog.bark()

9.3类的成员

类的成员包括属性（变量）和方法（函数）。属性定义了对象的状态，方法定义了对象的行为。

class Car:
    def __init__(self, make, model):
        self.make = make
        self.model = model

    def start_engine(self):
        print("Engine started.")

# 属性访问
my_car = Car("Toyota", "Corolla")
print(my_car.make)  # 输出: Toyota

# 方法调用
my_car.start_engine()

9.4封装

封装是将对象的状态（属性）和行为（方法）结合在一起，并隐藏内部实现细节的过程。在Python中，可以通过使用私有变量（以双下划线开头）来实现封装。

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.__balance = balance  # 私有变量

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            print("Deposit successful.")

    def get_balance(self):
        return self.__balance

# 私有变量不能直接访问
# my_account.__balance  # 这将引发错误
print(my_account.get_balance())  # 正确方式

9.5继承

继承允许一个类（子类）继承另一个类（父类）的属性和方法。这有助于代码重用和建立类之间的层次结构。

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        raise NotImplementedError("Subclasses must implement this method")

class Dog(Animal):  # Dog继承自Animal
    def speak(self):
        print("Woof!")

my_dog = Dog("Buddy")
my_dog.speak()  # 输出: Woof!

9.6多态

多态是指不同类的对象对同一消息做出响应的能力，即同一个接口可以被不同的实例以不同的方式实现。在Python中，多态通常是通过方法重写实现的。

class Animal:
    def speak(self):
        raise NotImplementedError("Subclasses must implement this method")

class Dog(Animal):
    def speak(self):
        print("Woof!")

class Cat(Animal):
    def speak(self):
        print("Meow!")

def animal_sound(animal):
    animal.speak()

my_dog = Dog("Buddy")
my_cat = Cat("Whiskers")

animal_sound(my_dog)  # 输出: Woof!
animal_sound(my_cat)  # 输出: Meow!

在上述代码中，animal_sound 函数可以接收任何Animal类型的对象，调用它们的speak方法，这就是多态的体现。

10 python文件操作

在Python中，文件操作是常见的任务，涉及到打开、读取、写入和关闭文件。以下是如何使用Python进行文件操作的一些基本方法：

10.1 打开文件

在Python中，可以使用内置的open()函数来打开文件。这个函数返回一个文件对象，你可以用它来读取或写入文件。

# 打开文件用于读取
with open('example.txt', 'r') as file:
    content = file.read()
    print(content)

# 打开文件用于写入
with open('example.txt', 'w') as file:
    file.write('Hello, World!')

10.2 关闭文件

在Python中，通常不需要显式关闭文件，因为open()函数返回的文件对象会在离开with块时自动关闭。如果文件是在with块外部打开的，则需要调用文件对象的close()方法来关闭文件。

file = open('example.txt', 'r')
content = file.read()
file.close()  # 显式关闭文件

10.3 使用with as进行文件续写

with语句提供了一种方便的方式来管理文件的打开和关闭，即使在发生异常时也能确保文件被正确关闭。使用with语句时，文件默认以独占模式打开，如果要进行文件续写，需要使用'a'（追加）模式。

# 使用with语句和'a'模式进行文件续写
with open('example.txt', 'a') as file:
    file.write('\nThis is another line.')

10.4 文件续写的其他方法

如果不使用with语句，也可以手动打开文件，写入内容，然后关闭文件。在使用这种方法时，需要确保在完成文件操作后调用close()方法。

# 手动打开文件，进行续写，然后关闭文件
file = open('example.txt', 'a')  # 'a'模式用于追加内容
file.write('\nThis is yet another line.')
file.close()

在Python中，推荐使用with语句来处理文件操作，因为它可以自动管理文件的打开和关闭，即使在发生异常时也能确保文件资源被正确释放。此外，with语句的代码更加简洁，可读性更好。

以上是python的基础内容，还请继续深入学习。

posted @ 2024-10-25 21:34  写代码的大学生  阅读(408)  评论(1)  编辑  收藏  举报