Python编程基础

Python编程基础

Python是一种广泛使用的高级编程语言，因其易于学习和使用的特点而深受欢迎。它支持多种编程范式，包括面向对象、命令式、函数式和过程式编程。Python的设计哲学强调代码的可读性和简洁的语法（尤其是使用空格缩进来区分代码块，而不是使用大括号或关键字）。

搭建Python环境

搭建Python环境通常包括以下几个步骤：

1. 安装Python：

操作截图太费时间就只写代码啥,看的懂就行，以后有时间重新一遍哈 --浅小兮(▽)

Windows

  1. 访问Python官方网站下载页面（https://www.python.org/downloads/windows/）。

  2. 下载适用于Windows的Python安装程序（通常是.exe文件）。

  3. 双击下载的安装程序并启动安装向导。

  4. 在安装向导中，确保选中“Add Python to PATH”选项，这样可以在命令提示符中直接运行Python。

  5. 完成安装向导，Python将安装在您的系统中。

macOS

macOS系统通常预装了Python，但版本可能较旧。为了安装最新版本的Python，您可以使用Homebrew（macOS的包管理器）：

  1. 打开终端（Terminal）。

  2. 如果尚未安装Homebrew，可以通过运行以下命令来安装：

    1
    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

  3. 使用Homebrew安装Python：

    1
    brew install python

Linux

在Linux上，Python通常已经预装在大多数发行版中。您可以使用发行版的包管理器来安装或更新Python。例如，在Ubuntu或Debian系统上，您可以使用以下命令：

1
2
sudo apt update
sudo apt install python3

在Fedora上，使用以下命令：

1
sudo dnf install python3

在Arch Linux上，使用以下命令：

1
sudo pacman -S python

验证安装安装完成后，您可以通过打开命令行工具并运行以下命令来验证Python是否正确安装：

1
python --version  # 或 python3 --version，取决于您的操作系统

如果安装成功，该命令将显示安装的Python版本号。

注意事项

  • 确保下载与您的操作系统兼容的Python版本。

  • 在安装过程中，建议将Python添加到系统的环境变量中，这样可以在任何地方通过命令行运行Python。

  • 如果您需要在系统上同时安装多个Python版本，可以考虑使用版本管理工具，如pyenv。安装Python后，您可以开始编写Python代码，并通过命令行运行您的脚本。

  • 打开命令行工具（在Windows上是CMD或PowerShell，在macOS或Linux上是Terminal）。

  • 输入python --version或python3 --version（取决于您的操作系统和安装的Python版本）来验证Python是否正确安装。

2. 安装IDE或代码编辑器（Python）：

（博主建议初学使用Visual Studio Code因为完全免费，进阶用PyCharm ，小编用的是IntelliJ IDEA,因为懒得下载太多，常见的包括PyCharm、Spyder和Visual Studio Code。等等）
JetBrains PyCharm 是一款强大的 Python 集成开发环境（IDE），它提供了许多便利的功能，如代码自动完成、调试、版本控制和许多其他特性，这些都有助于提高开发效率。以下是安装 PyCharm 的基本步骤：

一，下载 PyCharm

  1. 访问 JetBrains 官方网站 PyCharm 下载页面：https://www.jetbrains.com/pycharm/download/

  2. 选择适合您操作系统的版本（Community 或 Professional）。Community 版本是免费的，而 Professional 版本提供了更多高级功能，需要购买许可证。

这里建议使用社区版（Community），如果你和小编一样还是学生的话可以白嫖一年旗舰版（Professional）
ε≡٩(๑>₃<)۶ 我就是白嫖哒也可以通过一些别的方式获取破解的，坏处就是无法更新或者是更新后无法使用，写的代码泄露了没有版本保护你可以详细在网页上找找，打算以后专门写一篇关于这个破解版本的怎么弄

二，安装 PyCharm

Windows

  1. 下载 .exe 安装文件。直接下载最新版_

  2. 双击下载的文件开始安装。

  3. 遵循安装向导的指示完成安装。

macOS（没用过暂时写不了一点点）

  1. 下载 .dmg 安装包。

  2. 双击下载的文件，然后拖拽 PyCharm 到应用程序文件夹中。

