Python3-函数

转载自：https://www.cnblogs.com/ctztake/p/7234823.html

函数：

• 函数的定义
• 函数的返回值
• 函数的参数

 

一、函数的定义：

# mylen叫函数名
# def是关键字  define
# (): 必须写

def mylen():
    '''
    计算字符串长度的函数
    '''
    s = 'hello world'
    length = 0
    for i in s:
        length += 1
        #print('s的长度是%s'%（length）)
        #print(length)
    return length

# 函数的调用：函数名+括号

leng = mylen()
print(mylen())

# 函数名
# 必须由字母下划线数字组成，不能是关键字，不能是数字开头
# 函数名尽量别词不达意

定义：def关键词开头，空格之后接函数名称和圆括号()，最后还有一个':'。

　　　def 是固定的，不能改变，必须是连续的def三个字母，不能分开。

　　　空格为了将def关键字和函数分开，。

　　　函数名：函数名只能包括字符串，下划线和数字且不能以数字开头。虽然函数名可以随便起，但我们给函数名起名字还是尽量简短，并能表达函数功能。

　　　括号：是必须家的，先别问为啥要括号，总之加上括号就对了。

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

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

二、函数的返回值

def func():
    a = 111
    b = [1,2,3]
    #首先 返回值可以是任意的数据类型
    return b

#如果有返回值：必须要用变量接收才会有效果
# ret = func()
# print(ret)

def func1():
    a = 111
    b = [1,2,3]
# ret = func1()
# print(ret)
#函数可以没有返回值
#当不写return的时候，一个函数默认的返回值是'None'

def func2():
    a = 111
    b = [1,2,3]
    return
# ret = func2()
# print(ret)
#当只写一个return的时候，函数的返回值为None

def func3():
    a = 111
    b = [1,2,3]
    return None
# ret = func3()
# print(ret)
#return None的时候函数的返回值也为None（几乎不用）

def func4():
    print(1111)
    return
    print(2222)

# func4()
输出
1111

# 函数遇到return时就翻回结果了，所以return后面的代码不执行。

def func5():
    for i in range(20):
        if i == 5:
            return
        else:
            print(i)
func5()

输出：

　　0
　　1
　　2
　　3
　　4

 

# 总结：
# 函数的返回值为None有三种情况
# 1.不写返回值
# 2.只写一个return
# 3.return None   （几乎不用）
# return的作用：结束一个函数的执行并返回值

# 函数的返回值不为None，有返回值
# return xxx 返回一个值（一个变量）
# return a,b 返回多个值（多个变量），多个值之间用逗号区分   默认返回元组形式
　　　　　　　　#接收：可以用一个变量接收，以元组的形式返回
　　　　　　　　#　　亦可以多个变量接收，返回几个就用几个变量去接收


# 函数要先定义 后 使用

def func6():
    '''返回一个值'''
    #return 111
    #return 'abc'
    return ['abc',123]

def func7():
    '''返回多个值'''
    a = 123
    b = 'abc'
    return a,b,[1,2,3]

# ret = func7()
# print(ret)
# m,n,k = func7()
# print(m)
# print(n)
# print(k)

 

def func8():
    l = [1,2,3,4]
    return l[-1]

# ret = func8()
# print(ret)

三、参数

#函数定义
def mylen(s1):
    """计算s1的长度"""
    length = 0
    for i in s1:
        length = length+1
    return length

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

我们告诉mylen函数要计算的字符串是谁，这个过程就叫作传递参数，简称传参，我们调用函数时传递的这个'hello world'和定义函数时的s1就是参数。

实参与形参

参数还有区别：

我们调用函数时传递的这个'hello world'被称为实际参数，因为这个是实际的要求给参数的内容，简称实参。

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

传递多个参数

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

def mymax(x,y):
    the_max = x if x > y else y
    return the_max

ma = mymax(10,20)
print(ma)

位置参数

　　站在实参角度

1.按照位置传值

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

ma = mymax(10,20)
print(ma)

2.按照关键字传值

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

ma = mymax(y = 10,x = 20)
print(ma)

3.位置、关键字形式混着用

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

ma = mymax(10,y = 20)
print(ma)

注意！！！！！！！！！！

• 位置参数必须在关键字参数前面
• 对于一个形参只能赋值一次

 

站在形参角度

1.位置参数必须传值

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'

 2.默认参数

默认参数得在形参的位置参数后面。

　　　　a.正常使用

　　　　　　使用方法

　　　　　　为什么要有默认参数：将变化比较小的值设置成默认参数

　　　　b.默认参数的定义

def stu_info(name,sex = "male"):
    """打印学生信息函数，由于班中大部分学生都是男生，
        所以设置默认参数sex的默认值为'male'
    """
    print(name,sex)


stu_info('alex')
stu_info('eva','female')

Outpu：

　　alex male
　　eva female

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

