【2026】Python3入门基础教程一，附代码案例，快速入门。

Python 小路

772人浏览 · 2026-04-20 12:56:39

Python 小路 · 2026-04-20 12:56:39 发布

前言

Python的简介

Python是一种高级、解释型、通用的编程语言，以其简洁的语法和强大的可读性著称。它由Guido van Rossum于1991年首次发布，设计哲学强调代码的可读性和简洁性，尤其适合初学者入门编程。Python支持多种编程范式，包括面向对象、函数式和过程式编程。

Python的应用领域

Python广泛应用于多个领域：

Web开发：通过框架如Django、Flask快速构建后端服务。
数据分析与科学计算：借助NumPy、Pandas、Matplotlib等库处理数据。
人工智能与机器学习：TensorFlow、PyTorch等库的核心语言。
自动化脚本：简化重复性任务，提升工作效率。
嵌入式开发：通过MicroPython等实现硬件编程。

语法简单：接近自然语言，降低学习门槛。
丰富的库生态：开源社区提供了大量现成模块，避免重复造轮子。
跨平台兼容：支持Windows、macOS、Linux等操作系统。
高需求就业市场：Python开发者在数据科学、自动化等领域需求旺盛。

第一章：软件安装

一.Python解释器

电脑是没办法直接读懂我们编写的Python代码的，此刻需要一个解释器作为中间桥梁，把代码转换为字节码后再执行，Python的运行过程为翻译一行，执行一行。

二.代码编辑器

网盘地址有

三.软件安装

网盘地址有

四.软件地址(夸克网盘)

我用夸克网盘给你分享了「Python软件」，点击链接或复制整段内容，打开「夸克APP」即可获取。

链接：https://pan.quark.cn/s/39e18934a5ef
提取码：mG1i

安装步骤一并放到了文件夹里。

本文章代码编写基于Pycharm软件进行编写！！！

第二章：基础知识

1.第一个Python程序

创建一个Python程序的文件，文件（自行按照喜好命名）后缀名默认.py

输入以下代码，并右击空白处，选择Run运行，表示打印一个字符串"Hello World!"

print('Hello World')

2.注释

通过用自己熟悉的语言，在程序中对某些代码进行标注说明，这就是注释的作用，能够大大增强程序的可读性。

单行注释：

# 我是一个注释
print('Hello Word')  # 我是单行注释

多行注释：

"""
在三引号中的注释被称之为多行注释
在三引号中的注释被称之为多行注释
在三引号中的注释被称之为多行注释

"""

3.变量与常量

固定不变的量：就是常量

print(100)  # 这个100就是常量
print(3.1415)  # 3.1415也是一个常量

一个可以变化的量：就是变量

num1 = 10  # num1就是一个变量
num2 = 23  # num2也是一个变量
pi = 3.1  # pi也是一个变量

两个两句进行求和：

num1 = 10
num2 = 20
result = num1 + num2  # 将变量num1中的值 加上 num2中的值再给result变量
print(result) # 输出这个值

常量与变量的区别：

常量：就是一个值，至于这个值是整数100，还是小数3.14甚至是其它的类型都行

变量：就是一个可以存储数据的空间

4.数据类型

数字类型	`int`、`long`、`float`、`complex`
布尔类型	`True`、`False`
字符串类型	`str`
列表类型	`list`
元组类型	`tuple`
字典类型	`dict`
集合类型	`set`

如何判断数据类型：

print(type(100))  # 先用type检查100的类型，然后用print输出这个信息
print(type(3.6))
print(type("hello world"))



# 运行结果
<class 'int'>
<class 'float'>
<class 'str'>

5.关键字与标识符

关键字：一部分是Python解释器自己用了，用来实现某些特殊功能，像if。另外一部分是留给程序员自己用，像我们定义的名字name。

总结来说：Python中具有特殊含义的英文单词就是所谓的关键字

注意：关键字是Python已经在使用的特殊含义的单词，所以不允许程序员定义和关键字相同的名称的标识符。

False, None, True, and, as, assert, async, try, while, with, yield

# 等等还有很多 不一一列举



# 如何查看Python中的关键字
>>> import keyword
>>> keyword.kwlist

标识符：由字母、下划线和数字组成，并且数字不能开头。Python中的标识是区分大小写的！！

命名规则：1.见名知意 2.驼峰命名法 3.下划线命名法

Python中变量名、函数名都使用下划线命名法
Python中类名用大驼峰命名法
全局变量都是大写字母，且单词之间用下划线连接的方式，举例：GET_SUM

6.输出函数

输出变量：

print(变量名)  # 直接将已经定义的变量名放到()中即可

age = 20
print(age)

输出常量：

print(常量)  # 可以直接将常量放到()中
print(100)

输出表达式的结果：

print(表达式)  # 直接将表达式放到()中
print(10 + 20 + 30)  # 此时输出的是表达式计算的结果即600，而不是10+20+30

# 如果就是想要输出100+200+300而不是600，可以将它们用双引号包裹起来，表位字符串
print("10 + 20 + 30")

# 进阶用法
print(100, 200, 300)  # 此时会输出 100 200 300
print("hello", 200, "abc")  # 此时会输出 hello 200 abc
print(100 + 200 + 300, 500)  # 此时会输出 600 500

a = 100
b = 200
c = 300
print(a, b, c)  # 此时会输出100 200 300

格式化输出：

常用的格式化输出，看到了%这样的操作符，这就是Python中的格式化输出。

`%c`	字符
`%s`	字符串
`%d`	有符号十进制整数
`%u`	无符号十进制整数
`%o`	八进制整数
`%x`	十六进制整数（小写字母`0x`）
`%X`	十六进制整数（大写字母`0X`）
`%f`	浮点数
`%e`	科学计数法（小写`'e'`）
`%E`	科学计数法（大写`“E”`）
`%g`	`％f`和`％e`的简写
`%G`	`％f`和`％E`的简写

代码举例：

age = 10
print("我今年%d岁" % age)

age += 1
print("我今年%d岁" % age)

age += 1
print("我今年%d岁" % age)

...

综合举例：

age = 18
name = "张三"
email = "99888@qq.com"  # 这是我的真实的邮箱地址，可以联系哦
print("我的姓名是%s, 年龄是%d, 邮箱地址是%s" % (name, age, email))

什么是转义字符：通过下面代码演示

print("abcnABC");
print("abc\nABC");


# 输出结果为：
abcnABC
abc
ABC

\n表示换行以外，常用的还有\t表示一个tab键的间距。

print("abc\tABC")

# 输出结果：
abc    ABC

小练习：打印自己的名片

# 1 打印自己的名片
print("姓名: Tom")
print("年龄: 23岁")
print("体重: 66.2公斤")
print("手机号: 13460007000")
print("家庭住址: 河北省保定市")

7.输入函数

在Python中，获取键盘输入的数据的方法是采用input函数。

代码举例：

password = input("请输入密码:")
print('您刚刚输入的密码是:%s' % password)

input()的小括号中放入的是提示信息，用来在获取数据之前给用户的一个简单提示。
input()在从键盘获取了数据以后，会赋值给等号左边的变量中。
input()会把用户输入的任何值都作为字符串来对待。