Linux（有时间用ubuntu试试）

  1. 下载 .tar.gz 压缩包。

  2. 解压下载的文件到您选择的目录。

  3. 在解压后的目录中，通常会有一个 bin 文件夹，里面包含一个可执行的 pycharm.sh 脚本。

  4. 运行 bin/pycharm.sh 脚本来启动 PyCharm。

Python基础知识

Python 是一种广泛使用的高级编程语言，以其易读性和简洁性而闻名。下面是一些 Python 编程的基础知识：

给大家推荐一个专门学习Python的网站菜鸟教程可以给小编一个赞吗(▽)支持一下博主

1，Python 语法和基础概念

  1. 变量：用来存储数据。Python 是动态类型的，不需要显式声明变量类型。

    1
    2
    x = 10          # 整数 (int)
    y = "Hello"     # 字符串 (str)

  2. 数据类型：Python 中的常见数据类型包括整数（int）、浮点数（float）、字符串（str）、列表（list）、元组（tuple）、字典（dict）和集合（set）。

  3. 控制流：

    • 条件语句：使用 if、elif 和 else 来执行不同的代码块。
      1
      2
      3
      4
      5
      6
      if x > 10:
          print("x is greater than 10")
      elif x == 10:
          print("x is equal to 10")
      else:
          print("x is less than 10")
    • 循环：使用 for 和 while 进行循环。
      1
      2
      for i in range(5):
          print(i)
      1
      2
      3
      while x > 0:
          print(x)
          x -= 1

  4. 函数：使用 def 关键字定义函数。

    1
    2
    3
    def greet(name):
        return f"Hello, {name}!"
    print(greet("Alice"))

  5. 模块和包：使用 import 语句导入模块或包。

    1
    2
    import math
    print(math.sqrt(16))  # 输出 4.0

  6. 异常处理：使用 try 和 except 捕获和处理异常。

    1
    2
    3
    4
    try:
        x = 1 / 0
    except ZeroDivisionError:
        print("Cannot divide by zero!")

2，Python 内置函数和数据结构

  1. 列表（List）：有序的集合，可以包含不同类型的元素。

    1
    my_list = [1, 2, 3, "four", "five"]

  2. 元组（Tuple）：不可变的有序集合。

    1
    my_tuple = (1, 2, 3)

  3. 字典（Dictionary）：键值对的集合。

    1
    my_dict = {"name": "Alice", "age": 25}

  4. 集合（Set）：无序且元素唯一的集合。

    1
    my_set = {1, 2, 3}

  5. 字符串（String）：文本序列。

    1
    my_string = "Hello, World!"

  6. 内置函数：如 print()、len()、type() 等。

    1
    2
    print("Hello, World!")
    length = len(my_list)

3，Python 编程习惯

  1. 缩进：Python 使用缩进来表示代码块，而不是大括号 {} 或其他分隔符。通常，每个缩进级别使用 4 个空格。例如：

    1
    2
    3
    4
    if True:
        print("True")
    else:
        print("False")

  2. 语句结尾：Python 语句通常不需要分号 ; 结尾。但是，如果要在同一行编写多条语句，则必须使用分号分隔。例如：

    1
    a = 1; b = 2

  3. 注释：使用 # 符号来添加单行注释。例如：

    1
    # 这是一条注释

  4. 多行语句：如果一条语句太长，可以使用反斜杠 \ 来分行。例如：

    1
    2
    a_long_sentence = "This is a very long sentence " \
                      "that spans multiple lines."

  5. 字符串引号：Python 中可以使用单引号 '、双引号 " 或三引号 """ 来表示字符串。例如：

    1
    2
    3
    single_quotes = 'single quotes'
    double_quotes = "double quotes"
    triple_quotes = """triple quotes"""

  6. 变量命名：变量名必须以字母（a-z, A-Z）或下划线 _ 开头，后面可以跟任意数量的字母、数字或下划线。变量名区分大小写。例如：

    1
    valid_variable = 5

  7. 函数定义：使用 def 关键字定义函数，后面跟函数名和括号内的参数列表。函数体缩进。例如：

    1
    2
    def my_function(param1, param2):
        return param1 + param2

  8. 类定义：使用 class 关键字定义类，后面跟类名和括号内的父类列表（如果有）。类体缩进。例如：

    1
    2
    3
    class MyClass:
        def __init__(self, value):
            self.value = value

  9. 模块导入：使用 import 语句导入模块，可以使用 from...import... 导入模块中的特定元素。例如：

    1
    2
    import math
    from datetime import datetime

  10. 异常处理：使用 try 和 except 块来处理异常。例如：

    1
    2
    3
    4
    try:
        # 尝试执行的代码
    except Exception as e:
        # 异常处理

  11. 循环和条件语句：for 和 while 循环以及 if、elif 和 else 条件语句不需要大括号，而是通过缩进来定义代码块。例如：

    1
    2
    for i in range(5):
        print(i)
    1
    2
    3
    4
    if condition:
        print("True")
    else:
        print("False")

