函数

不使用函数的问题:
  • 1.同样的功能,相同的代码需要重复写很多次
  • 2.当功能发生改变了,需要修改多处代码
    怎么解决这些问题:使用函数!
1.函数的定义
  • a.定义
    函数就是对实现某一特定功能的代码段的封装
  • b.分类
    函数可以分为内置函数和自定义函数
    • 内置函数:python已经声明好了,程序员直接调用的函数。print函数, input函数,max等

      相当于已经造好的机器,程序员只需要知道机器的功能和使用方法

    • 自定义函数: 程序员自己声明,自己实现功能的函数。可以提供给别人用,也可以自己用。

      相当于自己设置和创建机器。

2.函数的声明
  • a.语法:
    def 函数名(形参列表):
    函数说明文档
    函数体

  • b.说明:

    • def - python中声明函数的关键字
    • 函数名 -自己命名;
      要求:标识符, 不能是关键字
      PEP8,名字中的字母小写,多个单词之间用下划线隔开
      见名知义(看到函数名,大概知道函数的功能)
    • () - 固定写法
    • 形参列表 - 形参名1,形参名2... (可以有一个参数,也可以有多个参数,也可以没有参数)
      形参的作用:从函数的外部,向函数内部传递数据
    • : - 固定写法
    • 函数说明文档 - 用来对函数的功能进行说明的注释。这个注释需要使用是三个双引号引起来
    • 函数体 - 实现函数功能的代码段
  • c.初学者函数声明的步骤

    • 第一步:确定函数的功能
    • 第二步:根据函数的功能,确定函数名
    • 第三步:确定参数,看实现函数的功能,需不需要额外的数据。需要几个数据,就需要几个参数
    • 第四步:实现函数的功能
    • 第五步:确定返回值
# 声明一个函数,求两个数的和,并且打印出来
def my_sum(num1, num2):
    print(num1 + num2)


# 声明一个函数,打印10个'*'
def print_star():
    print('*'*10)


# 声明一个函数,求1+2+3+...+n
def my_sum2(n):
    sum1 = 0
    for x in range(1, n+1):
        sum1 += x
    print(sum1)

2.函数的调用

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

def say_hello():
    print("hello") 


say_hello()  #hello
1.函数的调用过程(重点)
  • def 函数名(形参):
    函数体

    函数名(实参)

  • a.物理过程

    • 第一步:回到函数声明的位置
    • 第二步:用实参给形参赋值(传参);要保证每个形参都有值
    • 第三步:执行函数体
    • 第四步:获取返回值
    • 第五步:回到函数调用的位置
  • b.函数调用的过程是一个压栈的过程
    当函数调用的时候,系统会自动在内存中栈区间开辟空间,存储函数调用过程中产生的数据
    (这的数据包括参数和在函数的声明的变量)。当函数调用完成后,对应的内存空间会自动销毁。

a = 10
b = 20


def change(a, b):
    a, b = b, a
    print(a, b)  #20 10

change(a, b)
print("函数外", a, b)  #函数外 10 20
函数_第1张图片
函数调用流程图

3.函数的参数

1.根据实参分为位置参数和关键字参数(都需要保证每个参数有值)
  • a.位置参数
    实参的位置和形参的位置一一对应
  • b.关键字参数
    实参以 “形参名 = 值”形式来传参
  • c.位置参数和关键字参数混合使用
    • 前提:
      1.保证每个参数都有值;
      2.位置参数一定要在关键字参数前面
def function(a,b,c):
    print(a,b,c)

function(100,c=200,b=2)
2.从函数声明的角度又有:参数默认值,不定长参数,参数类型说明
  • a.参数默认值
    声明函数的时候可以给参数设置默认值,
    • 语法:参数名 = 默认值
      注意:设置默认值除了可以给参数一个默认的值,更多的时候可能只是想要对参数的类型进行说明。
      如果函数声明的时候参数有默认值,调用函数的时候,有默认值的参数可以不用赋值。
      有默认值得参数要在没有默认值的参数后面

def function2(b,c="a",a=1):
    print(a,b,c)

function2(1,"e",5) #5,1,"e"
3.不定长参数

不定长参数:声明函数的时候,函数的参数不确定

  • a.在声明函数的时候,参数名前加一个 * ,会将这个参数变为元组,来获取多个实参的值。
练习:声明一个函数,功能是求多个数的和
def num_sum(*num):
    print(sum(num)) #45
    print(num)  #(5, 9, 8, 7, 8, 8)

num_sum(5,9,8,7,8,8)
a=(5,9,8,7,8)
print(sum(a)) #37

a,*b = [1,5,6,9,8,7]
print(b) #[5, 6, 9, 8, 7]
  • b.在声明函数的时候,参数名前加一个 ** ,会将这个参数变为字典,来获取多个实参的值(必须使用关键字来传参)
def func5(**num):
    print(num)

func5(a=1,b=2,c=3) #{'a': 1, 'b': 2, 'c': 3}
func5() #{}
func5(name="asd",age=18) #{'name': 'asd', 'age': 18}

