python函数

1. python 函数简介

函数就是具有莫个功能的工具；

为什么要使用 函数，使用函数的好处：

　　提高开发效率

　　减少代码冗余

　　提高程序的扩展性

函数的定义

def 是定义的关键字

函数名：函数名的命名规则与变量命名一致

　　1. 不能以关键字命名

　　2. 函数也要见名知意。

　　3。函数在定义的时候，只会检测语法，不会执行函数代码

def func():
    print('hello)

调用函数的固定格式

　　函数名（）

　　函数名只要遇到（）就会立即执行函数代码，优先级最高。

函数必须先定义，后调用。

 

二，函数的返回值

讨论：我们自己写的函数现在的问题

　　1，没有返回值， 只能固定的执行打印操作

　　2， 只能固定的统计莫个类型容器的长度

函数内要想给调用着值， 必须用关键字return

"""

不写return

只写return

写return None

写return返回一个值

写return返回多个值

"""

 

 1 # 不写return:函数默认返回None
 2 def func():
 3     print('hahaha')
 4 res = func()
 5 print(res)
 6 
 7 
 8 只写return:return除了可以返回值之外 还可以直接结束整个函数的运行
 9 只写return 返回的也是None(None就表示什么都没有)
10 def func():
11    l = ['jason','egon','tank']
12     while True:
13        for i in l:
14            if i == 'egon':  # 当i为egon的时候 直接结束函数运行
15                # break
16                return
17                # print('asdasdkljlsjadl')  # 这一行代码拥有都不会运行
18            print(i)
19 res = func()
20 print(res)
21 
22 
23 # 写return None:跟上面的只写return是一样的
24 def func():
25    return None
26 res = func()
27 print(res)
28 
29 
30 # 写return返回一个值:这个值可以是python任意数据类型
31 def func():
32    return '123'
33 def func1():
34     return [1,2,3]
35 def func2():
36    return {'name':'jason'}
37 def func3():
38     return (1,)
39 def func4():
40    return {1,2,3,4,5}
41 def func5():
42    return True
43 print(func(),func1(),func2(),func3(),func4(),func5())
44 
45 
46 # 写return返回多个值:return会自动将多个值以元组的形式返回给调用者

View Code

 

# 写return 返回的多个值：return会自动将多个值以元祖的形式返回

 

"""

1.为什么组织成元祖返回

    函数不希望自己处理的结果被修改

2.如何不返回元祖

 

 1 def func():
 2     return 1,2,3,4  # 返回的是(1, 2, 3, 4)
 3 # res = func()
 4 # print(res)
 5 
 6 def func1():
 7     return 'a','b','c'  # ('a', 'b', 'c')
 8 res = func1()
 9 print(res)
10 
11 
12 def func2():
13     return [1,2,3],[1,2,3],[1,2,3]  # ([1, 2, 3], [1, 2, 3], [1, 2, 3])
14 res1 = func2()
15 print(res1)
16 
17 
18 def func3():
19     return {'name':'jason'},{'username':'tank'},{'user_name':'egon'}  # ({'name': 'jason'}, {'username': 'tank'}, {'user_name': 'egon'})
20 res2 = func3()
21 print(res2)
22 
23 # 返回多个值 并且不想让return帮你做处理  自己手动加上你想返回的数据类型符号
24 def func4():
25     return [[1,2,3,4],[1,2,3,4],[1,2,34]]
26 res = func4()
27 print(res)

View Code

1.所有的函数都有返回值,无论你写不写return

    python中所有的函数都有返回值 不写的情况下默认返回None

 

2.光写return 或者return None并不是为了考虑返回值 而是为了结束函数的运行

 

3.函数参数的量大类型：

　　形参：在函数的定义阶段，括号内写的变量名 ，叫函数的形式参数。

　　实参：在函数的调用阶段，括号内实际传入的值，叫实际参数

 

　　形参与实参的关系

　　　　形参就相当于变量名，而实参就相当于变量的值

　　　　函数调用传参的过程，就给形参赋值的过程

注意：形参和实参的绑定关系只在函数的调用阶段有效，函数运行结束关系自动解除

只在函数内部有效 函数外部无任何影响

 

函数的简易结构

　　def 函数名(形参1.。。。。)：

　　　　‘’‘函数的注释’‘’

　　　　函数体代码1

　　　　函数体代码2

　　　　。。。

　　　　return 返回值

。。

 

4.函数的位置参数

　# 位置参数：在函数的定义阶段，按照位置从左往右依次写的变量名，叫函数的位置形参

　# 位置形参在调用的时候，必须传入对应的值。

 

def my_max(x,y):
    print(x,y)
    if x > y:
        return x
    else:
        return y
# res = my_max(1)  # 在调用函数的时候 少一个实参不行
# res = my_max(1,2,3)  # 在调用函数的时候 多一个实参也不行

# res = my_max(20,10)

 

#位置实参：在函数的调用阶段 传入的参数会按照位置 --对应给形参

#关键字传参数

# my_max(y=20,x=10)
# my_max(10,y=20)  # 位置和关键字混合使用
# my_max(20,y=40)
my_max(20,y=40,x=30)

"""
注意:在函数的调用阶段 位置参数和关键字参数可以混合使用
但是必须保证
    1.位置参数必须在关键字参数的前面(越短的越靠前,越长的越复杂的越靠后)
    2.同一个形参不能被多次赋值
"""

5.默认值参数

# 默认值参数:在函数的定义阶段,形参(变量名)就已经被赋值了

# 在调用的时候可以不为默认值形参传值,默认使用定义阶段就已经绑定的值

# 在调用的时候如果可以给默认值形参传值 传了那么就使用你传的值

# 在定义阶段 默认值形参必须放在位置形参的后面

 

 

 1 # def my_max(x,y=100):
 2 #     if x > y:
 3 #         return x
 4 #     return y
 5 # # res = my_max(200)
 6 # res1 = my_max(200,1000)
 7 # res2 = my_max(y=200,x=1000)
 8 # print(res2)
 9 
10 # def register(username,age,gender='male'):
11 #     print(username,age,gender)
12 # register('jason',18)
13 # register('tank',28)
14 # register('egon',84)
15 # register('kevin',58)
16 # register('xiaohou',17,'female')

View Code

 

# 默认值参数的应用场景

# 当形参接收的到值比较单一的情况下 通常可以考虑用默认值形参

 

 1 def info(username,hobby,l=None):
 2     if l == None:
 3         l = []
 4     l.append(hobby)
 5     print('%s 的爱好是 %s'%(username,l))
 6 info('jason','study')
 7 info('tank','生蚝')
 8 info('kevin','喝腰子汤')
 9 info('egon','女教练')
10 
11 解决方法1
12 info('jason','study',[])
13 info('tank','生蚝',[])
14 info('kevin','喝腰子汤',[])
15 info('egon','女教练',[])
16 
17 解决方法2
18 info('jason','study')
19 info('tank','生蚝')
20 info('kevin','喝腰子汤')
21 info('egon','女教练')

View Code

 

函数在定义阶段 内部所使用的变量都已经初始化完毕了

不会因为调用的位置的变化 而影响到内部的值(暂时可忽略)

 

 

函数无论在什么地方被调用

都会跑到函数定义阶段去执行代码

形参中用到的值都是往函数定义阶段代码往上找

 

# 可变长参数

# 站在调用函数传递实参的角度  实参的个数不固定的情况

# 也就意味形参也不固定

# 站在形参的角度 可以用*和**来接收多余的(溢出的)位置参数和关键字参数

 

# 站在形参的角度 看 *

# 形参中的*会将多余的(溢出的)位置实参 统一用元组的形式处理 传递给*后面的形参名

# def func(x,y,*z):
#     print(x,y,z)  # z = (3, 4, 5, 6, 7, 8, 54, 43, 4, 5, 6, 6, 7, 8)
# func(1,2,3,4,5,6,7,8,54,43,4,5,6,6,7,8,)

# 站在实参的角度 看 *

 1 # def func(x,y,z):
 2 #     print(x,y,z)
 3 # # l = [1,2,3]
 4 # # a,b,c = l
 5 # # func(a,b,c)
 6 # # func(*[1,2,3,4,5,6])  # *会将列表打散成位置实参一一传入等价于func(1,2,3,4,5,6)
 7 # func(*(1,2,3))  # 等价于func(1,2,3)
 8 # def func(x,*z):
 9 #     print(x,z)
10 # func(1,*{1,2,3})  # *在形参中只能接收多余的位置实参 不能接收关键字实参
11 # *只能将列表 元组 集合 字符串
12 # *的内部你可以看成是for循环

View Code

# 站在形参的角度看 **

 def func(x,y,**z):
#     print(x,y,z)  # z = {'z': 1,'a': 1, 'b': 2, 'c': 3}
# func(x=1,y=2,z=1,a=1,b=2,c=3)
# **会接收所有多余的关键字参数 并将关键字参数 转换成字典的形式 字典的key就是关键字的名字
# 字典的value就是关键字的名字指向的值  将字典交给**后面的变量名

# 站在实参的角度看 **

ef func(x,y,z):
    print(x,y,z)
# func(12,3,4)
# func(x=1,y=2,z=3)
# d = {'x':1,'y':2,'z':333}
# func(x=1,y=2,z=3)
# func(**d)  # 等价于func(x=1,y=2,z=333)
# **会将字典拆封成 key = value的形式

总结 * 与 **

    *在形参中能够接受多余的位置参数 组织成一个元祖赋值给*后面的变量名

    **在形参中能够接受多余的关键字参数 组织成一个字典赋值给**后面的变量名

    

    

    *:在实参中 *能够将列表 元祖 集合 字符串 打散成位置实参的形式传递给函数

        (*就看成是for循环取值)

    **:在实参中 能将字典打散成key = value的形式 按照关键字参数传递给函数

"""

 

# 需求 你写的函数 无论调用者按照正确传参的方式无论怎么传 你的函数都能够正常执行

# def func1(*x,**y):

#     print(x,y)

# func1(1,2,3,4,5,6,x=1,y=2,z = 3)

 

"""

注意python推荐形参*和**通用的写法

"""

def func2(*args,**kwargs):

    print(args,kwargs)

func2(1,2,3,4,5,6,x=1,y=2,z = 3)

 

#函数可以接收调用者传入的任意个数的参数

def func(*args,**kwargs):

　　pass

　　return

 

　　

转载于:https://www.cnblogs.com/chendaodeng/p/11158813.html