python基础09 函数

1、函数的基础

1.1 概念

函数就是实现某一特定功能的封装。（函数就是实现某一特定功能的代码打成一个报，以后再需要这个功能的时候就直接调用这个函数）

1.2 分类

根据函数由创建可以将函数分为：a、系统函数：由系统创建好的函数，例如：ptint、input、max、chr等 b、自定义函数：由程序员自己造的函数

2、定义函数

• 语法

'''
def 函数名（形参列表）：
    函数说明文档
    函数体   
'''

• 说明

'''
def       固定写法
函数名    程序员自己命名
          两个要求：是标识符；不能是关键字
          三个规范：见名知义（看到函数名就大概知道功能）；
                  所有字母都小写，如果由多个单词，之间用下划线隔开；
                  不使用系统函数名、类名或者模块名
（）：    固定写法
形参列表  以‘变量名1，变量名2，变量名3.。。’的形式存在，里面每一个变量就是一个形参     
			   作用：将函数外部的数据传递到函数里面
				 怎么确定形参的数量：看实现函数的功能需不需要额外的数据，需要几个
说明文档    本质就是多行注释
函数体      结构上，就是和def保持一个缩进的一条或者多条语句，至少一条
           逻辑上，函数体就是实现函数功能的所有代码
'''

#案例： 定义一个函数统计字符串中数字字符的个数
def num_conut(str1):
    '''
    统计字符串中数字字符的个数
    :param str1: 原字符串
    :return: None
    '''
    count = 0
    for i in str1:
        if i.isdigit():
            count+=1
    print(count)

3、函数的调用

• 语法

  函数名（实参列表）

• 说明

'''
函数名       -需要哪个函数的功能就调用哪个函数，调用哪个函数就写哪个函数的函数名；
              函数名必须是已经定义过的函数的函数名
（）          固定写法
实参列表      以‘数据1，数据2，...’的形式存在
              实参就是从函数外部传递到函数内部的数据
              实参的个数由形参决定
'''

• 函数调用
  • 定义函数是不会执行函数体，调用函数时才会执行函数体（调用多少次就执行多少次
  • 具体步骤
    1. 回到函数定义位置
    2. 传参（用实参给形参赋值）
    3. 执行函数体
    4. 确定函数返回值
    5. 回到函数调用的位置接着往后执行

4、函数的参数

根据实参的提供方式不同可以将实参分为位置参数和关键字参数两种

4.1 位置参数

直接将多个数据用逗号隔开，让实参和形参从位置上一一对应。

func1(10,20,30)
func1(10,30,20)

4.2 关键字参数

以‘形参1=数据1，形参2=数据2。。。‘的形式传参

func1(x = 10,y = 20,c = 30)
func1(x = 10,y = 30,c = 20)

注意：位置参数和关键字参数可以一起使用，但是使用的时候位置参数必须在关键字参数前面

4.2 参数默认值

定义函数的时候可以以’形参名 = 值‘的方式给形参赋默认值，有默认值的形参在调用函数的时候可以不用传参

注意：如果有的形参没有默认值，有的没有，但是没有默认值的形参必须放在有默认值的前面

4.4 参数类型说明

定义函数的时候指定参数类型。

• 没有默认值的参数：在形参后加’：类型名‘
• 给参数赋默认值 ：
• 返回值类型说明： →类型名

4.5 不定长参数

参数个数不确定

• *对应的不定长参数

  定义函数的时候可以在某一个形参前加*，让这个参数变成一个不定长参数，可以同时接收若干个实参

  原理：让带*的形参变成一个元组，接收到的每个实参会成为元组中的元素

# 案例：定义一个函数，求多个数的和
# sum2(10, 20)
# sum2(1, 2, 3)
# sum2(10, 20, 30, 4, 5)

def can_num(*nums):
    s = 0
    for x in nums:
        s += x
    print(s)

can_num(10, 20)

注意：

