day14-python-函数参数

今日测验

1、编写代码实现功能tail -f access.log
    f.seek()

    应用程序(文件对象/文件句柄1)     应用程序(文件对象/文件句柄2)
    操作系统(真正的文件)a.txt z
    计算机硬件(硬盘空间)

2、代码展示文件修改的两种方式
    方式一:
    with open('源文件',mode='r') as src_f:
        res=src_f.read()
        new_res=修改res

    with open('源文件',mode='w') as dst_f:
        dst.write(new_res)


   方式二:
   with open('源文件',mode='r') as src_f,open('临时文件',mode='w') as dst_f:
        for line in src_f:
            new_line=修改line
            dst.write(new_line)

   删除源文件
   将临时文件重命名为源文件的名字


3、定义函数的语法是什么?
    函数-》盛放功能(一堆代码)的容器

    内置函数:python解释已经定义好了,直接调用即可
        open()
        input()
    自定义函数:
        先定义
        后调用

    def 函数名(参数1,参数2,...):
        """文档注释"""
        代码块
        return 值

4、函数的基本使用遵循的原则是?

5、简述函数定义阶段与调用阶段发生的事情
    定义阶段:
        1、申请内存空间将函数体代码存放起来,然后将内存地址绑定给函数名
            函数名=函数的内地址
        2、只检测语法,不执行代码

    调用函数:函数名()
        1、先通过函数名(变量名)找函数的内存
        2、加括号触发函数体代码的运行

6、代码展示定义函数的三种形式
    def func():
        pass
    func()

    def func(x,y):
        pass

    func(1,2)

    def func():
        pass

7、代码展示调用函数的三种形式
    # 语句形式:只运行功能
    func(1,2)
    func()

    # 表达式形式
    res=func(1,2)

    res=func(1,2)*10

    # 参数传入
    func(func(1,2),10)
8、return返回值的三种形式是什么?
    None:   没有return
            return
            return None

    一个值:
        return 值

    多个值
        return 值1,值2,值3

    强调:
        return是函数结束的标志,函数内可以有多个return,但只要执行一个
        整个函数就会立刻结束,并且将该return后的值作为本次运行的结果返回

今日内容概要

一 形参与实参介绍
二 形参与实参的具体使用
	2.1 位置参数
	2.2 关键字参数
	2.3 默认参数
	2.4 可变长度的参数(*与**的用法)
	2.4.1 可变长度的位置参数
	2.4.2 可变长度的关键字参数
	2.5 命名关键字参数(了解)
	2.6 组合使用(了解)	

今日内容详细

形参与实参介绍

形参:在定义函数阶段定义的参数称之为形式参数,简称形参, 相当于变量名
def func(x, y):  # x=1,y=2
    print(x, y)


实参:在调用函数阶段传入的值称之为实际参数,简称实参,相当于变量值
func(1, 2)

形参与实参的关系

1、在调用阶段,实参(变量值)会绑定给形参(变量名)
2、这种绑定关系只能在函数体内使用
3、实参与形参的绑定关系在函数调用时生效,函数调用结束后解除绑定关系

实参是传入的值,但值可以是以下形式
形式一:
func(1, 2)

形式二:
a = 1
b = 2
func(a, b)

形式三:
func(int('1'), 2)
func(func1(1, 2,), func2(2, 3), 333)

形参与实参的具体使用

位置参数

按照从左到右的顺序依次定义的参数称之为位置参数
位置形参: 在函数定义阶段,按照从左到右的顺序直接定义的"变量名"
       特点:必须被传值,多一个不行少一个也不行

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

func(1, 2, 3)
func(1,)

位置实参

在函数调用阶段, 按照从左到右的顺序依次传入的值
特点:按照顺序与形参一一对应

func(1, 2)
func(2, 1)

关键字参数

关键字实参:在函数调用阶段,按照key = value的形式传入的值
特点:指名道姓给某个形参传值,可以完全不参照顺序

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


func(y=2, x=1)
func(1, 2)

1、位置实参必须放在关键字实参前

func(1, y=2)
func(y=2, 1)

2、不能能为同一个形参重复传值

func(1, y=2, x=3)
func(1, 2, x=3, y=4)

默认参数

默认形参:在定义函数阶段,就已经被赋值的形参,称之为默认参数
特点:在定义阶段就已经被赋值,意味着在调用阶段可以不用为其赋值
def func(x, y=3):
    print(x, y)


# func(x=1)
func(x=1, y=44444)

def register(name, age, gender='男'):
    print(name, age, gender)

register('三炮', 18)
register('二炮', 19)
register('大炮', 19)
register('没炮', 19, '女')

混用时注意

1. 位置形参必须在默认形参的左边
def func(y=2, x):
    pass	
2、默认参数的值是在函数定义阶段被赋值的,准确地说被赋予的是值的内存地址

示范1:

m = 2
def func(x, y=m):  # y=>2的内存地址
    print(x, y)
