总合集-快速学习Python基础知识详细图文教程

来源引用网络知识与某站曹老师视频相互结合学习记录，仅供参考！字数10万+ 建议收藏保存逐步学习。

Python简介

百度百科

Python 是一门优雅而健壮的编程语言，由荷兰国家数学与计算机科学研究中心的吉多·范罗苏姆于1990年代初设计，作为ABC语言的替代品，它继承了传统编译语言的强大性和通用性，同时也借鉴了脚本语言和解释语言的易用性，是一种解释型脚本语言。Guido van Rossum在1995年于国家创新研究公司（CNRI）继续他在Python上的工作，2001年Python软件基金会（PSF）成立。

Python被设计成是 “符合大脑思维习惯” 的，采用极简主义的设计理念，加以统一规范的交互模式。这使得Python易于学习、理解和记忆。Python 开发者的哲学是 “用一种方法，最好是只有一种方法来做一件事”。它提供高效的数据结构、动态类型及面向对象编程特性，适用于脚本编写与快速开发。对于科研而言，Python的应用非常广泛。众多开源的科学计算软件包都提供了Python的调用接口，例如著名的计算机视觉库OpenCV、三维可视化库VTK、医学图像处理库ITK。而Python专用的科学计算扩展库就更多了，例如十分经典的科学计算扩展库：NumPy、SciPy和matplotlib，它们分别为Python提供了快速数组处理、数值运算以及绘图功能。因此Python语言及其众多的扩展库所构成的开发环境十分适合工程技术、科研人员处理实验数据、制作图表，甚至开发科学计算应用程序。

Python 2于2000年发布，Python 3于2008年发布且不完全兼容前代。 该语言已成为受欢迎的程序设计语言之一，其使用率自2004年起呈线性增长，广泛应用于Web开发、科学计算、金融分析、自动化等领域。

Python 基础知识

推荐书籍：Python 核心编程

推荐工具：PyCharm（环境搭建--Python-PyCharm）、Visual Studio Code 等等（烦请自行选择）

一、变量和简单类型

变量

无论使用什么语言编程，总要处理数据，处理数据就需要使用变量来保存数据；变量就像一个个小容器，用于“盛装”程序中的数据。

在 Python 中有以下六种数据类型：

        数字、字符串、列表、字典、元组、集合；

                数字类型又分四种小类：整数、浮点数、复数、布尔类型。

变量的定义方式

变量名称 = 变量的值

（“=”等号是赋值符号，意思是把右侧的值赋值给左侧变量）

变量的数据是可以变化的，重新给变量赋值即可；

PyCharm 工具快捷键 Ctrl+Alt+L 重新设置代码格式

注释

注释：对程序代码进行解释说明的文字；

可以用来解释程序某些部分的作用和功能，提高程序的可读性。

注释分为单行注释和多行注释：

        单行注释

python 使用 # （井号）表示单行注释的开始，跟在“#”号后面直到这行结束为止的代码都将被解释器忽略。

        多行注释

多行注释是指一次性将程序中的多行代码注释掉，在 python 程序中使用三个单引号或三个双引号将注释的内容括起来。

数据类型

python 是弱类型语言，变量的类型是可以改变的；