a、*对应的不定长参数的实参只能用位置参数

b、如果一个函数中既有带的不定长参数，又有定长参数，调用函数时前面的定长参数必须位置参数传参，*后面的定长参数必须用关键字参数传参

• **对应的不定参数

在某一个形惨前加**可以让中国形参变成一个不定参数同时接收多个实参

原理：让**的形参变成一个字典，接收实参变成字典中的元素

def func3(**x):
    print(x)

func3(name = '张三',age = 18,gender = 'nan')
#这儿*作用：让*前面的参数必须用位置参数，*后面的参数必须使用关键字参数
def func4(x,*,y,z):
    pass

#让func5在调用是可以以任何形式调用
def func(*args,**kwargs):
    pass

注意：调用参数的时候，**对应的不定长参数只能使用关键字传参，而且变量名可以是任何合法的变量名

5、函数的返回值

函数返回值就是从函数内部传递到函数外部的数据

• 为什么需要返回值

  在函数内部产生的数据，如果不作为函数的返回值返回，在函数调用结束的时候这个数据会自动释放。

• 什么时候需要返回值

  如果实现函数的功能产生了新的数据，就需要将新的数据作为返回值返回

• 怎么将数据作为返回值返回

  将需要返回的数据放在关键字return的后面

注意：如果执行函数体的到时候遇到return，函数的返回值就是None

• 怎么在函数外部使用函数的返回值

  函数调用表达式：调用函数的那条语句

6、return的作用

• 将数据作为函数的返回值返回
• 提前结束函数 -如果执行函数体的时候遇到了return，函数直接结束

def func2(x):
    for i in range(100):
        if i == i:
            return
        print(i)
result = func2(6)
print(result)         #None

7、匿名函数

7、匿名函数

• 概念

匿名函数的本质是函数，普通函数除了定义函数的语法意外其他内容都适用于匿名函数

• 语法

lambda 形参列表：返回值

• 说明

  lambda：固定写法 形参列表：和定义函数的形参列表一样，用逗号隔开 ：：固定写法 返回值：只有一个表达式，表达式的计算结果就是函数的返回值

• 匿名函数的应用场景

  将函数作为其他函数的实参，可以使用匿名函数 一个函数如果只需要使用一次，可以使用匿名函数

'''
lambda 形参列表：返回值
def 函数名（形参列表）：
    return
''''

#案例1：将函数作为实参传递
#需求：将列表中的每一个元素都进行平方运算，然后再将结果放到一个列表中
list1 = [1,2,3,4,5,6,7,8,9]
def func6(x):
    return x**2
result = map(func6,list1)
print(list(result))

#使用匿名函数实现
result = map(lambda x:x**2,list1)
print(list(result))

#案例2：给定一些字符串，要求使用统一的方式将每一个字符串进行处理
#需求：将每一个字符串中的大写字母转成小写字母，再将结果放到一个列表中
list2 = ['Hello World','Hello Kitty','Python','Java','C++']
def func7(x):
    return x.lower()
result = map(func7,list2)
print(list(result))

#使用匿名函数实现
result = map(lambda x:x.lower(),list2)
print(list(result))
# 练习：写一个匿名函数，判断指定的数是否是回文数
result = lambda nums:str(nums) == str(nums)[::-1]

8、实参高阶函数

8.1 概念

• 参数是函数的函数就是实参高阶函数；给参数是函数参数传参的时候可以使用普通函数的函数名也可以使用匿名函数
• 参数x的要求：是个函数；函数有两个形参；有一个是数字的返回值

8.2 常见的实参高阶函数的用法（重点掌握）

• max、min、sorted、列表.sort

'''
max(序列):    -直接比较序列中元素的大小求最大值
max(序列，key=函数)     -按照函数制定的比较规则比较元素的大小求最大值
函数的要求：a、有且只有一个参数，代表序列中的每个元素； b、需要一个返回值
，返回值就是比较对象
'''
#案例1：求nums中个位最大的元素
nums=[100,98,52,51,66,77]
result = max(nums,key=lambda item: item%10)

