Python 快速入门

大邳草民2024-06-09 17:52

1. 语言基础

1.1 数据类型与变量

Python 是一门动态类型语言，这意味着你不需要显式声明变量的类型。Python 解释器会根据你赋予变量的值自动推断其类型。这使得 Python 代码简洁易懂，但同时也需要注意一些潜在的问题。

1.1.1 Python 数据类型概述

Python 提供了多种内置数据类型，以下是一些常见的类型：

  • 数值类型 ：
    • 整型 (int)：用于表示整数，例如 10, -5, 0
    • 浮点型 (float)：用于表示小数，例如 3.14, -2.5, 0.0
    • 复数类型 (complex)：用于表示复数，例如 2+3j
  • 字符串类型 (str)：用于表示文本，例如 "Hello world!", "Python"
  • 布尔类型 (bool) ：用于表示真假，只有 True 和 False 两种值
  • 列表类型 (list) ：有序可变序列，用方括号 [] 包裹，元素之间用逗号 , 分隔
  • 元组类型 (tuple) ：有序不可变序列，用圆括号 () 包裹，元素之间用逗号 , 分隔
  • 字典类型 (dict) ：无序可变键值对集合，用花括号 {} 包裹，键值对之间用冒号 : 分隔

1.1.2 变量声明与赋值

在 Python 中，使用 = 符号来给变量赋值。

python 复制代码 
name = "Alice" 
age = 25 
is_student = True

需要注意的是，变量名必须以字母或下划线开头，后面可以跟字母、数字或下划线。同时，Python 变量名区分大小写。

1.1.3 类型转换

有时我们需要将不同数据类型之间进行转换，Python 提供了一些内置函数来实现类型转换：

  • int()：将其他数据类型转换为整型
  • float()：将其他数据类型转换为浮点型
  • str()：将其他数据类型转换为字符串类型
  • bool()：将其他数据类型转换为布尔类型

例如：

python 复制代码 
number = "10" 
int_number = int(number)  # 将字符串转换为整型

1.2 运算符与表达式

运算符是用来对操作数执行特定操作的符号，表达式则是由操作数和运算符组合而成的计算公式。

1.2.1 算术运算符

算术运算符用于进行数值计算，包括：

运算符 描述 示例 结果
+ 加法 10 + 5 15
- 减法 10 - 5 5
* 乘法 10 * 5 50
/ 除法 10 / 5 2.0
// 整数除法 10 // 5 2
% 取余 10 % 5 0
** 幂运算 10 ** 2 100

1.2.2 比较运算符

比较运算符用于比较两个操作数的大小或是否相等，结果为布尔值（True 或 False）。

运算符 描述 示例 结果
== 等于 10 == 5 False
!= 不等于 10 != 5 True
> 大于 10 > 5 True
< 小于 10 < 5 False
>= 大于等于 10 >= 5 True
<= 小于等于 10 <= 5 False

1.2.3 逻辑运算符

逻辑运算符用于对布尔值进行操作，包括：

运算符 描述 示例 结果
and 逻辑与 True and True True
or 逻辑或 True or False True
not 逻辑非 not True False

1.2.4 位运算符

位运算符用于对操作数的二进制位进行操作，包括：

运算符 描述 示例 结果
& 按位与 10 & 5 0
| 按位或 10 | 5 15
^ 按位异或 10 ^ 5 15
~ 按位取反 ~10 -11
<< 左移 10 << 2 40
>> 右移 10 >> 2 2

1.2.5 赋值运算符

赋值运算符用于将值赋给变量，包括：

运算符 描述 示例 等价于
= 赋值 x = 10 x = 10
+= 加法赋值 x += 5 x = x + 5
-= 减法赋值 x -= 5 x = x - 5
*= 乘法赋值 x *= 5 x = x * 5
/= 除法赋值 x /= 5 x = x / 5
//= 整数除法赋值 x //= 5 x = x // 5
%= 取余赋值 x %= 5 x = x % 5
**= 幂运算赋值 x **= 5 x = x ** 5
&= 按位与赋值 x &= 5 x = x & 5
|= 按位或赋值 x |= 5 x = x | 5
^= 按位异或赋值 x ^= 5 x = x ^ 5
<<= 左移赋值 x <<= 5 x = x << 5
>>= 右移赋值 x >>= 5 x = x >> 5

1.2.6 运算符优先级

在表达式中，不同的运算符具有不同的优先级。优先级高的运算符先执行，优先级低的运算符后执行。可以使用括号 () 来改变运算顺序，括号内的表达式优先执行。

以下列出了一些常用运算符的优先级，从高到低排序：

  1. 幂运算 **
  2. 按位取反 ~
  3. 乘法、除法、整数除法、取余 *, /, //, %
  4. 加法、减法 +, -
  5. 位运算 <<, >>, &, ^, |
  6. 比较运算符 ==, !=, >, <, >=, <=
  7. 逻辑运算符 not, and, or
  8. 赋值运算符 =, +=, -=, *=, /=, //= 等等

1.2.7 表达式

表达式是由操作数和运算符组合而成的计算公式， Python 解释器会根据运算符的优先级和结合性来计算表达式的值。

例如：

  • 10 + 5 * 2：由于乘法运算符优先级高于加法运算符，所以先执行 5 * 2，得到结果 10，然后再执行 10 + 10，最终结果为 20。
  • (10 + 5) * 2：由于括号内的表达式优先执行，所以先执行 10 + 5，得到结果 15，然后再执行 15 * 2，最终结果为 30。

