Python函数 & 变量
原创
python 函数
表示一个功能,函数定义者是提供功能的人，函数调用者是使用功能的人
print(数据) 作用：将括号中的内容显示在控制台中
变量 = input("需要显示的内容") 作用：将用户输入的内容赋值给变量
1.掌握函数的定义与调用;
2.掌握函数实参和形参的使用方法;
3.了解函数的返回值;
4.掌握缺省参数的使用方法;
1. 函数----简介
1.1、函数的作用
函数的作用,在开发程序时,使用函数可以提高编写的效率以及代码的重用。
函数的使用包含两个步骤:
1.定义函数--封装独立的功能;
2.调用函数--执行函数的代码。
函数的目的
●封装代码,提高代码的重用性
●<font color=red>函数先定义，然后再调用</font>
●函数的定义
。把代码封装到函数内部
●函数的调用
。执行函数内部封装的代码
1.2、函数基本使用
1.2.1函数的定义
定义函数的格式如下:
def函数名():
函数封装的代码
- def是英文define的缩写;
- 函数名称应该能够表达函数封装代码的功能，方便后续的调用;
- 函数名称的命名应该符合标识符的命名规则;（一般函数名用小写）
调用的时候和定义函数的时候，参数的数量一一对应
1.2.2函数调用
通过 函数名() 即可完成函数的调用
调用语法
函数名()
函数定义和调用语法
函数的主要功能是封装代码
一个已定于的完成函数，不应该在修改函数的内部的定义代码；
可以通过函数的参数，实现函数代码的灵活功能。
语法
def 函数名（参数1，参数2...）: 函数内部封装代码
函数名(参数1对应的值，参数2对应的值，......)
调用的时候和定义函数的时候，参数的数量一一对应
def my_sum(a,b):
print(a+b)
my_sum(10,20) # 把10赋值个my_sum的a参数，把20赋值给my_sum的b参数1.3、函数练习
1.需求
●编写一个hello 的函数,封装三行代码;
●在函数下方调用hello函数。
# 这里只是定义了一个函数，名叫hello
# 定义函数的时候，函数内部的代码并不会执行
def hello():
print("hello wold")
print("hello wold")
print("hello wold")
# 调用函数
# 只有调用函数的时候，函数内部的代码才会真正执行
hello()注意:因为函数体相对比较独立，函数定义的上方，应该和其他代码 (包括注释) 保留两个空行.
定义好函数之后，函数内的代码并不会执行，只表示这个函数封装了一段代码而已。
调用函数后，函数的代码才会执行。如果不主动调用函数，函数是不会主动执行的
2.思考
能否将函数调用放在函数定义的上方?
不能！
因为在调用函数之前，必须要提前定义函数
def hello():
print("hello world")
print("hello world")
print("hello world")
def my_fun():
print("学习python")
my_fun()def hello():
print("hello world")
print("hello world")
print("hello world")
def my_fun():
print("学习python")
print("开始")
my_fun()
print("结束")
3.练习
定义一个函数，名字叫my_ func1
调用函数结果为显示20个连续的星号
def my_func1():
print("*"*20)
my_func1()2. 函数----参数
# def my_sum():
# a = 10
# b = 20
# print(a + b)
# # 函数一旦定义完成，就不会再次修改函数内部代码
# my_sum()
def my_sum(a,b):
print(a + b)
my_sum(10,20) # 把10赋值个my_sum的a参数，把20赋值给my_sum的b参数2.1、需求
1.开发一个my_ sqm的函数;)
2.函数能够实现两个数字的求和功能;
def my_sum():
a = 10
b = 20
print(a + b)
# 函数一旦定义完成，就不会再次修改函数内部代码
my_sum()2.2、存在什么问题
函数只能处理固定数值的相加,如果能够把需要计算的数字，在调用函数
时，传递到函数内部就好了!
2.3、函数参数的使用
- 在函数名的后面小括号内部填写参数；
- 多个参数直接使用 ， 分隔。
- 带参数的求和函数
def my_sum(a,b):
print(a+b)
my_sum(10,20) # 把10赋值个my_sum的a参数，把20赋值给my_sum的b参数def my_sum1(a,b):
c = a + b
print(c)
my_sum1(5,3)2.4、参数的作用
函数:把具有独立功能的代码块组织为-一个小模块，在需要的时候调用;
函数的参数:增加函数的通用性，针对相同的数据处理逻辑，能够适应更多的数据;
1.在函数内部，把参数当做变量使用，进行需要的数据处理
2.函数调用时，按照函数定义的参数顺序,把希望在函数内部处理的数据,通过参数传递
2.5、形参和实参
形参:定义函数时，小括号中的参数，是用来接收参数用的，在函数内部作为变量使用;
实参:调用函数时，小括号中的参数 , 是用来把数据传递到函数内部用的。
。
def my_sum1(a,b): # a,b 形参
c = a + b
print(c)
my_sum1(5,3) # 5,3 实参def my_sum(a,b):
print(a+b)
num1 = 2
num2 = 3
my_sum(10,20) # 把10赋值个my_sum的a参数，把20赋值给my_sum的b参数
my_sum(num1,num2) # b变量num1的值为2，所以形参a的值为2，形参的b的值为3
my_sum(7+2,5*3) # 形参a的值为9，形参b的值为15 ,7+2 表达式●形参
。定义函数的时候括号里面的参数
。形参必须是变量;
●实参
。调用函数的时候,括号里面的参数
。实参可以是常量
。实参可以是变量
。实参可以是表达式
●定义函数的时候形参有值吗?
。定义函数的时候,形参没有值，只是一个变量名
。只要调用函数的时候通过实参把值实时赋值给形参
2.6、练习
定义一个函数，名字叫my_ func2, 有一个参数num1; 调用my func2时，num1 为1，输出个
*号，num1为5，输出5个*号;举例:调用函数my_ func2(3)应该输出如下结果:
*****
def my_func2(num1): #定义函数的时候，形参没有值
print("*" * num1)
my_func2(1)
my_func2(5)3. 函数----返回值
在程序开发中，有时候会希望一个函数执行结束后，告诉调用者一个结果,
以便调用者针对具体的结果做后续的处理。
3.1、return关键字
●return的意义
。需求不停的变化,但函数一 旦定义函数内部的代码不应该因为需求改变而改变
。所以要把因为需求而改变的代码放到函数之外,函数之内代码函数定义完不改变
●有时候,函数并不是要显示什么内容，而是要把一个值返回给调用者, 比如python自带的
len函数就是这样的
●函数内容通过return返回给调用者一个值
●return后面可以是常量,也可以是表达式
# # 对于没有返回值的函数，调用方法，直接函数名（参数）
# print("hello python")
# 对于没有返回值的函数，调用方法。直接函数名(参数)
# len函数是有返回值的函数
a = len("hello python") # 会把一个值返回个调用者
print(a)
print(len("hello python"))在程序开发中，有时候会希望一个函数执行结束后，告诉调用者一个结果,
以便调用者针对具体的结果做后续的处理。
# 有返回值的函数
def my_sum(a,b):
return a + b # 把a + b 的结果，返回给调用者
num1 = my_sum(2,3) # 调用my_sum函数，所以num得到了函数的返回值
print(num1)
print(my_sum(5,6))返回两个参数中的最大值
# 返回两个参数中的最大值
def my_max(num1,num2):
if num1 > num2:
return num1
else:
return num2
a = my_max(50,6) # 调用函数，实参是5和6，形参num1的值是5，形参num2的值是6
print(a)
3.2、函数参数和返回值练习
1.定义一个函数，有两个参数，start和stop, start代表开始范围，stop 代表终止范围，求这个范围中所有整数相加的和
# 有返回值的函数
'''
计算一个区间范围内的和
'''
def my_func1(start,stop): # start 形参
sum = 0
a = start
while a<= stop:
sum += a
a += 1
return sum
num1 = my_func1(4,10)
print(num1)2.定义一个函数能够根据半径计算圆的面积
def cir(r):
pai = 3.14
return pai * r**2
print(cir(10))
print(cir(15))
a = cir(20) + cir(30) # 计算两圆的和
print(a)3.定义一个函数,名字叫my_ squar, 功能为计算矩形的面积，
有两个参数height与width,分别代表矩形的高和宽;
函数返回值为矩形的面积;
如调用my_ squar(3, 4)，函数返回值为12。
def my_squar(height,width):
return height * width
a = my_squar(3,4) # 定义一个变量a，得到调用my_squar函数的返回值
print(a)
#或者
print(my_squar(3,4))4.定义一个函数，名字叫my_ func,有两个参数num1与num2，当num1能被
num2整除时，返回值为True,否则返回值为False。
如:调用my_ _func(8, 4)，函数返回值为True。
如:调用my_ _func(9, 4)，函数返回值为False。
def my_func(num1,num2):
if num1%num2==0:
return True
else:
return False
print(my_func(8,4))
print(my_func(9,4))3.3、为什么函数要用户return
<font color=red> 程序设计有个原则，需求是不停的变化的，可以修改函数外部的代码，但函数定义后，不应该修改内部的代码</font>
# 需求1
# 计算两个整数的和，当和等于10的时候显示10，当和大于10的时候显示太大了，当和小于10的时候显示太小了
# 需求2
# 计算两个整数的和，当和等于100的时候显示100，当和大于100的时候显示太大了，当和小于100的时候显示太小了
# def my_sum(a,b):
# c = a + b
# if c == 10:
# print(c)
# elif c > 10:
# print("太大了")
# else:
# print("太小了")
#
# my_sum(4,6)
# my_sum(12,3)
# my_sum(2,5)
# 程序设计有个原则，需求是不停的变化的，可以修改函数外部的代码，但函数定义后，不应该修改内部的代码
def my_sum(a,b):
return a + b
a = my_sum(4,5)
if a == 10:
print(a)
elif a > 10:
print("太大了")
else:
print("太小了")4. 函数----嵌套使用 中级
一个函数里面又调用了 另外一个函数，这就是函数嵌套调用。
如果函数 test2 中，调用了另外一个函数 test1
那么执行到调用 test1 函数时，会先把函数 test1 中的任务都执行完
才会回到 test2 中调用函数 test1 的位置,继续执行后续代码
# 一个函数里面又调用另一个函数
def test1():
print("我是test1")
def my_func():
print("我是my_func")
def test2(): #如果不调用test2函数，那么test1和my_func都不执行
test1() # test2 内部调用了test1
my_func()
test2() # 程序第一条执行的语句5 函数----变量的作用域
5.1、局部变量和全局变量
局部变量是在函数内部定义的变量，只能在函数内部使用;
全局变量是在函数外部定义的变量(没有定义在某一个函数内) ，所有函数
内部都可以使用这个变量，
提示:在其他的开发语言中，大多不推荐使用全局变量-可变范围太大， 导致程序不好维护!
5.2、局部变量
局部变量是在函数内部定义的变量，只能在函数内部使用;
函数执行结束后，函数内部的局部变量，会被系统回收;
不同的函数，可以定义相同的名字的局部变量，彼此之间不会产生影响;
5.3 、局部变量的作用
在函数内部使用，临时保存函数内部需要使用的数据
总结
●局部变量
。函数内部定义的变量就是局部变量
。局部变量只能在函数内部使用
。不同的函数局部变量名字可以相同
●全局变量
。函数外部定义的变量就是全局变量
。全局变量在所有函数内部也可以使用
。局部变量能解决的问题,不要通过全局变量解决,尽量少定义全局变量
5.4、局部变量的生命周期（局部变量作用范围）
def my_func1():
a = 1 # a是一个局部变量，只属于my_func1函数
print(a)
def my_func2():
a = 2 # a是一个局部变量，只属于my_func2函数
print(a)
my_func1() # 调用函数的时候，局部变量a出现了
# my_func1函数调用完毕，a 消失了
# 定义函数的时候局部变量并不存在，只有调用函数的时候局部变量出现了●局部变量从调用函数的时候开始在内存出现,函数调用完毕,局部变量从内存消失
●如果一个函数内部定义了局部变量,但这个函数没有被调用，那么局部变量也不在内存中存在
5.5 、全局变量（全局变量作用范围）
全局变量是在函数外部定义的变量，所有函数内部都可以使用这个变量
为了保证所有的函数都能够正确使用到全局变量,应该将全局变量定义放在其他函数上方。
●全局变量一般定义在函数定义的上方
●全局变量从定义变量开始在内存中出现,一直到程序运行完成,和程序起从内存中消失
num1 = 2
def my_func1():
print(num1)
def my_func2():
print(num1)
my_func1()
num1 = 10
my_func2()5.6、全局变量与局部变量重名
●如果在函数内部定义一个变量名字和全局变量重名,那么在这个函数内部只能使用局部变
量
num1 = 1
def my_func1():
num1 = 10 # 这里不是为全局变量赋值，这里是定义了一个局部变量,名字和全局变量重名
print(num1) # 打印的是局部变量num1的值
num1 += 1 # 这里改的是局部变量num1的值
def my_func2():
print(num1) # 全局变量num1
my_func1()
my_func2()
print(num1) # 打印的是全局变量的num1的值<font color=red>注意:只是在函数内部定义了一个局部变量而已，只是变量名相同在函数内部不能直接修改全局变量的值。</font>
5.7、global关键字
如果在函数中需要修改全局变量，需要使用global 进行声明
●当需要在函数内部修改全局变量的值,修改前需要用global修饰全局变量的名字
def 函数(): global 全局变量名
全局变量名 = 值
num1 = 10
def my_func1():
global num1 # 函数内部就不存在和全局变量重名的局部变量
num1 = 1 # 这里是给全局变量num1 修改值
def my_func2():
print(num1) # 如果在函数内部不修改全局变量的值，就不用global
print(num1)
my_func1()
print(num1)num1 = 10
def my_func1():
# global num1 # 函数内部就不存在和全局变量重名的局部变量
num1 = 1 # 这里是给全局变量num1 修改值
def my_func2():
print(num1) # 如果在函数内部不修改全局变量的值，就不用global
print(num1)
my_func1()
print(num1)5.8、 练习
定义一个全局变量name="张三”，定义一个函数my test1, 在函数my test1 内部
修改全局变量name的值为”李四”
name = "张三"
def my_test1():
global name
name = "李四"
my_test1()
print(name)变量的作用域
a = 1
def my_test1():
global a
a = 2
def my_test2():
a = 3 # 这里的a是一个只在my_test2里面的局部变量
my_test1()
print(a) # 程序入口在这里
my_test2()
print(a)原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。
原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。
如有侵权，请联系 cloudcommunity@tencent.com 删除。