函数基础

函数的定义

　　def+函数（参数）：                                     # 定义了之后，可以在任何需要它的地方调用

#函数定义 
#def k():
#     """计算s1的长度"""
#     s1 = "hello world"
#     n = 0
#     for i in s1:
#         n+=1
#     print(n)#此时只是简单的打印，而没有将变量的值返回给函数k

#函数调用 k()
# k()                 #k()得到的结果是None

函数的调用

#函数定义

# def k():
#     """计算s1的长度"""
#     s1 = "hello world"
#     n = 0
#     for i in s1:
#         n+=1
#     print(n)
#     return n     #return将n的值返回给函数k

#函数调用  
k()

返回值

返回值的3种情况
    #（1）没有返回值 —— 返回None
        # 不写return
        # 只写return:结束一个函数的继续
        # return None -- 不常用
    #（2） 返回1个值
        # 可以返回任何数据类型
        # 只要返回就可以接收到
        # 如果在一个程序中有多个return，那么只执行第一个
    #（3）返回多个值
        # 用多个变量接收：有多少返回值就用多少变量接收
        # 用一个变量接收: 得到的是一个元组

exp:（1）# def func():
　　#     l = ['阿猫','阿狗']
　　#     for i in l:
　　#         print(i)
　　#         if i=='阿猫':
　　#             return     #此时return后面的语句都不执行被中断了
　　#     print('='*10)
　　# ret = func()
　　# print(ret)

 

  （2）若return改成return i,则k()可以正常接收到i返回的

参数

 

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

# def my_len(s):  #自定义函数只需要0个参数，括号内's'为接收参数,形式参数，形参              #横线上面的是定义函数
#     for i in s:                               #形式参数：在定义函数时用来接收的
#         print(i)
#     return i  #返回值
------------------------------------------------------------------------------------------------------------------
# n = my_len('哈哈哈') #传递参数：传参，括号内'哈哈哈'为实际参数（实参）
# n = my_len([1,2,3,4,5])                       #传递参数：在调用函数时传递的参数
# print(n)                                                                          #横线下面的是调用函数

#定义函数的时候：

位置参数 ： 直接定义参数
　　默认参数，关键字参数 ：参数名 = '默认的值'
　　动态参数 : 可以接受任意多个参数
          参数名之前加*，习惯参数名args，    ,接收的是按照位置传参的值，组织成一个元组
          参数名之前加**，习惯参数名kwargs 　,接受的是按照关键字传参的值，组织成一个字典
   顺序：位置参数，*args,默认参数,**kwargs
调用函数的时候
   按照位置传 ： 直接写参数的值
   按照关键字： 关键字 = 值

动态参数：

# def sum(*args):
#     n = 0
#     for i in args:
#         n+=i
#     return n
# #
# print(sum(1,2))              #args由位置参数组成
# print(sum(1,2,3))
# print(sum(1,2,3,4))
-----------------------------------------------------------------------
# def func(**kwargs):
#     print(kwargs)
#
# func(a = 1,b = 2,c =3)       #kwargs由关键词参数组成
# func(a = 1,b = 2)
# func(a = 1)

#def func(*args,default = 1,**kwargs):
#     print(args,kwargs)
# func(1,2,3,4,5,default=2,a = 'aaaa',b = 'bbbb',)
#结果显示   (1, 2, 3, 4, 5) {'a': 'aaaa', 'b': 'bbbb'}

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

# def func(*args):#站在形参的角度上，给变量加上*，就是组合所有传来的值。
#     print(args)
exp:
# def func(*args):
#     return (args)
# print(func('1,2,3,4,5')

func(*l)  #站在实参的角度上，给一个序列加上*，就是将这个序列按照顺序打散

(1)# def func(l):
#     return (l)
# l = [3]
# print(func(*l))

结果显示：3

(2)# def func(*l):     如果在变量加上*  则可以将打散的序列则合成元祖。
#     return (l)
# l = [1,2,3,4,5]
# print(func(*l))
结果显示：(1, 2, 3, 4, 5)

 函数的注释

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

默认参数的陷阱：

def qqxing(l = []):    列表是可变数据类型
#     l.append(1)
#     print(l)
# qqxing()     #[1]
# qqxing()     #[1,1]
# qqxing()     #[1,1,1]

# 如果默认参数的值是一个可变数据类型，那么每一次调用函数的时候，如果不传值就共用这个数据类型的资源。