1.3 控制流语句

控制流语句允许我们控制程序执行的流程，改变程序的执行顺序。它们使程序能够根据条件做出决策，重复执行代码块，以及在需要时跳出循环。

1.3.1 条件语句 (if-elif-else)

条件语句根据条件判断，选择执行不同的代码块。

语法:

python 复制代码 
if 条件1:
    代码块1
elif 条件2:
    代码块2
else:
    代码块3
  • if: 如果条件1为真，则执行代码块1。
  • elif: 如果条件1为假，则判断条件2，如果条件2为真，则执行代码块2。可以有多个 elif 语句。
  • else: 如果所有条件都为假，则执行代码块3。else 语句是可选的。

示例:

python 复制代码 
score = int(input("请输入分数："))

if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 70:
    print("中等")
else:
    print("不及格")

1.3.2 循环语句 (for, while)

循环语句用于重复执行一段代码，直到满足特定条件为止。

for 循环

for 循环用于遍历序列 (例如列表、元组、字符串) 中的每个元素。

语法:

python 复制代码 
for 变量 in 序列:
    代码块
  • 变量: 用于保存当前迭代的元素值。
  • 序列: 需要遍历的序列。

示例:

python 复制代码 
names = ["Alice", "Bob", "Charlie"]

for name in names:
    print("Hello, " + name)

while 循环

while 循环会一直执行代码块，直到条件变为假。

语法:

python 复制代码 
while 条件:
    代码块
  • 条件: 循环的判断条件。

示例:

python 复制代码 
count = 0

while count < 5:
    print(count)
    count += 1

1.3.3 循环控制语句 (break, continue)

循环控制语句用于在循环中改变执行流程。

break 语句

break 语句用于立即退出循环。

示例:

python 复制代码 
for i in range(10):
    if i == 5:
        break
    print(i)

continue 语句

continue 语句用于跳过当前迭代，继续执行下一轮循环。

示例:

python 复制代码 
for i in range(10):
    if i % 2 == 0:
        continue
    print(i)

1.4 函数

函数是 Python 代码的模块化单元，它可以接受输入参数，执行一系列操作，并返回结果。函数可以提高代码的可重用性和可读性，使程序更加模块化和易于维护。

1.4.1 函数定义与调用

函数定义:

python 复制代码 
def 函数名(参数列表):
    """函数文档字符串"""
    代码块
    return 返回值
  • def: 定义函数的关键字。
  • 函数名: 函数的名称，必须以字母或下划线开头，可以包含字母、数字和下划线。
  • 参数列表: 函数接受的参数列表，多个参数用逗号隔开。
  • 函数文档字符串: 描述函数功能的字符串，可以使用三引号包裹。
  • 代码块: 函数体，包含要执行的代码。
  • return: 返回函数的结果，可以省略，此时函数返回 None。

函数调用:

python 复制代码 
函数名(参数列表)
  • 函数名: 要调用的函数名称。
  • 参数列表: 传递给函数的参数，顺序和类型要与函数定义中的参数列表一致。

示例:

python 复制代码 
def greet(name):
    """向用户问好"""
    print("Hello, " + name + "!")

greet("Alice") # 调用 greet 函数，传递参数 "Alice"

1.4.2 函数参数与返回值

参数:

  • 位置参数: 按顺序传递的参数，调用函数时参数的顺序要与函数定义中的参数顺序一致。
  • 关键字参数: 使用参数名和参数值对的形式传递参数，可以改变参数的顺序。
  • 默认参数: 函数定义中为参数指定默认值，如果调用函数时未提供该参数，则使用默认值。
  • 可变参数: 使用 *args 来接收任意数量的位置参数，这些参数会被打包成一个元组。
  • 关键字可变参数: 使用 **kwargs 来接收任意数量的关键字参数，这些参数会被打包成一个字典。

返回值:

  • 函数可以使用 return 语句返回值，返回值可以是任何类型的值，包括数字、字符串、列表、字典等。
  • 如果函数没有 return 语句，则默认返回 None。

示例:

python 复制代码 
def calculate_sum(a, b=10): # b 为默认参数，默认值为 10
    """计算两个数的和"""
    return a + b

result = calculate_sum(5) # 调用函数，传递一个参数，使用 b 的默认值
print(result) # 输出 15

result = calculate_sum(5, 20) # 调用函数，传递两个参数，覆盖 b 的默认值
print(result) # 输出 25

def sum_all(*args): # 使用 *args 接收任意数量的位置参数
    """计算所有参数的和"""
    total = 0
    for arg in args:
        total += arg
    return total

result = sum_all(1, 2, 3, 4, 5) # 传递多个参数
print(result) # 输出 15

1.4.3 递归函数

递归函数是指在函数内部调用自身的函数。

示例:

python 复制代码 
def factorial(n):
    """计算 n 的阶乘"""
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

result = factorial(5)
print(result) # 输出 120

注意: 递归函数必须有一个终止条件，否则会无限递归下去导致程序崩溃。

1.4.4 匿名函数 (lambda)

匿名函数是指没有名称的函数，使用 lambda 关键字定义。

语法:

python 复制代码 
lambda 参数列表: 表达式
  • lambda: 定义匿名函数的关键字。
  • 参数列表: 函数的参数列表。
  • 表达式: 函数体，只能包含一个表达式，返回值为该表达式的结果。

示例:

python 复制代码 
square = lambda x: x * x
print(square(5)) # 输出 25

add = lambda x, y: x + y
print(add(10, 20)) # 输出 30

