Python 函数

python 函数

函数简介

• 封装代码，提高代码的重要性

• 函数先定义，再调用

• 函数的定义

  • 把代码封装到函数内部

• 函数的调用

  • 执行函数内部封装的代码

1、函数定义和调用的语法

• 定义

def 函数名():
	函数内部封装的代码
# 函数名的命名规则与变量名命名规则一致

• 调用

函数名()

练习

# coding: utf-8
# 只定义一个函数，叫 hello
# 定义函数的时候，函数内部的代码并不会执行
def hello():
    print('hello world')
    print('hello world')
    print('hello world')

# 调用函数
# 只有调用函数的时候，函数内部的代码才会真正的执行
hello()

def my_func1():
    print('*'* 20)

my_func1()

2、函数的参数

• 函数的主要功能是封装代码
• 一个已经定义完成的函数，不应该再去修改函数内部的定义代码
• 可以通过函数的参数，实现函数代码的灵活功能
• 语法

def 函数名(参数1，参数2......)
	函数内部封装代码
函数(参数1对应的值，参数2对应的值......)
# 调用的时候和定义函数的时候，参数的数量要一一对应

# # coding: utf-8
# def my_sum():
#     a = 5
#     b = 6
#     print(a + b)
# # 函数一旦定义完成，就不会再次修改函数内部的代码
# my_sum()
def my_sum(a,b):
    print(a+b)
# 函数在定义的时候，有几个参数，调用的时候就对应几个值
my_sum(2,3) # 把2赋值给my_sum函数的a参数，把3赋值给my_sum函数的b参数

形参与实参

• 形参
  • 定义函数的时候，括号里面的参数
  • 形参必须是变量
• 实参
  • 调用函数的时候，括号里面的参数
  • 实参可以是常量
  • 可以是变量
  • 也可以是表达式
• 定义函数的时候，形参有无值？？？
  • 定义函数的时候，形参没有值，只是一个变量名
  • 只要调用函数的时候，通过实参把值实时赋值给形参

练习

# coding:utf-8
def my_func2(num1):   # 定义函数
    print('*' * num1)

my_func2(10)

3、函数——返回值

函数的返回值

• 把一个值返回给调用者，如：python自带的 len 函数就是这样
• 函数内容通过return返回给调用者一个值
• return后面可以是常量也可以是变量或者表达式

def my_sum(a,b):
    return a+b   # 把 a+b的结果，返回给调用者

num1=my_sum(2,3)  # 调用my_sum函数，num1得到函数的返回
print(num1)
# print(my_sum(3,4))

# coding: utf-8
def my_max(num1, num2):
    if num1 > num2:
        return num1
    else:
        return num2
a=my_max(5,7)
print(a)

练习

# coding: utf-8
def my_func1(start, stop):
    sum=0
    a = start
    while a <= stop:
        sum+=a
        a+=1
    return sum
# print(my_func1(4,10))
num1=my_func1(4,10)
print(num1)

# coding: utf-8
def cir(r):
    pai=3.14
    return pai*r**2

print(cir(2))
c=cir(3)+cir(2)
print(c)

• return意义：
  • 需求不停的变化，但函数一旦定义函数内部的代码，不应该因需求改变而改变
  • 所以要把因需求改变的代码放到函数外，函数内部代码定义为不改变
    

# coding: utf-8
def my_squar(height, width):
    return height * width

# a=my_squar(3,4)
# print(a)
my_squar(3, 4)
print(my_squar(3, 4))

def my_func(num1, num2):
    if num1 % num2 == 0:
        return True
    else:
        return False

print(my_func(8, 4))
print(my_func(9, 4))

4、函数的嵌套

• 一个函数内部调用另一个函数

# coding: utf-8
# 一个函数里调用另一个函数
def text1():
    print('我是text1')
def text2():
    print('我是text2')
def text3():   # 如果不调用 text3 函数，text1和text2都不会被执行
    text1()   # text3内部调用text1，text2
    text2()

text3()  # 执行第一条语句

5、变量作用域

• 局部变量
  • 函数内部定义的变量就是局部变量
  • 局部变量只能在函数内部使用
  • 不同的函数局部变量名字可以相同
• 全局变量
  • 函数外部定义的变量就是全局变量
  • 全局变量在所有函数内部也可以使用
  • 局部变量能解决的问题，不要通过全局变量来解决，尽量少定义全局变量

局部变量作用范围