获取多个数据：使用两个input语句

name = input("请输入用户名：")
pwd = input("请输入密码：")

print("您的用户名是：%s" % name)
print("您的密码是：%s" % pwd)

8.运算符

运算符，就是在Python编程语言中，能够实现操作的符号，像+能够实现加法，-能够实现减法。Python中的运算符有很多。

a =10 b = 20

运算符	描述	实例
`+`	加	两个对象相加 `a + b`，输出结果`30`
`-`	减	得到负数或是一个数减去另一个数`a - b`，输出结果`-10`
`*`	乘	两个数相乘或是返回一个被重复若干次的字符串 `a * b`，输出结果`200`
`/`	除	`b / a`，输出结果`2`
`//`	取整除	返回商的整数部分 `9//2`，输出结果`4` 。`9.0//2.0`，输出结果`4.0`
`%`	取余	返回除法的余数 `b % a`，输出结果`0`
`**`	指数	`2**3`为`2`的`3`次方，输出结果`8`

优先级顺序为： **高于*、/、%、//高于+、-，建议使用()来处理运算符优先级。

不同类型的数字在进行混合运算时，整数将会转换成浮点数进行运算。

>>> 10 + 3.3 * 2
16.6
>>> 10 + (3.3 * 2)
16.6

赋值运算符：

运算符	描述	实例
`=`	赋值运算符	把`=`号右边的结果赋给左边的变量，如`num = 2 + 2 * 3`，结果`num`的值为8

# 单个变量赋值
>>> num = 10

# 多个变量赋值
>>> num1, num2, f1, str1 = 100, 200, 3.14, "hello"
>>> num1
100
>>> num2
200
>>> f1
3.14
>>> str1
"hello"

复合赋值运算符：

运算符	描述	实例
`+=`	加法赋值运算符	`c += a`等效于`c = c + a`
`-=`	减法赋值运算符	`c -= a`等效于`c = c - a`
`*=`	乘法赋值运算符	`c = a`等效于`c = c a`
`/=`	除法赋值运算符	`c /= a`等效于`c = c / a`
`%=`	取模赋值运算符	`c %= a`等效于`c = c % a`
`**=`	幂赋值运算符	`c = a`等效于`c = c a`
`//=`	取整除赋值运算符	`c //= a`等效于 `c = c // a`

第三章：判断语句与循环语句

判断语句：通过if语句可以执行基于一定条件判断的代码块。结合elif和else子句，可以执行更复杂的分支逻辑。

if判断举例：

age = 18
if age < 18:
    print("未成年")
elif age == 18:
    print("刚好成年")
else:
    print("成年")

Python提供了两种循环语句：for循环和while循环。

for循环可以遍历任何序列的项目，如一个列表或者字符串。
while循环在条件为真时重复执行代码块。

for循环：

fruits = ["apple", "banana", "orange"]
for fruit in fruits:
    print(fruit)

while循环：

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

1.布尔类型

布尔类型只有两种结果：

True
False

Ture：表示真 ，通俗的说表示成立

False：表示假，通俗的说表示不成立

money = True
if money:
    print("你有钱...")
else:
    print("没有钱...")

# 输出
你有钱

2.比较运算符

在Python中，比较运算符可以判断两个值之间的关系，例如它们是否相等、一个是否大于另一个等等。使用比较运算符的结果通常是布尔值，即True或False。

比较运算符	描述	示例
`==`	检查两个操作数的值是否相等，如果是则条件变为真。	如`a=3,b=3`，则`a == b`为`True`
`!=`	检查两个操作数的值是否相等，如果值不相等，则条件变为真。	如`a=1,b=3`，则`a != b`为`True`
`>`	检查左操作数的值是否大于右操作数的值，如果是，则条件成立。	如`a=7,b=3`，则`a > b`为`True`
`<`	检查左操作数的值是否小于右操作数的值，如果是，则条件成立。	如`a=7,b=3`，则`a < b`为`False`
`>=`	检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。	如`a=3,b=3`，则`a >= b`为`True`
`<=`	检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。	如`a=3,b=3`，则`a <= b`为`True`

代码举例：

100 > 10  # 结果就是True
100 < 10  # 结果就是False

3.逻辑运算符

实现并且、或者、不，Python提供了逻辑运算符：

and实现并且的功能
or实现或者的功能
not实现不的功能

举例一：

# 实现的用户名与密码输入正确？

name = input("请输入用户名：")  # 获取用户名
password = input("请输入密码：")  # 获取密码


if name == "张三" and password == "123456":
    print("输入正确，登陆成功")
else:
    print("输入错误")

举例二：

# 年龄在18 - 60岁之间的男性或者年龄在18 - 50岁之间的女性
age = 20
gender = "男性"

print("符合要求吗？")
print((18 <= age <=50 and gender == "女性") or (18 <= age <= 60 and gender == "男性"))

and的特殊规则：代码示例

print(100 and 200)  # 输出什么呢？
print(100 and 100 > 50)  # 输出什么呢？
print(0 and 200)  # 输出什么呢？
print(0 and 100 > 50)  # 输出什么呢？


# 打印结果
200
True
0
0

●  print(100 and 200)：因为100不是0所以and左边为真，接下来执行右边，此时将200当做最后的结果 
●  print(100 and 100>50)：因为100不是0所以为真，执行右边100>50且将它的结果当做最后的结果，所以最后为True 
●  print(0 and 200)：因为and左侧为0所以为假，不会执行右边，且将左边的结果当做最后结果，所以最后为0
●  print(0 and 100>50)：原因与上述一样，结果为0

Python中也用：非0表示真，0表示假

or的特殊规则：

如果左边为真，那么就把左边的值当做最后的结果
如果左右为假，那么就把右边的值当做最后的结果

print(100 or 200)  # 输出什么呢？
print(100 or 100>50)  # 输出什么呢？
print(0 or 200)  # 输出什么呢？
print(0 or 100>50)  # 输出什么呢？



# 输出结果
100
100
200
True

汇总：

逻辑运算符	表达式	描述	实例
`and`	`x and y`	布尔与：如果 `x`为`False`，`x and y`返回`False`，否则它返回 `y`的值	`True and False`，返回`False`
`or`	`x or y`	布尔或：如果 `x`是`True`，它返回`True`否则它返回 `y`的值	`False or True`，返回`True`
`not`	`not x`	布尔非：如果 `x`为 `True`，返回 `False`。如果 `x`为 `False`，它返回 `True`	`not True`返回`False`, `not False`返回 `True`

4.判断语句 if

if使用格式：

if 要判断的条件:
    条件成立时，要做的事情

示例：

name = input("请输入用户名:")
password = input("请输入密码:")

if name == "张三" and password == "123456":
    print("登录成功...")

练习：从键盘获取自己的年龄，判断是否大于或者等于18岁，如果满足就输出：已成年

使用input从键盘中获取数据，并且存入到一个变量中
使用if语句，来判断 age >= 18是否成立

age = int(input("请输入你的年龄："))

if age >= 18:
    print("已成年")

5.判断语句 else

if-else使用格式：

if 条件:
    满足条件时要做的事情1
    满足条件时要做的事情2
    ......
else:
    不满足条件时要做的事情1
    不满足条件时要做的事情2
    ......