注意: 匿名函数通常用于简化代码，尤其是在需要使用函数作为参数或返回值的情况下。

2. 数据结构

数据结构是组织和存储数据的特定方式，在编程中扮演着至关重要的角色。Python 提供了多种内置数据结构，让我们可以方便地管理数据。

2.1 列表 (List)

列表是一种有序的可变数据结构，可以存储不同类型的元素。

2.1.1 列表创建与访问

  • 创建列表: 使用方括号 [] 包含元素，元素之间用逗号 , 分隔。

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

  • 访问元素: 使用索引访问列表中的元素，索引从 0 开始。

    python 复制代码 
    print(my_list[0])  # 输出: 1
print(my_list[3])  # 输出: hello

  • 负索引: 负索引从列表末尾开始计数，-1 代表最后一个元素，-2 代表倒数第二个元素，以此类推。

    python 复制代码 
    print(my_list[-1]) # 输出: True
print(my_list[-3]) # 输出: 3

2.1.2 列表操作 (添加、删除、修改)

  • 添加元素:

    • append(x): 在列表末尾添加元素。
    • insert(i, x): 在指定索引 i 处插入元素 x。
    • extend(iterable): 将可迭代对象的所有元素添加到列表末尾。
    python 复制代码 
    my_list.append(4)
my_list.insert(1, "world")
my_list.extend([5, 6])
print(my_list) # 输出: [1, 'world', 2, 3, 'hello', True, 4, 5, 6]

  • 删除元素:

    • remove(x): 删除第一个值为 x 的元素。
    • pop(i): 删除指定索引 i 处的元素，并返回该元素的值。
    • del list[i] 或 del list[i:j] : 删除指定索引或切片范围内的元素。
    python 复制代码 
    my_list.remove("hello")
removed_item = my_list.pop(2)
del my_list[0:2]
print(my_list) # 输出: [3, True, 4, 5, 6]

  • 修改元素: 使用索引直接修改元素的值。

    python 复制代码 
    my_list[0] = "new_value"
print(my_list) # 输出: ['new_value', True, 4, 5, 6]

2.1.3 列表遍历

  • 使用 for 循环遍历:

    python 复制代码 
    for item in my_list:
    print(item)

  • 使用索引遍历:

    python 复制代码 
    for i in range(len(my_list)):
    print(my_list[i])

2.2 元组 (Tuple)

元组是一种有序的不可变数据结构，使用圆括号 () 包含元素。

2.2.1 元组创建与访问

  • 创建元组: 使用圆括号 () 包含元素，元素之间用逗号 , 分隔。

    python 复制代码 
    my_tuple = (1, 2, "hello", True)

  • 访问元素: 使用索引访问元组中的元素，索引从 0 开始。

    python 复制代码 
    print(my_tuple[0])  # 输出: 1
print(my_tuple[2])  # 输出: hello

  • 负索引: 负索引从元组末尾开始计数，-1 代表最后一个元素，-2 代表倒数第二个元素，以此类推。

    python 复制代码 
    print(my_tuple[-1]) # 输出: True
print(my_tuple[-3]) # 输出: 2

2.2.2 元组不可变性

元组是不可变的，这意味着一旦创建，就不能修改其元素。

python 复制代码 
my_tuple[0] = "new_value" # 会导致错误

2.2.3 元组与列表的区别

特性 列表 元组
可变性 可变 不可变
括号 [] ()
使用场景 存储需要修改的数据 存储不需要修改的数据
  • 列表适合存储需要频繁添加、删除、修改元素的数据。
  • 元组适合存储不需要修改的数据，例如存储常量、坐标等。

2.3 字典 (Dictionary)

字典是一种无序的键值对集合，使用花括号 {} 包含键值对，键和值之间用冒号 : 分隔，键值对之间用逗号 , 分隔。

2.3.1 字典创建与访问

  • 创建字典: 使用花括号 {} 包含键值对。

    python 复制代码 
    my_dict = {"name": "John", "age": 30, "city": "New York"}

  • 访问元素: 使用键访问字典中的值。

    python 复制代码 
    print(my_dict["name"])  # 输出: John
print(my_dict["age"])  # 输出: 30

  • 不存在的键: 访问不存在的键会导致 KeyError 错误。

    python 复制代码 
    print(my_dict["hobby"])  # 抛出 KeyError

  • 使用 get() 方法访问: get() 方法可以安全地访问键，如果键不存在，则返回 None 或指定的值。

    python 复制代码 
    print(my_dict.get("hobby"))  # 输出: None
print(my_dict.get("hobby", "unknown"))  # 输出: unknown

2.3.2 字典操作 (添加、删除、修改)

  • 添加元素: 使用新的键和值直接赋值。

    python 复制代码 
    my_dict["hobby"] = "reading"
print(my_dict)  # 输出: {'name': 'John', 'age': 30, 'city': 'New York', 'hobby': 'reading'}

  • 删除元素:

    • del dict[key] : 删除指定键的键值对。
    • pop(key) : 删除指定键的键值对，并返回该键对应的值。
    python 复制代码 
    del my_dict["city"]
print(my_dict)  # 输出: {'name': 'John', 'age': 30, 'hobby': 'reading'}

city = my_dict.pop("hobby")
print(my_dict)  # 输出: {'name': 'John', 'age': 30}
print(city)  # 输出: reading

  • 修改元素: 使用键直接修改值。

    python 复制代码 
    my_dict["age"] = 31
print(my_dict)  # 输出: {'name': 'John', 'age': 31, 'hobby': 'reading'}

