函数不可以直接调用其他函数内部定义的变量_基础知识回顾函数（一）

一.函数的作用

函数就是将一段具有独立功能的代码块整合到一个整体并命名，在需要的位置调用这个名称即可完成对应的需求。函数在开发过程中，可以更高效的实现代码重用。

# 备注：因为在Python里面，函数先定义，后调用，所以步骤2和3要在步骤1的上面书写# 2.确定选择功能界面：显示余额、存款、取款  # 3.封装函数# 不同的需求，参数可有可无# 定义函数：def 函数名(参数)#             代码1#             代码2#             ......def sel_func():print('显示余额')print('存款')print('取款')# 1.搭建整体框架"""输入密码登录后显示功能；查询余额后显示功能；取完钱后显示功能"""print('恭喜您登录成功！')# 显示功能界面 # 4.在需要的位置调用函数sel_func()print('您的余额是100000000000')# 显示功能界面 # 4.在需要的位置调用函数sel_func()print('取了100元钱')# 显示功能界面 # 4.在需要的位置调用函数sel_func()

二.函数的使用步骤

1. 定义函数

2. 调用函数：不同的需求，参数可有可无；函数必须先定义后调用

# 1.使用一个函数# 2.测试注意事项# 需求：一个函数：打印 hello world# info_print() 报错# 定义函数def info_print():print('hello world')# 调用函数info_print()"""1.函数先定义，后调用，如果先调用后定义会报错2.如果没有调用函数，那么函数里面的代码不会执行3.函数执行流程***

当调用函数的时候，解释器回到定义函数的地方去执行下方缩进的代码，当这些代码执行

完，回到调用函数的地方继续向下执行

定义函数的时候，函数体内部缩进的代码并没有执行"""

三.函数的参数作用

1. 函数调用时候指定的数字和定义函数时候接收的数字即是函数的参数；

2. 定义函数时同时定义了接收用户数据的参数，即形参；

3. 调用函数时传入了真实的数据，真实数据为实参。

# 1.函数：固定数据1和2 加法def add_num():
    result = 1 + 2    print(result)
add_num()# 2.参数形式传入真实数据，做加法运算# 定义函数时同时定义了接收用户数据的参数a和b,a和b是形参def add_num2(a,b):
    result = a + bprint(result)# 调用函数时传入了真实的数据10和20，真实数据为实参add_num2(10,20)# add_num2(20)  定义函数有2个参数，传入数据也要有2个

四.函数的返回值作用

使用变量保存函数返回值。

# 定义一个函数，返回烟 这个数据def buy():return '烟'# 使用变量保存函数返回值goods = buy()print(goods)# return返回结果给函数调用的地方"""return 作用：1.负责函数返回值2.退出当前函数，导致return下方的所有代码(函数体内部)不执行"""

# 需求：制作一个计算器，计算任意两个数字的加法结果，并返回结果"""1.定义函数：2个参数 和 return返回值2.调用函数：传入2个真实数据--这里即有返回值结果，打印这个结果即可"""def sum_num(a,b):return a + b# 用result变量保存函数返回值result = sum_num(1,2)print(result)

五.函数的说明文档

1.函数的说明文档也叫函数的文档说明；

2.定义函数的说明文档

def 函数名(参数)：

       '' " " 说明文档  ”  ”  ”

3.查看函数的说明文档

  help(函数名)

# help(len)  help函数作用：查看函数的说明文档(函数的解释说明的信息)def sum_num(a,b):"""求和函数"""  return a + bhelp(sum_num)# 函数的说明文档的高级使用def sum_num1(a,b):"""  求和函数sum_num1  :param a:参数1  :param b:参数2  :return:返回值  """  return a + bhelp(sum_num1)

六.函数嵌套

所谓函数嵌套调用指的是一个函数里面又调用了另外一个函数

# 两个函数testA 和testB --在A里面嵌套调用B# 先定义B函数，再调用A函数# B函数def testB():print('B函数开始------')print('这是B函数------')print('B函数结束------')# A函数def testA():print('A函数开始------')# 嵌套调用B  testB()print('A函数结束------')
testA()

# 1.打印一条横线def print_line():print('-'*20)# print_line()# 2.函数嵌套调用，打印多条横线def print_lines(num):
    i = 0    while i < num:
      print_line()
      i += 1print_lines(5)

# 1.任意三个数之和def sum_num(a,b,c):return a + b + c
result = sum_num(1,2,3)# print(result)# 2.任意三个数求平均值def average_num(a,b,c):     # 定义形参  sumResult = sum_num(a,b,c)return sumResult / 3averageResult = average_num(1,2,3)print(averageResult)

七.总结(一)

1.函数的参数

函数调用的时候可以传入真实的数据，增大函数使用的灵活性

形参：函数定义时书写的参数(非真实数据)

实参：函数调用时书写的参数(真实数据)

2.函数的返回值

作用：函数调用后，返回需要的计算结果

写法：return表达式

3.函数的说明文档

作用：保存函数解释说明的信息

写法：def 函数名()：

                           " " " 函数说明文档 " " "

4.函数嵌套调用：一函数内部嵌套调用另外一个函数

八.变量作用域

变量作用域指的是变量生效的范围，主要分为两类：局部变量和全局变量

1.局部变量

所谓局部变量是定义在函数体内部变量，即只在函数体内部生效

a.局部变量的作用

在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量

# 定义一个函数，声明一个变量，函数体内部访问一次、函数体外部访问一次def testA():
  a = 100  print(a)  # 函数体内部访问，能访问到a变量testA()# print(a)  # 报错：a变量是函数内部的变量，函数外部无法访问--a是一个局部变量

2.全局变量

所谓全局变量，指的是在函数体内、外都能生效的变量

a.注意：global关键字声明a是全局变量

# 声明全局变量：函数体内外都能访问a = 100print(a)def testA():print(a)def testB():print(a)
testA()
testB()

# B函数想要a的取值是200a = 100print(a)def testA():print(a)def testB():

# a = 200 # 如果直接修改a = 200,此时的a是全局a还是局部a?--得到结论：

这个a是局部变量

# # 因为在全局位置(B函数调用后)打印a得到的不是200而是100 # print(a) # 调用的是局部变量a # 想要修改全局变量a,值是200 global a # 声明a为全局变量 a = 200 print(a)
testA()
testB()print(a) # 访问全局变量a"""总结：