练习：从键盘输入身高，身高没有超过150cm，进动物园不用买票，否则需要买票。提示：需要用int()转换，例如int("100")结果就是整数100

height = int(input("请输入身高:"))  # 获取身高

if height <= 150:
    print("无需买票")
else:
    print("请先买票")

6.判断语句 elif

if-elif-else使用格式：

if 条件1:
    事情1
elif 条件2:
    事情2
elif 条件3:
    事情3
elif 条件n:
    事情n
else:
    以上条件都不满足时执行的代码

else不是必须的，如果所有条件满足时做的事情很明确，且没有全部都不满足的时候，此时就不用写
如果能考虑的条件都有对应的代码，但不能保证所有条件都考虑到了，此时建议写上else

代码示例：

score = 66  # 定义变量存储分数

if score >= 90 and score <= 100:  # 如果分数在90~100
    print('等级为A')
elif score >= 80 and score < 90:  # 如果分数在80~90
    print('等级为B')
elif score >= 70 and score < 80:  # 如果分数在70~80
    print('等级为C')
elif score >= 60 and score < 70:  # 如果分数在60~70
    print('等级为D')
elif score >= 0 and score < 60:  # 如果分数在60以下
    print('等级为E')
else:  # 如果分数不在0~100之间，就认为错误
    print("分数有误...")

7.嵌套判断

if嵌套的格式：

if 条件一:
    满足条件一时可以做的事情
    满足条件一时可以做的事情
    ...
    if 条件二:
        满足条件二时可以做的事情
        满足条件二时可以做的事情
        ...

案例演示：

ticket = True # 用True代表有车票，False代表没有车票
knife_lenght = 9  # 刀子的长度，单位为cm

if ticket == 1:
    print("有车票，可以进站")
    if knife_lenght < 10:
        print("通过安检")
    else:
        print("没有通过安检")
        print("刀子的长度超过规定...")
else:
    print("没有车票，不能进站")

8.循环语句 while

Python主要提供了两种类型的循环：for循环和while循环。
循环使用的场景：跟女朋友承认错误，说一万遍：我错了

print("我错了")
print("我错了")
print("我错了")
print("我错了")
...(还有9996遍)...

使用循环搞定：

i = 0
while i < 10000:
    print("我错了")
    i += 1

while循环的代码格式：

while 条件:
    条件满足时，做的事情1
    条件满足时，做的事情2
    条件满足时，做的事情3
    ...(省略)...

总结：

while和if的用法基本类似，区别在于：if条件成立，则执行一次；while条件成立，则重复执行，直到条件不成立为止。
一般情况下，需要多次重复执行的代码，都可以用循环的方式来完成。
循环不是必须要使用的，但为了提高代码的重复使用率，有经验的开发者都会采用循环。

小练习：

使用while循环计算1-100的累加和，包含1与100。

i = 1
sum = 0
while i <= 100:
    sum_ = sum + i
    i += 1

print("1~100的累积和为:%d" % sum)

使用while循环计算1-100的偶数的累加和，包含1与100。

i = 1
sum = 0
while i <= 100:
    if i % 2 == 0:
        sum = sum + i
    i += 1

print("1~100之间偶数和为:%d" % sumt)

9.嵌套循环 while

嵌套循环while代码格式：

while 条件1:
    条件1满足时做的事情1
    条件1满足时做的事情2
    条件1满足时做的事情3
    ...
    while 条件2:
        条件2满足时做的事情1
        条件2满足时做的事情2
        条件2满足时做的事情3
        ...

小练习：

打印九九乘法表：

i = 1
while i <= 9:
    j = 1
    while j <= i:
        print("%d*%d=%d " % (j, i, j*i), end = '')
        j += 1

    print("\n")
    i += 1

打印下面图形：

*
* *
* * *
* * * *
* * * * *

演示代码示例：

i = 1
while i <= 5:
    j = 1
    while j <= i:
        print("* ", end = '')
        j += 1

    print("\n")
    i += 1

注意：

while循环嵌套运行时的特点：每次外层循环执行1次，内层循环执行全部步骤
while循环嵌套可以无限次的嵌套，但一般情况下不超过3层while循环嵌套
当外层while条件不满足时表示整个while循环嵌套结束

10.循环语句 for

概念：for可以完成循环的功能。for循环可以遍历任何序列的项目，如一个列表或者一个字符串等。

for循环代码格式：

for 临时变量 in 列表或者字符串等可迭代对象:
    循环满足条件时执行的代码

for循环代码示例：

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



# 运行结果
0
1
2
3
4

range(x)
当range中只有一个数字时，for循环取到的数据是0....x-1

for循环代码示例：

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



# 运行结果
1
2
3
4

range(x, y)
当range中有两个数字时，此时for循环取到的数据是x....y-1

for i in range(1, 5, 2):
    print(i)

# 运行结果
1
3

range(x, y, z)
当range中有三个数字时，此时for循环能取到的数据是从x...y-1但是每次间隔的数据是z

for循环案例：

sum = 0  # 用来存储总和
for i in range(1, 101):
    sum += i

print("1~100的和为:%d" % sum)



# 运行结果
1~100的和为:5050

注意：for循环使用最多的场景是直接遍历可以迭代的对象。

11.break和continue

在循环的过程中，有时可能会因为某些条件的满足或者不满足需要结束整个while，还有可能在当次循环代码执行过程中剩下的不执行了而是进行一次的循环，这种时候就需要用两个功能：

结束整个循环
结束本次循环

两个关键字：

break，用来结束整个循环

while循环中使用break：

i = 0

while i<5:
    print("我是输出")
    i = i+1
    break
    print(i)

# 运行结果
我是输出

continue，用来结束本次循环

while循环中使用continue:

i = 0
while i < 3:
    i = i + 1
    print('----')
    continue
    print(i)



# 运行结果
----
----
----

for循环中使用break：

web = 'www.baidu.com'

for i in web:
    print(i)
    break


# 运行结果
w

for循环中使用continue：

web = 'www.baidu.com'

for i in web:
    print(i)
    if i == 'w':
        continue
    print("我是continue语句")


# 运行结果
w
w
w
.
我是continue语句
b
我是continue语句
a
我是continue语句
i
我是continue语句
d
我是continue语句
u
我是continue语句
.
我是continue语句
c
我是continue语句
o
我是continue语句
m
我是continue语句

总结：

break、continue只能用在循环中，除此以外不能单独使用
break、continue在嵌套循环中，只对最近的一层循环起作用
break能够立刻结束所在的循环
continue的用来结束本次循环，紧接着执行下一次的循环
无论break放到while循环体中的任何位置，只要被执行一次，那么整个循环立刻结束

12.循环语句 else

while...else...的使用格式：

while 条件:
    # 条件满足时执行的代码...
else:
    # 如果上述的while循环没有调用break，就执行的代码...

while循环体中没有执行break，那么while循环体中所有的代码执行完后，else中的代码也会执行。
while循环中有break那么表示整个while结束，else中的代码也不会被执行。

有break时代码示例：

i = 1
while i <= 3:
    print("这是一段测试代码...")
    if i == 1:
        print("调用了break")
        break
    i += 1