• 局部变量从调用函数的时候开始在内存出现，函数调用完毕，局部变量从内存消失
• 如果一个函数内部定义了局部变量，但这个函数没有被调用，那局部变量也不会在内存中存在

# coding： utf-8
def my_func1():
    a=1    # a是一个局部变量，只属于my_func1函数
    print(a)
def my_func2():
    a=1    # a是一个局部变量，只属于my_func2函数
    print(a)

my_func1()  # 调用函数的时候，局部变量a出现
# my_func1 函数调用完毕后a消失

全局变量作用范围

• 全局变量一般定义在函数定义的上方
• 全局变量从定义变量开始在内存中出现，一直到程序运行完成，和程序一起从内存中消失

# coding： utf-8
num1 = 2

def my_func1():
    print(num1)

def my_func2():
    print(num1)

my_func1()
num1 = 10
my_func2()
print('end')

局部变量与全局变量重名

• 如果在函数内部定义一个变量，名字和全局变量重名，那么在这个函数内部只能使用局部变量

# coding: utf-8
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的值

6、global关键字（修改全局变量）

• 当需要在函数内部修改全局变量的值，修改前需要用global修饰全局变量的名字

def 函数():
	global 全局变量名
	全局变量名 = 值

# coding: utf-8
num1=10
def my_func1():
    global num1  # 函数内部不存在和全局变量同名的局部变量了
    num1=1     # 给全局变量num1修改值

def my_func2():
    print(num1)  # 在函数内部不修改全局变量的值，就不用global
print(num1)
my_func1()
print(num1)

# coding:utf-8
name='张三'
def my_text1():
    global name
    name='李四'

my_text1()
print(name)

7、形参和实参的值传递

• 如果形参的类型为数字或者字符串，在函数内部修改形参的值，实参的值不会改变

# coding: utf-8
def my_func1(a):  # a是形参，只是一个属于函数my_func1的形参，不是全局变量a
    a += 1        # 在函数内部，修改了形参a的值,不是修改全局变量a的值
    print(a)     # 输出了形参a的值

a=10         # 程序入口。定义一个全局变量a，值是10
my_func1(a)    # 把全局变量a作实参，去调用函数 my_func1
print(a)  # 全局变量a的值没有改变
# 当参数类型为数字或者字符串，形参的值改变了，实参的值不会改变

• 函数的形参本质就是一个属于函数内部的局部变量

# coding:utf-8
a=10

def my_text1(a):
    a+=1    # 重名后，这里的a是局部变量
    print(a)

my_text1(a)   # 把全局变量作为形参来调用my_text1函数
print(a)
# 代码中一共两个变量
# 全局变量a和一个形参a（形参就是属于函数内部的局部变量）
# 以上代码结果是全局变量与局部变量重名

• 形参类型如果是列表 、集合字典 形参的值会改变，会影响实参的值

# coding:utf-8
a=[1,2,3]

def my_text1(a):  # a 是一个形参，也是属于my_text1 的局部变量
    a[0]=10  # 修改的是形参a 的值
# 如果形参的类型为列表、集合、字典，修改形参的值会直接影响实参的值

print(a)   # 显示全局变量 a 的值
my_text1(a)  # 把全局变量作为实参，来调用 my_text1
print(a)

# coding: utf-8
a=[1,2,3]
def my_text1(a):
    a.clear()

my_text1(a)
print(a)

形参的缺省值

• 形参可以有缺省值，调用函数的时候，没有提供相应的实参，那么形参会采用缺省值

def 函数名(形参=缺省值)

# coding: utf-8
def my_text1(a,b=10):   # 形参b有缺省值
    print(a,b)

def my_text2(a=1,b=2):
    print(a,b)

my_text1(1,2)
my_text1(100)
my_text2()
my_text2(100,12)

• 不能把有缺省值的形参写到没缺省值形参的前面

# def my_text3(a=1,b):     不能把有缺省值的形参写到没缺省值形参的前面
#     print(a,b)

8、lambda匿名函数

• lambda是给特别小型的函数准备的一个简化语法
• 不用写def，也不用写return
• 一个代码就能定义一个函数
• 语法

lambda 参数1，参数2，…：函数执行代码

# coding: utf-8
# def my_sum(a,b):
#     return a+b
#
# print(my_sum(2,3))

my_sum = lambda a, b: a + b
print(my_sum(2,6))

num1=(lambda a,b:a if a>b else b)(2,3)
print(num1)

lambda的注意事项

• 匿名函数内部只有一条语句，而且这条语句要有具体的返回值
• 匿名函数不能使用print