字符串与数值

在 Python 中，字符串（str）和数值（整数 int、浮点数 float）是两种基本数据类型，它们分别用于表示文本数据和数值数据。以下是一些关于字符串和数值的基本操作和转换。

字符串（str）

字符串是用于表示文本的序列类型，可以包含字母、数字、标点符号和空格。在 Python 中，字符串可以使用单引号 '、双引号 " 或三引号 """ 来创建。

1
2
3
4
s1 = '这是一个字符串'
s2 = "这也是一个字符串"
s3 = """这是一个多行字符串
可以跨越多行"""

数值（int 和 float）

数值数据类型用于表示数字。int 类型表示整数，而 float 类型表示带小数的数值。

1
2
n1 = 10       # int
n2 = 3.14     # float

字符串与数值的转换

  1. 数值转字符串：使用 str() 函数将数值转换为字符串。

1
2
num = 123
str_num = str(num)  # '123'

  1. 字符串转数值：使用 int() 函数将字符串转换为整数，使用 float() 函数将字符串转换为浮点数。

1
2
3
4
s_num = "456"
int_num = int(s_num)  # 456
s_float = "3.14"
float_num = float(s_float)  # 3.14

如果字符串不能转换为有效的数值，这些函数将引发 ValueError 异常。

字符串与数值的格式化

可以使用字符串的 format() 方法或 f-string（Python 3.6+）来格式化包含数值的字符串。

1
2
3
4
num = 123
formatted_str = "The number is {}".format(num)  # "The number is 123"
#f-string
formatted_str = f"The number is {num}"  # "The number is 123"

数值运算

数值可以进行基本的算术运算，如加法、减法、乘法、除法等。

1
2
3
4
sum = n1 + n2  # 加法
difference = n1 - n2  # 减法
product = n1 * n2  # 乘法
quotient = n1 / n2  # 除法

字符串运算

字符串可以进行拼接、重复和索引等操作。

1
2
3
concatenated = s1 + s2  # 字符串拼接
repeated = s1 * 3  # 字符串重复
character = s1[0]  # 获取第一个字符

计算圆形的各参数

要计算圆形的参数，我们需要知道圆的半径（r）。圆的直径（d）是半径的两倍，即 d = 2r。圆的周长（C）和面积（A）可以通过以下公式计算：

  • 周长（C）：C = 2πr

  • 面积（A）：A = πr²
    其中，π（pi）是一个数学常数，大约等于 3.14159。以下是一个Python函数，用于计算给定半径的圆的直径、周长和面积：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import math
def calculate_circle_parameters(radius):
    # 计算直径
    diameter = 2 * radius
    # 计算周长
    circumference = 2 * math.pi * radius
    # 计算面积
    area = math.pi * radius ** 2
    return diameter, circumference, area
# 示例：计算半径为5的圆的参数
radius = 5
diameter, circumference, area = calculate_circle_parameters(radius)
print(f"半径: {radius}")
print(f"直径: {diameter}")
print(f"周长: {circumference:.2f}")
print(f"面积: {area:.2f}")

输出将是：

1
2
3
4
半径: 5
直径: 10
周长: 31.42
面积: 78.54

这个函数使用了Python的math模块来获取π的值。周长和面积的计算结果使用:.2f格式化字符串来保留两位小数。

Python数据结构

Python 提供了多种内置数据结构，用于存储和操作数据。这些数据结构包括列表（List）、元组（Tuple）、字典（Dictionary）、集合（Set）和字符串（String）。每种数据结构都有其独特的特性和用途。

