Python入门第一步：一文掌握Python3基础语法

Python 是一种高级编程语言，以其简洁清晰的语法而闻名。它在数据科学、机器学习、Web 开发等多个领域都有着广泛的应用。Python 3 作为 Python 的最新版本，拥有更多的新特性和改进。对于初学者来说，理解并掌握 Python 3 的基础语法是迈向编程世界的坚实一步。

bjxiaxueliang

4926人浏览 · 2017-12-15 14:48:10

bjxiaxueliang · 2017-12-15 14:48:10 发布

一、Python3基础简介

注释使用
变量定义
print 输出
import 导入
缩进代码块
命名规则

1.1 注释

单行注释以 # 开头：

#!/usr/bin/python3  
  
# 第一个注释  
# 第二个注释  
print("Hello, Python!")

多行注释可以用多个 # 号，还有 '''’ 和 """：

#!/usr/bin/python3
 
'''
多行注释：一
多行注释：二
'''
 
"""
多行注释：三
多行注释：四
"""
print ("Hello, Python!")

1.2 变量定义

Python 中的变量不需要声明，但每个变量在使用前必须赋值，变量赋值以后该变量才会被创建。

#!/usr/bin/python3  
  
# 整型变量  
counterInt = 100  
# 浮点型变量  
milesFlot = 1000.0  
# 字符串类型：  
wordStr01 = '字符串01'  
wordStr02 = "字符串02"  
  
# print默认换行，因此不存在println  
print(counterInt)  
print(milesFlot)  
print(wordStr01)  
print(wordStr02)

多变量按如下方式进行赋值：

#!/usr/bin/python3  

# 多变量 赋值
a = b = c = 1
# 多变量 赋值
d, e, f = 1, 2, "xiaxl"

# 内置 type() 函数可以用来查询变量所指的对象类型
print(type(a), type(b), type(c), type(d))

1.3 print 输出

print 默认换行，因此不存在 println；
print 若要实现不换行，需要在变量末尾加上 end=""；

#!/usr/bin/python3
 
x="a"
# 换行输出
print( x )
# 不换行输出
print( x, end=" " )
print ("Hello, Python!")

1.4 import 导入

在 python 用 import 或者 from...import 来导入相应的模块。

将整个模块(somemodule)导入： import somemodule
从某个模块中导入某个函数： from somemodule import somefunction
从某个模块中导入多个函数： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入： from somemodule import *

# 导入sys模块
import sys
# 导入特定成员
from sys import argv,path

1.5 缩进

python使用缩进来表示代码块，不需要使用大括号 {} 。
另外，同一个代码块的语句必须包含相同的缩进空格数。

#!/usr/bin/python3

if True:
    print ("True")
else:
    print ("False")

1.6 命名规则

在Python中，命名规则是编程者须遵守的一套标准，以确保代码的可读性和一致性。以下是Python中变量、函数、类等命名的一些基本规则和约定：

命名约定

变量名和函数名：对于变量名和函数名，推荐使用小写字母，单词之间用下划线连接。例如：my_variable, function_name。
类名：对于类名，推荐使用每个单词首字母大写的格式，例如PascalCase, MyClass。
常量：对于常量，通常全部使用大写字母，单词之间用下划线分隔。例如：MAX_CONNECTIONS。
私有成员：如果一个变量或方法仅在类的内部使用，可以在其名称前加上一个下划线来表示这是一个“私有的”成员。例如：_private_var。
特殊方法：Python中有一些特殊的方法，如__init__，__str__等。这些方法的名称前后都有双下划线。这些方法有特殊的含义，不应该被随意重定义，除非你知道它们的作用。

注意事项：

名称组成：名称可以由字母（a-z, A-Z）、数字（0-9）以及下划线（_）组成，但是不能以数字开头。
区分大小写：Python中的名称是区分大小写的。例如，myname 和 myName 被视为两个不同的变量名。
保留关键字：不能使用Python的保留关键字作为变量名或函数名。例如，if, else, for, while 等都是保留关键字，不能用作标识符。
特殊字符：除了下划线（_）之外，其他特殊字符如 @, $, % 等不可用于命名。
长度限制：虽然Python没有对标识符的长度进行严格限制，但为了保持代码的可读性，建议不要过长。

