day09初始函数

一、昨日内容回顾

文件处理
    打开文件
        open('路径'，'打开方式'，'指定编码方式')
        打开方式 r w a r+ w+ a+ b
            r+ 打开文件直接写 和读完再写
        编码方式 —— utf-8
    操作文件
        读
            read 一次性读
            readlines 一次性读
            readline 一行一行读
                不知道在哪儿结束
                视频 图片 rb bytes 按照字节读
            for循环 —— 最好！！！
        写
            write
        光标 —— 文件指针
            seek _ 指定光标移动到某个位置
            tell _ 获取光标当前的位置
            truncate _ 截取文件
    关闭文件
        close

# windows操作系统默认gbk编码方式

# 修改文件
with open('小班',encoding='utf-8') as f,open('小班.bak','w',encoding='utf-8') as f2:
    for line in f:
        if '星儿' in line:  #班主任:星儿
            line = line.replace('星儿','啊娇')
        #写文件
        f2.write(line) #小护士:金老板

import os
os.remove('小班') #删除文件
os.rename('小班.bak','小班')  #重命名文件

 二、函数

定义了之后，可以在任何需要它的地方调用，若没有返回长度，则只是单纯的打印。
（1）自定义函数

s = '金老板小护士'
def my_len():  #自定义函数
    i = 0
    for k in s:
        i += 1
    return i  #返回值

length = my_len()
print(length)

缺点：不能变，只能计算s字符串的长度

（2）返回值的重要性

返回值
返回值的3种情况
    没有返回值 —— 默认返回None
        不写return
        只写return:结束一个函数的继续
　　　　　　与break的区别是：break只是跳出循环，而return是结束一个函数，即循环之外的代码也是不执行的。
        return None  —— 不常用
    返回1个值
        可以返回任何数据类型
        只要返回就可以接收到
        如果在一个程序中有多个return，那么只执行第一个
    返回多个值
        用多个变量接收：有多少返回值就用多少变量接收
        用一个变量接收: 得到的是一个元组

def func():
    l = ['金老板','二哥']
    for i in l:
        print(i)
        if i=='金老板':
            return None
    print('='*10)
ret = func()
print(ret)

def func():
    return {'k':'v'}
print(func())

def func2():
    return 1,2,3  #return 1,2,3
r= func2()
print(r)

 （3）参数，参数的语法，形参和实参

def my_len(s):  #接收参数,形式参数(形参)
    i = 0
    for k in s:
        i += 1
    return i  #返回值

ret = my_len('金老板小护士')  #传递参数（传参） #实际参数（实参）
ret = my_len([1,2,3,4,5])  #传递参数（传参）
print(ret)

 定义两个函数：在函数中调用函数

def f2(l1):
    f1(l1)   # 调用f1
    for i in l1:
        print(i)

def f1(l1):
    for i in l1:
        print(i)

f2([1,2,3,4])

 三、参数的定义形式

没有参数
    定义函数和调用函数时括号里都不写内容
有一个参数
    传什么就是什么
有多个参数
    位置参数

def my_sum(a,b):   #  定义了两个参数
    print(a,b)
    res = a+b  #result
    return res

ret = my_sum(1,2)
print(ret)

站在实参的角度上：
    按照位置传参,按照顺序传参
    按照关键字传参
    混着用可以:但是 必须先按照位置传参，再按照关键字传参数
             不能给同一个变量传多个值

站在形参的角度上
    位置参数：传参时必须传,且有几个参数就传几个值
    默认参数: 传参时可以不传，如果不传就是用默认的参数，如果传了就用传的

def classmate(name,sex='男'):   #默认参数
    print('%s : %s'%(name,sex))

classmate('二哥')
classmate('小孟')
classmate('大猛')
classmate('朗哥','女')   #  sex的值会被覆盖为'女'

只有调用函数的时候
    按照位置传 ： 直接写参数的值
    按照关键字： 关键字 = 值

定义函数的时候：
    位置参数 ： 直接定义参数
    默认参数（关键字参数 ）：参数名 = '默认的值'
    动态参数 : 可以接受任意多个参数
                定义方式：参数名之前加*，习惯参数名args，
                参数名之前加**，习惯参数名kwargs
    顺序：位置参数，*args, 默认参数,**kwargs

def classmate(name,sex):
    print('%s : %s'%(name,sex))

classmate('二哥','男')  #按照位置传参
classmate(sex='男',name = '二哥')  # 按关键字传参

def classmate(name,sex='男'):  #  sex是默认参数
    print('%s : %s'%(name,sex))

classmate('二哥')  # 默认参数可以不写
classmate('朗哥',sex= '女') # 按关键字传参

def sum(*args):  #定义了动态参数
    n = 0
    for i in args:
        n+=i
    return n

print(sum(1,2))
print(sum(1,2,3))
print(sum(1,2,3,4))

def func(**kwargs):  # 定义了动态参数**kwargs
    print(kwargs)

func(a = 1,b = 2,c =3)   #以字典的行式输出
func(a = 1,b = 2)
func(a = 1)

动态参数有两种：可以接受任意个参数
    *args   ： 接收的是按照位置传参的值，组织成一个元组
    **kwargs： 接受的是按照关键字传参的值，组织成一个字典
    args必须在kwargs之前

def func(*args,default = 1,**kwargs):  # 注意顺序
    print(args,kwargs)

func(1,2,3,4,5,default=2,a = 'aaaa',b = 'bbbb',)

动态参数的另一种传参方式

def func(*args):#站在形参的角度上，给变量加上*，就是组合所有传来的值。
    print(args)

func(1,2,3,4,5)
l = [1,2,3,4,5]
func(*l)  #站在实参的角度上，给一个序列加上*，就是将这个序列按照顺序分配

def func(**kwargs):
    print(kwargs)

func(a=1,b=2)
d = {'a':1,'b':2} #定义一个字典d
func(**d)

函数的注释
def func():
    '''
    这个函数实现了什么功能
    参数1：
    参数2：
    :return: 是字符串或者列表的长度
    '''
    pass


四、总结

    默认参数的陷阱（明天讲）
文件的修改
函数
1.函数的定义 def
2.函数的调用
3.函数的返回值 return
4.函数的参数
    形参：
        位置参数 ： 必须传
        *args ：可以接收任意多个位置参数
        默认参数 ： 可以不传
        **kwargs ： 可以接收多个关键字参数
    实参：按照位置传参（先），按照关键字传参（后）

函数
    内置函数
    自定义函数 ！！！！！