一、函数

1.函数的定义

a.定义

• 函数就是对实现某一特定功能的代码段的封装

b.分类

• 函数可以分为内置函数和自定义函数
• 内置函数：python已经声明好了。程序员直接调用的函数。print函数 input函数等
  相当于已经造好的机器，程序员只需要知道机器的功能和使用方法
• 自定义函数：程序员自己声明，自己实现功能的函数，可以提供给别人使用，也可以自己用
  相当于自己设计和创建机器。

2.函数的声明

a.语法

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

b.说明：

**def **- 是python中声明函数的关键字

**函数名 **- 自己命名的 要求：标识符，不能是关键字
PEP8 名字当中的字母小写，多个单词之间用下划线隔开
见名知意（看到函数名大概知道函数的功能）

**（） **- 固定写法

形参列表 - 形参1，形参2，... （可以有一个函数，也可以有多个参数，也可以没有参数）
形参作用：从函数的外部向函数内部传值

： - 固定写法

函数说明文档 - 用来对函数功能进行说明的注释 这个注释需要使用三个双引号引起来
函数体 - 实现函数功能的代码段

c.函数声明的过程

第一步：确定函数功能
第二步：根据函数功能，确定函数名
第三步：确定参数,看实现函数的功能，需不需要额外的数据，需要几个数据，就需要几个参数
第四步：实现函数的功能
第五步：确定返回值

#声明一个函数，求两个函数的和并打印
def my_sum(num1,num2):
    print(num1 + num2)
my_sum(10,20)

#打印10个*
def print_star():
    print('*'*10)
print_star()

#声明一个函数，求1+2+3+4+...+n
def n_sum(n):
    sum1 = 0
    for i in range(n+1):
        sum1 += i
    print(sum1)
n_sum(4)

3.函数的调用

• (重点)函数的在声明的时候不会执行函数体，只有再调用的时候才会执行

a.语法：

函数名（实参列表）

b.说明：

函数名 - 必须是已经声明过的函数
（） - 固定写法
实参列表 - 用来给形参赋值（需要传递给函数内部的数据）
目前 形参有多少个，实参就需要多少个

my_sum(10,20)
n_sum(4)

二、函数的调用

函数在声明的时候不会执行函数体。只有在调用函数的时候才会执行函数体

# def say_hello():
#     print("hello")

1函数的调用过程（重点）

a.物理过程

第一步：回到函数声明的位置
第二步：用实参给形参赋值(传参)
传参一定要保证每个形参都有值
第三步：执行函数体
第四步：获取返回值
第五步：回到函数调用的位置,接着往下执行

b.函数调用的过程就是一个压栈的过程

• 当函数调用的时候，系统会自动的在内存中栈区间开辟空间，存储函数调用过程中产生的数据
  （这儿的数据包括参数和在函数声明的变量） 当函数调用完成后，对应的内存空间会自动销毁

def say_hello(name):
    print(name,"hello")

print('=======')
say_hello("小米")
say_hello("小花")

a = 10
b = 20
def change(a,b):
    #a = 10  b = 20
    a,b = b,a
    print("函数中：",a,b)
change(a,b)
print("函数外：",a,b)

三、函数的参数

1.根据实参分为位置参数和关键字参数

a.位置参数：

实参的位置和形参的位置一一对应

def func1(a,b,c):
    #a = 20 b = 5 c = 100
    print("a:%d b:%d c:%d" %(a,b,c))#a:20 b:5 c:100

func1(20,5,100)

a.关键字参数

实参以“形参名=值”的形式来传参

func1(c=100,b=5,a=20)#a:20 b:5 c:100

c.位置参数和关键字参数混合使用

前提是保证每个参数都有值，位置参数一定要在关键字参数前面

func1(100,c=5,b=20)#a:100 b:20 c:5

2.从函数声明的角度又有：参数默认值，不定长参数。参数类型说明

1.参数默认值：

声明函数的时候可以给参数设置默认值，
语法： 参数名 = 默认值

注意：设置参数默认值除了可以给参数一个默认值，更多的时候也可以对参数的类型进行说明

def func2(a=1,b=2,c=3):
    print("a:%d b:%d c:%d" %(a,b,c))

#如果函数声明的时候参数有默认值，调用函数的时候，有默认值的参数可以不用赋值
func2(10,20,30)#a:10 b:20 c:30
func2()#a:1 b:2 c:3
func2(10,20)#a:10 b:20 c:3
func2(b = 20)#a:1 b:20 c:3

#如果有的参数有默认值，有的参数没有默认值，有默认值的参数一定要放到没有默认值参数的后面
def func3(a,b,c=3):
    print("a:%d b:%d c:%d" % (a, b, c))


func3(10,20,30)#a:10 b:20 c:30
func3(10,20)#a:10 b:20 c:3
func3(a = 10,b = 20)#a:10 b:20 c:3

3.不定长参数

• 不定长参数：声明函数的时候函数的参数不确定

a.在声明函数的时候，在参数名前加一个“*”，会将这个参数变成元祖来获取多个实参的值（位置参数传参）

#声明一个函数，球多个数的和、
def sum_num(*num):
    print(sum(num))

• 调用参数是不定长参数的函数的时候，不定长参数对应的位置，可以传任意个实参

sum_num(1,5,3)


def func4(name,*scores):
    print(name,scores)

func4("小明",55,66,55)

a.在声明函数的时候，在参数名前加两个“*”，会将这个参数变成字典来获取多个实参的值（关键字参数传参）

def func5(**kwargs):
    print(kwargs)

• 如果是调用不定长关键字参数（参数名前家了两个*），调用的时候关键字可以随便命名

func5(a=1,b=2,c=3)

def func6(a,**kwargs):
    print(a,kwargs)

func6('das',x=4,b=5)