二、数据类型

Python 支持多种数据类型，包括但不限于整数、浮点数、布尔值等。变量用于存储数据值，无需声明类型即可使用。

基本数值类型
String 字符串类型
List 列表
Tuple 元组
Set 集合
Dictionary 字典
Stack 栈

2.1 基本数值类型

python3 的基本数值类型包括 int、float、complex、bool

类型	描述	举例
int	长整型	1
float	浮点型	1.23
complex	复数	1.1 + 2.2j
bool	布尔	True

# !/usr/bin/python3  
  
# 长整型：十进制  
counterInt01 = 100  
# 长整型：二进制  
counterInt02 = 0b1010  
# 长整型：十六进制  
counterInt03 = 0x0F  
  
# 布尔  
isRight = True  
  
# 浮点型  
milesFlot = 1000.0

可能会有疑问，数值类型中为什么会有bool？
Python3 中，bool 是 int 的子类，因此 True 和 False 可以和数字相加（True=1、False=0）。

数值运算

数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数；
数值乘方用 ** 表示；

5 + 4  # 加法：9
4.3 - 2 # 减法：2.3
3 * 7  # 乘法：21
2 / 4  # 除法 得到一个浮点数：0.5
2 // 4 # 除法 得到一个整数：0
17 % 3 # 取余：2
2 ** 5 # 乘方：32

2.2 String 字符串

String是一个Unicode字符序列，是Python中最重要的数据类型之一。