m=333
func(1) # 输出1 2 不是 1 333

示范2:

m=[111111, ]
def func(x, y=m):  # y=>[111111, ]的内存地址
    print(x, y) 

m.append(3333333)
func(1) #输出的是1 [111111, 3333333]
3、虽然默认值可以被指定为任意数据类型,但是不推荐使用可变类型

函数最理想的状态:函数的调用只跟函数本身有关系,不外界代码的影响

m=[111111, ]

def func(x, y=m):
    print(x, y)

m.append(3333333)
m.append(444444)
m.append(5555)


func(1)
func(2)
func(3)


def func(x, y, z, l=None):
    if l is None:
        l=[]
    l.append(x)
    l.append(y)
    l.append(z)
    print(l)

func(1, 2, 3)
func(4, 5, 6)

new_l=[111, 222]
func(1, 2, 3, new_l)

可变长度的参数(即* 与**的用法)

可变长度指的是在调用函数时,传入的值(实参)的个数不固定
而实参是用来为形参赋值的,所以对应着,针对溢出的实参必须有对应的形参来接收	

可变长度的位置参数

I:格式:* 形参名
用来接收溢出的位置实参,溢出的位置实参会被*保存成元组的格式然后赋值紧跟其后的形参名
* 后跟的可以是任意名字,但是约定俗成应该是args
def func(x, y, *z):  # z =(3,4,5,6)
    print(x, y, z)

func(1, 2, 3, 4, 5, 6)

def my_sum(*args):
    res=0
    for item in args:
        res += item
    return res

res=my_sum(1, 2, 3, 4,)
print(res)
II:*可以用在实参中,实参中带 *,先*后的值打散成位置实参
def func(x, y, z):
    print(x, y, z)

# func(*[11,22,33]) # func(11,22,33)
# func(*[11,22]) # func(11,22)

l=[11, 22, 33]
func(*l)
III: 形参与实参中都带 *
def func(x, y, *args):  # args=(3,4,5,6)
    print(x, y, args)

func(1, 2, [3, 4, 5, 6])
func(1, 2, *[3, 4, 5, 6])  # func(1,2,3,4,5,6)
func(*'hello')  # func('h','e','l','l','o')

可变长度的关键字参数

I:** 形参名
用来接收溢出的关键字实参,** 会将溢出的关键字实参保存成字典格式,然后赋值给紧跟其后的形参名
** 后跟的可以是任意名字,但是约定俗成应该是kwargs
def func(x, y, **kwargs):
    print(x, y, kwargs)

func(1, y=2, a=1, b=2, c=3)
II: **可以用在实参中(**后跟的只能是字典),实参中带 **,先**后的值打散成关键字实参
def func(x, y, z):
    print(x, y, z)

func(*{'x': 1, 'y': 2, 'z': 3})  # func('x','y','z') 一个*打散取到的是key
func(**{'x': 1, 'y': 2, 'z': 3})  # func(x=1,y=2,z=3)

错误
func(**{'x': 1, 'y': 2, })  # func(x=1,y=2) 少一个
func(**{'x': 1, 'a': 2, 'z': 3})  # func(x=1,a=2,z=3) 名字对不上
III: 形参与实参中都带 **
def func(x, y, **kwargs):
    print(x, y, kwargs)

func(y=222, x=111, a=333, b=444)
func(**{'y': 222, 'x': 111, 'a': 333, 'b': 4444})

混用*与 ** :*args必须在**kwargs之前

def func(x, *args, **kwargs):
    print(args)
    print(kwargs)

func(1, 2, 3, 4, 5, 6, 7, 8, x=1, y=2, z=3)


def index(x, y, z):
    print('index=>>> ', x, y, z)

def wrapper(*args, **kwargs):  # args=(1,) kwargs={'z':3,'y':2}
    index(*args, **kwargs)
    # index(*(1,),**{'z':3,'y':2})
    # index(1,z=3,y=2)

wrapper(1, z=3, y=2)  # 为wrapper传递的参数是给index用的
分析过程:原格式---》汇总-----》打回原形

作业

1、写函数,,用户传入修改的文件名,与要修改的内容,执行函数,完成批了修改操作
2、写函数,计算传入字符串中【数字】、【字母】、【空格] 以及 【其他】的个数

3、写函数,判断用户传入的对象(字符串、列表、元组)长度是否大于5。

4、写函数,检查传入列表的长度,如果大于2,那么仅保留前两个长度的内容,并将新内容返回给调用者。

5、写函数,检查获取传入列表或元组对象的所有奇数位索引对应的元素,并将其作为新列表返回给调用者。

6、写函数,检查字典的每一个value的长度,如果大于2,那么仅保留前两个长度的内容,并将新内容返回给调用者。
dic = {"k1": "v1v1", "k2": [11,22,33,44]}
PS:字典中的value只能是字符串或列表

# 选做作业:同昨天
已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 深蓝海洋 设计师:CSDN官方博客 返回首页