第五章 Python 函数

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了第五章 Python 函数相关的知识,希望对你有一定的参考价值。

 

第1章 为什么要使用函数

#1、代码的组织结构不清晰,可读性差

#2、遇到重复的功能只能重复编写实现代码,代码冗余

#3、功能需要扩展时,需要找出所有实现该功能的地方修改之,无法统一管理且维护难度极大 

 

第2章 函数是什么

定义:函数是指将一组语句的集合通过一个名字(函数名)封装起来,要执行这个函数,只需要调用函数名即可。

 

特性:

1、减少重复代码

2、使程序变的可扩展

3、使程序变得易维护

 

函数的使用必须遵循:先定义,后调用

 

2.1 函数的分类

1、 内置函数:python解释器自带的函数,python解释器启动就会定义好这些函数

如len(),sum(),max(),min()

 

2、自定义函数:开发人员根据需求,定制好自己的函数来实现某种功能,在遇到应用场景时,调用自定义函数即可。

 

 

 

 

 

2.2 定义函数语法

def 函数名(参数1,参数2,...)

    """ 注释 """

    函数体

    return 返回值

 

def = define(定义)

#函数名要能反映其意义

 

2.3 函数的定义与调用

### 定义一个函数,并且调用

def hello():
    print(‘hello word‘)
hello()

>>> hello word

 

### 函数与变量一样,函数的内容也会占用内存空间

### 打印函数名会返回函数所占的内存空间

def hello():
    print(‘hello word‘)

print(hello)

<function hello at 0x000000DD707F3E18>

 

2.4 函数的使用规则:先定义 再调用

函数即“变量”,“变量”必须先定义后引用。未定义而直接引用函数,就相当于在引用一个不存在的变量名

函数在定义阶段,只检测语法,不执行代码

 

def foo():
    print(‘from foo‘)
    bar()  #报错 在定义的时候就已经报语法错误了
foo()

 

def bar():
    print(‘from bar‘)
def foo():
    print(‘from foo‘)
    bar()
foo() #正常

 

### 不会报错,因为在定义阶段没有出现语法错误
def foo():
    print(‘from foo‘)
    bar()
def bar():
    print(‘from bar‘)
foo()

 

#结论:函数的使用,必须遵循原则:先定义,后调用

#我们在使用函数时,一定要明确地区分定义阶段和调用阶段

#定义阶段

def foo():

    print(‘from foo‘)

    bar()

def bar():

    print(‘from bar‘)

#调用阶段

foo()

 

函数在定义阶段都干了哪些事?

只检测语法,不执行代码

也就说,语法错误在函数定义阶段就会检测出来,而代码的逻辑错误只有在执行时才会知道

 

 

第3章 定义参数的三种形式

#1、无参:应用场景仅仅只是执行一些操作,比如与用户交互,打印

#2、有参:需要根据外部传进来的参数,才能执行相应的逻辑,比如统计长度,求最大值最小值

#3、空函数:设计代码结构

 

3.1 无参

def login():
    while True:
        user_name=input(‘user_name>>>: ‘).strip()
        if not user_name:continue
       
user_pass=input(‘user_pass>>>: ‘).strip()
        if user_name == ‘leo‘ and user_pass == ‘123‘:
            print(登录成功‘)
        else:
            print(登录失败‘)
login()

 

### 这是一个无参函数,虽然满足逻辑,但是用户名和密码都写死在函数体力,无法灵活使用。   

 

3.2 传参

def main():
    while True:
        name=input(‘name>>>  ‘).strip()
        if not name:continue
       
password=input(‘password>>>: ‘).strip()
        if not password:continue
       
res=arth(name,password)
        if res:
            print(登录成功‘)
        else:
            print(登录失败‘)

def arth(user,password):
    if user == ‘leo‘ and password == ‘123‘:
        return True
    else
:
        return False

main()

 

 

3.3 空函数

def auth(user,password):                            

    ‘‘‘                                                          

    auth function                                                

    :param user: 用户名                                             

    :param password: 密码                                          

    :return: 认证结果                                                

    ‘‘‘                                                           

    pass                                                         

                                                                 