String 单引号 ' 和双引号 " 使用作用相同；
String 三引号(''' 或 """)可以指定一个多行字符串；

# !/usr/bin/python3  
wordStr01 = '字符串01'  
wordStr02 = "字符串02"    
wordStr03 = """字符串段落， 
字符串段落"""  

# print默认换行，因此不存在println  
print(wordStr01)  
print(wordStr02)  
print(wordStr03)

反斜杠 \ 可以用做转义符；
使用 r 可以让反斜杠不发生转义；

# !/usr/bin/python3

# 若输出D:Download\note\notebook，可以使用反斜杠\转译
print('D:Download\\note\\notebook')
# 若输出D:Download\note\notebook，还可以在字符串前添加r或R
print(r'D:Download\note\notebook')

字符串的截取的语法格式：变量[头下标:尾下标:步长]
Python 没有单独的字符类型，一个字符就是长度为 1 的字符串；
Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始；
字符串可以用 + 运算符连接在一起；
字符串可以用 * 运算符重复；

#!/usr/bin/python3

str='Hello world,你好 世界'

# 获取第1个字符
print(str[0])
# 获取第7个字符
print(str[6])

# 负数：获取倒数第一个字符
print(str[-1])    # 界
# 负数：获取倒数第二个字符
print(str[-2])    # 世

# 输出从第3个到第5个的字符
print(str[2:5])
# 输出从第3个开始后面所有的字符
print(str[2:])
# 输出从第2个到第5个且每隔一个的字符（步长为2）
print(str[1:5:2])

# 字符串重复：输出字符串两次
print(str * 2)

# 字符串连接：连接字符串
print(str + ' 你好')

in 、not in 判断字符串的包含关系：

in 、not in 判断字符串的包含关系：

#!/usr/bin/python3

a='hello'
b='hello world'

# 判断 b 中是否包含 a 
print(a in b)
# 判断 b 中是否包含 a 
print(a not in b)

upper() 字母大写

#!/usr/bin/python3

a='hello World'
# 字母大写：输出 HELLO WORLD
print(a.upper())

lower() 字母小写

#!/usr/bin/python3

a='hELLO WORLD'
# 字母小写：输出 hello world
print(a.lower())

capitalize() 首字母转大写、其他字母小写

#!/usr/bin/python3

a='hELLO WORLD 12345'
# 首字母转大写、其他字母小写：输出：Hello world 12345
print(a.capitalize())

title() 每个单词的首字母大写

#!/usr/bin/python3

a='this is an apple'
# 每个单词的首字母大写：输出 This Is An Apple
print(a.title())

swapcase() 大写转小写,小写转大写

#!/usr/bin/python3

a='hELLO world'
# 大写转小写,小写转大写：输出 Hello WORLD
print(a.swapcase())

startswith 判断是否以某个字符串开头

#!/usr/bin/python3

a='Hello world'
# 判断是否以'Hello'开头
print(a.startswith('Hello'))

endswith 判断是否以某个字符串结束

#!/usr/bin/python3

a='Hello world'
# 判断是否以'world'结尾
print(a.endswith('world'))

count() 统计字符串中字符出现的次数

#!/usr/bin/python3

a='Hello worLd'

# l 在字符串中出现的次数
print(a.count('l'))
# l 在字符串0-5之前出现的次数
print(a.count('l',0,5))

strip() 删除前后空格或移除前后给定字符

#!/usr/bin/python3
a=' Hello world '

# 删除前后空格
print(a.strip())

# 移除给定字符
print(a.strip('Hd'))

replace() 替换给定字符

#!/usr/bin/python3

a='Hello world'
# 替换给定字符：将world替换为python
print(a.replace('world','python'))

find() 查找字符在字符串中的位置

#!/usr/bin/python3

a='Hello world'
# 查找'world'在字符串中的位置
print(a.find('world'))

# 如果查找不到在则返回-1
print(a.find('Worlds'))

2.3 List 列表

List（列表）是 Python 中使用最频繁的数据类型，列表可以完成大多数集合类的数据结构实现。

列表写在方括号 [] 之间、用逗号分隔开；
列表中元素的类型可以不相同，支持数字、字符串、甚至可以包含列表（所谓嵌套）。
列表与字符串一样，可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
列表截取的语法格式：变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置

#!/usr/bin/python3

list01 = [ 'a', 123 , 2.23, 'xia', 456 ]
list02 = [123, 'xia']

print (list01)            # 输出完整列表
print (list01[0])         # 输出列表第一个元素
print (list01[1:3])       # 从第二个开始输出到第三个元素
print (list01[2:])        # 输出从第三个元素开始的所有元素
print (list01 * 2)    # 输出两次列表
print (list01 + list02) # 连接列表

以上举例中：

加号 + 是列表连接运算符；
星号 * 是重复操作；

#!/usr/bin/python3

# 遍历list
list01 = [2, 3, 4]
for value in list01:
    print(value)

# 遍历list
list02 = [2, 3, 4]
for index in range(len(list02)):
    print(index,list02[index])

2.4 Tuple 元组

在 Python 中，元组（tuple）是一种非常有用的数据结构，它与列表类似，都是用来存储一系列有序的项目。但是，元组与列表有一个重要的区别：元组是不可变的（immutable），而列表是可变的（mutable）。这意味着一旦创建了元组，就不能修改其内容，例如不能添加、删除或改变其中的元素。这种不可变性使得元组在某些情况下比列表更加适用。

元组写在小括号 () 里，元素之间用逗号隔开；
元组中元素的类型可以不相同，支持数字、字符串、甚至可以包含列表。
元组与字符串一样，可以被索引和截取，列表被截取后返回一个包含所需元素的新元组。
元组不可变，当你不想让数据在程序运行过程中被意外修改时，可以使用元组来确保数据的安全性。当需要一组固定不变的值时，如星期几的名称、月份等，使用元组是一个很好的选择。
元组的处理速度通常比列表快，尤其是在数据量大的时候。如果你只需要读取数据而不进行任何修改，使用元组可以提高程序的效率。

#!/usr/bin/python3

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
tup3 = (1, 2, 3, 4, 5, 6)

print(tup3[0])  # 结果：1
print(tup3[1:5])  # 结果：(2, 3, 4, 5)

# 创建元组
days_of_week = ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday')
# 访问元组中的元素
print(days_of_week[0])  # 输出: Monday

2.5 Set 集合

在 Python 中，集合（set）是一种无序且不重复的数据结构，用于存储唯一的元素。集合是基于哈希表实现的，这使得集合在查找、插入和删除元素时具有很高的效率。

创建集合：
可以使用大括号 { } 或者 set() 函数创建集合；
创建空集合：
创建一个空集合必须用 set()而不是 { }，因为 { } 是用来创建一个空字典；
集合中不允许存在重复元素：
集合自动去除重复的元素，非常适合用来从列表或其他可迭代对象中提取唯一值。
集合与或非运算：
使用-求集合的差集，使用|求集合的并集，使用&求集合的交集，使用^求两个集合不同时存在的元素。
由于集合是通过哈希表实现的，所以检查某个元素是否存在于集合中是非常快的。

#!/usr/bin/python3
# 创建集合：可以使用大括号 { } 或者 set() 函数创建集合
# 创建集合：重复的元素被自动去掉
set01 = {'a', 'b', 'c', 'a', 'b', 'c', 'd'}
set02 = set('abcdabcd')
# 创建空集合：创建一个空集合必须用 set()
set03 = set()

# 去重
numbers = [1, 2, 2, 3, 4, 4, 5]
unique_numbers = set(numbers)
print(unique_numbers)  # 输出: {1, 2, 3, 4, 5}

# 成员测试
print(2 in s1)  # 输出: True

# set可以进行集合运算
setA = set('abcdabcd')
setB = set('abcabc')
# 集合与或非
print(setA - setB)  # A 和 B 的差集
print(setA | setB)  # A 和 B 的并集
print(setA & setB)  # A 和 B 的交集
print(setA ^ setB)  # A 和 B 中不同时存在的元素

2.6 Dictionary 字典

在 Python 中，字典（dictionary）用于存储键值对（key-value）。字典是无序的，可以通过键快速访问、添加、删除或修改值。

快速查找：字典通过哈希表实现，这意味着查找、插入和删除操作的时间复杂度平均为 O(1)，非常高效。
关联数据：字典允许你将数据关联起来，每个键对应一个值。这对于存储和检索结构化数据非常有用，比如用户信息、配置设置等。
动态数据结构：字典是动态的，可以在运行时随时添加、删除或修改键值对，非常适合处理不确定数量的数据。

#!/usr/bin/python3

# 创建字典
person = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}
# 访问字典中的值
print(person["name"])  # 输出: Alice
# 添加新的键值对
person["email"] = "alice@example.com"
print(person)  # 输出: {'name': 'Alice', 'age': 30, 'city': 'New York', 'email': 'alice@example.com'}
# 修改现有的键值对
person["age"] = 31
print(person)  # 输出: {'name': 'Alice', 'age': 31, 'city': 'New York', 'email': 'alice@example.com'}
# 删除键值对
del person["city"]
print(person)  # 输出: {'name': 'Alice', 'age': 31, 'email': 'alice@example.com'}
# 检查键是否存在
if "email" in person:
    print("Email is present")
# 遍历字典
for key, value in person.items():
    print(f"{key}: {value}")

2.7 栈

在 Python 中，栈（stack）是一种后进先出（LIFO, Last In First Out）的数据结构。尽管 Python 没有内置的栈类型，但可以很容易地使用列表（list）来实现栈的功能。栈在许多编程任务中都非常有用，尤其是在需要处理递归、回溯和算法设计等问题时。

栈的主要用途包括：

函数调用和递归：栈用于保存函数调用的信息，如局部变量和返回地址。递归算法通常依赖于隐式的调用栈来跟踪函数调用的状态。
表达式求值：栈可以用于解析和求值算术表达式，如中缀表达式转换为后缀表达式（逆波兰表示法）。
回溯算法：在解决迷宫问题、八皇后问题等需要回溯的算法中，栈可以帮助记录路径或状态，以便在遇到死胡同时回退到上一步。
撤销操作：在文本编辑器或绘图软件中，栈可以用于实现撤销功能，每次执行操作时将其压入栈中，撤销时弹出最近的操作。
括号匹配：栈可以用于检查括号是否匹配，如在代码编辑器中检测语法错误。
内存管理：操作系统和编程语言的运行时系统使用栈来管理函数调用和局部变量的内存分配。
使用列表实现栈
Python 列表提供了栈所需的基本操作，如 append() 和 pop() 方法。

# 创建一个空栈
stack = []

# 压入元素
stack.append(1)
stack.append(2)
stack.append(3)

print("Stack:", stack)  # 输出: Stack: [1, 2, 3]

# 弹出元素
top_element = stack.pop()
print("Popped element:", top_element)  # 输出: Popped element: 3
print("Stack after pop:", stack)  # 输出: Stack after pop: [1, 2]

# 检查栈是否为空
is_empty = len(stack) == 0
print("Is stack empty?", is_empty)  # 输出: Is stack empty? False

# 获取栈顶元素（不弹出）
top_element = stack[-1] if stack else None
print("Top element:", top_element)  # 输出: Top element: 2

三、数据类型转换

Python 数据类型转换可以分为两种：

隐式类型转换：自动完成
显式类型转换：需要使用类型函数来转换

3.1 隐式类型转换

# !/usr/bin/python3  
  
num_int = 123  
num_float = 1.23  
num_new = num_int + num_float  
  
print("num_int：",num_int)  
print("num_int type：",type(num_int))  
  
print("num_float：",num_float)  
print("num_float type：", type(num_float))  
  
print("num_new：",num_new)  
print("num_new type:",type(num_new))

3.2 显式类型转换

显式类型转换

在显式类型转换中，用户将对象的数据类型转换为所需的数据类型：使用 int()、float()、str() 等预定义函数来执行显式类型转换。

int() 转换为整型：

# !/usr/bin/python3  
  
x = int(1)   # x 输出结果为 1
y = int(2.8) # y 输出结果为 2
z = int("3") # z 输出结果为 3

float() 转换为浮点型：

# !/usr/bin/python3  
  
x = float(1)     # x 输出结果为 1.0
y = float(2.8)   # y 输出结果为 2.8
z = float("3")   # z 输出结果为 3.0
w = float("4.2") # w 输出结果为 4.2

str() 转换为字符串：

x = str("s1") # x 输出结果为 's1'
y = str(2)    # y 输出结果为 '2'
z = str(3.0)  # z 输出结果为 '3.0'

四、条件与循环控制

if 语句
while 循环

4.1 if 语句

if语句的关键字为：if – elif – else；
每个条件后面要使用冒号 : 表示接下来是满足条件后要执行的语句块；
使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块；

#!/usr/bin/python3
 
age = 18
if age <= 0:
    print("你是在逗我吧!")
elif age <=2:
    print("婴儿宝宝")
elif age < 18:
    print("未成年")
else:
    print("成年")

4.2 while 循环

Python中没有do..while循环，在Python中while语句的一般形式是：

#!/usr/bin/python3

i = 1
while i<=100:
	print(i)
	i += 1

Python中while搭配else使用时：如果while后面的条件语句为false时，则执行else的语句块的内容。

#!/usr/bin/python3

i = 1
while i<=100:
	print(i)
	i += 1
else:
   	print("end：",i)

4.3 for 循环

Python for 循环可以遍历任何可迭代对象，格式为for <variable> in <sequence>

#!/usr/bin/python3  
  
# 构建array列表  
arrayList = ["a", "b", "c", "d"]  
for content in arrayList:  
    if content == "a":  
        print("if判断 a continue：", content)  
        continue  
 if content == "d":  
        print("if判断 d break：", content)  
        break  
 print("打印循环内容：" + content)  
else:  
    print("没有循环数据")  
print("完成循环")

Python 如果需要遍历数字序列，可以使用内置range()函数。

#!/usr/bin/python3

for i in range(5):
    print(i)

五、迭代器与生成器

迭代器
生成器

5.1 迭代器

Python中迭代器是访问集合元素的一种方式，有两个基本的方法iter() 和 next()；

字符串、列表、元组都可创建迭代器；

# encoding: utf-8  
  
arry_list = [1, 2, 3, 4]  
# 创建迭代器对象  
iter01 = iter(arry_list)  
# 输出迭代器的下一个元素  
print("next: ", next(iter01))  
  
# for循环遍历迭代器  
for content in iter01:  
    print("循环: ", content)

5.2 生成器

Python中生成器是迭代器的一种，使用yield返回值函数，每次调用yield会暂停，而可以使用next()函数恢复生成器。

生成器类似于返回值为数组的一个函数：

这个函数可以接收参数与被调用，但是不同于一般的函数会一次性返回包括了所有数值的数组，生成器一次只能产生一个值，从而减少内存消耗。因此生成器看起来像是一个函数，但是表现却是迭代器。
一般在迭代一组数据时（以 list 容器为例），须先将所有数据存储到容器中，才能开始迭代；而生成器却不同，它可以实现在迭代的同时生成元素，对于可以用某种算法推算得到的多个数据，生成器并不会一次性生成它们，而是什么时候需要，才什么时候生成。

创建迭代器方式比较简单，大体分为以下 2 步：

定义一个以 yield 关键字标识返回值的函数；
调用刚刚创建的函数，即可创建一个生成器。

# encoding: utf-8

# 定义一个以 yield 关键字标识返回值的函数
def intNum():
    print("--- intNum start ---")
    for index in range(5):
        print("开始循环: ", index)
        yield index
        print("继续循环: ", index)
    print("--- intNum end ---")


# 调用函数，创建生成器
num = intNum()
# 调用 next() 内置函数
# print(next(num))
# 通过for循环遍历生成器
for i in num:
    print("遍历生成器：", i)

六、Python3 函数

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()；
任何传入参数和自变量必须放在圆括号()中间，圆括号之间可以用于定义参数；
函数内容以冒号 : 起始，并且缩进；
return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

#!/usr/bin/python3  
  
# 定义一个比较函数  
def max(a, b):  
    if a > b:  
        return a  
    else:  
        return b  
  
  
print("比较结果:", max(4, 5))

六、Python3 类(class)

在 Python 中，类（class）是面向对象编程（OOP）的核心概念之一。类用于定义对象，包括对象的属性（数据成员）和方法（成员函数）。通过类，可以创建多个具有相同属性和行为的对象（实例）。

6.1 定义类

类的定义使用 class 关键字，通常包括以下部分：

类名：遵循驼峰命名法（CamelCase），首字母大写。
构造函数：init 方法，用于初始化对象的属性。
属性：类的变量，可以是实例变量或类变量。
方法：类中的函数，用于定义对象的行为。

6.2 示例

class Person:
    # 类变量
    species = "Homo sapiens"

    # 构造函数
    def __init__(self, name, age):
        # 实例变量
        self.name = name
        self.age = age

    # 实例方法
    def introduce(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

    # 类方法
    @classmethod
    def get_species(cls):
        return cls.species

    # 静态方法
    @staticmethod
    def is_adult(age):
        return age >= 18

# 创建对象（实例化）
person1 = Person("Alice", 30)
person2 = Person("Bob", 25)

# 调用实例方法
person1.introduce()  # 输出: Hello, my name is Alice and I am 30 years old.
person2.introduce()  # 输出: Hello, my name is Bob and I am 25 years old.

# 访问类变量
print(Person.species)  # 输出: Homo sapiens

# 调用类方法
print(Person.get_species())  # 输出: Homo sapiens

# 调用静态方法
print(Person.is_adult(20))  # 输出: True
print(Person.is_adult(15))  # 输出: False

类的组成部分详解

类变量：
- 类变量是所有实例共享的变量，定义在类的内部但不在任何方法中。
- 在上面的例子中，species 是一个类变量。
实例变量：
- 实例变量是每个实例独有的变量，定义在构造函数 init 中。
- 在上面的例子中，name 和 age 是实例变量。
构造函数 init：
- 构造函数用于初始化对象的属性。
- 第一个参数通常是 self，表示当前实例。
实例方法：
- 实例方法是作用于实例的方法，第一个参数通常是 self。
- 在上面的例子中，introduce 是一个实例方法。
类方法：
- 类方法是作用于类的方法，第一个参数通常是 cls，表示类本身。
- 使用 @classmethod 装饰器定义。
- 在上面的例子中，get_species 是一个类方法。
静态方法：
- 静态方法是与类和实例无关的方法，不接受 self 或 cls 参数。
- 使用 @staticmethod 装饰器定义。
- 在上面的例子中，is_adult 是一个静态方法。

6.3 继承

继承是面向对象编程中的一个重要概念，允许一个类继承另一个类的属性和方法。子类可以重写或扩展父类的功能。

class Student(Person):
    def __init__(self, name, age, student_id):
        super().__init__(name, age)  # 调用父类的构造函数
        self.student_id = student_id

    def study(self):
        print(f"{self.name} is studying.")

# 创建 Student 对象
student1 = Student("Charlie", 20, "S123456")
# 调用继承的方法
student1.introduce()  # 输出: Hello, my name is Charlie and I am 20 years old.
# 调用子类特有的方法
student1.study()  # 输出: Charlie is studying.