#如果不是调用不定长关键字参数(产生前面加两颗*),调用的时候关键字可以随便命名。
  • c.一颗 * 和两颗 * 一起使用 - 用来表示不定长参数,
    调用时候更灵活,可以用位置参数传参,也可以关键字参数传参。

    要求:一颗的参数要放在两颗的前面
def func7( * args, ** kwargs):
    print(args,kwargs)


func7() #() {}
func7(8,9,10,20) #(8, 9, 10, 20) {}
func7(a=10,b=20) #() {'a': 10, 'b': 20}
func7(8,9,10,a=50,b=97) #(8, 9, 10) {'a': 50, 'b': 97}
练习:求多个数的和,要求:调用函数的时候可以多样性。
def sum1_num(*args,**kwargs):
    sum = 0
    sum = sum(args)+sum(kwargs.values())
    print(sum)
sum1_num(8,9,10,60,a=10,b=20)
4.参数类型的说明

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

  • a.设置默认值
  • b.参数名:类型名
    注意:类型说明除了说明类型以外,还可以做相应类型对应的语法提示
def func8(a1,a:str="sd",b=20):
    print(a1,a,b)
func8(1) #1,“sd”,20

4.函数的返回值

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

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

  • return - 关键字(只能用在函数体中);返回返回值;结束函数(当函数在执行的过程中遇到了return就结束函数)
    如果函数体重没有return,函数会在函数体执行完成后将None作为返回值

  • 函数调用表达式 -调用函数的语句;当函数调用完成后,函数调用表达式会有一个结果,结果就是函数的返回值。

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


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

def func3(m,n):
    return None  # 将None作为返回值,在这儿结束函数。函数体后面的其他语句不会执行
    print(m,n)
看一个函数的返回值,永远只看是否能遇到return,遇到了就是return后面的值,遇不到就是None
def  func4(m):
    if  m%2==0:
        return "偶数"


func4(2) # "偶数"
  • 返回值的作用:就是讲函数内部产生的数据,传递到函数的外面。防止函数调用完成后被销毁
  • 什么时候使用返回值:如果实现函数的功能会产生新的数据,一般都会将这个数据返回。
2.同时返回多个返回值

python的函数中支持返回多个值

  • 语法:
    return 返回值1,返回值2...,返回值3 - 实质是以元组的形式返回
写一个函数,功能是求多个数的和以及平均值
def  func7(*args):
    a=sum(args)
    b=sum(args)/len(args)
    return a,b


a,b =func7(1,3,5,7,9) #func7 =>(25,5.0)
print(a,int(b))    #25 5.0

5.返回值的应用

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

1.用函数调用表达式给变量赋值
def func1():
    return 'hello'


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

2.通过函数调用表达式使用相应的方法
def func2():
    return [1, 2]


# print([1, 2][0])
item = func2()[0]
print(item)


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

list1 = func2()
list1.append(3)
print(list1)
3.将函数调用表达式作为容器的元素,函数的参数,函数的返回值
def func3():
    print('hello')
    return 100


# 作为值惨叫运算
print(func3() + 3)   # print(100 + 3)

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

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


# 作为函数的返回值
def func4(m):
    print(m)
    return func3()


# 作为函数的实参
re = func4(func3())   # func4(100)
print(re)   # 100

6.匿名函数

匿名函数还是函数,除了声明的语法以外,函数其他的语法匿名函数都支持

1.匿名函数的声明
  • a.语法:
    函数名 = lambda 参数列表:返回值

  • b.说明:

    • 函数名 - 变量名
    • lambda - 关键字
    • 参数列表 - 和普通函数的参数列表的作用和要求一样
    • 返回值 - 相当于普通函数retrun关键字后面的表达式
      注意:匿名函数中冒号后面的语句属于函数体。在声明的时候不会执行

匿名函数的调用和普通函数一模一样

# 用匿名函数求两个数的和
def my_sum(num1, num2=0):
    return num1 + num2

print(my_sum(10, 20))
print(my_sum(num1=1, num2=2))

my_sum1 = lambda num1, num2=0: num1+num2
print(my_sum1(100, 200))
print(my_sum1(num1=11, num2=22))
练习:写一个匿名函数,求两个数的最大值
my_max = lambda x, y: max(x, y)

print(my_max(100, 200))
补充: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
x = 10
y = 20
max1 = x if x > y else y
"""
x = 100
y = 20
max1 = x if x > y else y
print(max1)


my_max2 = lambda num1, num2: num1 if num1 > num2 else num2
print(my_max2(20, 89))
print(my_max2(200, 89))
练习:写一个匿名函数,获取字典中指定的key对应的值
get_value = lambda dict1, key: dict1.get(key)
print(get_value({'a': 100, 'b': 200}, 'a'))

 def func1(item: dict):
    return item['age']
list1.sort(key=func1)

list1 = [
    {'name': '张三', 'age': 20},
    {'name': '李四', 'age': 10},
    {'name': '王五', 'age': 30}
]
list1.sort(key=lambda item: item['age'])
print()
print(list1)

def key(item):
    return item["age"]

print(key({'name': '张三', 'age': 20}))

你可能感兴趣的:(函数)