def get(filename):                                               

    ‘‘‘                                                           

    :param filename:                                             

    :return:                                                     

    ‘‘‘                                                          

    pass                                                          

                                                                 

def put(filename):                                               

    ‘‘‘                                                          

    :param filename:                                             

    :return:                                                     

    ‘‘‘                                                          

def ls(dirname):                                                  

    ‘‘‘                                                          

    :param dirname:                                              

    :return:                                                     

    ‘‘‘                                                           

    pass                                                         

 

#程序的体系结构立见 

 

第4章 调用函数

4.1 调用函数

#1 调用函数:函数名(),
#需要注意:先通过名字找到函数的内存地址,然后加括号调用

 

4.2 函数的返回值

#注意的第一点:
#在调用函数的过程中,一旦执行到return,就会立刻终止函数,并且把return后的结果当做本次调用的返回值返回
#函数体内可以有多个return,但是只能执行一次

 

def foo():
    print(‘111‘)
    return 1
    print(‘2222‘)
    return 2
    print(‘3333‘)
    return 3

res=foo()
print(函数调用完毕‘,res)

 

 

 

#注意的第二点:
#返回的值,可以是任意类型

 

#注意的第三点:
#没有return:默认返回None
#可以返回一个值===>值
#可以用逗号分隔,返回多个值===>tuple

 

def foo():
    return None

res=foo()
print(函数调用完毕‘,res,type(res))

>>> 函数调用完毕 None <class ‘NoneType‘>

 

4.3 调用函数的三种形式

1 语句形式:foo()

2 表达式形式:3*len(‘hello‘)

3 当中另外一个函数的参数:range(len(‘hello‘))

 

语句模式:

def foo():
    print(‘from foo‘)
    return 123

foo()

>>> from foo

 

def foo():
    print(‘from foo‘)
    return 123

res=foo()
print(res)
>>> 123
res=foo()*10
print(res)

>>> 1230

 

第5章 函数的参数

5.1 形参与实参

#形参:在函数定义阶段,括号内定义的参数的称为形参,就相当于变量名
#实参:在函数调用阶段,括号内定义的参数的称为实参,就相当于变量值
#在调用阶段,实参的值会绑定给形参,在调用结束后,解除绑定

 

5.2 参数的分类

5.2.1 位置参数

1、位置参数:按照从左到右的顺序定义的参数

位置形参:必须被传值的参数

位置实参:按照位置给形参传值,从左到右

 

def foo(x,y): #x=1,y=2 #形参
    print(x,y)

foo(1,2)    #实参

 

5.2.2 关键字参数

2、关键字参数:按照key=value的形式定义的实参

无需按照位置为形参传值

注意的问题:

1. 关键字实参必须在位置实参后面

2. 对同一个形参不能重复传值

 

def foo(x,y):
    print(x,y)

foo(1,y=20)

 

5.2.3 默认参数

三:默认参数:在定义函数阶段,已经为形参赋值了,在定义阶段已经赋值,意味着在调用阶段
可以不传值
    注意的问题:
        1 默认参数的值,只在定义时赋值一次
        2 位置形参应该在默认参数的前面
        3 默认参数的值应该是不可变类型

 

 

def foo(x,y=10):
    print(x,y)
foo(x=1)

>>> 1 10

 

def foo(x,y,z=10):
    print(x,y,z)
foo(x=1,y=2)

>>> 1 2 10
位置参数 > 关键字参数 > 默认参数

 

### 如果实参在调用阶段传参,那么将使用传参而不使用默认参数,但是不建议这么用

def register(name,age,sex=‘male‘):
    print(name,age,sex)

register(‘egon‘,18)
register(‘wsb‘,18)
register(‘alex‘,38,‘xxxxxx‘)

 

>>> egon 18 male

>>> wsb 18 male

>>> alex 38 xxxxxx

 

### 只在定义的时候赋值一次,赋值完成后,再赋值将不改变默认参数

x=‘123‘
x=‘456‘
def
register(name,age,sex=x):
    print(name,age,sex)

x=‘female‘
register(‘alex‘,18)

>>> alex 18 456

 

5.2.4 可变长参数(非固定参数)

