Python之函数

1、文件的修改

修改文件：
当前文件下只有一行内容：女主角：星儿
with open ('zzm',encoding='utf-8') as f:
    for line in f:
        if '星儿' in line :
            line = line.replace('星儿', '赵志铭')


当前文件下有两行内容：小护士：爱萝莉
                   小迷妹：zzm
要求：将小迷妹改成赵志铭
with open ('zzm',encoding='utf-8') as f,open('zzm.bak',mode='w',encoding='utf-8') as f2:
    for line in f :
        if '小迷妹' in line:
            line=line.replace('小迷弟','赵志铭')
        f2.write(line)

import os
os.remove('zzm')
os.rename('zzm.bak','zzm')                    

 2、函数的定义及定义:

为什么使用函数？

（1）提高代码的可读性

（2）提高代码的复用性

使用函数的特点：可以多次调用。

函数定义：必须以关键词def开头，空格之后接函数名称和圆括号()，最后是":"。如：def My_len():

　　　　　　My_len： 函数名（数字。字母下划线任意组合，不能用数字开头，不能不能使用关键字）

注释：每一个函数都应该对功能和参数进行相应的说明，应该写在函数下面第一行。以增强代码的可读性。

def func()
    '''
    注释
    
    '''
    pass

调用：就是 函数名() 要记得加上括号。

函数：定义了之后，可以在任何和需要它的地方使用。

def my_len():
    i = 0
    for k in s:     #定义函数、申明函数
        i +=1
    print(i)
    return  i

s = 'asf234wedsx'

my_len() #函数的调用

my_len()函数

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

　　　　2只是输出了结果

　　　　3没有返回长度，只是单纯的打印

返回的重要性：

 下列例子无法进行a+b的计算，那这个时候就需要用到返回值了。

a,b
len(a)
len(b)

2、返回值

def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    print(length)

#函数调用
str_len = mylen()
print('str_len : %s'%str_len)

 当我们执行以上代码，得到的值是None,说明什么也没有返回。如要想要得到返回值就需要用到return。

#函数定义
def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    return length　　　　#返回length，得到s1的长度。

#函数调用
str_len = mylen()
print('str_len : %s'%str_len)

return关键字：

　　return是一个关键字，放在return后面的值被叫做返回值。

返回值的几种情况：没有返回值，返回一个值，返回多个值

没有返回值

　　不写return的情况下，是没有返回值的。

def func():
    '"""循环打印l中的元素"""
    l=['amy','taeyang']
    for i in l:
        print(i)
#函数的调用
ret = func()
print(ret)

　　只写return，但return后面没有值，也是没有返回值的。虽然写return也会返回None,为什么还要写return呢？因为函数的执行当中遇到return了之后就会结束整个函数。

def func():
    """循环打印l中的元素"""
    l=['amy','taeyang']
    for i in l:
        print(i)
    return  None
    print('12345')
ret = func()
print(ret)

　　return后面写None，也是没有返回值的。但是一般不会这么写。

def func():
    """循环打印l中的元素"""
    l=['amy','taeyang']
    for i in l:
        print(i)
    return  None

ret = func()
print(ret)

　　返回一个值

只需在return后面写上要返回的内容即可

             可以返回任意类型

             只要返回了就可以接收

             如果一个程序中有多个return，那么只返回第一个return

def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    return length

#函数调用
str_len = mylen()
print('str_len : %s'%str_len)

　　返回多个值　　

        多个返回值用多个变量接收，有多少个返回值就用多少个变量接收。

        返回多个值，用一个变量接收，得到的是一个元组。

def func():
    return({'k1','v2'})
print(func())

接收

python中把用逗号分割的多个值就认为是一个元组。

>>> 1,2  #python中把用逗号分割的多个值就认为是一个元组。
(1, 2)
>>> 1,2,3,4
(1, 2, 3, 4)
>>> (1,2,3,4)
(1, 2, 3, 4)

解压：

#序列解压一
>>> a,b,c,d = (1,2,3,4)
>>> a
1
>>> b
2
>>> c
3
>>> d
4
#序列解压二
>>> a,_,_,d=(1,2,3,4)
>>> a
1
>>> d
4
>>> a,*_=(1,2,3,4)
>>> *_,d=(1,2,3,4)
>>> a
1
>>> d
4
#也适用于字符串、列表、字典、集合
>>> a,b = {'name':'eva','age':18} 
>>> a
'name'
>>> b
'age'