else:
    print("这是else中的代码")



# 运行结果
这是一段测试代码...
调用了break

没有break代码示例：

i = 1
while i <= 3:
    print("这是一段测试代码...")
    i += 1
else:
    print("这是else中的代码")


# 运行结果
这是一段测试代码...
这是一段测试代码...
这是一段测试代码...
这是else中的代码

for...else...的使用方式：

for 变量 in 可迭代对对象:
    # 代码体
else:
    # 另一代码体

使用break代码示例：

for i in range(5):
    print("i=%d" % i)
    if i == 1:
        print("break语句")
        break
else:
    print("else中的代码")



# 运行结果
i=0
i=1
我是break

没有break代码示例：

for i in range(5):
    print("i=%d" % i)
else:
    print("else中的代码")

注意：

在while...else...与for...else...中，break会让else中的代码不执行，而continue没有这个功能

第四章：容器类型

1.字符串

b = "www.baidu.com"



# 双引号或者单引号中的数据，就是字符串。

1.1 字符串切片

下标：就是标记空间的一个数字

从左侧开始编号，那么下标从 0 开始
右侧开始编号，那么下标从-1开始

word = "abcdef"

下标为正数：

第0个空间	第1个空间	第2个空间	第3个空间	第4个空间	第5个空间
`a`	`b`	`c`	`d`	`e`	`f`

下标为负数：

第 -6 个空间	第 -5 个空间	第 -4 个空间	第 -3 个空间	第 -2 个空间	第 -1 个空间
`a`	`b`	`c`	`d`	`e`	`f`

切片：是指对操作的对象截取其中一部分的操作，简单来说：一种能够从数据中取到一部分数据的方式。

代码示例1：

name = 'abcdef'
print(name[1:5:2])



#运行结果

bd

# 步长为2表示间隔1个值取一次

代码实例2：

name = 'abcdef'
print(name[5:1:-2])


# 运行结果

fd

'''
5: 起始位置
1: 结束位置 （不包含）
-2: 步长，表示从右往左取值并间隔一个值
'''

注意：

从起始位开始，到结束位的前一位结束（不包含结束位本身)，步长表示选取间隔
默认步长为1，即取完一个下标的数据之后，第二个下标的是在刚刚下标基础上+1
步长为正数，表示从左向右取数据
步长为负数，表示从右向左取数据

1.2 字符串的内置方法

find方法：str是否包含在 my_str中，如果是返回开始的索引值，否则返回-1

my_str = "welcome to www.baidu.com"

result = my_str.find("to")
print(result)


# 运行结果
8

replace方法：

my_str = "welcome to www.baidu.com"

result = my_str.replace('w', 'W', 1)

print(result)
# 运行结果

'Welcome to www.tulingxueyuan.com'

strip方法：删除字符串两端的空白字符

my_str = "   welcome to www.baidu.com   "

result = my_str.strip()
print(result)

# 运行结果
'welcome to www.baidu.com'

内置方法还有许多，不需要死记硬背，不会的及时查资料即可，理解为主。。。

2.列表

列表：是一种有序的数据集合，用于存储多个元素。

定义列表的方式是 []

代码示例：

names = ['张三', '李四', '王五']

num = [100, 99, 100, 92, 91]

列表中的数据可以使用下标进行定位，然后就可以使用这个数据

stu_names = ['张三', '李四', '王五']

print(stu_names[0])  # 此时只输出张三

stu_names[0] = "赵六"

print(stu_names[0])  # 此时只输出赵六

列表切片：

列表也是支持切片操作的。

names = ['张三', '李四', '王五']
names[1:3]  



# 运行结果
# 此时得到一个新列表 [李四', '王五']

列表逆序：

names = ['张三', '李四', '王五']
new_names = names[::-1]  # 得到一个新列表['王五', '李四', '张三']
print(id(names) == id(new_names))

for循环列表遍历：

stu_names = ['张三', '李四', '王五']
for name in stu_names:
    print(name)



# 运行结果
张三
李四
王五

while循环遍历列表：

names = ['张三', '李四', '王五']
length = len(names)
i = 0
while i < length:
    print(names[i])
    i += 1


# 运行结果
张三
李四
王五

2.1 列表的内置方法

数据增加（append、extend、insert）

列表.append(新元素数据)

append方法代码示例：

# 定义列表存储3个姓名
names = ['张三','李四','王五']

for name in names:
    print(name)

# 添加学生
temp = input('请输入要添加的学生姓名:')
names.append(temp)

for name in names:
    print(name)

extend方法是将另一个列表中的元素逐一添加到列表中

a = [1, 2]
b = [3, 4]
a.append(b)
print(a)


# 运行结果

[1, 2, [3, 4]]
a.extend(b)
print(a)


#运行结果 

[1, 2, [3, 4], 3, 4]

insert(index, object)：在指定位置前添加元素

a = [0, 1, 2]
a.insert(1, 3)
print(a)


# 运行结果
[0, 3, 1, 2]

数据修改：通过下标确定需要修改哪个元素

列表[下标] = 新数据

# 定义列表存储3个姓名
names = ['张三', '李四', '王五']

for name in names:
    print(name)

# 修改元素
names[1] = '赵六'

for name in stu_names:
    print(name)

数据查询（in、not in、count）

直接上代码示例：


names = ['张三','李四','王五']

# 获取要查找的名字
find_name = input('请输入要查找的姓名:')

# 查找是否存在
if find_name in names:
    print('找到了')
else:
    print('没有找到')

count查询元素个数：


列表.count("要查询的数据")

nums = [1, 2, 3, 4, 5, 1, 2, 3]

nums.count(1)  # 查找的数据1 一共有2个，所以结果为2


nums.count(9)  # 没有找到数据9 所以结果为0

数据删除（del、pop、remove）

del：根据下标进行删除

movie_names = ['加勒比海盗', '骇客帝国', '第一滴血', '指环王', '霍比特人', '速度与激情']

print('------删除之前------')
for name in movie_names:
    print(name)

del movie_names[2]  # 这里根据下标进行删除

print('------删除之后------')
for name in movie_names:
    print(name)

pop：删除最后一个元素

movie_names = ['加勒比海盗', '骇客帝国', '第一滴血', '指环王', '霍比特人', '速度与激情']

print('------删除之前------')
for name in movie_names:
    print(name)

movie_names.pop()  # 删除最后1个

print('------删除之后------')
for name in movie_names:
    print(name)

remove：根据元素的值进行删除

movie_names = ['加勒比海盗', '骇客帝国', '第一滴血', '指环王', '霍比特人', '速度与激情']

print('------删除之前------')
for name in movie_names:
    print(name)

movie_names.remove('指环王')  # 删除指定的数据

print('------删除之后------')
for name in movie_names:
    print(name)

数据排序（sort、reverse）

sort方法是将列表按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。

>>> a = [1, 4, 2, 3]
>>> a.sort()
>>> a
[1, 2, 3, 4]
>>> a.sort(reverse=True)
>>> a
[4, 3, 2, 1]

reverse方法是将列表倒序

>>> a = [1, 4, 2, 3]
>>> a
[1, 4, 2, 3]
>>> a.reverse()
>>> a
[3, 2, 4, 1]

3.元组