四:可变长参数
实参可变长度指的是:实参值的个数是不固定
而实参的定义形式无非两种:1、位置实参,2、关键字实参
针对这两种形式的实参个数不固定,相应的,形参也要有两种解决方案

分别是*args,**kwargs

 

 

def func(x,y,z,*args): #args=(4,5,6)
   
print(x,y,z)
    print(args)

func(1,2,3)

>>> 1 2 3

>>> ()

 

### 情景是加入新参数的时候使用:

def str_register(name,age,country,course,*args):
    print(‘------注册学员信息------‘)
    print(姓名: %s‘ %(name))
    print(年龄: %s‘ %(age))
    print(国籍: %s‘ %(country))
    print(科目: %s‘ %(course))
    print(‘other args‘,args)

str_register(‘leo‘,28,‘CN‘,‘Python‘)

 

------注册学员信息------

姓名: leo

年龄: 28

国籍: CN

科目: Python

other args ()

### 如果我什么都不传给 其他参数的话 并不会报错,而且会返回来一个空元组

 

### 如果传值 将会被放到元组中,可从中拿出来

def str_register(name,age,country,course,*args):
    print(‘------注册学员信息------‘)
    print(姓名: %s‘ %(name))
    print(年龄: %s‘ %(age))
    print(国籍: %s‘ %(country))
    print(科目: %s‘ %(course))
    print(‘other args‘,args)

str_register(‘leo‘,28,‘CN‘,‘Python‘,‘stu001‘,10000)

 

------注册学员信息------

姓名: leo

年龄: 28

国籍: CN

科目: Python

other args (‘stu001‘, 10000)

 

### 将溢出的参数 放入字典中

### 如果在传参时没有指定名字,那么他就是*args,非固定参数的元组模式

### 如果指定名字了,那么他就是**kwargs,非固定参数的字典模式

def str_register(name,age,country,course,*args,**kwargs):
    print(‘------注册学员信息------‘)
    print(姓名: %s‘ %(name))
    print(年龄: %s‘ %(age))
    print(国籍: %s‘ %(country))
    print(科目: %s‘ %(course))
    print(‘other args‘,args)
    print(‘other args‘,kwargs)

str_register(‘leo‘,28,‘CN‘,‘Python‘,10000,stuid=‘stu001‘)

------注册学员信息------

姓名: leo

年龄: 28

国籍: CN

科目: Python

other args (10000,)

other args {‘stuid‘: ‘stu001‘}

 

比如将来要用到这个参数了,就可以直接用字典方式取值:

def str_register(name,age,country,course,*args,**kwargs):
    print(‘------注册学员信息------‘)
    print(姓名: %s‘ %(name))
    print(年龄: %s‘ %(age))
    print(国籍: %s‘ %(country))
    print(科目: %s‘ %(course))
    print(‘other args‘,args)
    print(‘other args‘,kwargs)
    print(‘学号:%s‘ %(kwargs[‘stuid‘]))

str_register(‘leo‘,28,‘CN‘,‘Python‘,10000,stuid=‘stu001‘)

 

------注册学员信息------

姓名: leo

年龄: 28

国籍: CN

科目: Python

other args (10000,)

other args {‘stuid‘: ‘stu001‘}

学号:stu001

 

def foo(x, y, z):
    print(x, y, z)

foo(**{‘z‘: 1, ‘x‘: 2, ‘y‘: 3})

 

5.2.5 命名关键字函数

#五:命名关键字参数(了解):
# 形参中,在*后定义的参数称之为命名关键字参数,
# 它的特性是;传值时,必须按照关键字实参的形式传值
def foo(x,y=20,*args,a=1,b):
    print(x,y,a,b)

# foo(10,b=3)
foo(10,22,33,44,a=2,b=3)
>>> 10 22 2 3

# 位置参数,默认参数,*args,命名关键字参数,**kwargs

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

                                                     

































































































































































以上是关于第五章 Python 函数的主要内容,如果未能解决你的问题,请参考以下文章

第五章 Python函数

Python学习系列----第五章 模块

『Python』Numpy学习指南第五章_矩阵和通用函数

Python程序开发——第五章 函数

python 第五章 迭代器,生成器,生成器函数

python程序设计基础(嵩天)第五章课后习题部分答案