2019-04-25
函数基础
摘要
函数基础.png
函数
1. 什么是函数
- 函数就是对实现某一特定功能的代码块的封装
2. 函数的分类
- 系统函数(内置函数) - 系统已经实现的函数(已经造好的机器)，程序员只需要回调用就行
print函数、input函数、len函数、sum函数、max函数等等... - 自定义函数 - 程序员自己声明的函数(自己造机器)
nums = [1, 23, 6, 78]
print(max(nums))
3. 函数的声明(定义) - 造机器
1)语法:
def 函数名(形参列表):
函数说明文档
函数体
2)说明
- def - python声明函数的关键字
- 函数名 - 要求：程序自己命名，标识符但不能是关键字(和变量名要求一样)
规范：见名知义(看到函数名大概知道函数的功能) - () - 固定写法
- 形参列表 - 变量名1,变量名2,变量名3,...(根据情况变量名的个数可以是0个、1个或者多个)
形参的作用是将函数外面的数据传递到函数的里面 - : - 固定写法
- 函数体 - 和def保持一个缩进的一条或者多条语句。(实现函数功能的代码块)
3)初学者声明函数的步骤
第一步：确定函数的功能
第二步：根据功能确定函数名
第三步：确定形参(看实现函数的功能需不需要从外面传值，如果需要传值，需要几个)
第四步：实现函数的功能
第五步：确定返回值
(!!!!)注意：函数声明的时候，函数体不会执行！
- 练习：写一个函数求两个数的和
def sum2(n):
"""
:param n: 累加的个数
:return:
"""
sum3 = 0
for i in range(1, n+1):
sum3 += i
print(sum3)
4. 函数的调用 - 使用机器
1)语法：
函数名(实参列表)
2)说明
- 函数名 - 已经声明过的函数
- () - 固定写法
- 实参列表 - 数据1,数据2,数据3,...(实参是用来给形参赋值的)
3)函数的调用过程(特别重要!!!)
第一步：回到函数声明的位置
第二步：用实参给形参赋值(这个过程又叫传参，传参要保证每个形参都有值)
第三步：执行函数体
第四步：获取返回值
第五步：回到函数调用的位置，接着往后执行
# 同一个函数可以调用多次
sum1(5, 3)
print('===========')
sum2(10)
参数
1. 位置参数和关键字参数
- 调用函数的时候根据实参的写法分为位置参数和关键字参数
1)位置参数：
- 让实参的顺序和形参一一对应，中间用逗号隔开
2)关键字参数：
以’形参名1= 值1,形参名2= 值2...‘格式来确定实参
注意：如果既有位置参数又有关键字参数，位置参数必须在关键字参数前面
def func1(a, b, c):
# a=10, b=20, c=30
print('a:', a, 'b:', b, 'c:',c)
# 位置参数
func1(10, 20, 30)
# 关键字参数
func1(c=30, b=20, a=10)
# 位置参数+关键字参数
func1(10, c=30, b=20)
# func1(c=30, 20, a=10) # SyntaxError: positional argument follows keyword argument
2. 参数默认值
声明函数的时候，可以给形参赋默认值。有默认值的形参，在调用函数的时候可以不用给这个形参赋值
注意：声明的时候有默认值的参数要放在没有默认值的参数的后面
ef func2(a=10, b=20, c=30):
print(a, b, c)
func2()
func2(100)
func2(100, 200)
func2(100, 200, 300)
# 调用函数只给a和c赋值，b使用默认值(要跳着赋值，需要用到关键字参数)
func2(a=100, c=200)
func2(100, c=200)
3. 参数的类型说明
python中类型只有说明的作用，没有约束的作用
- 1)参数赋默认值
- 2)参数名：类型
def func3(a: str, b=''):
print(a, b)
func3([1, 3], 'anc')
4. 不定长参数 - 形参的参数不确定
- 1)声明函数的时候，在形参的前面加*，那么这个参数就变成不定长参数，可以同时接受多个位置实参(将这个参数变成元祖)
用位置参数传参 - 2)声明函数的时候，在形参的前面加**，那么这个参数也会变成不定长参数.可以同时接受多个位置实参(将这个参数变成字典)
用关键字参数传参 - 注意：不带的参数要放在带参数的前面(定长参数要在不定长参数的前面)
# 练习：写一个函数，求多个数的和
def yy_sum(a, *nums):
print(a, nums)
# yy_sum()
yy_sum(10, 21)
yy_sum(10, 21, 45)
yy_sum(10, 21, 45, 80)
# operation('+',23. 45, 55) -> 求和
# operation('-',23. 45, 55) -> 求差
# operation('*',23. 45, 55) -> 求乘积
# operation('/',23. 45, 55) -> 求除
def func4(*nums):
print('======*不定长====')
print(nums)
func4(2, 5, 6)
def func5(**nums):
print('======**不定长====')
print(nums)
func5(a=2, b=5, c=6)
def func6(*args, **kwargs): # 两者都有时，*参数必须在**的前面
print('======*不定长+**不定长参数====')
print(args, kwargs)
func6(2, 5, c=6) # 先位置参数，在关键字参数
# 练习：写一个函数，按指定的方式计算多个数字的结果
def operation(a, *nums):
if a == '+':
sum1 = 0
for item in nums:
sum1 += item
print(sum1)
if a == '-':
sum1 = nums[0]
for i in range(1, len(nums)):
sum1 -= nums[i]
print(sum1)
if a == '*':
sum1 = 1
for item in nums:
sum1 *= item
print(sum1)
if a == '/':
sum1 = nums[0]
for i in range(1, len(nums)):
sum1 /= nums[i]
print(sum1)
operation('+', 2, 10, 10)
operation('-', 2, 10, 10)
operation('*', 2, 10, 10)
operation('/', 2, 10, 10)
# 练习：写一个函数，求多个数的和。要求既可以用位置参数传参，有可以用关键字参数传参
def sum_1(*args, **kwargs):
"""
求多个数的和
:param args:求不定长参数，数字 --位置参数
:param kwargs: 求不定长参数，数字 --关键字参数
:return:
"""
sum1 = sum(args)
for key in kwargs:
sum1 += kwargs[key]
print(sum1)
sum_1(10, 20, a=30, b=40)
函数返回值
1. 什么是函数的返回值
返回值就是return关键字后面表达式的值，就是函数调用表达式的值
1) return
return是函数体中的关键字(只能出现在函数体中)
作用：结束函数，确定函数的返回值调用函数：执行函数体，获取函数返回值
(重要！！！)函数调用过程：
1.回到函数声明的位置
2.传参
3.执行函数体
4.执行完函数体，确定函数返回值
执行完函数体：函数体执行完、执行过程中遇到return
确定函数返回值：看执行函数的过程中有没有遇到return，
如果遇到了return后面表达式的值就是函数的返回值。
如果没有return函数的返回值就是None
5.回到函数调用的位置，接着往后执行。(这个时候函数调用表达式的值就是函数的返回值)
def func1():
print('=====')
# return # 提前结束函数
print('aaaaaaa')
a = 100
if a > 1000:
return 100+a # 确定函数返回值
# return: None
n = func1()
print(n) # n = 100
print(func1())
2. 什么时候需要返回值(初学者) -- 返回值比直接输出的操作更多
- 指导思想：如果实现函数的功能会产生新的数据，就可以吧这个数据作为函数的返回值
return 返回值1,返回值2.....
def yy_sum(num1, num2):
return num1 + num2
sum1 = yy_sum(10, 20)
print(sum1)
匿名函数
1. 什么是匿名函数
- 匿名函数就是没有名字的函数
1)
lambda 参数列表:返回值
2)说明
lambda - 关键字
参数列表 - 相当于普通函数的形参列表，变量1，变量2.....
: - 固定写法
返回值 - 相当于普通函数函数体中的return语句。可以是除了赋值语句以外的任何语句
-
注意：
- 1.匿名函数本质还是函数，之前函数中讲的语法绝大多数都适用(通过类项目来对参数类型说明是不支持的)
- 2.匿名函数能做的事情，普通函数都可以做。只是匿名函数简洁
# 1.使用匿名函数求两个数的和
func1 = lambda x, y: x+y # function类型
print(func1(10, 20))
print(func1, type(func1))
func2 = lambda x, y: max(x, y)
print(func2(20, 50))
变量
1. 变量的作用域
- 指的就是变量的使用范围
2. 全局变量、局部变量
1)全局变量：没有声明在函数/类中的变量都是全局变量，全局变量的作用域是从变量声明开始到
整个py文件结束
2)局部变量：声明在函数中的变量都是局部变量，作用域是从变量声明到函数结束
注意：形参也是局部变量
当在调用函数的时候，系统会自动在内存的栈区间为这个函数开辟一个独立的内存区域，用来
保存在函数中声明的变量或者产生的数据。当函数调用结束后，这个内存区域会自动销毁
a = 10
if True:
print('if:', a)
for x in range(4):
print('for:', a)
def func1():
print('函数:', a)
func1()
for num in range(3):
temp = 100 # temp也是全局变量
print(num) # num还是全局变量
print('循环外：', num)
def func2():
print('函数里', num)
func2()
print('=========局部变量=========')
def func3(xx):
yy = 100
print('函数中', xx, yy)
# print(xx) # NameError: name 'xx' is not defined
3. global和nonlocal
1)global - 在函数中声明一个全局变量(只能在函数中使用)
global 变量名
变量名 = 值2)nonlocal - 想要在局部的局部中去修改一个局部变量的值，就使用nonlocal
print('=============global==========')
# x1 = 100
def func4():
global x1 # 说明后面的x1是一个全局变量
x1 = 200
print('函数中:', x1)
func4()
print('函数外面:', x1)
print('===============nonlocal=============')
def func5():
x2 = 100
def func6():
nonlocal x2
x2 = 200
print('函数中的函数:', x2)
func6()
print('函数中:', x2)
func5()
# print(x2)
def func7():
global x4
x4 = 100
func7()