元组使用小括号()

# 定义一个元组
nums = (10, 20, 30)

# 获取元组中的元素
print(nums[0])

# 遍历
for temp in nums:
    print(temp)

不能修改元组中的元素指的是如果当前元组中的元素为不可变对象则不能修改，如果是可变对象在不修改元素类型的情况下可以修改可变对象中的值。

不可变对象：tuple、string、int、float、bool

可变对象：list、dict、set

4.集合

集合是一种能够存储多个数据的方式，数据不能重复。

列表可以存储多个数据，支持增删改查
元组可以存储多个数据，不能修改
集合依然可以存储多个数据，数据不能重复

# 定义一个集合
nums = {10, 20, 30}

print(type(nums))

# 遍历
for temp in nums:
    print(temp)

# 运行结果
<class 'set'>
10
20
30

集合可以去重，但是顺序不确定了，是无序的了。代码示例：

# 定义一个集合
nums = {100, 200, 200, 300, 300, 300}


print(type(nums))

# 遍历
for temp in nums:
    print(temp)


# 运行结果
<class 'set'>
200
100
300

内置的方法：

方法	描述
`add()`	为集合添加元素
`clear()`	移除集合中的所有元素
`copy()`	拷贝一个集合
`difference()`	返回多个集合的差集
`difference_update()`	移除集合中的元素，该元素在指定的集合也存在。
`discard()`	删除集合中指定的元素
`intersection()`	返回集合的交集
`intersection_update()`	返回集合的交集。
`isdisjoint()`	判断两个集合是否包含相同的元素，如果没有返回`True`，否则返回`False`。
`issubset()`	判断指定集合是否为该方法参数集合的子集。
`issuperset()`	判断该方法的参数集合是否为指定集合的子集
`pop()`	随机移除元素
`remove()`	移除指定元素
`symmetric_difference()`	返回两个集合中不重复的元素集合。
`symmetric_difference_update()`	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
`union()`	返回两个集合的并集
`update()`	给集合添加元素

5.字典

字典的定义格式：


{key: value, key2: value ...}

定义一个字典，存储学生信息：

info = {
    'name': '张三', 
    'age': 18, 
    'home': '河北省保定市'
}

字典的每个元素由2部分组成，键:值
字典能够存储多个数据
列表中找某个元素时，是根据下标进行的，字典中找某个元素时，是根据key（就是冒号:前面的那个值，例如上面代码中的name、home、age）

遍历字典（keys、values、items）

keys()方法

info = {
    'name': '张三', 
    'age': 18, 
    'home': '河北省保定市'
}


for key in info.keys():
    print(key)

# 运行结果
name
age
home

values()方法

info = {
    'name': '张三', 
    'age': 18, 
    'home': '河北省保定市'
}


for v in info.values():
    print(v)


# 运行结果
张三
18
河北省保定市

items()方法

info = {
    'name': '张三',
    'age': 18,
    'home': '河北省保定市'
}


for item in info.items():
    print(item)

#运行结果
('name', '张三')
('age', 18)
('home', '河北省保定市')

6.字典操作

数据查询：

info = {
    'name': '张三',
    'age': 18,
    'home': '河北省保定市'
}

print(info['score'])

# 运行结果
会报错

数据查询 - get方式：程序不会因为key的不存在而崩溃

info = {
    'name': '张三',
    'age': 18,
    'home': '河北省保定市'
}


print(info.get('score', '当前字典不存在score这个key'))

# 运行结果
当前字典不存在score这个key

数据修改：

info = {'name': '班长', 'id': 1, 'sex': '男'}

new_id = int(input('请输入新的学号:'))
info['id'] = new_id

print('修改之后的id为: %d' % info['id'])

数据增加：

info = {'name': '班长', 'id': 1, 'sex': '男'}

print(info)

info['web_address'] = "www.baidu.com"  # 添加一个新的键值对

print(info)


# 运行结果
{'name': '班长', 'id': 1, 'sex': '男'}
{'name': '班长', 'id': 1, 'sex': '男', 'web_address': 'www.baidu.com'}

数据删除：del clear()

del删除指定的元素：

info = {
    'name': '张三',
    'age': 18,
    'home': '河北省保定市'
}
print(info)

def info['home']

print(info)


# 运行结果
{'name': '张三', 'age': 18, 'home': '河北省保定市'}
{'name': '张三', 'age': 18}

del删除整个字典：

info = {
    'name': '张三',
    'age': 18,
    'home': '河北省保定市'
}
print(info)

def info

print(info)

# 运行结果
{'name': '张三', 'age': 18, 'home': '河北省保定市'}
Traceback (most recent call last):
  File "D:\测试代码\1 测试代码.py", line 9, in <module>
    print(info)
          ^^^^
NameError: name 'info' is not defined

clear()清空整个字典元素：

info = {
    'name': '张三',
    'age': 18,
    'home': '河北省保定市'
}
print(info)

info.clear()

print(info)

# 运行结果
{'name': '张三', 'age': 18, 'home': '河北省保定市'}
{}

7.推导式

推导式：就是一种能够快速生成数据的方式。

代码示例：想要快速生成由1~100内所有偶数数组成的列表

[x for x in range(1, 101) if x % 2 == 0]

列表推导式：一种可以快速生成列表的方式。

a = [x for x in range(4)]


[0, 1, 2, 3]


a = [x for x in range(3, 19, 2)]



[3, 5, 7, 9, 11, 13, 15, 17]

集合推导式：一种快速生成集合的方式。

a = {x for x in range(1, 21) if x % 2 == 0}



{2, 4, 6, 8, 10, 12, 14, 16, 18, 20}

字典推导式：一种快速生成字典的方式。

{x: x ** 2 for x in range(1, 11)}


{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81, 10: 100}

8.拆包

拆包：是一种快速提取数据的方式。

num1, num2, num3, num4 = (11, 22, 33, 44)

列表拆包：

a, b = [12, 21]
print(a)
print(b)

# 运行结果
12
21

元组拆包：

a, b = （12, 21)
print(a)
print(b)

# 运行结果
12
21

集合拆包：

a, b = {12, 21}
print(a)
print(b)

# 运行结果
12
21

字典拆包：

info = {"name": "张三", "age": 18}

for k, v in info.items():
    print(f'输出：{k},{v}')


# 运行结果
输出：name,张三
输出：age,18

10.深拷贝和浅拷贝

深拷贝：拷贝一个对象时，只要发现对象有可变类型就会对该对象到最后一个可变类型的每一层对象就行拷贝，对每一层拷贝的对象都会开辟新的内存空间进行存储。深拷贝需要使用copy模块下的copy()函数举例: b = copy.deepcopy(a)

import copy

list1 = [["张三", "李四"], "王五", "赵六", "钱七"]
list2 = copy.deepcopy(list1)   # 进行深拷贝

# 打印 list1 和 list2 两个列表的内存地址 => 结果不一样
print(id(list1))    
print(id(list2))   

# 打印 list1 和 list2 两个列表中的子列表的内存地址 => 结果不一样
print(id(list1[0]))   
print(id(list2[0]))   


list2[0][0] = "小明"