1.如果在函数里面直接把变量a = 200赋值，此时的a不是全局变量的修改，

而是相当于在函数内部声明了一个新的局部变量

2.函数体内部修改全局变量：先gloable声明a为全局变量，然后再变量重新赋值"""

九.多函数程序执行流程

一般在实际开发过程中，一个程序往往由多个函数组成，并且多个函数共享某些数据，比如：共用全局变量、返回值作为参数传递。

# 1.声明全局变量；2.定义2个函数；3.函数一修改全局变量，函数二访问全局变量glo_num = 0def test1():global glo_num  # 声明全局变量  glo_num = 100def test2():print(glo_num)print(glo_num) # 0 因为修改的函数没有执行test2()  # 0 因为修改的函数没执行test1()
test2()  # 先调用了函数1print(glo_num)   # 调用了函数1

十.函数的返回值

1.return a,b写法，返回多个数据的时候，默认是元组类型

2.return 后面可以连接列表、元组或字典，以返回多个值

# 1.定义两个函数 ；2.函数1有返回值，函数2把返回值50作为参数传入

(定义函数2要有形参)

def test1():return 50def test2(num):print(num)# 先得到函数1的返回值，再把这个返回值传入到函数result = test1()# print(result)test2(result)

# 需求：一个函数有两个返回值

# 一个函数如果有多个return不能都执行，只执行第一个return,无法做到一个函数

多个返回值

# def return_num():# return 1# return 2## result = return_num()# print(result)# 一个函数多个返回值的写法def return_num():# return 1,2 # 返回一个元组 # return 后可以直接书写元组、列表、字典，返回多个值 # return(10,30) return{100,300}return{'name':'python','age':20}
result = return_num()print(result)

十一.总结

函数的作用：封装代码，高效的代码重用

函数使用步骤：定义函数、调用函数

函数的参数：函数调用时可以传入真实数据，增大函数使用的灵活性

形参：函数定义时书写的参数(非真实数据)

实参：函数调用时书写的参数(真实数据)

函数的返回值

作用：函数调用后，返回需要的计算结果

写法：return表达式

函数的说明文档

作用：保存函数解释说明的信息

写法：def 函数名()：

            " " " 函数的说明文档 " " "

函数的嵌套调用：一个函数内部嵌套调用另外一个函数

十二.函数的参数

位置参数：调用函数时根据函数定义的参数位置来传递参数

注意：传递和定义参数的顺序及个数必须一致

# 需求：函数3个参数name,age,genderdef user_info(name,age,gender):print(f'你的姓名是{name},年龄是{age},性别是{gender}')# user_info('tom',20,'男')# user_info('tom',20,)  个数定义和传入不一致会报错# user_info(20,'tom','男')  顺序和定义必须是一致的，否则导致数据无意义

关键字参数：函数调用，通过“ 键=值 ”形式加以指定，可以让函数更加清晰，容易使用，同时也清除了参数的顺序需求

注意：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序

def user_info(name,age,gender):print(f'你的姓名是{name},年龄是{age},性别是{gender}')# 调用函数传参user_info('rose',age = 20, gender = '男')
user_info('rose',gender = '男',age = 20)  #关键字参数之间不分先后顺序# 位置参数必须写在关键字参数的前面# user_info(age = 20, gender = '男','tom')# 注意：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序

缺省参数：缺省参数也叫默认参数，用于定义函数，为参数提供值，调用函数时可不传该默认参数的值(注意：所有位置参数必须出现在默认参数前，包括函数定义和调用)

注意：函数调用时，如果为缺省参数传入则修改默认参数值，否则使用这个默认值

不定长参数：不定长参数也叫可变参数。用于不确定调用的时候会传递多少个参数(不传参也可)的场景。此时，可用包裹(packing)为位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便

def user_info(name,age,gender= '男'):print(f'你的姓名是{name},年龄是{age},性别是{gender}')
user_info('tom', 18)  # 没有为缺省参数传值，表示使用默认值user_info('tom', 18, gender = '女')  # 为缺省参数传值，使用这个值，即修改了默认值

# 包裹位置传递：接收所有位置参数，返回一个元组(tuple)def user_info(*args):print(args)
user_info('tom')
user_info('tom',20)
user_info('tom',20,'man')
user_info()

注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple),args是元组类型，这就是包裹位置传递

# 包裹关键字传递：收集所有关键字参数，返回字典def user_info(**kwargs):print(kwargs)
user_info()
user_info(name = 'tom')
user_info(name = 'tom',age = 20)

注意：无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程