python学习日记(函数基础)

修改文件（原理）--回顾

#修改文件（原理）
with open('name','r',encoding='utf-8') as f,
    open('password','w+',encoding='utf-8') as f1:
    for line in f:
        if '开始' in line:
            line = line.replace('开始','千字文')#替换字符
        f1.write(line)
    f1.seek(0)
    print(f1.read())
#import后续再详解
import os
os.remove('name')#删除'name'文件
os.rename('password','name')#重命名

函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。

python提供了许多内建函数，也可以自己创建函数，这叫做用户自定义函数。

自定义函数

简单调用

s = '天地玄黄'
def my_len():#定义函数名
    count = 0
    for i in s:
        count += 1
    print(count)
my_len()#调用函数

1、没有返回值--返回None

①、不写return

s = '天地玄黄'
def my_len():#定义函数名
    count = 0
    for i in s:
        count += 1
    print(count)
l = my_len()
print(l)

②、只写return

s = ['天地玄黄','1','宇宙洪荒']
def my_out():#定义函数名
    for i in s:
        if i == '1':
            return#直接结束了一个函数的继续
        print(i)
l = my_out()
print(l)

③、return None

s = ['天地玄黄','1','宇宙洪荒']
def my_out():#定义函数名
    for i in s:
        if i == '1':
            return None#return直接结束了一个函数的继续
        print(i)
l = my_out()
print(l)

2、带有返回值

s = '天地玄黄'
def my_len():#定义函数名
    count = 0
    for i in s:
        count += 1
    return count#带有返回值
print(my_len())

s = ['天地玄黄','1','宇宙洪荒']
def my_out():#定义函数名
    for i in s:
        if i == '1':
            print(i)
            return i
l = my_out()#输出 1 是调用函数执行里面的print(i)打印出来的
print(l)#输出 1 是 return 返回的

①、返回一个值

def my_one():
    return [1,2,3]
print(my_one())
#可以返回任何数据类型,只要返回就可以接收到
def my_one():
    return {'a':'apple','b':'buy it'}
print(my_one())

②、返回多个值

1、多个参数进行接收，有多少返回值用多少参数进行接收

def my_more():
    return 'happy','day'
a,b = my_more()
print(a,b)

2、一个参数进行接收所有返回值，返回的数据类型是一个元组

def my_more():
    return 'happy','day'
l = my_more()
print(l)

python机制，输入1，2，3逗号隔开就相当于（1，2，3）一个元组。

函数参数

def my_len(s):#定义函数名,传递参数--形参
    count = 0
    for i in s:#必须与定义的形参一致
        count += 1
    return count#带有返回值
l1 = '天地玄黄'
l2 = 'good life'
print(my_len(l1))#这里传过去的参数为实际参数--实参
print(my_len(l2))

一个小问题：调用互不影响，顺序可能会影响

def f1(a):
    for i in a:
        print(i,end=' ')
def f2(b):
    for j in b:
        print(j,end=' ')
f1([1,2,3])
f1((7,8,9))
f2([4,5,6])

def f1(a):
    f2([4, 5, 6])
    for i in a:
        print(i,end=' ')
f1([1, 2, 3])#此时调用f1,但f2尚未定义
def f2(b):
    for j in b:
        print(j,end=' ')

多个参数

位置参数

def my_sum(a,b):#定义求和函数
    print(a,b)
    r = a+b
    return r
print(my_sum(1,2))
print(my_sum(2,1))

关键字参数

一、

def my_sum(a,b):#定义求和函数
    print(a,b)
    r = a+b
    return r
l = my_sum(2,b = 1)
print(l)

二、位置参数必须在关键字参数的前面

def my_sum(a,b):#定义求和函数
    print(a,b)
    r = a+b
    return r
l = my_sum(a = 2,b)#位置参数必须在关键字参数的前面
print(l)

默认参数

可以不传，会使用默认值，传了使用传的值。

先位置参数，后默认参数。

def my_default(name,sex='female'):
    print('姓名:{},性别:{}'.format(name,sex))
my_default('Miss')
my_default('Mrs')
my_default('Mr','male')

动态参数

*args（位置参数）

可接收若干个位置参数

def my_sum(*args):
    count = 0
    for i in args:
        count += i
    return count
print(my_sum(1))
print(my_sum(1,2,3))
print(my_sum(1,2,3,4,5))

只能接收位置参数，如果接收关键字参数，会引发异常。

def test(*args):
    print(args)
test(1,2,3)
test(1,2,a = 'oneday')

def test(*args,a='lalala'):
    print(args,a)
test(1,2,3)
test(1,2,a = 'oneday')

**kwargs（关键字参数）

可接收若干个关键字参数

def func(**kwargs):
    print(kwargs)
func(a = '李白')
func(a = '李白',b = '杜甫')
func(a = '李白',b = '杜甫',c = '张爱玲')

前面就有提到，关键字参数必须在位置参数之后。

动态参数另一种传参方式

def sin(*args):
    print(args)
sin(1,2,3,4,5)
li = [1,2,3,4,5,['avengers']]
sin(*li)#给一个序列加上 * ,就是将序列按照顺序传递

def mul(**kwargs):
    print(kwargs)
mul(a = 'captain',b = 'loki')
dic = {'a':'captain','b':'loki'}#字典,无序
mul(**dic)

函数参数顺序

顺序

a,*args,default = 'none',**kwargs

位置参数，动态位置参数，默认参数，动态关键字参数

一、（参数同名错误）

def func(a,b,*args,default = 'here',**kwargs):
    print(a,b,args,default,kwargs)
func(1,2)
func(1,2,999)
func(1,2,999,default='coming')
func(1,2,999,default='coming',a = 'aaa',b = 'bbb')#位置参数必须在关键字参数之前。a,b为位置参数

位置参数不能在关键字参数之后出现

二、（正确）

def func(a,b,*args,default = 'here',**kwargs):
    print(a,b,args,default,kwargs)
func(1,2)
func(1,2,999)
func(1,2,999,default='coming')
func(1,2,999,default='coming',m = 'aaa',n = 'bbb')#

函数注释

def func():
    '''
    函数实现功能介绍
    参数1:作用或者数据类型
    参数2:
    :return:返回值
    '''
    pass

默认参数的陷阱

如果默认参数的值是一个可变数据类型，调用函数的时候，不传值就会共用这个数据类型。

def hh(li = []):
    li.append(1)
    print(li)
hh()        #没传，用了默认
hh([2,3])   #传了，用的传的
hh()        #没传，用了默认+1

def di(k,d = {}):
    d[k] = 'value'
    print(d)
di(1)# d 参数没传，共用一个默认的字典
di(2)
di(3)

pass