python-函数

第 1 章 函数------简介

一、函数的作用

函数的作⽤，在开发程序时，使⽤函数可以提⾼编写的效率以及代码的重⽤。

函数的使⽤包含两个步骤：

1. 定义函数 —— 封装独⽴的功能 ；
2. 调⽤函数 —— 执行函数的代码 。

二、函数基本使⽤

1. 函数的定义

定义函数的格式如下：

def 函数名():

​ 函数封装的代码

​ ……

def 函数名（）：
	函数内部封装代码

1. def 是英⽂ define 的缩写 ；

2. 函数名称应该能够表达函数封装代码的功能，⽅便后续的调⽤ ；

3. 函数名称的命名应该符合标识符的命名规则 ；

2. 函数调⽤

​ 通过 **函数名（） ** 即可完成函数的调用

函数名（）

三、函数演练

1. 需求

• 编写⼀个 hello 的函数，封装三⾏代码
• 在函数下⽅调⽤hello 函数

#这里只是定义了一个函数，名叫hello
def hello():
    print("hello world")
    print("hello world")
    print("hello world")

#调用函数
hello()

hello world
hello world
hello world

Process finished with exit code 0

注意：因为函数体相对⽐较独⽴，函数定义的上⽅，应该和其他代码（包括 注释）保留两个空⾏。

定义好函数之后，函数内的代码并不会执行，只表示这个函数封装了⼀段代 码⽽已 。

调用函数后，函数的代码才会执行。如果不主动调⽤函数，函数是不会主动 执⾏的。

2. 思考

• 能否将函数调⽤放在函数定义的上⽅？

不能！

因为在调⽤函数之前，必须要提前定义函数。

1. 课堂练习---

定义一个函数，名字叫 my_func1

调用函数结果为显示 20 个连续的星号

#定义函数
def my_func():
    print("*"*20)


#调用函数
my_func()

第 2 章 函数------参数

一、需求

1. 开发⼀个 my_sum 的函数 ;

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)

四、参数的作⽤

函数: 把具有独⽴功能的代码块组织为⼀个⼩模块，在需要的时候调⽤；

函数的参数: 增加函数的通⽤性，针对相同的数据处理逻辑，能够适应更多的数据；

1. 在函数内部，把参数当做变量使⽤，进⾏需要的数据处理
2. 函数调⽤时，按照函数定义的参数顺序，把希望在函数内部处理的数据，通过参数传递

五、形参和实参

形参：定义函数时，⼩括号中的参数，是⽤来接收参数⽤的，在函数内部作为变量使⽤；

实参：调⽤函数时，⼩括号中的参数，是⽤来把数据传递到 函数内部⽤的 。

（实参可以是变量，常量，表达式；形参只能是变量）

1. 课堂练习---

定义一个函数，名字叫 my_func2，有一个参数 num1；

调用 my_func2 时，num1 为 1，输出1个 * 号，num1 为 5，输出 5 个 * 号；

举例：调用函数 my_func2(3)应该输出如下结果:

def my_func2(num1):
    print("*" * num1)

my_func2(3)

第 3 章 函数------返回值

在程序开发中，有时候会希望⼀个函数执⾏结束后，告诉调⽤者⼀个结果， 以便调⽤者针对具体的结果做后续的处理。

返回值是函数完成⼯作后，最后给调⽤者的⼀个结果。

一、return 关键字

在函数中使⽤ return 关键字可以返回结果。

调⽤函数⼀⽅，可以使⽤变量来接收函数的返回结果 。

注意： return 表示返回, 后续的代码都不会被执行

• 带返回值的 my_sum2 函数

  def my_sum2(num1, num2):
      result = num1 + num2
      return result
      # return 后面的代码，将不会被执行 print("test")
      print("test")
  
  a=my_sum2(1,3)
  print(a)
  
  4
  
  Process finished with exit code 0
  

• 返回参数中的最大值

  def my_max(num1, num2):
      if num1 > num2:
          return num1
      else:
          return num2
  
  a=my_max(1,3)
  print(a)
  
  3
  
  Process finished with exit code 0
  