# 结果 list2 列表修改了，但是不影响list1列表数据
print(list2)    # [['小明', '李四'], '王五', '赵六', '钱七']
print(list1)    # [['张三', '李四'], '王五', '赵六', '钱七']

浅拷贝只对可变类型的第一层对象进行拷贝，对拷贝的对象开辟新的内存空间进行存储，且不会拷贝对象内部的子对象。浅拷贝需要使用copy模块下的copy()函数，举例: b = copy.copy(a)

list1 = [["张三", "李四"], "王五", "赵六", "钱七"]
list2 = list1.copy()   # 进行浅拷贝

# 打印 list1 和 list2 两个列表的内存地址 => 结果不一样
print(id(list1))    
print(id(list2))    

print('------------------------')

# 打印 list1 和 list2 两个列表中的子列表的内存地址 => 结果一样
print(id(list1[0]))    
print(id(list2[0]))    


list2[0][0] = "小明"

# 结果list2列表修改了，list1列表数据也修改了
print(list2)   
print(list1)

第五章：函数基础

函数:是一个被命名的、独立的、完成特定功能的代码段，其可能给调用它的程序一个返回值通俗的说函数就是把一段可以实现某种功能的代码封装起来, 想要使用这个功能就可以直接调用函数。

1.介绍函数

在Python中，大部分函数都是有名函数完成特定功能的代码段：函数的功能要专一，专门为了完成某个功能而定义返回值：当函数执行完毕后，其可能会返回一个值给函数的调用处.

函数的主要作用： ① 模块化编程 ② 代码重用

函数代码示例：

# 定义一个函数，能够完成打印信息的功能
def print_info():
    print('------------------------------------')
    print('         人生苦短，我用Python         ')
    print('------------------------------------')

2.自定义函数

两部分知识：

定义函数（怎样制作函数）

调用函数（怎样使用函数）

定义函数的格式如下：

def 函数名(形参):
   函数体

函数名：一定有，按照命名规则起个名字，注意Python中建议使用小写加下划线的方式，例如print_info.....
函数体：一定有，就是整个函数真正要执行的代码，注意函数体前面缩进四个空格。
形参：可有可无，专门用过来存储调用时传递给函数的数据用的。

打印菜单小练习：

def print_menu():
    print("-----------------------")
    print("        欢迎光临        ")
    print("套餐1")
    print("套餐2")
    print("套餐3")
    print("套餐4")
    print("-----------------------")

调用函数格式如下：

函数名(实参)

函数名：一定有，想要调用的函数的名字
实参：可有可无，调用函数时给它传递的数据

演示示例：

def print_menu():
    print("-----------------------")
    print("        欢迎光临        ")
    print("套餐1")
    print("套餐2")
    print("套餐3")
    print("套餐4")
    print("-----------------------")


print_menu()

pass关键字：如果不确定函数体的代码，可以用pass占用位置，这样没有语法错误，也能够不报错，让开发人员知道这个函数功能没有实现，可以在后面进行编写。

def 函数名():
    pass

一个函数可以进行多次调用，每次调用函数时，函数都会从头开始执行，当这个函数中的代码执行完毕后，意味着调用结束了。

def test():
    num = 100
    num += 1
    print("在test函数中num=%d" % num)


test()
test()

# 运行结果
在test函数中num=101
在test函数中num=101

3.内置函数

常见内置函数如下：

len:

>>> len("hello world")
11
>>> len([1, 2, 3, 4])
4
>>> len((3,4))
2
>>> len({"a":1, "b":2})
2

time:

import time  # 引入time模块


currentTime = time.time()
print("当前时间戳为:", currentTime)

random:

import random

a = random.uniform(1, 5)
print("a：", a)

b = random.randint(10, 50)
print("b：", b)

c = random.randrange(0, 50, 2)
print("c：", c)



# 每次运行结果都可能不一样

还有许多内置函数，就不一一列举了

4.函数的说明文档

说明文档：顾名思义就是一个对函数说明的信息文档。

def 函数名():
    """
    三双引号进行包裹，说明文档，用来对函数的功能，使用方式等进行说明
    以便开发人员能够快速的了解此函数的功能
    """
    pass

说明文档方便同事，领导快速观看。

5.函数的参数

定义函数时()中定义变量，变量的个数根据需要的个数来确定，这些变量的目的是用来存储传递过来的数据。我们把这些变量称之为形参
调用函数时()中写入要传递的数据，可以是常量、表达式、变量等，这些就是要真实传递的数据。我们把这些数据称之为实参

代码示例：

def text(num1, num2):  # 形参：调用函数时用来存储数据的变量
    print("传递过来的第1个数是:%d" % num1)
    print("传递过来的第2个数是:%d" % num2)
    print("它们的和是:%d" % (num1 + num2))


text(10, 20)  # 实参：在调用函数时传入具体的值


# 运行结果
传递过来的第1个数是:10
传递过来的第2个数是:20
它们的和是:30

小练习：定义一个函数，有三个形参，函数体中要实现的功能为：第1个形参 + 第2个形参 - 第3个形参，将结果输出。

def text(num1, num2, num3):
    print(num1 + num2 - num3)


text(10, 20, 30)

6.函数的返回值

定义函数时，需要使用return将结果返回
调用函数时，需要存储这个返回值

使用return示例：

def add_nums(a, b):
    c = a + b
    return c  # 此时就相当于把变量c的结果返回

return实际上有两个作用：

返回数据给调用方
结束函数的执行

def text(num1, num2, num3):
    print("text--1")
    return 100
    print("text--2")
    print(num1 + num2 - num3)


ret = text(10, 20, 30)
print(ret)


# 运行结果
text--1
100

7.自定义函数的类型

无参数无返回值函数：

def print_menu():
    print('--------------------------')
    print('菜单')
    print('1.京酱肉丝')
    print('2.辣椒炒肉')
    print('3.红烧肉')
    print('--------------------------')

无参数有返回值函数：

# 获取度数
def get_temp():

    return 24


temperature = get_temp()
print('当前的温度为:%d' % temperature)

有参数无返回值函数：

def old_age(new_age):
    age = new_age


old_age(18)

有参数有返回值函数：

# 计算1~num的累积和
def add_nums(num):
    sum_result = 0
    for x in range(1, num + 1):
        sum_result += x
    return sum_result


result = add_nums(100)
print('1~100的累积和为:%d' % result)

总结：

根据函数有没有参数，有没有返回值可以相互组合。
定义函数时，是根据实际的功能需求来设计的，所以不同程序员编写的函数类型各不相同

8.函数之间的隔离

Python 中函数之间的隔离主要通过作用域规则和命名空间实现，确保不同函数的变量和逻辑互不干扰。

def func1():
    x = 10  # 局部变量
    print(x)

def func2():
    x = 20  # 不同函数的同名变量隔离
    print(x)

func1()  # 输出 10
func2()  # 输出 20

global 和 nonlocal 关键字：

x = 30  # 全局变量

def func3():
    global x
    x = 40  # 修改全局变量

func3()
print(x)  # 输出 40

嵌套函数中使用 nonlocal：

def outer():
    y = 50
    def inner():
        nonlocal y
        y = 60  # 修改闭包变量
    inner()
    print(y)  # 输出 60

9.函数的嵌套