• map

  基于原序列中的元素创建一个新的序列

'''
map(函数,序列)   -按照函数制定的规则基于指定序列中的元素创建一个新的序列
函数的要求：a、有且只有一个参数，代表序列中的每个元素；需要有一个返回值
返回值就是新序列中的元素。

map(函数,序列1,序列2...)   
-函数的要求：a、有且只有两个参数，代表后面两个序列中的每个元素，需要有一个返回值
返回值就是新序列中的元素。
'''
nums = [100,98,72,19,55,37]
#[0,8,2,9,5,7]
#一个序列
result = list(map(lambda item:item%10,nums))
print(result)
#两个序列
num1=[10,20,30,40]
num2=[34,56,9,80]
#[44,76,39,120]
result = list(map(lambda i,j:i+j,num1,num2))
print(result)
#map练习题
#练习3：基于students构建一个新的字典，字典中的元素是学生姓名和学生对应的总分的键值对。
students = [
    {'name': '张三', 'math': 98,  'chinese': 80, 'english': 90},
    {'name': '李四', 'math': 82, 'chinese': 55, 'english': 72},
    {'name': '王五', 'math': 77, 'chinese': 80, 'english': 88},
    {'name': '张六', 'math': 99, 'chinese': 95, 'english': 98},
    {'name': '何琪', 'math': 56, 'chinese': 80, 'english': 62}
]
result = dict(map(lambda item:(item['name'],item['math']+item['chinese']+item['english']),students))
print(result)

# 练习4：已知三个列表依次保存的是学生的姓名、年龄和性别，基于这些创建每个学生信息对应的新列表
names = ['张三', '李四', '王五']
ages = [19, 22, 18]
genders = ['男', '女', '男']
# [{'name': '张三', 'age': 19, 'gender': '男'}, {'name': '李四', 'age': 22, 'gender': '女'}, .....]
result = list(map(lambda i,j,k:{'name':i,'age':j,'gender':k},names,ages,genders))
print(result)

• reduce

  将序列中的元素合并成一个数据

'''
reduce(函数，序列，默认值)      -按照函数制定的规则将序列中的元素合并成一个数据
函数的要求：有且只有两个参数，第一个参数代表默认值，第二个参数代表序列中的每个元素
需要一个返回值，返回值是合并方式
'''
from functools import reduce
nums = [11,22,30,40,15]
#+
result=reduce(lambda i,item:i+item ,nums,0)
print(result)
#*
result = reduce(lambda i,item:i*item,nums,1)
print(result)
#个位+
result = reduce(lambda i,item:i+item%10,nums,0)
print(result)

9、全局变量和局部变量

9.1 全局变量

    没有定义在函数或者类里面的变量都是全局变量，全局变量的作用域是从定义开始到程序结束

# a是全局变量
a = 100
print(f'外面使用a:{a}')
# b 和 c 是全局变量
for b in range(5):
    print(f'循环中使用a:{a}')
    c = 200
def func1():
    print(f'函数里面使用a:{a}, b:{b}, c:{c}')
func1()
print(f'b:{b}, c:{c}')

9.2 局部变量

   定义在函数中的变量就是局部变量；局部变量的作用域是从定义开始到函数结束

def func2():
    # d 是局部变量
    d = 300
    print(f'函数里面d:{d}')

9.3 变量保存数据的原理

• 全局变量保存在全局栈区间中，全局栈区间中的数据在程序结束时才会自动释放；局部变量保存在函数对应的临时栈区间中的，函数对应的临时栈区间调用函数的时候创建，函数调用结束的时候会自动释放
• global关键字可以修改局部变量的保存位置，让局部变量保存到全局栈区间中

def func3():
    global m
    m = 400

func3()
print(m)