1、return的意义

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

二、函数参数和返回值演练

1、需求1：求和

1. 定义⼀个函数，有两个参数，start 和 stop，start 代表开始范围，stop 代表终止范围，求这个范围中所有整数相加的和

def my_func(start,stop):
    sum=0
    a=start
    while a<=stop:
        sum=sum+a
        a=a+1
    return sum


print(my_func(2,10))

2、需求2：计算圆的面积

2. 定义⼀个函数能够根据半径计算圆的面积

def circular(r):
    pai=3.14
    s=pai* r**2
    return s

print(circular(2))
12.56

Process finished with exit code 0

3. 课堂练习---

定义一个函数，名字叫 my_squar，功能为计算矩形的面积，有两个参数 height 与 width，分别代表矩形的高和宽；

函数返回值为矩形的面积；

如调用 my_squar(3, 4)，函数返回值为 12。

def my_squar(height,width):
    s=height*width
    return s

print(my_squar(2,3))

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))

第 4 章 函数------嵌套调⽤

⼀个函数⾥⾯又调⽤ 了另外⼀个函数，这就是函数嵌套调⽤。

如果函数 test2 中，调⽤了另外⼀个函数 test1

那么执⾏到调⽤ test1 函数时，会先把函数 test1 中的任务都执⾏完

才会回到 test2 中调⽤函数 test1 的位置, 继续执行后续代码

def test1():
    print("我是 test1")

def test2():
# 先执行函数 test1 的代码
    test1()
# test1 函数执行完毕后，再执行下面代码
    print("我是 test2")

test2()

我是 test1
我是 test2

Process finished with exit code 0

第 5 章 函数------变量的作用域

一、局部变量和全局变量

局部变量是在函数内部定义的变量，只能在函数内部使⽤ ；

全局变量是在函数外部定义的变量（没有定义在某⼀个函数内），所有函数内部都可以使⽤这个变量 。

提示：在其他的开发语⾔中，大多不推荐使⽤全局变量 —— 可变范围太⼤，导致 程序不好维护！

二、局部变量

• 局部变量是在函数内部 定义的变量，只能在函数内部使⽤；

• 函数执⾏结束后，函数内部的局部变量，会被系统回收；

• 不同的函数，可以定义相同的名字的局部变量，彼此之间不会产⽣影响 ；

三、局部变量的作⽤

在函数内部使⽤，临时保存函数内部需要使用的数据

def my_func1():
    a=10      #a是一个局部变量，只属于my_fun1函数
    print(a)

def my_func2():
    a = 20
    my_func1()  # 调用 my_func2 函数，不会影响 a 的值
    print("a = %d" % a)

my_func2()

10
a = 20

Process finished with exit code 0

四、局部变量的⽣命周期

所谓⽣命周期就是变量从被创建到被系统回收的过程 ；

局部变量在函数执⾏时才会被创建 ；

函数执⾏结束后局部变量被系统回收 ；

局部变量在⽣命周期内，可以⽤来存储 函数内部临时使⽤到的数据 。

五、全局变量

• 全局变量是在函数外部定义的变量，所有函数内部都可以使⽤这个变量 。

• 为了保证所有的函数都能够正确使⽤到全局变量，应该将全局变量定义放在其他函数上方。

# 定义一个全局变量 num
num = 100
def my_func1():
    print(num)

def my_func2():
    print(num)

my_func1()
my_func2()

六、全局变量与局部变量重名

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

# 定义一个全局变量 num
num = 100
def my_func1():
    # 函数内部定义一个变量和全局变量重名
    num = 1
    print(num)   #打印的是局部变量num的值


# 全局变量 num 的值并没有改变
my_func1()     
print(num)    #打印的是全局变量num的值

1
100

Process finished with exit code 0

注意：只是在函数内部定义了⼀个局部变量⽽已，只是变量名相同 —— 在函数内部不能直接修改全局变量的值。

七、global 关键字

如果在函数中需要修改全局变量，需要使⽤ global 进⾏声明

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