2.3.3 字典遍历

  • 遍历键: 使用 for key in dict.keys() 遍历字典的所有键。

    python 复制代码 
    for key in my_dict.keys():
    print(key)  # 输出: name, age, hobby

  • 遍历值: 使用 for value in dict.values() 遍历字典的所有值。

    python 复制代码 
    for value in my_dict.values():
    print(value)  # 输出: John, 31, reading

  • 遍历键值对: 使用 for key, value in dict.items() 遍历字典的所有键值对。

    python 复制代码 
    for key, value in my_dict.items():
    print(f"{key}: {value}")  # 输出: name: John, age: 31, hobby: reading

2.4 集合 (Set)

集合是一种无序的、不可重复的元素集合，使用花括号 {} 包含元素，元素之间用逗号 , 分隔。

2.4.1 集合创建与访问

  • 创建集合: 使用花括号 {} 包含元素。

    注意：空集合必须使用 set() 函数创建。

    python 复制代码 
    my_set = {1, 2, 3, 4}
empty_set = set()

  • 访问元素: 集合是无序的，无法通过索引访问元素。可以判断元素是否存在于集合中：

    python 复制代码 
    print(1 in my_set)  # 输出: True
print(5 in my_set)  # 输出: False

2.4.2 集合操作 (交集、并集、差集)

  • 交集: 使用 & 或 intersection() 方法求两个集合的交集。

    python 复制代码 
    set1 = {1, 2, 3}
set2 = {2, 3, 4}
intersection_set = set1 & set2
print(intersection_set)  # 输出: {2, 3}

  • 并集: 使用 | 或 union() 方法求两个集合的并集。

    python 复制代码 
    union_set = set1 | set2
print(union_set)  # 输出: {1, 2, 3, 4}

  • 差集: 使用 - 或 difference() 方法求两个集合的差集。

    python 复制代码 
    difference_set = set1 - set2
print(difference_set)  # 输出: {1}

2.4.3 集合的不可重复性

集合中的元素是唯一的，不允许重复。

python 复制代码 
my_set = {1, 2, 2, 3}
print(my_set)  # 输出: {1, 2, 3}

3. 面向对象编程

面向对象编程 (OOP) 是一种编程范式，它将程序视为一组相互作用的对象，每个对象都包含数据和操作这些数据的函数。OOP 帮助组织和管理大型程序，使其更容易维护和扩展。

3.1 类与对象

3.1.1 类定义

  • 类 是对象的蓝图，它定义了对象的属性和方法。

  • 在 Python 中，使用 class 关键字定义类，后面跟着类名和冒号：

    python 复制代码 
    class Dog:
  # 类体

  • 类体包含了类的属性和方法的定义。

3.1.2 对象创建

  • 对象 是类的实例，它拥有类定义的属性和方法。

  • 在 Python 中，使用类名和括号创建对象：

    python 复制代码 
    my_dog = Dog()

  • 这行代码创建了一个名为 my_dog 的 Dog 类对象。

3.1.3 属性与方法

  • 属性 是对象的特征，通常用变量表示。

  • 方法 是对象的行为，通常用函数表示。

    python 复制代码 
    class Dog:
  def __init__(self, name, breed):
    self.name = name
    self.breed = breed

  def bark(self):
    print(f"{self.name} barks!")

  • __init__ 方法是构造函数，用于初始化对象属性。

  • self 参数表示当前对象，用于访问对象的属性和方法。

  • bark 方法定义了狗叫的行为。

3.1.3 实例化和调用类的方法

python 复制代码 
class Dog:
  def __init__(self, name, breed):
    self.name = name
    self.breed = breed

  def bark(self):
    print(f"{self.name} barks!")

my_dog = Dog("Buddy", "Golden Retriever")
print(f"My dog's name is {my_dog.name} and it's a {my_dog.breed}.")
my_dog.bark()

3.2 封装

封装是面向对象编程中的一个重要概念，它将数据和操作数据的方法捆绑在一起，形成一个独立的、自包含的单元，即对象。封装的目标是隐藏对象的内部实现细节，只对外暴露必要的接口，以控制对对象的访问。

3.2.1 类

类是封装的核心概念，它定义了对象的属性和方法。属性表示对象的特征，方法表示对象的行为。

python 复制代码 
class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def bark(self):
        print("Woof!")

my_dog = Dog("Buddy", "Golden Retriever")
print(my_dog.name)  # 输出：Buddy
my_dog.bark()      # 输出：Woof!

3.2.2 私有属性和方法

  • 使用双下划线 __ 开头的属性和方法被认为是私有的，只能在类内部访问。
  • 私有属性和方法有助于隐藏实现细节，防止外部代码误操作。
python 复制代码 
class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.__breed = breed  # 私有属性

    def bark(self):
        print("Woof!")

    def __private_method(self):  # 私有方法
        print("This is a private method.")

my_dog = Dog("Buddy", "Golden Retriever")
print(my_dog.name)  # 可以访问公有属性
# print(my_dog.__breed)  # AttributeError: private access
my_dog.bark()  # 可以调用公有方法
# my_dog.__private_method()  # AttributeError: private access

注意： 虽然 Python 的私有机制是通过名称改写来实现的，仍然可以通过一些技巧来访问私有属性和方法。例如，使用 _ClassName__attribute_name 或者 _ClassName__method_name 可以访问私有属性和方法。

python 复制代码 
# 通过名称改写访问私有属性
print(my_dog._Dog__breed)  # 输出：Golden Retriever