# l = [] 相当于是定义了一个默认参数[]
def defult_param(a,l = []):
    l.append(a)
    print(l)

defult_param('alex')
defult_param('egon')

 

3.动态参数（非固定参数）

　　按位置传值多余的参数都由args统一接收，保存成一个元组的形式

 a.*args

def func(a,b,*c):
    my_sum = a+b
    for i in c:
        my_sum += i
    return my_sum

# 按位置传参数，尽量使用*args
# print(func(3,2))
# print(func(1,2,5,6))

b.**kwargs

**kwargs 也可以说是把' 未定义的关键字参数传入dict中 '

def fun(a,b,**kwargs):
    print(a,b,kwargs）

# 按照关键字传参数
#fun(a = 10,b = 20,cccc= 30,dddd = 50)

c.*args，**kwargs传递的另外一种方式

def send_alert(msg, *args):
    print(msg, args)

# 方式一
send_alert('hello', 'alex','egon','irving')
Output: hello ('alex', 'egon', 'irving')

# 新姿势,当你需要传入一个列表的时候
send_alert('hello', ['alex', 'egon', 'irving'])
Output: hello (['alex', 'egon', 'irving'],)
#它就把传入的列表整体当成元组的一个元素传进去了，如果我们日后需要循环这个元组发消息，显然是不行的

send_alert('hello', *['alex', 'egon', 'irving'])
Output :hello ('alex', 'egon', 'irving')
#在列表前面加个*，列表里面的每一个元素就会转成元组里面的了。


# **args差不多，  在字典前面加 ** 就ok

 

本章小结：

面向过程编程的问题：代码冗余、可读性差、可扩展性差(不易修改)

定义函数的规则：

复制代码
1.定义：def 关键词开头，空格之后接函数名称和圆括号()。
2.参数：圆括号用来接收参数。若传入多个参数，参数之间用逗号分割。
　　　　参数可以定义多个，也可以不定义。
　　　　参数有很多种，如果涉及到多种参数的定义，应始终遵循位置参数、*args、默认参数、**kwargs顺序定义。
　　　　如上述定义过程中某参数类型缺省，其他参数依旧遵循上述排序
3.注释：函数的第一行语句应该添加注释。
4.函数体：函数内容以冒号起始，并且缩进。
5.返回值：return [表达式] 结束函数。不带表达式的return相当于返回 None

def 函数名(参数1,参数2,*args,默认参数,**kwargs):
        """注释：函数功能和参数说明"""
        函数体
        ……
        return 返回值


调用函数的规则：

1.函数名()
    函数名后面+圆括号就是函数的调用。
2.参数：
    圆括号用来接收参数。
    若传入多个参数：
        应按先位置传值，再按关键字传值
        具体的传入顺序应按照函数定义的参数情况而定
3.返回值
    如果函数有返回值，还应该定义“变量”接收返回值
    如果返回值有多个，也可以用多个变量来接收，变量数应和返回值数目一致

无返回值的情况：
函数名()

有返回值的情况：
变量 = 函数名()

多个变量接收多返回值：
变量1，变量2，... = 函数名()

 

四、函数的命名空间

命名空间一共分为三种：

　　全局命名空间

　　局部命名空间

　　内置命名空间

*内置命名空间中存放了python解释器为我们提供的名字：input,print,str,list,tuple...它们都是我们熟悉的，拿过来就可以用的方法。

三种命名空间之间的加载与取值顺序：

加载顺序：内置命名空间(程序运行前加载)->全局命名空间(程序运行中：从上到下加载)->局部命名空间(程序运行中：调用时才加载)

取值：

　　在局部调用：局部命名空间->全局命名空间->内置命名空间

 

五、函数的作用域：

作用域

作用域就是作用范围，按照生效范围可以分为全局作用域和局部作用域。

全局作用域：包含内置命名空间，全局命名空间，在整个文件的任意位置都能被引用，全局有效

局部作用域：局部命名空间，只能在局部范围内生效。

 

小范围的可以用大范围的，但是大范围的不能用小范围的

范围从大到小在小范围内，如果要用一个变量，是当前这个小范围有的，就用自己的如果在小范围内没有，就用上一级的，上一级没有就用上上一级的，以此类推。如果都没有，报错

代码定义完成后，作用域已经生产，作用链向上查找

age = 18

def func1():
    age = 73
    def func2():
        print(age)

    return func2

val = func1()
val()

Output：73

 

六、函数的嵌套和作用域链

函数嵌套

def f1():
    def f2():
        def f3():
            print("in f3")
        print("in f2")
        f3()
    print("in f1")
    f2()
    
f1()

Output：

　　in f1
　　in f2
　　in f3

函数作用域链

def f1():
    a = 1
    def f2():
        def f3():
            print(a)
        f3()
    f2()

f1()

Output：
1

def f1():
    a = 1
    def f2():
        a = 2
    f2()
    print('a in f1 : ',a)

f1()

Output：
a in f1 :  1