# 定义一个全局变量 num
num = 100
def my_func1():
    # 函数内部使用 global 关键字声明全局变量num
    global num
    num = 1

# 全局变量 num 的值被 my_func1 函数改变

print(num)
my_func1()
print(num)

100
1

Process finished with exit code 0

1. 课堂练习---

定义一个全局变量 name=”张三”, 定义一个函数 my_test1, 在函数 my_test1 内部 修改全局变量 name 的值为”李四”

name="张三"
def my_test1():
    global name
    name="李四"

print(name)
my_test1()
print(name)

第 6 章 函数------参数进阶

一、形参和实参的值传递

• 如果函数的参数为数字，字符串，在函数内部，针对形参使⽤赋值语句，不会影响调⽤函数时传递的实参的值。------形参的值改变了，实参不会改变（形参为数字，字符串）

def my_test(num):
    num=num+1     #在函数内部，修改了形参num的值
    print(num)

num=10            #程序入口，定义一个全局变量num 值为10
my_test(num)	  #把全局变量num作为实参，去调用函数my_test
print(num)

11
10

Process finished with exit code 0

• 如果函数参数为列表，集合，字典等类型。函数内部修改了参数的内容，会影响到外部的数据 。

def my_test(list1):
    list1[0] = "刘备"
    print(list1)

a = ["周瑜", 100, 3]
print(a)
my_test(a)
print(a)

['周瑜', 100, 3]
['刘备', 100, 3]
['刘备', 100, 3]

Process finished with exit code 0

1. 课堂练习---

定义一个函数，参数为列表类型，调用函数过后，删除列表所有值

def my_test(list1):
    list1.clear()
    print(list1)

a = [2,5,3]
print(a)
my_test(a)
print(a)

[2, 5, 3]
[]
[]

Process finished with exit code 0

二、缺省参数

• 定义函数时，可以给 某个参数指定⼀个默认值，具有默认值的参数就叫做 缺省参数 。

• 调⽤函数时，如果没有传⼊缺省参数的值，则在函数内部使⽤定义函数时指 定的参数默认值 。

• 函数的缺省参数，将常⻅的值设置为参数的缺省值，从⽽简化函数的调⽤ 。

1. 单个缺省参数

# 第二个参数的缺省值为 100
def my_func1(a, b = 100):
    print("a = {}, b = {}" .format(a,b))

my_func1(1, 2)
# 没有写第二个参数，第二个参数采用缺省值 100
my_func1(1)

a = 1, b = 2
a = 1, b = 100

Process finished with exit code 0

2. 多个缺省参数

当函数有多个缺省参数，调用函数的时候，对于不使用默认值的缺省参数可 以通过：参数 = 值 的方式，明确具体参数的值。

# 第一个参数的缺省值为 50 第二个参数的缺省值为 100
def my_func1(a=50, b = 100):
    print("a = {}, b = {}" .format(a,b))

my_func1(1, 2)
# 没有写二个参数，二个参数采用缺省值50  100
my_func1()

a = 1, b = 2
a = 50, b = 100

Process finished with exit code 0

• 缺省参数的注意事项：

  • 缺省参数的定义位置

    • 必须保证带有默认值的缺省参数在参数列表末尾 。

  • 所以，以下定义是错误的！

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

第 7 章 函数------匿名函数

⽤lambda 关键词能创建⼩型匿名函数。这种函数得名于省略了⽤def 声明函数的标准步骤。

lambda 函数的语法只包含⼀个语句，如下：

​ lambda [arg1 [,arg2,.....argn]]:expression

如下实例：

sum = lambda arg1, arg2: arg1 + arg2

• lambda 案例 1

# 简化版的 sum 求和函数
my_sum = lambda a, b: a + b
num = my_sum(3, 6)
print(num)

• lambda 案例 2

# 简化版的 lambda 函数，求最大值
num = (lambda a, b: a if a > b else b)(3, 6)
print(num)

6

Process finished with exit code 0

• Lambda 函数只能返回⼀个表达式的值 ;

• 匿名函数不能直接调⽤print，因为 lambda 需要⼀个表达式 。