# 通过名称改写访问私有方法
my_dog._Dog__private_method()  # 输出：This is a private method.

3.2.3 属性装饰器

  • Python 中可以使用 @property 装饰器将方法转换为属性，允许开发者通过类似访问属性的方式来调用方法。
  • 同时，可以使用 @name.setter 和 @name.deleter 装饰器来定义属性的 setter 和 deleter 方法，分别用于设置和删除属性的值。
  • 使用属性装饰器可以更方便地控制对属性的访问，并隐藏内部实现细节。
python 复制代码 
class Dog:
    def __init__(self, name, breed):
        self._name = name
        self._breed = breed

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, value):
        self._name = value

    @name.deleter
    def name(self):
        del self._name

my_dog = Dog("Buddy", "Golden Retriever")
print(my_dog.name) # 输出：Buddy
my_dog.name = "Max"
print(my_dog.name) # 输出：Max
del my_dog.name
# print(my_dog.name)  # AttributeError: 'Dog' object has no attribute 'name'

3.2.4 模块和包

  • 模块： 模块是包含 Python 代码的独立文件，可以将相关的代码封装在一起，方便管理和重用。
  • 包： 包是包含多个模块的文件夹，可以将多个相关的模块组织在一起，方便大型项目管理。
python 复制代码 
# 模块
# my_module.py
def greet(name):
    print(f"Hello, {name}!")

# 使用模块
import my_module
my_module.greet("Alice")

# 包
# package/__init__.py
# package/module1.py
# package/module2.py
# ...

# 使用包
from package import module1
module1.some_function()

模块和包可以有效地隐藏内部实现细节，提高代码可读性和可维护性。

3.3 继承

继承是面向对象编程中重要的概念之一，它允许创建一个新的类（子类）继承另一个类的属性和方法（父类），从而实现代码复用和扩展。

3.3.1 单继承

单继承是指一个子类只继承一个父类。使用 class 子类名(父类名): 语法实现单继承。

python 复制代码 
class Animal:
    """
    定义一个动物类
    """

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

    def speak(self):
        print("Animal sound")

class Dog(Animal):
    """
    定义一个狗类，继承自 Animal 类
    """

    def speak(self):
        print("Woof!")

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

在 Dog 类中，我们使用 Animal 作为父类进行继承。子类 Dog 可以访问父类 Animal 中的属性和方法。需要注意的是，子类 Dog 重写了父类的 speak 方法，实现了特定于狗的行为。

3.3.2 多继承

多继承是指一个子类可以继承多个父类。使用 class 子类名(父类1, 父类2, ...): 语法实现多继承。

python 复制代码 
class Flyer:
    """
    定义一个飞行类
    """

    def fly(self):
        print("Flying...")

class Swimmer:
    """
    定义一个游泳类
    """

    def swim(self):
        print("Swimming...")

class Duck(Flyer, Swimmer):
    """
    定义一个鸭子类，继承自 Flyer 和 Swimmer 类
    """

    def quack(self):
        print("Quack!")

my_duck = Duck()
my_duck.fly()  # 输出 "Flying..."
my_duck.swim()  # 输出 "Swimming..."
my_duck.quack()  # 输出 "Quack!"

在 Duck 类中，我们继承了 Flyer 和 Swimmer 类。Duck 类可以访问这两个父类的属性和方法。多继承可以实现更加复杂的类关系，但需要注意的是，多继承可能会导致一些复杂的问题，例如方法名冲突和菱形继承问题。

注意:

  • 子类可以重写父类的方法，实现特定于子类的行为。
  • 多继承可能会导致一些复杂的问题，例如方法名冲突和菱形继承问题。

3.4 多态

多态是面向对象编程中的一个重要概念，它指的是同一个操作在不同的对象上表现出不同的行为。这使得代码更加灵活、可扩展和易于维护。

3.4.1 方法重写

方法重写是实现多态的一种方式。子类可以重写父类的方法，实现特定于子类的行为。

示例:

python 复制代码 
class Animal:
    def speak(self):
        print("Animal sound")

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

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

animals = [Dog(), Cat(), Animal()]
for animal in animals:
    animal.speak()  # 输出 "Woof!", "Meow!", "Animal sound"

在上面的例子中，Dog 和 Cat 类都重写了 Animal 类的 speak 方法，实现了各自不同的声音。通过循环遍历 animals 列表，调用每个对象的 speak 方法，我们可以看到不同的对象表现出不同的行为。

方法重写的规则:

  • 子类方法的名称必须与父类方法的名称相同。
  • 子类方法的参数列表必须与父类方法的参数列表相同。
  • 子类方法的返回值类型必须与父类方法的返回值类型相同或兼容。
  • 子类方法的访问权限必须与父类方法的访问权限相同或更宽松。

3.4.2 多态的应用场景

多态在面向对象编程中有着广泛的应用场景，例如:

  • 代码复用: 通过重写父类的方法，可以实现不同类型的对象共享同一个接口，而无需编写重复的代码。
  • 可扩展性: 通过继承和方法重写，可以轻松地添加新的对象类型，而无需修改现有代码。
  • 代码简洁: 多态可以使代码更加简洁，避免重复的条件判断。
  • 易于维护: 多态可以提高代码的可读性和可维护性，使代码更容易理解和修改。

示例:

假设我们要开发一个游戏，其中包含不同的角色，例如战士、法师和弓箭手。我们可以使用多态来实现角色的行为，例如攻击、防御和技能。