函数的参数

def mylen(s): #s自定义函数只需要0个参数，接收参数，形式参数，形参
    """计算s1的长度"""
    length = 0
    for i in s:
        length = length+1
    return length

#函数调用
s = 'fwewvedwedw'
str_len = mylen(s)  #s:传递参数：传参，实际参数，实参
print('str_len : %s'%str_len)

我们告诉mylen函数要计算的字符串是谁，这个过程就叫做 传递参数，简称传参，我们调用函数时传递的这个“s = 'fwewvedwedw'”和定义函数时的s就是参数。

实参与形参

参数还有分别：

我们调用函数时传递的这个s = 'fwewvedwedw'”被称为实际参数，因为这个是实际的要交给函数的内容，简称实参。

定义函数时的s，只是一个变量的名字，被称为形式参数，因为在定义函数的时候它只是一个形式，表示这里有一个参数，简称形参。

没有参数：

定义函数和调用函数时括号里都不写内容

有一个参数

传什么就是什么

有多个参数

参数可以传递多个，多个参数之间用逗号分割

#位置参数
def my_sum(a,b):
    sum = a+b    #result
    return sum
ret=my_sum(1,23)
print(reet)

位置参数

不能给同一个变量传多个值。

站在实参位置上：

　　按照位置传参

def my_sum(a,b):
    sum = a+b
    return sum
ret=my_sum(1,23)
print(ret)

　　按照关键字传参

def my_sum(a,b):
    sum = a+b
    return sum
ret=my_sum(b=1,a=23)
print(ret)

　　混着用可以，但是传参必须按照位置穿，再按关键传参

def my_sum(a,b):
    sum = a+b
    return sum
ret=my_sum(a=1,23)
print(ret)

站在形参的角度上： 

         位置参数：必须传，有几个传几个

def mymax(x,y):
    #此时x = 10,y = 20
    print(x,y)
    the_max = x if x > y else y
    return the_max

#调用mymax不传递参数
ma = mymax()
print(ma)

#结果
TypeError: mymax() missing 2 required positional arguments: 'x' and 'y'

　　关键字参数：

def stu_info(name,sex = "male"):
    """设置默认参数sex的默认值为'male'
    """
    print(name,sex)
stu_info('amy')
stu_info('emy','female')

　　参数陷阱：默认参数是一个可变数据类型

def fuc(l=[]):
    l.append(1)
    print(l)

fuc()   #[1]
fuc()   #[1][1]
fuc([]) #[1]
fuc()   #[1][1][1]
fuc()   #[1][1][1]

动态参数

*args:　　　　接收的是按照位置传参的值，组织成一个元组

def sum(*args):
    n = 0
    for i in args:
        n +=i
    return n
print(sum(1,2))
print(sum(3,5,5))

**kwargs　　　接收的是按照关键字传参的值，组织成一个字典

def stu_info(**kwargs):
    print(kwargs)
    print(kwargs['name'],kwargs['sex'])

stu_info(name = 'alex',sex = 'male')

args必须在kwargs之前

def fun1(*args,defau=2,**kwargs):
    return(args,defau,kwargs)
print(fun1('1','sdff','23d',defau=4,a='1234',s='234rf'))

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

def func2(*args):#站在形参的角度上，给变量加上*，就是组合所有传来的值
    print (args)
print(func2(1,2,3,4,5,6))
l=['af','sa',1234,5]
print(func2(*l))    #站在实参的角度上，给一个序列加上*，就是将这个序列将顺序打散

只有调用函数的时候：

         按照位置传：直接写参数的值

         按照关键字： 关键字 = 值

定义函数的时候：

　　位置参数：直接定义参数

　　默认参数：关键字参数：

　　动态参数：又可以多个任意参数（必须有*，但args可变）

                           必须有*，习惯定义args　　

　　　　　　　接收按关键字传值的动态参数：**kwargs，返回值为字典。

　　　参数的顺序：位置参数 *args 默认参数 **kwargs