函数嵌套能够让函数之间互相使用，增加代码复用性。

# 打印一条横线
def print_1_line():
    print("-" * 30)


# 打印多条横线
def print_num_line(num):
    i = 0

    # 因为print_1_line函数已经完成了打印横线的功能，
    # 只需要多次调用此函数即可
    while i < num:
        print_1_line()
        i += 1

# 调用函数
print_num_line(3)

嵌套函数的优势

封装性：隐藏内部实现细节，仅暴露必要接口。
作用域隔离：内层函数可访问外层变量，但外部无法访问内层变量。
逻辑分层：将复杂任务拆解为多个小函数，提升可读性。

10.变量的作用域

局部变量
定义在函数或代码块内部，仅在该范围内有效，生命周期随函数结束而销毁。

def calculate():
    x = 10  # 局部变量
    print(x)  # 输出10

calculate()
print(x)  # 报错：NameError，x未定义

全局变量
定义在模块或脚本顶层，整个程序可见，生命周期持续到程序结束。

y = 20  # 全局变量

def show():
    print(y)  # 输出20

show()
print(y)  # 输出20

在函数外边定义的变量叫做全局变量
全局变量能够在所有的函数中进行访问
当函数内出现局部变量和全局变量相同名字时，函数内部中的变量名 = 数据此时理解为定义了一个局部变量，而不是修改全局变量的值
如果在函数中出现global 全局变量的名字 那么这个函数中即使出现和全局变量名相同的变量名 = 数据也理解为对全局变量进行修改，而不是定义局部变量
如果在一个函数中需要对多个全局变量进行修改，并且全局变量的类型为不可变，则可以使用global 变量1, 变量2

11.案例—学生管理系统

# 定义索引常量
ID = 0
NAME = 1
PHONE = 2


students = [
        ["1001","小明",12320],
        ["1002","小王",22130],
        ["1003","小红",21230],
        ["1004","小李",21230],
        ["1005","小明",21230]
    ]


print("""
************************
欢迎来到学生管理系统：
1. 添加学生
2. 删除学生
3. 修改学生信息
4. 根据学生姓名查询学生信息
5. 查询所有的学生信息
6. 退出系统
************************
""")

while True:
    choice = input("请输入你的选项（1-6）：")

    if choice == "1":
        print("添加学生")

        # 获取用户输入的学生信息
        id = input("请输入学号：")
        name = input("请输入姓名：")
        phone = input("请输入手机号：")

        # 循环遍历判断学号是否存在
        for student in students:
            if student[ID] == id:
                print("学号已存在")
                break
        else:
            # 学号不存在
            students.append([id,name,phone])
            print("添加成功")
            print(students)


    elif choice == "2":
        print("删除学生")

        # 获取用户输入的学号
        id = input("请输入要删除的学生学号：")

        # 循环找到匹配学号的学生的索引位置
        for i in range(len(students)):
            # 匹配成功
            if students[i][ID] == id:
                # 根据索引删除
                del students[i]
                print("删除成功")
                print(students)
                break
        else:
            # 没有找到该学号的学生
            print("未找到该学生")

    elif choice == "3":
        print("修改学生")

        # 获取用户输入的学号
        id = input("请输入要修改的学生学号：")

        # 循环学生信息找到匹配的信息
        for i in range(len(students)):
            if students[i][ID] == id:
                # 匹配到要修改的学生信息
                new_name = input(f"当前姓名：{students[i][NAME]}，请输入修改后的姓名：")
                new_phone = input(f"当前手机号：{students[i][PHONE]}，请输入修改后的手机号：")

                # 重新赋值
                students[i][NAME] = new_name
                students[i][PHONE] = new_phone

                print("修改成功")
                print(students)
                break
        else:
            # 没有找到该学号的学生
            print("未找到该学生")


    elif choice == "4":
        print("根据姓名查询学生")

        # 获取用户输入的姓名
        name = input("请输入要查询的姓名：")

        # 定义新列表，存储查询结果
        result = []

        for student in students:
            if student[NAME] == name:
                result.append(student)
                # print(f"学号：{student[ID]}，姓名：{student[NAME]}，手机号：{student[PHONE]}")
                # continue

       # 判断查询结果列表是否为空
        if len(result) == 0:
            print("未找到该学生")
        else:
            for student in result:
                print(f"学号：{student[ID]}，姓名：{student[NAME]}，手机号：{student[PHONE]}")


    elif choice == "5":
        print("查询所有学生")

        for student in students:
            print(f"学号：{student[ID]}，姓名：{student[NAME]}，手机号：{student[PHONE]}")
    elif choice == "6":
        print("退出系统")
        break
    else:
        print("输入有误")

第六章：进阶函数

1.函数的参数

缺省参数也叫做默认参数，是指定义函数时形参变量有默认值，如果调用函数时没有传递参数，那么函数就用默认值，如果传递了参数就用传递的那个数据。

当调用函数时，有些参数不必传递，而是用默认值，这样的场景往往都用缺省参数。

代码示例：

def print_info(name, age=35):
    print(f'name: {name}')
    print(f'age: {age}')

print_info('张三')
print_info('张三', 18)

# 运行结果
name: 张三
age: 35
name: 张三
age: 18

总结：

缺省参数只能在形参的最后（即最后侧）
缺省参数全挨在一起（在右侧），不是缺省参数挨在一起（在左侧）

命名参数是指：在调用函数时，传递的实参带有名字，这样的参数叫做命名参数。

命名参数能够在调用函数的时候，不受位置的影响，可以给需要的参数指定传递数据

代码示例：

def test(a, b):
    print('-----')
    print(f'a={a}')
    print(f'b={b}')

test(11, 22)
test(a=11, b=22)
test(a=22, b=11)  # 根据名称将值传入到指定的变量中

总结：

命名参数的名字要与形参中的名字相同，不能出现命名参数名字叫做num，而形参中没有变量num
如果形参左侧有普通的形参，调用函数时传递的参数一定要先满足这些形参，然后再根据需要编写命名参数

不定长参数：定义函数的时候形参不确定到底有多少个，这样的参数就叫做不定长参数。

*args ：表示调用函数时多余的未命名参数都会以元组的方式存储到args中
**kwargs：表示调用函数时多余的命名参数都会以键值对的方式存储到kwargs中

*和**是必须要写的，否则就变成了普通的形参了
当我们说不定长参数的时候，就是指*args和**kwargs

代码示例：

def test(a, b, *args, **kwargs):
    print(a, type(a))
    print(b, type(b))
    print(args, type(args))
    print(kwargs, type(kwargs))

test(11, 22, 33, 44, 55, 66, name='张三', address='郑州')

注意点：

加了星号*的变量args会存放所有未命名的变量参数，args为元组
而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典
一般情况下*args、**kwargs会在形参的最右侧
args与kwargs的名字可以变，例如叫*aa，**bb都是可以，但一般为了能够让其他的开发者快速读懂我们的代码最好还是不改

*args后可以有缺省参数，想要给这些缺省参数在调用时传递参数，需要用命名参数传递，否则多余的未命名参数都会给args
如果有**kwargs的话，**kwargs必须是最后的

2.返回值拆包