c.一颗和两颗一起使用 - 用来表示不定长参数。调用的时候可以不传参，也可以用关键字传参或者位置传参，也可以两个一起用

要求：一颗的参数要放在两颗的前面

def func7(*args,**kwargs):
    print(args,kwargs)

func7()#() {}
func7(4,5,6,7)#(4, 5, 6, 7) {}
func7(a=1,b=1,c=2)#() {'a': 1, 'b': 1, 'c': 2}
func7(1,2,3,a=1,b=2)#(1, 2, 3) {'a': 1, 'b': 2}


#练习  球多个数的和，要求调用函数的时候可以多样性（位置，关键字可以一起）
def my_sum(*args,**kwargs):
    sum1 = sum(args)
    sum2 =sum(kwargs.values())
    print(sum1 + sum2)
my_sum(1,2,3,a=2,b=3)


def my_sum1(*args,**kwargs):
    sum3 = 0
    #获取所有位置参数
    for item in args:
        sum3 += item
    #获取关键字参数
    for key in kwargs:
        sum3 += kwargs[key]
    print(sum3)
my_sum1(1,2,3,a=2,b=3)

4.参数类型说明

• 参数类型说明，只是对参数类型进行提示，不能限制参数类型

• 说明方式：
  a.设置默认值
  b.参数名：类型名

• 注意：类型说明除了说明类型以外，还可以做相应类型对应的语法提

def func8(a:int,b:'',c:list):
    c.append('3')
    print(a,b,c)

func8(10,'ac',[1,2])

四、函数的返回值

1.返回值

a.函数的返回值就是return关键字后面表达式的值，就是函数调用表达式的值

b.python中所有的函数都有返回值，默认是None

• return - 关键字，返回返回值，结束函数（当函数执行中遇到return函数直接结束）
  如果函数体中没有return，函数会在函数体执行结束时将None作为返回值

• 函数调用表达式 - 调用函数的语句；当函数调用完成后，函数调用表达式的结果就是函数的返回值

• 作用：就是将在函数内部产生的数据，传递到函数的外面。防止在函数调用完成后被销毁

• 什么时候使用返回值：如果实现函数的功能会产生新的数据，一般都会将这个数据返回

def func1(a,b):
    print(a,b)
    #将100作为函数func1的返回值
    return 100 #return - 关键字  100 - 返回值

def func2(m,n):
    return m+n  #m+n的结果就是返回值

def func3(m,n):
    return None  #None作为返回值，在这结束函数，函数体后面的其他语句不会执行
    print(m,n)

def func4(m):
    if m % 2 ==0:
        return '偶数'

str1 = func4(10) #func4(10) = '偶数'
print(func4(10),str1,len(str1)) #偶数 偶数 2
print(func4(11)) #None

• 看一个函数的返回值，永远只看是否遇到return，遇到就是return后面的值，遇不到就None

2.同时返回多个值

• python的函数中支持返回多个值
  return 返回值1，返回值2，返回值3...(实质是以元祖的形式返回)

#写一个函数，求多个数的和 以及 平均值
def func5(*num):
    sum1 = sum(num)
    avg1 = sum(num)/len(num)
    return sum1,avg1


sum1,avg1 = func5(1,2,3)
print(func5(1,2,3))
print(sum1,avg1)

五、返回值的应用

• 返回值能做的事情，函数调用表达式都可做以

1用函数调用表达式给变量赋值

def func1():
    return 'hello'

#str1 = 'hello'
str1 = func1()
print(str1)

2.通过函数调用表达式，使用相应的方法

def func2():
    return [1,2]

item = func2()[0]
print(item)

item = func2().append(3) #获取的是append函数的返回值，append函数没有返回值所以是None
print(item)#None

list1 = func2()
list1.append(3)
print(list1)#[1, 2, 3]

3.将函数调用表达式作为容器的元素或者作为函数的参数以及函数的返回值

def func3():
    print('hello')
    return 100

#作为值参加运算
print(func3()+3) #print(100+3)

#作为列表元素
list2 = [func3(),'abc']
print('list2:',list2)# list2: [100, 'abc']

#作为字典的key和value
dict1 = {func3():func3()}
print(dict1)

六、匿名函数

• 匿名函数还是函数，除了声明的语法外，函数其他的语法都适用于匿名函数

1.匿名函数的声明

a.语法

• 函数名 = lambda 参数列表:返回值

b.说明

函数名= 变量名
lambda - 关键字
参数列表 - 和普通函数的参数列表的作用一样
返回值 - 相当于普通函数的return关键字后面的表达式

• 注意：匿名函数中 冒号后面的语句属于函数体，在声明的时候不会执行
  匿名函数的调用和普通函数一模一样

#用匿名函数球两个数的和
my_sum1 = lambda n,m : n+m

my_sum1(3,4)
print(my_sum1(3,4)) # 7
print(my_sum1(n=5,m=4)) #  9

#练习  些匿名函数 球两个数中的最大值
my_max = lambda a,b :max(a,b)
my_max(3,5)
print(my_max(7,5))

my_max = lambda x,y : x if x > y else y

my_max(3,5)
print(my_max(7,5))

补充：python中的三目运算符

a.

C中的三目运算符：条件语句？值1：值2 - 条件语句为True，整个表达式的结果是值1，否则就是值2

int x = 10, y = 20
max = x>y?x:y

b.

python中的三目运算符： 值1 if 条件语句 else 值2 - 条件语句为True，整个表达式的结果是值1，否则就是值2

max = x if x>y else y
'''
x,y = 10,20
max = x if x>y else y
print(max)


#写一个匿名函数  获取字典中指定的key对应的值
my_value = lambda dict1,key : dict1.get(key)
print(my_value({'a':1,'b':100},'a'))