列表（List）

列表是 Python 中最常用的数据结构之一。它是一个有序的元素集合，可以包含不同类型的元素，并且大小可变。

1
my_list = [1, 2, 3, "four", "five"]
元组（Tuple）

元组与列表类似，但它是不可变的，这意味着一旦创建了元组，就不能修改它。

1
my_tuple = (1, 2, 3, "four", "five")
字典（Dictionary）

字典是一种键值对集合，每个键都是唯一的，并且与一个值相关联。键和值之间使用冒号分隔。

1
my_dict = {"name": "John", "age": 30, "city": "New York"}
集合（Set）

集合是一个无序的不重复元素集。它用于消除重复项，并执行数学上的集合运算，如并集、交集和差集。

1
my_set = {1, 2, 3, 4, 5}
字符串（String）

字符串是字符的序列。在 Python 中，字符串是不可变的，这意味着一旦创建了字符串，就不能修改它。

1
my_string = "Hello, World!"
常用操作

  • 添加元素：列表和集合可以使用 .append()（列表）或 .add()（集合）方法添加元素。

  • 访问元素：列表、元组和字符串可以使用索引访问元素，如 my_list[0]。

  • 更新元素：列表和字典可以更新元素，如 my_list[0] = "new_value"。

  • 删除元素：列表和字典可以使用 del 关键字删除元素，如 del my_list[0]。

  • 遍历：可以使用 for 循环遍历列表、元组、字典和集合。

示例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#列表
my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  # 输出：[1, 2, 3, 4]
#元组
my_tuple = (1, 2, 3)
print(my_tuple[0])  # 输出：1
#字典
my_dict = {"name": "John", "age": 30}
my_dict["city"] = "New York"
print(my_dict)  # 输出：{'name': 'John', 'age': 30, 'city': 'New York'}
#集合
my_set = {1, 2, 3}
my_set.add(4)
print(my_set)  # 输出：{1, 2, 3, 4}
#字符串
my_string = "Hello"
print(my_string[0])  # 输出：H

创建列表并进行增删改查操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#创建一个空列表
my_list = []

#创建一个包含一些初始元素的列表
my_list = [1, 2, 3, "four", "five"]

#增加元素
my_list.append("six")   # 在列表末尾添加一个元素
my_list.insert(2, "three")   # 在列表的指定位置插入一个元素
my_list.extend([7, 8, 9])   # extend() 方法用于合并两个列表

#删除元素
my_list.remove("three")   # 删除列表中指定的元素
my_list.pop(2)   # 删除列表中指定位置的元素（默认删除最后一个元素）删除索引为2的元素!
 my_list.clear()   # 删除列表中的所有元素
del my_list[0]   # 删除索引为0的元素
del my_list[1:3]   # 删除索引为1到2的元素（不包括索引3）

#修改列表中指定位置的元素
my_list[3] = "new value"

#查询元素
print(my_list[0])  # 输出第一个元素
print(my_list.index("new value"))  # 输出元素的索引
print("four" in my_list)  # 检查元素是否在列表中
print(my_list.count("four"))  # 计算元素出现的次数

#遍历列表
for item in my_list:
    print(item)

创建字典并进行增删改查

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#创建一个空字典
my_dict = {}
#创建一个包含一些初始键值对的字典
my_dict = {"name": "John", "age": 30, "city": "New York"}


#增加键值对
my_dict["email"] = "john@example.com"   # 添加一个新的键值对
my_dict.update({"phone": "555-1234", "country": "USA"})   # 使用update()方法添加多个键值对

#删除键值对
del my_dict["age"]
#使用pop()方法删除键值对并返回值
age = my_dict.pop("age", None) # 如果键不存在，返回None
my_dict.pop("age")   # 清空字典中的所有键值对

#修改键值对
my_dict["name"] = "Johnny"

#查询键值对
name = my_dict["name"]   # 通过键访问字典中的值
age = my_dict.get("age", "Unknown")   # 使用get()方法访问字典中的值，如果键不存在返回None
has_city = "city" in my_dict   # 检查键是否在字典中
keys = my_dict.keys()   # 获取字典中的所有键
values = my_dict.values()   # 获取字典中的所有值
items = my_dict.items()   # 获取字典中的所有键值对

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