函数返回值拆包：一个函数通过return返回了一个元组、列表、集合，可以通过拆包的方式将返回值进行拆分到每个变量中，这就是返回值拆包。

def test():
    return 11, 22, 33

a, b, c = test()
print(a, b, c)

拆包的使用：

def get_info():
    high = 170
    weight = 120
    age = 18
    return high, weight, age


# result = get_info()
# print(result)

# 通过返回值拆包，能够更加方便的对每个数据使用
my_high, my_weight, my_age = get_info()
print(my_high)
print(my_weight)
print(my_age)

注意：

拆包时要注意，需要拆的数据的个数要与变量的个数相同，否则程序会异常

3.星号(*)拆包

在调用函数时，这个函数需要的是多个参数，而自己拥有的是一个列表或者集合这样的数据，此时就用可以用*拆包。

代码示例：

def test(a, b, c):
    print(a + b + c)


nums = [11, 22, 33]
test(*nums)  

# 此时的*的作用就是拆包，此时*nums相当于11, 22, 33 即test(11, 22, 33)

总结：

*对列表、元组、集合可以拆包，但一般都是在调用函数时使用

使用**可以对字典进行拆包，拆包的结果是命名参数。

代码示例：

def test(name, age, address):
    print(name)
    print(age)
    print(address)


info = {
    "name": "张三",
    "age": 18,
    "address": "郑州"
}

test(**info)

'''
当前**info相当于以下代码：
	name='张三'
	age=18
	address='郑州'
	
** 主要对字典进行拆包
'''

4.函数的引用

代码示例：

def test1():
    print("我是test1函数...")


def test2():
    print("我是test2函数...")


test1()

test1 = test2
test1()


# 运行结果
我是test1函数...
我是test2函数...

总结：

Python中函数名是变量，可通过赋值改变其引用。
重新赋值后，test1 的原始定义被覆盖，后续调用行为由新引用决定。

5.匿名函数

没有名字的函数称之为匿名函数，在Python中用lambda关键字定义。

使用格式：

lambda 形参1, 形参2, 形参3: 表达式

代码示例：

# 定义了一个匿名函数，然后让变量add_ums指向它
add_nums = lambda x, y: x + y

# 调用add_nums指向的匿名函数
print("10+20=%d" % add_nums(10, 20))

# 运行结果

10+20=30

代码示例：

stus = [
    {"name": "张三", "age": 18},
    {"name": "李四", "age": 19},
    {"name": "王五", "age": 20}
]

print("排序前，stus=", stus)
stus.sort(key=lambda x: x['age'])
print("排序后，stus=", stus)
# 运行结果
排序前，students= [{'name': '张三', 'age': 18}, {'name': '李四', 'age': 19}, {'name': '王五', 'age': 20}]
排序后，students= [{'name': '张三', 'age': 18}, {'name': '李四', 'age': 19}, {'name': '王五', 'age': 20}]

6.递归函数

递归函数是指在函数定义中直接或间接调用自身的函数。通过将复杂问题分解为相似的子问题，递归能够以简洁的方式解决分治类问题（如阶乘、斐波那契数列、树遍历等）。递归需满足两个条件：基线条件（终止条件）和递归条件（调用自身）。

递归函数主要由两部分组成：

递归案例(Recursive Case)：函数调用自身来解决子问题。
基案(Base Case)：递归终止的条件，防止无限递归。

递归案例：

# 1.
# 定义函数factorial(n)
# 2.
# 设置基准条件：当n为0时返回1
# 3.
# 对于其他情况，返回n * factorial(n - 1)

# 1. 阶乘的数学定义：n! = n × (n-1)!
# 2. 需要设置递归终止条件（基准条件）
# 3. 注意递归深度与性能问题
# 4! = 4*3*2*1
def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)
    # 4*3*2*1
print(factorial(4))

递归案例：

# （斐波那契数列是指这样一个数列：0，1，1 ，2，3，5，8，13，21，34 …
# 这个数列从第3项开始 ，每一项都等于前两项之和。）


# 1. 定义函数fib(n)
# 2. 设置基准条件：n≤1时返回n
# 3. 对于其他情况，返回fib(n-1) + fib(n-2)

def fib(n):
    # 请实现递归计算斐波那契数列
    if n <=1:
        return n
    else:
        return fib(n-1) + fib(n-2)
# fib(2)+fib(1) fib=1 计算fib(2)=(fib(1)=1)+(fib(0)=0)
print(fib(3))

后续知识点会进一步更新。（如有错误可指正，共同进步。谢谢）

龙虾开发者社区

小龙虾开发者社区是 CSDN 旗下专注 OpenClaw 生态的官方阵地，聚焦技能开发、插件实践与部署教程，为开发者提供可直接落地的方案、工具与交流平台，助力高效构建与落地 AI 应用

更多推荐

大模型安全实战】智能体安全的攻防二元性：同一种能力，为什么既是防线也是攻击面？（第4期）

龙虾开发者社区

SparkSQL 之 Hive On Spark 原理分析

龙虾开发者社区

2026大厂AI Agent面试深度复盘：从“会背概念“到“能扛生产“的范式跃迁

2026年AI Agent面试核心要点摘要（147字）大厂AI Agent面试已从概念背诵转向工程实践考核，重点考察：1）理解Agent与Chatbot的本质差异在于闭环行动能力；2）掌握ReAct循环、记忆分层设计（工作/短期/长期记忆）及优化策略；3）熟悉MCP协议对工具调用的标准化改进及安全风险；4）具备异常处理、性能优化的工程能力。面试官更关注候选人在非确定性系统中构建确定性保障的能力，

龙虾开发者社区

所有评论(0)

查看更多评论

Python 小路

@weixin_70276309

已为社区贡献1条内容

【2026】Python3入门基础教程一，附代码案例，快速入门。

Python 小路

前言

Python的简介

Python的应用领域

推荐学习路径

第一章：软件安装

一.Python解释器

二.代码编辑器

三.软件安装

四.软件地址(夸克网盘)

第二章：基础知识

1.第一个Python程序

2.注释

3.变量与常量

4.数据类型

5.关键字与标识符

6.输出函数

7.输入函数

8.运算符

第三章：判断语句与循环语句

1.布尔类型

2.比较运算符

3.逻辑运算符

4.判断语句 if

5.判断语句 else

6.判断语句 elif

7.嵌套判断

8.循环语句 while

9.嵌套循环 while

10.循环语句 for

11.break和continue

12.循环语句 else

第四章：容器类型

1.字符串

1.1 字符串切片

1.2 字符串的内置方法

2.列表

2.1 列表的内置方法

3.元组

4.集合

5.字典

6.字典操作

7.推导式

8.拆包

10.深拷贝和浅拷贝

第五章：函数基础

1.介绍函数

2.自定义函数

3.内置函数

4.函数的说明文档

5.函数的参数

6.函数的返回值

7.自定义函数的类型

8.函数之间的隔离

9.函数的嵌套

嵌套函数的优势

10.变量的作用域

11.案例—学生管理系统

第六章：进阶函数

1.函数的参数

2.返回值拆包

3.星号(*)拆包

4.函数的引用

5.匿名函数

6.递归函数

所有评论(0)

温馨提示：您尚未绑定手机号

Python 小路