python 复制代码 
class Character:
    def attack(self):
        print("General attack")

class Warrior(Character):
    def attack(self):
        print("Warrior attack with sword")

class Mage(Character):
    def attack(self):
        print("Mage attack with magic")

characters = [Warrior(), Mage(), Character()]
for character in characters:
    character.attack()  # 输出 "Warrior attack with sword", "Mage attack with magic", "General attack"

通过多态，我们可以用统一的方式处理不同角色的攻击行为，而无需关心角色的具体类型。

4. 常用模块

模块是 Python 代码的组织单元，它可以包含函数、类、变量等。使用模块可以提高代码的可重用性和可维护性。

4.1 模块导入

在 Python 中，可以使用 import 语句导入模块。

4.1 导入整个模块

python 复制代码 
import math

print(math.pi)
print(math.sqrt(25))

这将导入 math 模块，并使用 math.pi 和 math.sqrt() 访问模块中的常量和函数。

4.2 导入特定属性

python 复制代码 
from math import pi, sqrt

print(pi)
print(sqrt(25))

这将只导入 math 模块中的 pi 和 sqrt 属性，并直接使用它们。

4.3 导入模块并指定别名

python 复制代码 
import math as m

print(m.pi)
print(m.sqrt(25))

这将导入 math 模块并将其指定为 m，可以使用 m.pi 和 m.sqrt() 访问模块中的属性。

4.4 导入所有属性

python 复制代码 
from math import *

print(pi)
print(sqrt(25))

这将导入 math 模块中的所有属性，但建议不要使用这种方式，因为它会导致命名冲突。

4.5 模块搜索路径

Python 在导入模块时会搜索以下路径：

  • 当前目录
  • 环境变量 PYTHONPATH 中指定的目录
  • 标准库目录

4.2 常用模块介绍

以下是几个 Python 中常用的模块的介绍：

4.2.1 math 模块

math 模块提供了大量的数学函数和常量，可以帮助我们进行各种数学运算。

常用函数：

  • pi: 圆周率
  • sqrt(x): 求平方根
  • pow(x, y): 求 x 的 y 次方
  • sin(x), cos(x), tan(x): 三角函数
  • ceil(x): 向上取整
  • floor(x): 向下取整
  • log(x): 自然对数
  • log10(x): 以 10 为底的对数

示例：

python 复制代码 
import math

print(math.pi)  # 输出圆周率
print(math.sqrt(25))  # 输出 5
print(math.pow(2, 3))  # 输出 8
print(math.sin(math.pi / 2))  # 输出 1
print(math.ceil(3.14))  # 输出 4
print(math.floor(3.14))  # 输出 3

4.2.2 random 模块

random 模块提供了生成随机数的功能，可以用于各种场景，例如模拟随机事件、洗牌等。

常用函数：

  • random(): 生成 0 到 1 之间的随机浮点数
  • randint(a, b): 生成 a 到 b 之间的随机整数
  • choice(seq): 从序列中随机选择一个元素
  • shuffle(seq): 打乱序列的元素顺序
  • sample(seq, k): 从序列中随机抽取 k 个元素

示例：

python 复制代码 
import random

print(random.random())  # 输出 0 到 1 之间的随机浮点数
print(random.randint(1, 10))  # 输出 1 到 10 之间的随机整数
print(random.choice(["apple", "banana", "orange"]))  # 输出 "apple", "banana" 或 "orange" 之一
numbers = [1, 2, 3, 4, 5]
random.shuffle(numbers)  # 打乱 numbers 列表的元素顺序
print(numbers)
print(random.sample(numbers, 2))  # 从 numbers 列表中随机抽取 2 个元素

4.2.3 os 模块

os 模块提供了与操作系统交互的功能，可以用来执行操作系统命令、操作文件和目录等。

常用函数：

  • getcwd(): 获取当前工作目录
  • chdir(path): 改变工作目录
  • listdir(path): 列出指定目录下的所有文件和子目录
  • mkdir(path): 创建目录
  • makedirs(path): 创建多级目录
  • remove(path): 删除文件
  • rmdir(path): 删除空目录
  • rename(old_path, new_path): 重命名文件或目录
  • system(command): 执行操作系统命令
  • environ: 获取环境变量字典

示例：

python 复制代码 
import os

print(os.getcwd())  # 输出当前工作目录
os.chdir("/tmp")  # 改变工作目录到 /tmp
print(os.listdir("/tmp"))  # 列出 /tmp 目录下的所有文件和子目录
os.mkdir("/tmp/mydir")  # 创建目录 /tmp/mydir
os.remove("/tmp/mydir/myfile.txt")  # 删除文件 /tmp/mydir/myfile.txt
os.rename("/tmp/mydir", "/tmp/mynewdir")  # 重命名目录 /tmp/mydir 为 /tmp/mynewdir
os.system("ls -l")  # 执行 ls -l 命令
print(os.environ["HOME"])  # 输出环境变量 HOME 的值

4.2.4 datetime 模块

datetime 模块提供了与日期和时间相关的功能，可以用来创建、格式化、计算日期和时间等。

常用类：

  • datetime.date: 表示日期
  • datetime.time: 表示时间
  • datetime.datetime: 表示日期和时间

常用方法：

  • now(): 获取当前日期和时间
  • today(): 获取当前日期
  • strftime(format): 格式化日期和时间
  • strptime(string, format): 解析日期和时间字符串

示例：

python 复制代码 
import datetime