考试成绩划分（老师布置的一个小测验，使用try和except语句）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def grade_score(score):
    try:
        score = float(score)
        if score >= 90:
            return "优秀"
        elif score >= 80:
            return "良好"
        elif score >= 70:
            return "中等"
        elif score >= 60:
            return "及格"
        else:
            return "不及格"
    except ValueError:
        return "请输入有效的分数！"
#用户输入分数
user_input = input("请输入你的分数：")
#调用函数并输出结果
result = grade_score(user_input)
print(f"你的等级是：{result}")

实现一组数的连加和连乘

实现一组数的连加（累加）和连乘（累乘）可以通过for循环来实现。

1
2
3
4
5
6
7
8
9
10
11
12
#定义一组数
numbers = [1, 2, 3, 4, 5]
#连加（累加）
m = 0
for num in numbers:
    m += num   # m=m+num
print(f"连加结果：{m}")
#连乘（累乘）
n = 1
for num in numbers:
    n *= num   # n=n*num
print(f"连乘结果：{n}")

输出将会是：

1
2
连加结果：15
连乘结果：120

此外，Python还提供了内置函数sum()和math.prod()（在Python 3.8及以上版本中）来分别实现连加和连乘的功能：

1
2
3
4
5
6
7
import math
#使用内置函数连加
sum_result = sum(numbers)
print(f"连加结果：{sum_result}")
#使用内置函数连乘（需要Python 3.8及以上版本）
product_result = math.prod(numbers)
print(f"连乘结果：{product_result}")

冒牌排序法排序

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小（或越大）的元素会经由交换慢慢“浮”到数列的顶端。以下是一个冒泡排序的Python实现示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def bubble_sort(arr):
    n = len(arr)
    #遍历所有数组元素
    for i in range(n):
        # 最后i个元素已经是排好序的了，所以不需要再比较
        for j in range(0, n-i-1):
            # 遍历数组从0到n-i-1
            #交换如果找到的元素大于下一个元素
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
#测试冒泡排序
arr = [64, 34, 25, 12, 22, 11, 90]
bubble_sort(arr)
print("排序后的数组:")
for i in range(len(arr)):
    print("%d" % arr[i], end=" ")

输出将会是：

1
2
排序后的数组:
11 12 22 25 34 64 90

在这个示例中，我们定义了一个名为bubble_sort的函数，它接受一个列表arr作为参数。函数内部有两个嵌套的for循环：外层循环控制总共需要多少轮排序，内层循环负责每一轮的元素比较和交换。如果发现当前元素大于下一个元素，就交换它们的位置。这样，每一轮排序后，最大的元素都会“冒泡”到数组的末尾。经过n-1轮排序后，数组就被完全排序了。

函数

在编程中，函数是一段可重复使用的代码，用于执行一个特定的任务。在Python中，你可以定义自己的函数（称为用户定义函数），也可以使用Python内置的函数。函数通过def关键字来定义，后面跟着函数名和括号内的参数列表。函数体是缩进的代码块，包含了要执行的任务。

使用def定义函数

使用 def 关键字在Python中定义函数非常直接。下面是一些基本的步骤和规则：

  1. 使用 def 关键字开始函数定义。

  2. 紧接着 def 关键字后面是函数的名称，函数名称应该遵循标识符的命名规则（例如，它可以包含字母、数字和下划线，但不能以数字开头）。

  3. 函数名称后面是一对圆括号，括号内可以包含零个或多个参数。参数之间用逗号分隔。

  4. 圆括号后面是一个冒号 :。

  5. 函数体是缩进的代码块，它包含了函数执行的操作。下面是一个简单的例子，定义了一个名为 greet 的函数，它接受一个参数 name 并打印一个问候语：

1
2
3
4
5
def greet(name):
    """这是一个打招呼的函数"""
    print(f"你好，{name}！")
#调用函数
greet("张三")

在这个例子中，greet 是函数的名称，name 是函数的参数。当调用 greet("张三") 时，函数会打印出 你好，张三！。函数可以有不同的参数类型，如位置参数、默认参数、关键字参数和任意参数。函数也可以有返回值，使用 return 语句来指定返回值。如果没有 return 语句，函数默认返回 None。下面是一个带有返回值的函数示例：

