【Python学习】Python语言基础
目录
前言
Python是一种面向对象、解释型、跨平台的高级编程语言，具有语法简洁、可读性强、生态丰富的特点，广泛应用于数据分析、人工智能、Web开发、自动化测试等领域。本教程针对零基础学习者，从环境搭建开始，逐步讲解Python基础语法、核心知识点，搭配大量实例代码，帮助大家快速入门Python，打下扎实的基础。
学习建议：本教程每一个知识点都配有实例，建议大家边看边动手运行代码，理解代码的执行逻辑，多练习、多思考，才能真正掌握Python基础。
第一章：Python环境搭建
1.1 什么是Python环境
Python环境是运行Python代码的基础，主要包括Python解释器（负责解析和执行Python代码）、编辑器（用于编写代码）。常见的环境搭配有两种：
-
基础搭配：Python解释器 + 简单编辑器（如Notepad++、Sublime Text）
-
集成环境（推荐新手）：Anaconda（包含Python解释器、常用库、Spyder编辑器，一键安装，无需手动配置）
1.2 安装Python解释器（Windows系统）
-
下载安装包：访问Python官方网站（https://www.python.org/），点击“Downloads”，选择对应Windows系统的版本（推荐3.8及以上版本，兼容性更好）。
-
运行安装包：双击下载的.exe文件，勾选“Add Python 3.x to PATH”（关键步骤，避免后续配置环境变量），然后点击“Install Now”，等待安装完成。
-
验证安装：按下Win+R，输入“cmd”打开命令提示符，输入“python --version”，若显示Python版本号（如Python 3.10.0），则安装成功。
1.3 安装Anaconda（推荐新手）
-
下载安装包：访问Anaconda官方网站（https://www.anaconda.com/），点击“Download”，选择对应系统的版本（Windows/Mac/Linux）。
-
运行安装包：双击安装包，按照提示下一步操作，建议默认安装路径，勾选“Add Anaconda3 to my PATH environment variable”（可选，若未勾选，后续可手动配置）。
-
验证安装：安装完成后，打开“Anaconda Navigator”，若能正常启动，且Spyder、Jupyter Notebook等工具可正常打开，则安装成功。
1.4 选择编辑器
-
Spyder：Anaconda自带，界面简洁，适合新手，支持代码高亮、自动补全，可直接运行代码。
-
PyCharm：专业的Python编辑器，功能强大，适合大型项目开发，分为社区版（免费）和专业版（付费），新手可使用社区版。
-
Jupyter Notebook：基于浏览器的编辑器，适合数据分析、代码演示，可分段运行代码，方便查看结果。
第二章：Python基础语法入门
2.1 第一个Python程序
打开编辑器（以Spyder为例），新建一个.py文件（如hello.py），输入以下代码，点击运行按钮，即可看到输出结果。
# 第一个Python程序
print("Hello, Python!")代码解释：
-
# 后面的内容是注释，Python会忽略注释，用于说明代码功能，提高可读性。
-
print()是Python内置函数，用于输出括号内的内容，括号内可以是字符串、数字等。
运行结果：Hello, Python!
2.2 注释规则
注释是代码中不执行的内容，用于解释代码、标注思路，方便自己和他人阅读。Python中有两种注释方式：
-
单行注释：以#开头，后面的内容为注释，只能注释一行。
# 这是单行注释print("这是一个单行注释示例") # 注释也可以写在代码后面 -
多行注释：用三个单引号（'''）或三个双引号（"""）包裹，可注释多行内容。
'''这是多行注释可以注释多行内容适合详细说明代码功能'''"""这也是多行注释两种方式效果一致"""print("这是多行注释示例")
2.3 缩进规则（重点）
Python与其他编程语言（如Java、C++）不同，它不使用大括号（{}）划分代码块，而是通过缩进来区分代码层级，缩进错误会导致程序报错，这是新手最容易踩的坑。
缩进规则：
-
缩进一般使用4个空格（推荐）或1个制表符（Tab），但不能混合使用（如有的地方用空格，有的地方用Tab）。
-
同一层级的代码，缩进必须一致；不同层级的代码，缩进不同。
# 正确缩进示例
if 1 < 2:
print("1小于2") # 缩进4个空格，属于if语句的代码块
print("缩进一致") # 同一层级，缩进相同
print("不属于if语句，无缩进") # 与if同级，无缩进
# 错误缩进示例（会报错）
if 1 < 2:
print("正确缩进")
print("缩进不一致，报错") # 缩进不足4个空格，与上一行层级不同，报错2.4 变量与赋值
2.4.1 变量的定义
变量是用来存储数据的容器，就像一个盒子，我们可以把数据放进去，也可以随时取出、修改数据。Python中定义变量不需要声明数据类型，直接赋值即可。
# 变量赋值示例
name = "张三" # 变量name存储字符串"张三"
age = 18 # 变量age存储整数18
height = 1.75 # 变量height存储浮点数1.75
is_student = True # 变量is_student存储布尔值True
# 输出变量的值
print(name) # 输出：张三
print(age) # 输出：18
print(height) # 输出：1.75
print(is_student)# 输出：True2.4.2 变量命名规则
变量命名有严格的规则，不符合规则会导致程序报错，具体规则如下：
-
变量名只能由字母（a-z、A-Z）、数字（0-9）、下划线（_）组成，不能包含特殊符号（如@、#、$、空格等）。
-
变量名不能以数字开头（如123name是错误的，name123是正确的）。
-
变量名区分大小写（如Name和name是两个不同的变量）。
-
不能使用Python内置关键字（如if、for、while、print等）作为变量名。
推荐命名方式：使用小写字母，多个单词之间用下划线连接（如student_name、user_age），简洁明了，符合Python的编码规范。
2.4.3 变量的修改与删除
# 变量修改
name = "张三"
print(name) # 输出：张三
name = "李四" # 重新赋值，修改变量的值
print(name) # 输出：李四
# 变量删除（使用del关键字）
del name # 删除变量name
# print(name) # 报错：name 'name' is not defined，因为变量已被删除第三章：Python数据类型
Python中的数据类型分为基本数据类型和复合数据类型，基本数据类型是构成复杂数据的基础，常用的基本数据类型有：字符串（str）、整数（int）、浮点数（float）、布尔值（bool）；复合数据类型将在后续章节讲解。
3.1 整数（int）
整数是没有小数部分的数字，包括正整数、负整数和0，Python中整数的取值范围没有限制，可大可小。
# 整数示例
a = 10 # 正整数
b = -5 # 负整数
c = 0 # 0
d = 1000000000000000000000 # 超大整数，Python支持
# 查看数据类型（使用type()函数）
print(type(a)) # 输出：<class 'int'>，表示a是int类型3.2 浮点数（float）
浮点数是带有小数部分的数字，也可以表示科学计数法（如1.23e5表示123000）。
# 浮点数示例
a = 3.14 # 普通浮点数
b = -0.5 # 负浮点数
c = 1.23e5 # 科学计数法，等价于123000
d = 2.0 # 虽然小数部分是0，仍属于浮点数
print(type(a)) # 输出：<class 'float'>
# 注意：浮点数运算可能存在精度问题
print(0.1 + 0.2) # 输出：0.30000000000000004，而非0.3
# 解决方法：可使用round()函数保留指定小数位数
print(round(0.1 + 0.2, 1)) # 输出：0.3，保留1位小数3.3 字符串（str）
字符串是由单个或多个字符组成的序列，用于表示文本信息，字符串必须用单引号（'）、双引号（"）或三引号（'''/"""）包裹。
3.3.1 字符串的定义
# 字符串示例
s1 = 'Hello' # 单引号包裹
s2 = "Python" # 双引号包裹
s3 = '''I love Python''' # 三单引号包裹（可换行）
s4 = """Python is easy""" # 三双引号包裹（可换行）
print(type(s1)) # 输出：<class 'str'>
print(s3) # 输出：I love Python注意：单引号和双引号不能混合使用（如'str"是错误的）；若字符串中包含单引号，可使用双引号包裹，反之亦然。
# 字符串中包含单引号
s = "He said 'I am fine'"
print(s) # 输出：He said 'I am fine'
# 字符串中包含双引号
s = 'She said "I love you"'
print(s) # 输出：She said "I love you"3.3.2 字符串的常用操作
字符串是不可变的（即不能直接修改字符串中的某个字符），但可以通过一些方法对字符串进行操作，常用操作如下：
-
字符串拼接：使用+号将两个或多个字符串拼接在一起。
s1 = "Hello"s2 = "Python"s3 = s1 + ", " + s2 # 拼接字符串print(s3) # 输出：Hello, Python -
字符串重复：使用*号将字符串重复指定次数。
s = "Python"print(s * 3) # 输出：PythonPythonPython -
获取字符串长度：使用len()函数。
s = "Hello, Python"print(len(s)) # 输出：13（包含逗号和空格） -
字符串切片：通过索引获取字符串中的部分内容，语法：字符串[起始索引:结束索引:步长]（索引从0开始，结束索引不包含）。
s = "Python123"print(s[0]) # 输出：P（获取第0个字符）print(s[1:4]) # 输出：yth（获取索引1到3的字符，不包含4）print(s[::2]) # 输出：Pto13（步长为2，每隔一个字符取一次）print(s[::-1]) # 输出：321nohtyP（步长为-1，反转字符串） -
常用字符串方法：
s = "Hello, Python"print(s.lower()) # 输出：hello, python（全部转为小写）print(s.upper()) # 输出：HELLO, PYTHON（全部转为大写）print(s.strip()) # 输出：Hello, Python（去除字符串前后的空格，无空格则不变）print(s.split(","))# 输出：['Hello', ' Python']（按逗号分割字符串，返回列表）print(s.replace("Python", "World")) # 输出：Hello, World（替换字符串中的内容）
3.4 布尔值（bool）
布尔值只有两个取值：True（真）和False（假），主要用于判断条件（如if语句、循环语句），注意True和False的首字母必须大写，不能小写（如true、false是错误的）。
# 布尔值示例
a = True
b = False
print(type(a)) # 输出：<class 'bool'>
# 布尔值运算（后续章节详细讲解）
print(a and b) # 输出：False（逻辑与，两者都为真才为真）
print(a or b) # 输出：True（逻辑或，两者有一个为真就为真）
print(not a) # 输出：False（逻辑非，取反）
# 注意：Python中，0、空字符串、空列表等会被判断为False，非0、非空会被判断为True
print(bool(0)) # 输出：False
print(bool(1)) # 输出：True
print(bool("")) # 输出：False
print(bool("abc")) # 输出：True3.5 数据类型转换
在实际编程中，经常需要将一种数据类型转换为另一种数据类型，Python提供了内置的转换函数，常用转换函数如下：
# 1. 转为整数（int()）
a = "123" # 字符串类型
b = int(a) # 转为整数类型
print(b, type(b)) # 输出：123 <class 'int'>
# 注意：只有能表示整数的字符串才能转为int，否则报错
# print(int("123.45")) # 报错：invalid literal for int() with base 10: '123.45'
# 2. 转为浮点数（float()）
a = 123 # 整数类型
b = float(a) # 转为浮点数类型
print(b, type(b)) # 输出：123.0 <class 'float'>
c = "123.45"
d = float(c)
print(d, type(d)) # 输出：123.45 <class 'float'>
# 3. 转为字符串（str()）
a = 123
b = str(a)
print(b, type(b)) # 输出：123 <class 'str'>
c = True
d = str(c)
print(d, type(d)) # 输出：True <class 'str'>
# 4. 转为布尔值（bool()）
a = 0
b = bool(a)
print(b) # 输出：False
c = "abc"
d = bool(c)
print(d) # 输出：True第四章：Python运算符
运算符是用于对数据进行运算的符号，Python中的运算符主要分为：算术运算符、赋值运算符、比较运算符、逻辑运算符、成员运算符、身份运算符，下面逐一讲解。
4.1 算术运算符
算术运算符用于进行基本的数学运算（如加、减、乘、除），常用算术运算符如下表：
| 运算符 | 描述 | 示例 | 结果 |
|---|---|---|---|
| + | 加法 | a = 10, b = 5, a + b | 15 |
| - | 减法 | a = 10, b = 5, a - b | 5 |
| * | 乘法 | a = 10, b = 5, a * b | 50 |
| / | 除法（结果为浮点数） | a = 10, b = 5, a / b | 2.0 |
| // | 整除（取整数部分，舍去小数） | a = 10, b = 3, a // b | 3 |
| % | 取余（取除法后的余数） | a = 10, b = 3, a % b | 1 |
| ** | 幂运算（求a的b次方） | a = 2, b = 3, a ** b | 8 |
# 算术运算符示例
a = 10
b = 3
print(a + b) # 输出：13
print(a - b) # 输出：7
print(a * b) # 输出：30
print(a / b) # 输出：3.3333333333333335
print(a // b) # 输出：3
print(a % b) # 输出：1
print(a ** b) # 输出：10004.2 赋值运算符
赋值运算符用于将右侧的值赋给左侧的变量，常用赋值运算符如下，其中+=、-=等是简化写法，等价于先运算再赋值。
| 运算符 | 描述 | 示例 | 等价于 |
|---|---|---|---|
| = | 基本赋值 | a = 10 | - |
| += | 加后赋值 | a += 5 | a = a + 5 |
| -= | 减后赋值 | a -= 5 | a = a - 5 |
| * | 乘后赋值 | a *= 5 | a = a * 5 |
| /= | 除后赋值 | a /= 5 | a = a / 5 |
| //= | 整除后赋值 | a //= 5 | a = a // 5 |
| %= | 取余后赋值 | a %= 5 | a = a % 5 |
| **= | 幂运算后赋值 | a **= 5 | a = a ** 5 |
# 赋值运算符示例
a = 10
a += 5 # 等价于a = a + 5
print(a) # 输出：15
a -= 3 # 等价于a = a - 3
print(a) # 输出：12
a *= 2 # 等价于a = a * 2
print(a) # 输出：24
a //= 5 # 等价于a = a // 5
print(a) # 输出：44.3 比较运算符
比较运算符用于比较两个值的大小或是否相等，返回结果为布尔值（True或False），常用比较运算符如下：
| 运算符 | 描述 | 示例 | 结果 |
|---|---|---|---|
| == | 等于（判断两个值是否相等） | 10 == 5 | False |
| != | 不等于（判断两个值是否不相等） | 10 != 5 | True |
| > | 大于 | 10 > 5 | True |
| < | 小于 | 10 < 5 | False |
| >= | 大于等于 | 10 >= 10 | True |
| <= | 小于等于 | 10 <= 5 | False |
# 比较运算符示例
a = 10
b = 5
print(a == b) # 输出：False
print(a != b) # 输出：True
print(a > b) # 输出：True
print(a < b) # 输出：False
print(a >= 10) # 输出：True
print(b <= 4) # 输出：False4.4 逻辑运算符
逻辑运算符用于对布尔值进行逻辑运算，返回结果仍为布尔值，常用逻辑运算符有3个：and（逻辑与）、or（逻辑或）、not（逻辑非）。
| 运算符 | 描述 | 规则 | 示例 | 结果 |
|---|---|---|---|---|
| and | 逻辑与 | 两者都为True，结果才为True；否则为False | True and False | False |
| or | 逻辑或 | 两者有一个为True，结果就为True；都为False才为False | True or False | True |
| not | 逻辑非 | 取反，True变False，False变True | not True | False |
# 逻辑运算符示例
a = True
b = False
print(a and b) # 输出：False
print(a or b) # 输出：True
print(not a) # 输出：False
print(not b) # 输出：True
# 逻辑运算优先级：not > and > or
print(not a or b and a) # 等价于 (not a) or (b and a)，输出：False4.5 成员运算符
成员运算符用于判断一个元素是否在某个序列（如字符串、列表）中，返回结果为布尔值，常用成员运算符：in（在...中）、not in（不在...中）。
# 成员运算符示例（字符串）
s = "Python"
print("P" in s) # 输出：True（"P"在字符串s中）
print("p" in s) # 输出：False（区分大小写）
print("abc" not in s)# 输出：True（"abc"不在字符串s中）
# 成员运算符示例（列表，后续章节讲解列表）
lst = [1, 2, 3, 4]
print(2 in lst) # 输出：True
print(5 not in lst) # 输出：True4.6 身份运算符
身份运算符用于判断两个变量是否指向同一个对象（即内存地址是否相同），常用身份运算符：is（是）、is not（不是）。
注意：is与==的区别：==判断两个变量的值是否相等，is判断两个变量的内存地址是否相同。
# 身份运算符示例
a = 10
b = 10
print(a == b) # 输出：True（值相等）
print(a is b) # 输出：True（内存地址相同，小整数会被缓存）
c = [1, 2, 3]
d = [1, 2, 3]
print(c == d) # 输出：True（值相等）
print(c is d) # 输出：False（内存地址不同，列表是可变对象）
print(c is not d) # 输出：True第五章：Python流程控制
流程控制是指程序执行的顺序，Python中的流程控制主要分为三种：顺序结构、选择结构（if语句）、循环结构（for循环、while循环）。顺序结构是默认的执行顺序（从上到下依次执行），下面重点讲解选择结构和循环结构。
5.1 选择结构（if语句）
选择结构用于根据条件判断，执行不同的代码块，Python中的if语句有三种形式：if单分支、if-else双分支、if-elif-else多分支。
5.1.1 if单分支
语法：if 条件表达式: 缩进的代码块（条件为True时执行）
说明：条件表达式的结果为布尔值，若为True，执行缩进的代码块；若为False，跳过代码块，继续执行后续代码。
# if单分支示例
age = 18
if age >= 18:
print("你已成年，可以进入网吧。") # 条件为True，执行该代码
print("程序结束。") # 无论条件是否成立，都会执行该代码运行结果：你已成年，可以进入网吧。程序结束。
5.1.2 if-else双分支
语法：if 条件表达式: 缩进的代码块1（条件为True时执行） else: 缩进的代码块2（条件为False时执行）
说明：条件为True时执行代码块1，为False时执行代码块2，两者只能执行一个。
# if-else双分支示例
age = 16
if age >= 18:
print("你已成年，可以进入网吧。")
else:
print("你未成年，禁止进入网吧。")
print("程序结束。")运行结果：你未成年，禁止进入网吧。程序结束。
5.1.3 if-elif-else多分支
语法：if 条件表达式1: 缩进的代码块1（条件1为True时执行） elif 条件表达式2: 缩进的代码块2（条件2为True时执行） ... else: 缩进的代码块n（所有条件都为False时执行）
说明：elif可以有多个，依次判断条件，只要有一个条件为True，执行对应的代码块，后续条件不再判断；若所有条件都为False，执行else后的代码块。
# if-elif-else多分支示例（成绩分级）
score = 85
if score >= 90:
print("优秀")
elif score >= 80:
print("良好")
elif score >= 60:
print("及格")
else:
print("不及格")运行结果：良好
5.2 循环结构
循环结构用于重复执行某段代码，Python中常用的循环有两种：for循环和while循环。
5.2.1 for循环
for循环主要用于遍历序列（如字符串、列表、元组），执行次数由序列的长度决定，语法：for 变量 in 序列: 缩进的代码块（每次遍历执行一次）
# 遍历字符串
s = "Python"
for char in s:
print(char) # 依次输出字符串中的每个字符
# 遍历列表（后续章节讲解）
lst = [1, 2, 3, 4, 5]
sum = 0
for num in lst:
sum += num # 累加列表中的所有元素
print("列表元素的和：", sum) # 输出：15
# range()函数：生成一个整数序列，常用于for循环，语法：range(起始值, 结束值, 步长)（结束值不包含）
for i in range(5):
print(i) # 输出：0 1 2 3 4（默认起始值为0，步长为1）
for i in range(2, 10, 2):
print(i) # 输出：2 4 6 8（起始值2，结束值10，步长2）5.2.2 while循环
while循环用于根据条件重复执行代码块，只要条件为True，就会一直执行，语法：while 条件表达式: 缩进的代码块（条件为True时执行）
注意：使用while循环时，必须确保条件会在某个时刻变为False，否则会陷入无限循环（死循环）。
# while循环示例（计算1到10的和）
sum = 0
i = 1
while i <= 10:
sum += i
i += 1 # 关键：修改变量i的值，使条件最终变为False
print("1到10的和：", sum) # 输出：55
# 无限循环示例（谨慎运行）
# while True:
# print("无限循环") # 会一直输出，需手动停止程序5.2.3 循环控制语句（break、continue）
在循环中，可使用break和continue语句控制循环的执行流程：
-
break：终止整个循环，跳出循环体，不再执行后续循环。
# break示例for i in range(10):if i == 5:break # 当i=5时，终止循环print(i) # 输出：0 1 2 3 4 -
continue：跳过当前循环的剩余代码，直接进入下一次循环。
# continue示例for i in range(10):if i % 2 == 0:continue # 跳过偶数，直接进入下一次循环print(i) # 输出：1 3 5 7 9
5.2.4 循环嵌套
循环嵌套是指一个循环中包含另一个循环，外层循环执行一次，内层循环执行全部次数。
# 循环嵌套示例（打印99乘法表）
for i in range(1, 10): # 外层循环：控制行数（1到9）
for j in range(1, i+1): # 内层循环：控制每行的列数（1到当前行数）
print(f"{j}×{i}={i*j}", end="\t") # end="\t"表示用制表符分隔，不换行
print() # 每行结束后换行运行结果：
1×1=1
1×2=2 2×2=4
1×3=3 2×3=6 3×3=9
...（依次类推，直到9×9=81）
第六章：Python函数基础
6.1 函数的定义与作用
在Python中，函数是一段封装好的、可重复使用的代码块，用于实现特定的功能。前面我们已经接触过一些Python内置函数，比如print()（输出）、len()（获取长度）、type()（查看数据类型）等，而本章我们将学习如何自定义函数，满足个性化的功能需求。
6.1.1 函数的作用
-
代码复用：将常用的功能封装成函数，无需重复编写相同代码，提高开发效率。
-
代码简洁：将复杂功能拆分成多个函数，使代码结构更清晰，便于阅读和维护。
-
功能独立：每个函数实现一个特定功能，修改一个函数不会影响其他函数的正常运行（只要接口不变）。
6.1.2 函数的定义语法
Python中自定义函数的基本语法如下，严格遵循缩进规则（与条件、循环语句一致）：
def 函数名(参数列表):
"""函数文档字符串（可选，用于说明函数功能、参数、返回值等）"""
函数体（实现函数功能的代码块）
return 返回值（可选，用于返回函数执行结果）语法说明：
-
def：定义函数的关键字，必须放在函数名前面。
-
函数名：遵循变量命名规则（字母、数字、下划线组成，不能以数字开头，区分大小写，不使用内置关键字），建议简洁明了，体现函数功能（如add、calculate_area）。
-
参数列表：用于接收外部传入的数据，可无参数、单个参数或多个参数，参数之间用逗号分隔。
-
函数文档字符串：用三个单引号或三个双引号包裹，用于说明函数的功能、参数含义、返回值等，可通过help(函数名)查看，提高代码可读性。
-
函数体：实现函数核心功能的代码块，必须缩进（推荐4个空格），与def关键字对齐。
-
return：用于返回函数的执行结果，可选；若没有return，函数默认返回None（表示空值）。
6.1.3 简单函数实例
# 示例1：无参数、无返回值的函数（实现简单打印功能）
def print_welcome():
"""打印欢迎语"""
print("欢迎学习Python函数基础！")
# 调用函数（函数定义后，必须调用才能执行函数体）
print_welcome() # 输出：欢迎学习Python函数基础！
# 示例2：有参数、有返回值的函数（实现两个数的加法）
def add(a, b):
"""计算两个数的和
参数：
a: 第一个整数
b: 第二个整数
返回值：两个数的和
"""
result = a + b # 函数体：计算两个数的和
return result # 返回计算结果
# 调用函数，接收返回值
sum_result = add(3, 5)
print("3 + 5 =", sum_result) # 输出：3 + 5 = 8
# 直接调用函数并输出结果
print("10 + 20 =", add(10, 20)) # 输出：10 + 20 = 30
# 示例3：无参数、有返回值的函数（返回固定值）
def get_python_version():
"""返回当前Python推荐版本"""
return "Python 3.14.4" # 结合Python官方最新版本（参考官方网站）
print("推荐使用的Python版本：", get_python_version()) # 输出：推荐使用的Python版本：Python 3.14.46.2 函数的参数
函数的参数用于接收外部数据，根据传递方式的不同，可分为：位置参数、关键字参数、默认参数、可变参数。
6.2.1 位置参数
位置参数是最常用的参数类型，调用函数时，参数值的顺序必须与函数定义时的参数顺序一致，个数也必须相同。
# 定义一个计算长方形面积的函数（位置参数：长、宽）
def calculate_rect_area(length, width):
"""计算长方形面积
参数：
length: 长方形的长（位置参数）
width: 长方形的宽（位置参数）
返回值：长方形的面积
"""
area = length * width
return area
# 正确调用：按照参数顺序传入，数量一致
print("长方形面积：", calculate_rect_area(5, 3)) # 输出：长方形面积：15
# 错误调用1：参数数量不足（缺少width）
# print(calculate_rect_area(5)) # 报错：missing 1 required positional argument: 'width'
# 错误调用2：参数顺序错误（长和宽颠倒，结果错误但不报错）
print("顺序错误的面积：", calculate_rect_area(3, 5)) # 输出：顺序错误的面积：15（巧合正确，实际逻辑错误）6.2.2 关键字参数
关键字参数是调用函数时，通过“参数名=值”的方式传入，无需遵循参数顺序，可提高代码可读性，避免因参数顺序错误导致的问题。
# 沿用上面计算长方形面积的函数
def calculate_rect_area(length, width):
area = length * width
return area
# 关键字参数调用（无需遵循顺序）
print("长方形面积：", calculate_rect_area(length=5, width=3)) # 输出：15
print("长方形面积：", calculate_rect_area(width=3, length=5)) # 输出：15（顺序颠倒，结果正确）
# 混合调用：位置参数在前，关键字参数在后（必须遵循此规则）
print("混合调用面积：", calculate_rect_area(5, width=3)) # 输出：15
# 错误混合调用：关键字参数在前，位置参数在后
# print(calculate_rect_area(length=5, 3)) # 报错：positional argument follows keyword argument6.2.3 默认参数（可选参数）
默认参数是函数定义时，给参数指定一个默认值，调用函数时，若不传入该参数，则使用默认值；若传入，则使用传入的值。默认参数必须放在位置参数的后面，否则会报错。
# 定义一个计算圆形面积的函数（默认参数：圆周率pi=3.14）
def calculate_circle_area(radius, pi=3.14):
"""计算圆形面积
参数：
radius: 圆的半径（位置参数，必传）
pi: 圆周率（默认参数，默认值3.14，可选传）
返回值：圆形的面积
"""
area = pi * radius ** 2 # 用到前面学的幂运算符
return area
# 调用1：不传入默认参数，使用默认值3.14
print("圆形面积（默认pi）：", calculate_circle_area(5)) # 输出：78.5
# 调用2：传入默认参数，覆盖默认值
print("圆形面积（自定义pi）：", calculate_circle_area(5, pi=3.1415926)) # 输出：78.539815
# 错误定义：默认参数放在位置参数前面
# def calculate_circle_area(pi=3.14, radius): # 报错：non-default argument follows default argument6.2.4 不定长参数
当不确定需要传入多少个参数时，可使用不定长参数，Python中不定长参数主要有两种：*args 和 **kwargs。
-
*args：接收任意数量的位置参数，将其打包成一个元组（后续第七章讲解），参数名args可自定义，但约定俗成用args。
# 定义一个计算多个数之和的函数（不定长参数*args）def add_many(*args):"""计算任意多个数的和参数：*args: 任意数量的位置参数（打包成元组）返回值：所有数的和"""sum_result = 0for num in args: # 遍历元组中的每个元素sum_result += numreturn sum_result# 调用函数，传入不同数量的参数print("1+2 =", add_many(1, 2)) # 输出：1+2 = 3print("1+2+3+4 =", add_many(1, 2, 3, 4)) # 输出：1+2+3+4 = 10print("无参数求和：", add_many()) # 输出：无参数求和：0（args为空元组） -
**kwargs：接收任意数量的关键字参数，将其打包成一个字典（后续第七章讲解），参数名kwargs可自定义，约定俗成用kwargs。
# 定义一个打印用户信息的函数（不定长关键字参数**kwargs）def print_user_info(**kwargs):"""打印用户信息参数：**kwargs: 任意数量的关键字参数（打包成字典）"""for key, value in kwargs.items():print(f"{key}: {value}")# 调用函数，传入不同数量的关键字参数print_user_info(name="张三", age=18, height=1.75)# 输出：# name: 张三# age: 18# height: 1.75print_user_info(username="python123", password="123456")# 输出：# username: python123# password: 123456
注意：*args 和 **kwargs 可同时使用，且*args必须放在**kwargs前面。
# 同时使用*args和**kwargs
def mixed_args(*args, **kwargs):
print("位置参数打包：", args)
print("关键字参数打包：", kwargs)
mixed_args(1, 2, 3, name="张三", age=18)
# 输出：
# 位置参数打包： (1, 2, 3)
# 关键字参数打包： {'name': '张三', 'age': 18}6.3 函数的返回值
函数的返回值是函数执行完成后，向外部传递的结果，通过return语句实现，return语句有以下几个特点：
-
return语句可以返回任意类型的数据（整数、浮点数、字符串、布尔值等），也可以返回多个值（用逗号分隔，默认打包成元组）。
-
return语句执行后，函数会立即终止，后续的代码不会执行。
-
若函数中没有return语句，默认返回None（None是Python中的空值类型，可用于表示“无结果”）。
6.3.1 单个返回值
# 定义一个判断一个数是否为偶数的函数（返回布尔值）
def is_even(num):
"""判断一个数是否为偶数
参数：num: 待判断的整数
返回值：True（偶数）、False（奇数）
"""
if num % 2 == 0:
return True # 满足条件，返回True，函数终止
return False # 不满足条件，返回False
print(is_even(4)) # 输出：True
print(is_even(5)) # 输出：False6.3.2 多个返回值
# 定义一个函数，返回两个数的和与差
def add_and_subtract(a, b):
sum_ab = a + b
sub_ab = a - b
return sum_ab, sub_ab # 多个返回值，默认打包成元组
# 接收多个返回值（两种方式）
# 方式1：用一个变量接收（得到元组）
result = add_and_subtract(10, 3)
print("和与差：", result) # 输出：和与差： (13, 7)
print("和：", result[0], "差：", result[1]) # 输出：和： 13 差： 7
# 方式2：用多个变量接收（变量数量与返回值数量一致）
sum_ab, sub_ab = add_and_subtract(10, 3)
print("和：", sum_ab, "差：", sub_ab) # 输出：和： 13 差： 76.3.3 return与None
# 无return语句的函数，默认返回None
def print_hello():
print("Hello")
result = print_hello()
print("函数返回值：", result) # 输出：Hello 函数返回值： None
# 有return但无具体值，也返回None
def empty_return():
print("有return但无返回值")
return # 等价于return None
result = empty_return()
print("函数返回值：", result) # 输出：有return但无返回值 函数返回值： None6.4 函数的调用与嵌套
6.4.1 函数的调用
函数定义完成后，必须通过“函数名(参数列表)”的方式调用，才能执行函数体并获取返回值。函数调用的方式主要有以下几种：
-
直接调用：仅执行函数功能，不接收返回值（适合无返回值或无需使用返回值的函数）。
def print_welcome():print("欢迎！")print_welcome() # 直接调用，执行打印功能 -
赋值调用：将函数返回值赋值给变量，后续可使用该变量。
def add(a, b):return a + bsum_result = add(3, 5) # 赋值调用，接收返回值print(sum_result) # 使用返回值 -
嵌套调用：在一个函数的函数体中，调用另一个函数，实现更复杂的功能。
# 定义函数1：计算两个数的和def add(a, b):return a + b# 定义函数2：计算三个数的和（嵌套调用add函数）def add_three(a, b, c):# 先计算a和b的和，再加上creturn add(add(a, b), c)print(add_three(1, 2, 3)) # 输出：6（1+2=3，3+3=6）
6.4.2 函数的嵌套定义
除了嵌套调用，Python还支持在一个函数内部定义另一个函数（内部函数），内部函数只能在外部函数的函数体中使用，外部无法直接调用，这种方式可以实现功能的封装和隐藏。
# 外部函数：计算长方形的周长和面积
def rectangle_calc(length, width):
# 内部函数：计算周长
def calculate_perimeter():
return 2 * (length + width) # 可直接使用外部函数的参数
# 内部函数：计算面积
def calculate_area():
return length * width
# 外部函数返回内部函数的结果
perimeter = calculate_perimeter()
area = calculate_area()
return perimeter, area
# 调用外部函数，获取周长和面积
perimeter, area = rectangle_calc(5, 3)
print("长方形周长：", perimeter) # 输出：16
print("长方形面积：", area) # 输出：15
# 错误：外部无法直接调用内部函数
# calculate_perimeter() # 报错：name 'calculate_perimeter' is not defined6.5 函数的应用实例
结合前面所学的知识点（变量、运算符、条件语句、循环语句），编写几个实用的函数实例，帮助大家巩固函数的使用。
实例1：判断一个数是否为质数
def is_prime(num):
"""判断一个正整数是否为质数
质数：大于1的整数，除了1和它本身，不能被其他数整除
参数：num: 待判断的正整数
返回值：True（质数）、False（非质数）
"""
if num <= 1:
return False # 小于等于1的数不是质数
if num == 2:
return True # 2是最小的质数
# 判断2到num-1之间是否有能整除num的数
for i in range(2, num):
if num % i == 0:
return False # 能被整除，不是质数
return True # 不能被任何数整除，是质数
# 调用函数，测试结果
print(is_prime(7)) # 输出：True（质数）
print(is_prime(10)) # 输出：False（非质数）
print(is_prime(2)) # 输出：True（质数）
print(is_prime(1)) # 输出：False（非质数）实例2：计算斐波那契数列的第n项
斐波那契数列：1, 1, 2, 3, 5, 8, 13... 从第3项开始，每一项等于前两项之和。
def fibonacci(n):
"""计算斐波那契数列的第n项
参数：n: 正整数（第n项）
返回值：第n项的数值
"""
if n <= 0:
return "n必须是正整数" # 异常处理，返回提示信息
if n == 1 or n == 2:
return 1 # 前两项都是1
# 从第3项开始计算
a, b = 1, 1 # a表示第n-2项，b表示第n-1项
for i in range(3, n+1):
c = a + b # 第n项 = 第n-2项 + 第n-1项
a = b # 更新a为第n-1项
b = c # 更新b为第n项
return b
# 调用函数，测试结果
print("斐波那契数列第5项：", fibonacci(5)) # 输出：5
print("斐波那契数列第10项：", fibonacci(10)) # 输出：55
print("斐波那契数列第0项：", fibonacci(0)) # 输出：n必须是正整数实例3：封装函数，实现用户登录验证
def login(username, password):
"""用户登录验证
参数：
username: 用户名
password: 密码
返回值：登录成功（True）、登录失败（False）及提示信息
"""
# 模拟正确的用户名和密码（实际开发中会从数据库获取）
correct_username = "admin"
correct_password = "123456"
if username == correct_username and password == correct_password:
return True, "登录成功！欢迎您，管理员！"
elif username != correct_username:
return False, "登录失败：用户名错误！"
else:
return False, "登录失败：密码错误！"
# 调用函数，模拟登录
success, message = login("admin", "123456")
print(message) # 输出：登录成功！欢迎您，管理员！
success, message = login("user", "123456")
print(message) # 输出：登录失败：用户名错误！
success, message = login("admin", "654321")
print(message) # 输出：登录失败：密码错误！6.6 注意事项
-
函数名不能与Python内置函数重名（如不能定义名为print、len、type的函数），否则会覆盖内置函数，导致内置函数无法正常使用。
-
参数的顺序：位置参数在前，默认参数、不定长参数在后，*args在前，**kwargs在后。
-
函数体必须缩进，否则会报错，推荐使用4个空格缩进，与def关键字对齐。
-
return语句执行后，函数会立即终止，后续的代码不会执行，编写函数时需注意逻辑顺序。
-
内部函数只能在外部函数内部使用，外部无法直接调用，若需使用，可通过外部函数返回内部函数实现。
这里是“一人公司”的成长家园。我们提供从产品曝光、技术变现到法律财税的全栈内容，并连接云服务、办公空间等稀缺资源，助你专注创造，无忧运营。
更多推荐
20
0- 0
已为社区贡献14条内容
所有评论(0)