now = datetime.datetime.now()  # 获取当前日期和时间
print(now)
print(now.strftime("%Y-%m-%d %H:%M:%S"))  # 格式化日期和时间
birthday = datetime.date(1990, 1, 1)  # 创建日期对象
print(birthday)
date_str = "2023-04-01"
date = datetime.datetime.strptime(date_str, "%Y-%m-%d").date()  # 解析日期字符串
print(date)

4.2.5 requests 模块

requests 模块提供了与网络请求相关的功能，可以用来发送 HTTP 请求、获取网页内容等。

常用方法：

  • get(url): 发送 GET 请求
  • post(url, data): 发送 POST 请求
  • put(url, data): 发送 PUT 请求
  • delete(url): 发送 DELETE 请求
  • json(): 获取响应内容的 JSON 格式
  • text: 获取响应内容的文本格式
  • status_code: 获取响应状态码

示例：

python 复制代码 
import requests

response = requests.get("https://www.google.com")  # 发送 GET 请求
print(response.status_code)  # 输出响应状态码
print(response.text)  # 输出响应内容的文本格式
response = requests.post("https://www.example.com/api/login", data={"username": "user", "password": "password"})  # 发送 POST 请求
print(response.json())  # 输出响应内容的 JSON 格式

注意： requests 模块不是 Python 的内置模块，需要使用 pip 安装。

bash 复制代码 
pip install requests

这些只是 Python 中常用的模块的一部分，还有很多其他的模块可以满足各种需求，请参考官方文档或其他学习资源进行更深入的了解。

5. 常见错误与调试

程序员在编写代码时不可避免地会遇到各种错误。了解常见的错误类型、掌握错误处理机制以及调试技巧是编写高质量代码的关键。

5.1 常见错误类型

Python 中常见的错误类型包括：

5.1.1 语法错误 (SyntaxError)

  • 代码结构或语法不符合 Python 规范。
  • 例如：缺少冒号、括号不匹配、变量未定义等。

5.1.2 运行时错误 (RuntimeError)

  • 运行时错误，也称为异常，是在程序执行过程中发生的错误。它们会导致程序无法正常执行，并可能引发崩溃或其他意外行为。

5.1.3 逻辑错误 (Logical Error)

  • 代码逻辑存在问题，导致程序无法正常运行或产生错误结果。
  • 例如：循环条件错误、算法逻辑错误等。

5.1.4 常见的运行时错误类型

  • TypeError

    • 描述：类型错误，发生在操作数的类型不匹配时。

    • 例子：

      python 复制代码 
      print("Hello" + 10)  
# TypeError: can only concatenate str (not "int") to str

  • ValueError

    • 描述：值错误，发生在函数接收了类型正确但值不合法的数据时。

    • 例子：

      python 复制代码 
      int("abc")  
# ValueError: invalid literal for int() with base 10: 'abc'

  • NameError

    • 描述：名称错误，发生在访问未定义的变量时。

    • 例子：

      python 复制代码 
      print(my_variable)  
# NameError: name 'my_variable' is not defined

  • IndexError

    • 描述：索引错误，发生在访问列表、元组或字符串时，索引超出了范围。

    • 例子：

      python 复制代码 
      my_list = [1, 2, 3]
print(my_list[3])  
# IndexError: list index out of range

  • KeyError

    • 描述：键错误，发生在访问字典时，指定的键不存在。

    • 例子：

      python 复制代码 
      my_dict = {"name": "John"}
print(my_dict["age"])  # KeyError: 'age'

  • AttributeError

    • 描述：属性错误，发生在访问对象不存在的属性时。

    • 例子：

      python 复制代码 
      my_str = "Hello"
print(my_str.length)  
# AttributeError: 'str' object has no attribute 'length'

  • IOError

    • 描述：输入/输出错误，发生在与文件或网络进行交互时出现问题。

    • 例子：

      python 复制代码 
      with open("nonexistent_file.txt", "r") as f:  
# IOError: [Errno 2] No such file or directory: 'nonexistent_file.txt'
    content = f.read()

注意：

  • 这些错误会在运行时发生，而不是在编译时发生。
  • 使用 try...except 语句可以捕获这些错误并进行处理，从而避免程序崩溃。

通过理解常见的运行时错误类型，可以更有效地编写和调试代码，并确保程序的稳定性和可靠性。

5.2 错误处理机制 (try-except)

try-except 语句是 Python 中强大的错误处理机制，它允许你在程序执行过程中捕获并处理异常。

5.2.1 语法

python 复制代码 
try:
    # 可能引发错误的代码
except 错误类型1:
    # 处理错误类型1的代码
except 错误类型2:
    # 处理错误类型2的代码
    ...
else:
    # 如果没有错误，执行此代码块
finally:
    # 无论是否发生错误，都会执行此代码块

5.2.2 捕获不同错误类型

python 复制代码 
try:
    num1 = int(input("请输入第一个数: "))
    num2 = int(input("请输入第二个数: "))
    result = num1 / num2
    print(f"{num1} 除以 {num2} 等于 {result}")
except ZeroDivisionError:
    print("除数不能为零！")
except ValueError:
    print("请输入有效的整数！")
else:
    print("计算成功！")
finally:
    print("程序结束！")

解释:

  • 该代码尝试从用户获取两个整数，并计算它们的商。
  • 如果用户输入的第二个数为 0，则会引发 ZeroDivisionError 异常，程序会捕获该异常并打印错误信息。
  • 如果用户输入的不是整数，则会引发 ValueError 异常，程序会捕获该异常并打印错误信息。
  • 如果没有发生任何异常，程序会成功计算结果并打印。
  • 最后，无论是否发生异常，finally 代码块都会执行，打印 "程序结束！"。