1
2
3
4
5
6
def add(a, b):
    """返回两个数的和"""
    return a + b
#调用函数并打印结果
result = add(10, 20)
print(result)  # 输出：30

在这个例子中，add 函数接受两个参数 a 和 b，返回它们的和。调用 add(10, 20) 后，函数返回值 30 被赋值给变量 result，然后打印出来。

使用lambda创建匿名函数

在Python中，你可以使用lambda关键字来创建匿名函数，这些函数没有函数名，但可以有参数和表达式。匿名函数通常用于简单的、一次性的任务，或者作为其他函数的参数。匿名函数的基本语法如下：

1
lambda arguments: expression

  • arguments：参数列表，可以是任意数量和类型的参数。

  • expression：一个表达式，计算后返回一个值。匿名函数可以作为其他函数的参数，例如在map()、filter()和sorted()函数中。下面是一些使用lambda创建匿名函数的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#创建一个匿名函数，该函数将传入的数字乘以2
double = lambda x: x * 2
#调用匿名函数并打印结果
print(double(5))  # 输出：10
#使用匿名函数作为map()函数的参数
numbers = [1, 2, 3, 4, 5]
doubled_numbers = map(lambda x: x * 2, numbers)
#打印map()函数的返回值
print(list(doubled_numbers))  # 输出：[2, 4, 6, 8, 10]
#使用匿名函数作为filter()函数的参数
numbers = [1, 2, 3, 4, 5]
even_numbers = filter(lambda x: x % 2 == 0, numbers)
#打印filter()函数的返回值
print(list(even_numbers))  # 输出：[2, 4]

在这个例子中，我们首先创建了一个匿名函数double，它接受一个参数x并返回x * 2。然后，我们使用map()函数将这个匿名函数应用于一个列表numbers，得到一个新的列表doubled_numbers，其中包含原始列表中每个数字乘以2的结果。接着，我们使用filter()函数创建了一个新列表even_numbers，其中包含原始列表中所有偶数。

面向对象编程

面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它将数据和操作数据的方法组合在一起，形成对象。这种方法强调将数据和操作数据的函数封装在一个称为类的结构中。面向对象编程的主要特点包括封装、继承和多态。

封装

封装是将数据（属性）和操作数据的方法（方法或函数）组合在一起，形成对象。这样可以隐藏对象的内部实现细节，只暴露对外接口。

1
2
3
4
5
6
7
8
9
class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
    def start(self):
        print("汽车启动了")
    def stop(self):
        print("汽车停止了")

在这个例子中，Car 类封装了汽车的制造商、型号和年份，以及启动和停止汽车的方法。

继承

继承是面向对象编程中的一种机制，允许你创建一个新类（子类），该类继承自一个现有类（父类）。子类可以继承父类的属性和方法，并添加新的属性和方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Vehicle:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
    def start(self):
        print("车辆启动了")
    def stop(self):
        print("车辆停止了")
class Car(Vehicle):
    def __init__(self, make, model, year, num_doors):
        super().__init__(make, model, year)
        self.num_doors = num_doors
    def honk(self):
        print("汽车鸣笛了")

在这个例子中，Car 类继承自 Vehicle 类。Car 类除了继承 Vehicle 类的属性和方法外，还添加了一个新的属性 num_doors 和一个新方法 honk。

多态

多态是指不同的对象对同一消息可以给出不同的响应。在Python中，多态通常通过继承来实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Animal:
    def make_sound(self):
        print("动物发出声音")
class Dog(Animal):
    def make_sound(self):
        print("汪汪汪")
class Cat(Animal):
    def make_sound(self):
        print("喵喵喵")
#创建动物对象
animal = Animal()
dog = Dog()
cat = Cat()
#调用make_sound方法
animal.make_sound()  # 输出：动物发出声音
dog.make_sound()     # 输出：汪汪汪
cat.make_sound()     # 输出：喵喵喵

在这个例子中，Animal 类有一个方法 make_sound，Dog 和 Cat 类都继承了这个方法。但是，它们给出了不同的实现。当我们调用 make_sound 方法时，会根据对象的实际类型执行相应的实现。