变量定义成功后，可以使用 type(() 方法来查看变量的类型；

Python数据类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可；

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

变量的命名规则

 Python 需要使用标识符给变量命名，其实标识符就是用于给程序中变量、类、方法命名的符号（简单来说，标识符就是合法的名字）。python 语言的标识符必须以字母、下划线 _ 开头，后面可以跟任意数量的字母、数字、下划线；这里的字母并不局限于 26 个英文字母，可以包含中文字符（可以是中文，不报错），不过不推荐。

在使用标识符时，需要注意以下规则：

        1、标识符可以由字母、数字、下划线组成，但是不能由数字开头；

        2、标识符不能是 python 关键字；

        3、标识符不能包含空格；

python 常用关键字

系统有一些常用关键字不可以用来当作标识符。

运算符

运算符是一种特殊的符号，用来表示数据的运算、赋值和比较等等；

赋值运算符

赋值运算符用于为变量或常量指定值，python 中使用“=”（一个等号）作为赋值运算符；通常使用赋值运算符将表达式的值赋给另一个变量。

算数运算符

python 支持所有的基本算数运算符，这些算数运算符用于执行基本的数学运算，例如加、减、乘、除和求余、取模等等。

a = 10
b = 21

print("a+b=", a + b)
print("a-b=", a - b)
print("a*b=", a * b)
print("b/a=", b / a)
print("b%a=", b % a)
print("a**b=", a ** b)
print("b//a=", b // a)
print("9//2=", 9 // 2)
print("9.0//2.0=", 9.0 // 2.0)


运行结果
a+b= 31
a-b= -11
a*b= 210
b/a= 2.1
b%a= 1
a**b= 1000000000000000000000
b//a= 2
9//2= 4
9.0//2.0= 4.0

扩展后的赋值运算符

其他

Python算术运算符

>>> 9//2
4
>>> -9//2
-5

Python 比较（关系）运算符

Python赋值运算符

if (n := len(a)) > 10:
    print(f"List is too long ({n} elements, expected <= 10)")

Python位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

Python逻辑运算符

Python语言支持逻辑运算符；

Python成员运算符

除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。

Python身份运算符

身份运算符用于比较两个对象的存储单元

注： id() 函数用于获取对象内存地址。

Python运算符优先级

以下表格列出了从最高到最低优先级的所有运算符， 相同单元格内的运算符具有相同优先级。 运算符均指二元运算，除非特别指出。 相同单元格内的运算符从左至右分组（除了幂运算是从右至左分组）：

字符串

字符串的意思就是“一串字符”，python 中要求字符串必须使用引号（单引号、双引号、三引号）括起来，需要两边的引号能配对；

str1 = "python"
str2 = 'pycharm'
print(str1)
print(str2)


运行结果
python
pycharm

字符串定义和转义字符

例如：定义的字符串里面含有单引号或者双引号，对于这种情况，有两种解决方案：

1、使用不同的引号将字符串括起来；

2、通过使用 \ 对引号进行转义；

str1 = "python '520'"
str2 = 'pycharm "521"'
str3 = 'pycharm \'1314\''
print(str1)
print(str2)
print(str3)


运行结果
python '520'
pycharm "521"
pycharm '1314'

长字符串的定义

长字符串的写法是使用三个引号（单引号或者双引号），在长字符串中可以放置任意内容，包括放置单引号、双引号等等，若所定义的长字符串没有赋值给任何变量，那么这个长字符串就相当于是一个多行注释，被注释掉了，会被 python 解释器忽略。

str1 = """
    《静夜思》
       李白
    床前明月光，
    疑是地上霜。
    举头望明月，
    低头思故乡。
       """

print(str1)

字符串拼接

在 python 中，使用“+”加号作为字符串的拼接运算符；

str1 = "python"
str2 = 'pycharm'
print("str1:" + str1 + ",str2:" + str2)


运行结果
str1:python,str2:pycharm

有时需要将字符串与数值进行拼接，而 python 中不允许直接拼接数值和字符串，程序必须先将数值转化成字符串；为了将数值转换成字符串，可以使用 str() 或 repr() 函数；

str1 = "python"
str2 = 'pycharm'
int_str3 = 123
print("str1:" + str1 + ",str2:" + str2 + ",int_str3:" + str(int_str3))
print("str1:" + str1 + ",str2:" + str2 + ",int_str3:" + repr(int_str3))


运行结果
str1:python,str2:pycharm,int_str3:123
str1:python,str2:pycharm,int_str3:123

使用 input 获取用户输入

input() 函数用于向用户生成一条提示，然后获取用户输入的内容；由于 input() 函数总会将用户输入的内容放入字符串中，因此用户可以输入任何内容，input() 函数总是返回一个字符串；一般可以通过 int()、float() 等方法来转换类型。

name = input("请输入您的姓名：")
print(name, type(name))

age = input("请输入您的年龄：")
# 使用int()函数把字符串类型转换成整型
age = int(age)
print(age, type(age))

height = input("请输入您的身高（cm）：")
# 转换成浮点型
height = float(height)
print(height, type(height))


运行结果
请输入您的姓名：小明
小明 <class 'str'>
请输入您的年龄：15
15 <class 'int'>
请输入您的身高（cm）：177
177.0 <class 'float'>

字符串格式化

前面介绍了字符串拼接，若是简单的 2、3 个字符串拼接那还算好，如果大于 3 个变量的拼接，就会比较麻烦，还有就是字符串无法和其他类型直接拼接，需要先进行类型转换；python 中提供了“%”对各种类型的数据进行格式化输出。

name = "小明"
print("姓名是：%s" % name)


运行结果
姓名是：小明

print("姓名是：%s" % name)

这里 “%s”是占位符，第二个“%”是分隔符，后面的 name 就是变量了；

name = "小明"
age = 15
print("姓名是：%s,已经%s岁了" % (name, age))


运行结果
姓名是：小明,已经15岁了

再添加一个 int 类型的 age 变量，输出时使用两个“%s”，中间依然用“%”间隔，后面括号里面两个参数；需要注意参数的顺序不能乱；

除了“%s”以外，还有很多占位符，例如常用的 %s，%d，%f，分别把参数或者表达式转换成字符串，整型，浮点型。

name = "小明"
age = 15
height = 177.7
print("姓名是：%s,已经%s岁了,身高%f" % (name, age, height))


运行结果
姓名是：小明,已经15岁了,身高177.700000

可以看到打印结果中，身高字段后面多了 5 个 0，此处涉及到一个格式化精度控制；

可以使用辅助符号“m,n”来控制数据的宽度和精度：

        m，控制宽度（包括小数点），需要注意若设置的宽度小于数字本身，则不会生效；

        n，控制小数点精度，若数字的宽度大于小数位数，则需要进行四舍五入；

name = "小明"
age = 15
height = 171.55
print("姓名是：%s,已经%s岁了,身高%.1f" % (name, age, height))


运行结果
姓名是：小明,已经15岁了,身高171.6

快速 format 格式化用法，一种更加简单快捷优雅的格式化方式；

语法是：f"内容{变量}内容"

在字符串前面添加“f”，字符串里面的对应变量使用“{}”大括号括起来；

name = "小明"
age = 15
height = 171.55
print(f"姓名是：{name},已经{age}岁了,身高{height:.1f}")


运行结果
姓名是：小明,已经15岁了,身高171.6

二、流程控制

if 条件分支结构

若 python 程序中的多行代码没有任何的流程控制，则程序总是从上向下依次执行（顺序执行）。

布尔类型和比较运算符

布尔（bool）表达现实生活中的逻辑，即真和假，True 表示真，False 表示假，其中首字母需大写；

b1 = True
b2 = False
print(f"b1 = {b1}，类型是{type(b1)}")
print(f"b2 = {b2}，类型是{type(b2)}")


运行结果
b1 = True，类型是<class 'bool'>
b2 = False，类型是<class 'bool'>

比较运算符的返回结果是布尔类型；

if 语句语法格式

if 语句基本语法格式

if 判断条件：

        执行内容...

age = input("Enter your age: ")
age = int(age)
print("Your age is:", age)

if age >= 18:
    print("You are a teenager.")
print("好好学习，天天向上！")

注意点：

1、判断条件后面要加冒号:

2、执行内容前面是四个空格

3、判断条件返回值是布尔类型

if else 语句语法格式

if 判断条件：

        满足条件执行内容...

else：

        不满足条件执行内容...

age = input("Enter your age: ")
age = int(age)
print("Your age is:", age)

if age >= 18:
    print("You are a young man.")
else:
    print("You are a teenager.")
    
print("好好学习，天天向上！")

注意点：

1、else 后面要加冒号:

2、else 执行内容前面也是四个空格

if elif else 语句语法格式

当有多个条件判断时，可以通过 if elif else 来实现；

if 条件 1：

        条件 1 满足执行内容

elif 条件 2：

        条件 2 满足执行内容

elif 条件 n：

        条件 n 满足执行内容

else：

以上条件都不满足执行内容

score = input("烦请输入您的学习成绩：")
print(f"学习成绩是：{score}分")
score = float(score)

if score >= 90:
    print("学习成绩优秀！")
elif score >= 80:
    print("学习成绩良好！")
elif score >= 60:
    print("学习成绩及格！")
else:
    print("学习成绩不及格！")

print("再接再厉，努力加油！")

if 语句的嵌套应用

有些时候业务上有多维度复杂条件判断，需要使用到 if 语句的嵌套来实现；

例如：在一些游戏网站活动充值的时候，冲 100 送 20，冲 200 送 50；但是 vip 用户是冲 100 送 30，冲 200 送 70；

# vip = True
vip = False
amount = input("请输入充值金额：")
amount = int(amount)

if amount == 100:
    if vip:
        print("总共充值", 100 + 30)
    else:
        print("总共充值", 100 + 20)
elif amount == 200:
    if vip:
        print("总共充值", 200 + 70)
    else:
        print("总共充值", 200 + 50)

猜数字游戏，1 到 10 随机生成一个数字；通过 if 嵌套语句，用户输入数字猜测，若猜对了，则直接提示正确，否则提示大了或者小了，最多猜三次；

通过 random.randint() 方法可以生成随机数字；

# 导包
import random

# 生成1到10之间的随机整数
target = random.randint(1, 10)
attempts_left = 3

print("欢迎来到猜数字游戏！你有三次机会猜出我想的数字（范围是1到10）。")

while attempts_left > 0:
    guess = int(input("请输入你的猜测: "))

    if guess == target:
        print("恭喜你，猜对了！")
        break
    elif guess < target:
        print("太小了，再试一次吧～")
    else:
        print("太大了，再试一次吧～")

    attempts_left -= 1
    if attempts_left > 0:
        print(f"你还剩下 {attempts_left} 次机会。")
else:
    print(f"很遗憾，你没有在规定次数内猜对。正确的答案是 {target}。")

while 循环结构

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体；当反复执行这个循环体时，需要在合适的时候把循环条件改为假，从而结束循环；否则循环将一直执行下去，形成死循环。

while 循环语句语法格式

初始化语句

while 循环条件：

        循环体

        迭代语句

初始化语句：一条或多条语句，用于完成一些初始化工作；初始化语句在循环开始之前执行；

循环条件：这是一个布尔表达式，这个表达式能决定是否执行循环体；

循环体：这个部分是循环的主体，如果循环条件允许，这个代码块将被重复执行；

迭代语句：这个部分在一次执行循环体结束后，对循环条件求值之前执行，通常用于控制循环条件中的变量，使得循环在合适的时候结束；

基本案例：1+2+3+...+10 求和，使用 while 循环语句来实现；

# 定义变量sum，用来保存运行过程中的累计和
sum = 0
# 定义变量i，循环过程每次被加的值
i = 1

while i <= 10:
    print(f"while执行第{i}次")
    # 进行累加
    sum += i
    # i每次执行加1
    i += 1
print("1+2+3+...+10=", sum)


运行结果
while执行第1次
while执行第2次
while执行第3次
while执行第4次
while执行第5次
while执行第6次
while执行第7次
while执行第8次
while执行第9次
while执行第10次
1+2+3+...+10= 55

while 循环嵌套

在 while 循环内部还可以继续通过 while 循环来实现复杂的应用；例如：打印二维的行列；

# 定义行
i = 1

# 外层嵌套，打印5行
while i <= 5:
    print(f"打印第{i}行")
    i += 1

print("打印5行完成了")


运行结果
打印第1行
打印第2行
打印第3行
打印第4行
打印第5行
打印5行完成了

print() 里面有个默认 end 参数 print(end="\n")，默认值是”\n“，省略不写时在方法中也会有这个默认参数；

# 定义行
i = 1

# 外层嵌套，打印5行
while i <= 5:
    print(f"打印第{i}行")
    # 定义列
    j = 1
    # 打印5列
    while j <= 5:
        print(f"打印第{j}列", end=" ")
        j += 1
    print()
    i += 1

print("打印二维行列完成了")


运行结果
打印第1行
打印第1列 打印第2列 打印第3列 打印第4列 打印第5列 
打印第2行
打印第1列 打印第2列 打印第3列 打印第4列 打印第5列 
打印第3行
打印第1列 打印第2列 打印第3列 打印第4列 打印第5列 
打印第4行
打印第1列 打印第2列 打印第3列 打印第4列 打印第5列 
打印第5行
打印第1列 打印第2列 打印第3列 打印第4列 打印第5列 
打印二维行列完成了

在字符串中，有一个特殊的符号 \t ，这个是制表符，效果等同于键盘上的”tab“键；

\n：换行符，表示换行，相当于按一个 回车键；
\t：制表符，表示空4个字符，类似于文档中的缩进功能，相当于按一个Tab键；
\n\t：表示换行的同时空4个字符；

通过 while 循环嵌套打印九九乘法表；

# 初始化外层循环变量 i 控制行数，从1开始
i = 1
while i <= 9:
    # 初始化内层循环变量 j 控制每行的列数，也从1开始
    j = 1
    while j <= i:
        # 打印当前的乘法表达式及其结果，后面加一个制表符对齐
        print(f"{j} × {i} = {j * i}", end='\t')
        # 更新内层循环变量 j
        j += 1
    # 换行以便下一行输出更清晰
    print()
    # 更新外层循环变量 i
    i += 1


运行结果
1 × 1 = 1	
1 × 2 = 2	2 × 2 = 4	
1 × 3 = 3	2 × 3 = 6	3 × 3 = 9	
1 × 4 = 4	2 × 4 = 8	3 × 4 = 12	4 × 4 = 16	
1 × 5 = 5	2 × 5 = 10	3 × 5 = 15	4 × 5 = 20	5 × 5 = 25	
1 × 6 = 6	2 × 6 = 12	3 × 6 = 18	4 × 6 = 24	5 × 6 = 30	6 × 6 = 36	
1 × 7 = 7	2 × 7 = 14	3 × 7 = 21	4 × 7 = 28	5 × 7 = 35	6 × 7 = 42	7 × 7 = 49	
1 × 8 = 8	2 × 8 = 16	3 × 8 = 24	4 × 8 = 32	5 × 8 = 40	6 × 8 = 48	7 × 8 = 56	8 × 8 = 64	
1 × 9 = 9	2 × 9 = 18	3 × 9 = 27	4 × 9 = 36	5 × 9 = 45	6 × 9 = 54	7 × 9 = 63	8 × 9 = 72	9 × 9 = 81	

for 循环结构

对于固定数据集的元素挨个操作，通常使用 for 循环遍历更加合适；

常见的数据集（字符串，集合，元组，列表，字典等等）

for 循环语句语法格式

for 临时变量 in 待遍历的数据集：

        执行代码

案例 1： 通过 for 循环遍历字符串，打印挨个每个字符；

# 定义字符串
website = 'https://www.baidu.com'

# 通过for循环遍历website字符串，拿到每个字符串的字符
for webs in website:
    print(webs, end='\t'))


运行结果
h	t	t	p	s	:	/	/	w	w	w	.	b	a	i	d	u	.	c	o	m

案例 2： 通过 for 循环遍历字符串，统计特定字符 o，打印出个数；

# 定义字符串
website = 'https://www.baidu.com'

# 定义total变量，用于统计某个字符的个数
total = 0

# 通过for循环遍历website字符串，拿到每个字符串的字符
for webs in website:
    # 判断webs等于‘w’字符时，将total变量+1
    if webs == 'w':
        total += 1
    print(webs, end='\t')
print(f'\n字符串中“w”的总个数是{total}个。')


运行结果
h	t	t	p	s	:	/	/	w	w	w	.	b	a	i	d	u	.	c	o	m	
字符串中“w”的总个数是3个。

for 循环嵌套

在有复杂应用的时候，可以通过使用 for 循环的嵌套来实现；

例如：打印二维的行列；

for i in range(1,6):
    print(f'第{i}行')
    for j in range(1,6):
        # print('第{}列'.format(j), end=' ')
        print(f'第{j}列', end=' ')
    print()


运行结果
第1行
第1列 第2列 第3列 第4列 第5列 
第2行
第1列 第2列 第3列 第4列 第5列 
第3行
第1列 第2列 第3列 第4列 第5列 
第4行
第1列 第2列 第3列 第4列 第5列 
第5行
第1列 第2列 第3列 第4列 第5列 

建议先学习 range() 方法，获取一个数字序列；

# range(stop)返回0到stop-1的数字序列
for i in range(10):
    print(i, end=' ')

print()

# range(start,stop)返回start到stop-1的数字序列
for i in range(5, 10):
    print(i, end=' ')

print()

# range(start,stop,step)返回start到stop-1的数字序列，步长step
for i in range(2, 10, 2):
    print(i, end=' ')


运行结果
0 1 2 3 4 5 6 7 8 9 
5 6 7 8 9 
2 4 6 8 

使用 for 循环嵌套打印九九乘法表；

for i in range(1, 10):
    for j in range(1, i + 1):
        print(f'{j}×{i}={j * i}', end='\t')
    print()


运行结果
1×1=1	
1×2=2	2×2=4	
1×3=3	2×3=6	3×3=9	
1×4=4	2×4=8	3×4=12	4×4=16	
1×5=5	2×5=10	3×5=15	4×5=20	5×5=25	
1×6=6	2×6=12	3×6=18	4×6=24	5×6=30	6×6=36	
1×7=7	2×7=14	3×7=21	4×7=28	5×7=35	6×7=42	7×7=49	
1×8=8	2×8=16	3×8=24	4×8=32	5×8=40	6×8=48	7×8=56	8×8=64	
1×9=9	2×9=18	3×9=27	4×9=36	5×9=45	6×9=54	7×9=63	8×9=72	9×9=81	

循环控制 continue 和 break

为了增强循环控制逻辑能力，python 提供了 continue 和 break 循环控制支持；

        continue：中断本次循环，直接进入下一次循环；

        break：直接结束循环；

for i in range(1, 10):
    if i == 5:
        continue
    print(i, end=' ')


运行结果
1 2 3 4 6 7 8 9 

for i in range(1, 10):
    if i == 5:
        break
    print(i, end=' ')


运行结果
1 2 3 4

循环经典综合案例--求水仙花数

水仙花数是指一个 3 位数，它的每个数位上的数字的 3 次幂之和等于它本身；（使用 for 循环嵌套是最简单的）

# 百位数i，取值范围1~9
for i in range(1, 10):
    # # 十位数j，取值范围0~9
    for j in range(0, 10):
        # # 个位数k，取值范围0~9
        for k in range(0, 10):
            # 本身值
            num1 = i * 100 + j * 10 + k
            # 每个数位上的数字的3次幂之和
            num2 = i ** 3 + j ** 3 + k ** 3
            if num1 == num2:
                print(f'水仙花有：{num1}')


运行结果
水仙花有：153
水仙花有：370
水仙花有：371
水仙花有：407

# 定义初始化变量，从100开始遍历
i = 100

while i < 1000:
    # 百位数
    x = i // 100
    # 十位数
    y = (i - x * 100) // 10
    # 个位数
    z = (i - x * 100) % 10
    # 自身值
    num1 = x * 100 + y * 10 + z
    # 每个数位上的数字的3次幂之和
    num2 = x ** 3 + y ** 3 + z ** 3
    if num1 == num2:
        print(f'水仙花有：{num2}')
    i += 1


运行结果
水仙花有：153
水仙花有：370
水仙花有：371
水仙花有：407

三、函数

函数是执行特定任务的一段代码，程序通过将一段代码定义成函数，并为该函数指定一个函数名，这样即可在需要的时候多次调用这段代码；例如：之前使用的 range() 函数，就是系统内置的函数，功能是通过传入参数，返回特定范围的数字序列，函数名是 range，当需要使用的时候，可以直接调用函数名，可反复多次使用；

函数的定义

函数的定义语法：

def 函数名(形参列表):

        函数体（由零条或多条可执行语句组成的函数）

        return 返回值

• 函数名要符合标识符定义，取名的时候要有意义，看名知义；
• 形参列表是定义该函数可以接受的参数，可以为空，多个参数之间使用逗号隔开，调用函数的地方传入对应的参数值；
• return 返回值，返回函数的执行结果，若没有返回值可省略；

# 定义一个最基础的函数，例如 say_helloworld
def say_helloworld():
    print("Hello World!")


# 调用函数，直接使用函数名 say_helloworld
say_helloworld()

# 再次调用 say_helloworld 函数
say_helloworld()


运行结果
Hello World!
Hello World!

函数的参数

函数形参部分，可以不定义参数，直接空括号即可；若有多个参数，可以使用 ”,“ 逗号隔开；在调用的时候，传入的就是实际参数，按照形参定义，顺序传入即可；

# 定义一个加法函数
def add(a, b):
    result = a + b
    print(f'{a} + {b} = {result}')

# 调用函数
add(1, 2)
add(3, 4)
add(5, 6)


运行结果
1 + 2 = 3
3 + 4 = 7
5 + 6 = 11

关键字(keyword)参数

上面的实例中是位置参数，在调用的时候，必须严格按照定义函数时指定的顺序来传入参数值；若根据参数名来传入参数值，则无需蹲守定义形参的顺序，这种方式被称为关键字(keyword)参数；

注意点：

• 在使用关键字参数的时候，顺序可以随便换；
• 部分使用关键字参数，部分使用位置参数；
• 混合使用的时候，关键字参数必须位于位置参数之后，否则会报错；

# 定义一个加法函数
def add(a, b):
    result = a + b
    print(f'{a} + {b} = {result}')


# 根据关键字参数来传入数值
add(a=1, b=2)

# 在使用关键字参数的时候，指定参数名后，顺序可以随意更换
add(b=2, a=3)

# 混合使用，部分使用位置参数，部分使用关键字参数
add(4, b=5)

# 在混用时，关键字参数务必要在位置参数之后，否则报错
# add(b=6, 7)

参数默认值

在某些情况下，程序需要在定义函数时为一个或多个形参指定默认值；这样在调用函数时就可以省略为该形参传入参数值，而是直接使用该形参的默认值；

语法格式：形参名=默认值

# 定义一个加法函数
def say(name='张三', msg='法外狂徒'):
    print(f'{name} 的称号是：{msg}')


# 全部使用默认参数
say()

# 部分使用默认参数
say('李四')

# 都不使用默认参数
say('王二', '客栈王小二弟弟')

# name使用默认参数值，msg则需要使用关键字参数
say(msg='西行记大师')


运行结果
张三 的称号是：法外狂徒
李四 的称号是：法外狂徒
王二 的称号是：客栈王小二弟弟
张三 的称号是：西行记大师