5.2.3 捕获所有错误和错误信息

除了捕获特定类型的错误，还可以使用 Exception 来捕获所有类型的错误。

语法:

python 复制代码 
try:
    # 可能引发错误的代码
except Exception as e:
    # 处理错误
    print(f"发生错误: {e}")
  • Exception 是所有错误类型的父类，因此使用 Exception 可以捕获所有类型的错误。
  • as e 将错误对象赋值给变量 e，可以方便地获取错误信息。
  • 在 except 代码块中，使用 f-string 格式化输出错误信息。

示例:

python 复制代码 
try:
    num1 = int(input("请输入第一个数: "))
    num2 = int(input("请输入第二个数: "))
    result = num1 / num2
    print(f"计算结果: {result}")
except Exception as e:
    print(f"发生错误: {e}")
finally:
    print("程序结束")

解释:

  1. 如果输入的两个数都是数字，且除数不为零，程序会正常计算并输出结果。
  2. 如果输入的除数为零，程序会输出 "发生错误: division by zero"。
  3. 如果输入的不是数字，程序会输出 "发生错误: invalid literal for int() with base 10: '...' " (其中 "..." 是用户输入的非数字字符)。
  4. 无论程序是否出错，都会输出 "程序结束"。

其他需要注意的点:

  • 虽然可以使用 Exception 捕获所有类型的错误，但一般建议捕获特定的错误类型，以便更精准地处理错误。
  • 可以使用 e.__class__.__name__ 获取错误类型的名称。

示例:

python 复制代码 
try:
    # 可能引发错误的代码
except Exception as e:
    print(f"发生错误类型: {e.__class__.__name__}")
    print(f"错误信息: {e}")

5.3 调试技巧

调试是程序员必备技能之一，用于发现并解决代码中的错误。常见的调试技巧包括：

5.3.1 打印调试信息 (print)

在代码中插入 print 语句，打印变量的值或执行流程，帮助定位错误。

python 复制代码 
def calculate(a, b):
    print(f"a: {a}, b: {b}")
    result = a + b
    print(f"result: {result}")
    return result

calculate(5, 10)

5.3.2 使用调试器 (debugger)

Python 内置的调试器 pdb 可以逐步执行代码，查看变量的值和执行流程。

python 复制代码 
import pdb

def calculate(a, b):
    pdb.set_trace()  # 设置断点
    result = a + b
    return result

calculate(5, 10)

5.3.3 使用日志 (logging)

将错误信息记录到日志文件中，便于分析和排查问题。

python 复制代码 
import logging

logging.basicConfig(filename='app.log', level=logging.DEBUG)

def calculate(a, b):
    logging.debug(f"a: {a}, b: {b}")
    result = a + b
    logging.debug(f"result: {result}")
    return result

calculate(5, 10)

5.3.4 使用断言 (assert)

在代码中插入断言，用于验证程序逻辑，一旦断言失败，程序会抛出异常。

python 复制代码 
def calculate(a, b):
    assert a > 0, "a 必须大于 0"
    result = a + b
    return result

calculate(5, 10)
相关推荐
ACP广源盛139246256737 小时前
硬件选型笔记：国产 PCIe Gen2.1 交换芯片 IX6024@ACP，工控与存量设备国产化改造方案评估
笔记·硬件架构·硬件工程·pcie·国产芯片
IT_Octopus7 小时前
【零基础入门 LLM 开发 · Day 13】：LangChain 的对话记忆——Message 对象版
人工智能·python·langchain
2603_965148117 小时前
社区与学习资源：从入门到精通的API选品学习路径
数据库·人工智能·python·学习·数据挖掘
文人sec8 小时前
SQL基础入门笔记 | 从零基础到掌握核心查询语句
数据库·笔记·sql
程序猿追8 小时前
kotlin-retry 接入鸿蒙后，怎样确认它真的会停止重试
开发语言·kotlin·harmonyos
我是人✓8 小时前
Java文件上传三方式对比：从传统到SpringBoot
java·开发语言
智能直播8 小时前
网络RTMP拉流不卡顿、声音不同步，一文讲透缓冲区、时间戳
开发语言·ffmpeg·php·音视频·视频编解码
CCblandy8 小时前
令牌桶在 0.9 倍负载超发 19%、固定窗口边界放行 20 个：四种限流算法同构实测
后端·python·算法·性能优化·架构
墨云安全9 小时前
内网资产无法暴露到公网，怎么做安全检测？2026 年内网渗透测试的落地路径
开发语言·安全·网络安全·渗透测试·php
摇滚侠9 小时前
《计算机是如何工作的：人人都能懂的计算机软硬件工作原理》第 9 章 机器码与汇编语言 阅读笔记 9
java·开发语言·笔记
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02历年考研数学一、数学二、数学三真题试卷及答案PDF03GitHub 镜像站点04「全语录+省流版」邵艾伦 × 孙宇晨：聊风口、聊个人IP、聊年轻人如何抓住 AI 时代的机会05蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接06Windows 10/11 如何退出微软账户并改用本地账户登录（含找不到选项的解决方法）07Telegram APK 下载安装完整指南 — 2026年最新08轻量化AI渗透武器库｜ARTEX自主攻防系统、资产梳理、漏洞挖掘、链路分析全流程智能化落地09如何新建文件夹？ 电脑新建文件夹的4种方法10微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新