文件基础

在Python中，文件处理是一个非常重要的部分。文件是计算机存储数据的容器，可以用来存储各种类型的数据，如文本、二进制数据等。Python提供了多种方式来读取和写入文件，包括内置的文件操作方法和io模块。

文件操作方法

Python提供了内置的文件操作方法，如open()、read()、write()、close()等。

  • open()：用于打开文件，并返回一个文件对象。

  • read()：从文件中读取内容。

  • write()：向文件中写入内容。

  • close()：关闭文件，释放资源。

文件读写

读取文件

1
2
3
4
5
6
#打开文件
with open('example.txt', 'r') as file:
    # 读取文件内容
    content = file.read()
    print(content)
#或者使用readline()、readlines()等方法

写入文件

1
2
3
4
#打开文件
with open('example.txt', 'w') as file:
    # 写入文件内容
    file.write("这是一个例子")

文件模式

在open()函数中，你可以指定文件模式，常见的模式有：

  • 'r'：只读模式（默认）。

  • 'w'：写入模式，如果文件已存在，则会覆盖原文件。

  • 'a'：追加模式，向文件末尾添加内容。

  • 'b'：二进制模式。

  • '+'：读写模式。你可以组合这些模式，例如'r+'表示可读可写，'w+'表示可写可读，但会覆盖原文件。

文件路径

在Python中，文件路径可以是一个字符串，指定文件在文件系统中的位置。文件路径可以是相对路径或绝对路径。

  • 相对路径：相对于当前工作目录。

  • 绝对路径：从文件系统的根目录开始的完整路径。

文件编码

在Python中，默认情况下，文本文件是以UTF-8编码打开的。如果你需要以其他编码打开文件，可以在open()函数中指定编码。

1
2
with open('example.txt', 'r', encoding='utf-16') as file:
    content = file.read()

异常处理

在文件操作中，可能会遇到各种异常，如文件不存在、权限问题等。使用try和except语句可以捕获并处理这些异常。

1
2
3
4
5
6
7
try:
    with open('example.txt', 'r') as file:
        content = file.read()
except FileNotFoundError:
    print("文件未找到")
except PermissionError:
    print("没有权限读取文件")

模块和第三方库

在Python中，模块（Module）是一组相关的Python文件的集合，用于组织和重用代码。每个模块都有一个唯一的名称，通常以.py为扩展名。模块可以包含变量、函数、类和文档字符串等。

导入模块

要使用模块中的功能，你需要导入它。Python提供了多种导入方式：

  1. 导入整个模块：

    1
    import module_name

    使用module_name作为前缀来访问模块中的元素。

  2. 导入特定函数或变量：

    1
    from module_name import function_name, variable_name

    直接使用function_name和variable_name来访问。

  3. 导入并重命名：

    1
    from module_name import function_name as new_name

    将function_name重命名为new_name。

第三方库

第三方库是由Python社区开发的库，可以扩展Python的功能。它们通常用于特定任务，如科学计算、网络编程、数据库操作等。

安装第三方库

安装第三方库通常使用pip（Python的包管理器）。你可以使用以下命令来安装库：

1
pip install library_name

例如，要安装requests库（用于HTTP请求），你可以运行：

1
pip install requests

安装后，你就可以在Python代码中导入并使用这个库了。

导入第三方库

使用第三方库时，你需要导入它。这通常在import语句中完成，如下所示：

1
import requests

或者，如果你只使用库中的特定函数或变量：

1
from requests import get

然后，你就可以使用get函数来发起HTTP请求了。

示例

假设你想要使用requests库来获取一个网页的内容：

1
2
3
4
5
6
7
import requests
url = 'https://www.example.com'
response = requests.get(url)
if response.status_code == 200:
    print(response.text)
else:
    print(f"请求失败，状态码：{response.status_code}")

在这个例子中，我们导入了requests库，并使用requests.get()函数来获取网页内容。如果请求成功，我们打印出网页的文本内容；如果请求失败，我们打印出状态码。模块和第三方库是Python强大的功能之一，它们使得编写高效的代码变得更加容易。通过导入和使用这些库，你可以利用社区开发的代码来解决各种问题。