函数
函数是能够实现特定功能的计算机代码，是一种特定的代码组结构。
- 在编程语言中称之为函数
- 在现实生活中称之为功能
# 写一个一行三列的"白裤裆寒冬一击"
col = 0
while col < 3:
print("白裤裆寒冬一击", end='')
col += 1
#写一个三行三列的"白裤裆寒冬一击"
row = 0
while row < 3:
#输出一行"白裤裆寒冬一击"
#一行七三的"白裤裆寒冬一击"
col = 0
while col < 3:
print("白裤裆寒冬一击 ", end='')
col += 1
#换行
print('')
row += 1
#r行c列的"白裤裆寒冬一击"
def myPrint(r, c, s='白裤裆寒冬一击'):
row = 0
while row < r:
col = 0
while col < c:
print(s, " ", end='')
col += 1
print('')
row += 1
myPrint(2, 2)
函数的作用
- 提升代码的重复利用率，避免重复开发相同代码
- 提高程序开发效率
- 便于程序维护
函数的定义
基本格式
def 函数名():
函数功能代码...
... ...
#调用函数
函数名()
函数定义后不会自动执行，必须在调用函数后才会执行
函数名的命名规则（和变量基本一样）
- 推荐使用英文或者拼音，禁止使用中文
- 可以使用数字，但是不能以数字开头
- 不可以使用特殊字符，除了_
- 函数名严格区分大小写
- 函数名必须要有意义
- 不能和系统已经存在的保留关键字冲突
- 禁止使用和系统提供函数相同的函数名
含有参数的格式
def 函数名(参数, 参数, 参数, ...):
函数功能代码...
... ...
#调用函数
函数名(参数, 参数, 参数, ...)
- 调用函数的位置传入的数据叫实参(本质是值)
- 定义函数的位置的参数是形参（本质是变量名）
- 将实参的值传递给形参的过程叫做传参（本质是赋值）
带有默认值的参数
def 函数名(形参=默认值, 形参=默认值, 形参=默认值, ...):
函数功能代码...
... ...
#调用函数
函数名() #调用函数时所有形参采用默认值操作
函数名(实参, 实参, 实参, ...) ##调用函数时形参采用实参的值而抛弃默认值
在此情况下，使用实参值覆盖原有形参的默认值，本质上就是变量的重新赋值工作
关键字参数
关键字参数就是调用函数时，在实参前面指定形参的做法，为了防止参数按照位置传递出现错误
def create_role(name, clothes, shoes, weapon):
print('我是：', name)
print('身披：', clothes)
print('脚踏：', shoes)
print('手握：', weapon)
create_role('孙悟空', '锁子黄金甲', '藕丝步云履', '金箍棒')
def create_role(name, clothes, shoes, weapon):
print('我是：', name)
print('身披：', clothes)
print('脚踏：', shoes)
print('手握：', weapon)
create_role('锁子黄金甲', '孙悟空', '金箍棒', '藕丝步云履' )
def create_role(name, clothes, shoes, weapon):
print('我是：', name)
print('身披：', clothes)
print('脚踏：', shoes)
print('手握：', weapon)
create_role(clothes='锁子黄金甲', name='孙悟空', weapon='金箍棒', shoes='藕丝步云履' )
收集参数
- 非关键字收集参数，在形参前添加一个*即可
- 非关键字收集参数收集实参组成一个元组
- 非关键字收集参数，仅收集没有任何形参接收的非关键字实参
- 非关键字收集参数和普通形参可以共存
#计算2个数的和的函数
def my_sum(a, b):
result = a + b
print(result)
my_sum(1, 1)
#计算任意个数据的和的函数
def my_supersum(*args):
print(args)
total = 0
for i in args:
total += i
print(total)
my_supersum(1, 2, 3, 4, 5)
#计算任意个数据的和的函数
#收集参数，仅仅收集没有形参接收的参数
def my_supersum(a, b, c, *args):
print(args)
total = 0
for i in args:
total += i
print(total)
my_supersum(1, 2, 3, 4, 5)
- 关键字收集参数，在形参前添加两个**即可
- 关键字收集参数，收集的结果组成一个字典，关键字成为字典的键，实参成为值
- 关键字收集参数，仅收集没有任何形参接收的关键字参数
- 关键字参数可以和普通的形参共存
# 输出参加party的用户和性别
def party(**args):
print(args)
for name, gender in args.items():
print(name, gender)
party(Wukong='Male', Qiqi='Female', Wufan='Male')
# 输出参加party的用户和性别
#收集参数，仅仅收集没有形参接收的参数
def party(Qiqi, **args):
print(args)
for name, gender in args.items():
print(name, gender)
party(Wukong='Male', Qiqi='Female', Wufan='Male')
关于返回值的问题
函数根据执行完毕是否可以得到一个结果，将函数分为两个类型：
- 执行过程函数：print()
函数执行完毕之后，不会有任何结果可以被接受的函数 - 具有返回值的函数：id() type()
函数执行完毕之后，会产生一个结果，可以被变量接收或者使用的函数
def 函数名(参数...):
函数功能代码...
... ...
return 语句
return的特征：
- 具有return语句的函数称为具有返回值的函数
- return可以为当前函数执行完毕返回一个结果， 这样的函数调用可以被接受
- return执行之后，函数则会终止，所有return之后的语句不会被执行
- 一个函数可以书写多个return语句，但是一般会放入分支结构当中
- 一个函数如果需要返回多个数据，需要借助复合数据类型（list, tuple, set, dict）来操作即可
# 执行过程函数
def shashou():
print('白裤裆寒冬一击')
I = shashou()
print(I)
# 具有返回值的函数
def shashou():
print('白裤裆寒冬一击')
# 为函数添加返回结果
return '🩲'
I = shashou()
print(I)
# 执行过程的加法运算
def my_sum(a, b):
result = a + b
my_sum = my_sum(1, 2)
print(my_sum)
# 具有返回值的加法运算
def my_sum(a, b):
result = a + b
return result
my_sum = my_sum(1, 2)
print(my_sum)
def study():
print('不辅导作业')
print('母慈子孝')
print('一辅导作业')
print('鸡飞狗跳')
return '合家欢乐'
study()
def study():
print('不辅导作业')
print('母慈子孝')
print('一辅导作业')
print('鸡飞狗跳')
return '合家欢乐'
result = study()
print('返回结果',result)
def study():
print('不辅导作业')
print('母慈子孝')
return '合家欢乐'
print('一辅导作业')
print('鸡飞狗跳')
result = study()
print('返回结果',result)
变量的作用域
变量的作用域就是指变量的有效范围。
变量按照作用范围非为两类：
- 全局变量：
在函数外部声明的变量就是全局变量（在函数内部需要global关键字才可以使用） - 局部变量
在函数内部声明的变量就是局部变量
全局变量和局部变量的有效范围：
- 全局变量在函数外部可以正常使用
- 全局变量在函数内部也可以正常使用（需要global声明）
- 局部变量在函数内部可以正常使用
- 局部变量在函数外部不可以被访问
# 局部变量
def juhua():
#定义一个麻药
my = '局部麻醉剂'
print('函数内部调用：',my)
juhua()
def juhua():
#定义一个麻药
my = '局部麻醉剂'
print('函数内部调用：',my)
#在函数外部调用麻药
print(my)
# 全局变量
# 定义全局变量
my = '全身麻醉剂'
def juhua():
#在函数内部调用全局变量
print('在函数内部调用：',my)
juhua()
# 全局变量
# 定义全局变量
my = '全身麻醉剂'
def juhua():
#在函数内部调用全局变量
print('在函数内部调用：',my)
# 在函数外部调用全局变量
print('函数外部调用：',my)
#局部变量
def juhua():
#局部变量
num = 99
#使用局部变量
print(num)
#运算
num += 1
#使用局部变量
print(num)
juhua()
# 全局变量
num = 99
def juhua():
#使用全局变量
print(num)
#运算
num += 1
#使用变量
print(num)
juhua()
# 全局变量
num = 99
def juhua():
#声明全局变量
global num
#使用全局变量
print(num)
#运算
num += 1
#使用变量
print(num)
juhua()
print(num)
global关键字
将局部变量提升为全局变量。
只有在函数内部使用global关键字对变量进行全局声明，该变量才是一个完整的全局变量，在函数内外可以进行任意获取修改删除等操作。
内部函数
在函数内部声明的函数就是内部函数。
特征：
- 内部函数的本质就是局部变量（函数就是一个变量）
- 内部函数在函数外部不可以直接调用
- 内部函数在函数内部调用必须在定义了内部函数之后才可以调用
# 内部函数
# 内部函数可以在函数内部访问吗？ 可以！
def outer():
#声明一个内部函数
def inner():
print('这是一个内部函数')
#调用内部函数
inner()
outer()
# 内部函数
# 内部函数在函数内部调用是否有顺序？ 有！必须先定义后使用！！
def outer():
inner()
#声明一个内部函数
def inner():
print('这是一个内部函数')
#调用内部函数
outer()
# 内部函数
# 内部函数在函数外部使用嘛？ 不可以！
def outer():
#声明一个内部函数
def inner():
print('这是一个内部函数')
#调用内部函数
inner()
# 内部函数
# 调用外部函数之后，可以调用内部函数嘛？不可以！
def outer():
#声明一个内部函数
def inner():
print('这是一个内部函数')
#调用内部函数
inner()
outer()
inner()
变量作用域链
变量可以按照函数的嵌套结构组层向下传递下去。
nonlocal关键字允许修改外部函数的变量值！（既不是全局也不是局部！ ）
leader = '习大大'
#山西省
def shanxi():
#太原市
def taiyuan():
#万柏林区
def wanbolin():
#窊流村
def waliu():
pass
#测试
leader = '习大大'
#山西省
def shanxi():
print('山西省：',leader)
#太原市
def taiyuan():
print('太原市：',leader)
#万柏林区
def wanbolin():
print('万柏林区：',leader)
#窊流村
def waliu():
print('窊流村：',leader)
waliu()
wanbolin()
taiyuan()
shanxi()
