python之函数

#函数
#可读性强，复用性强
#函数定义：定义了之后，可以在任何需要的地方调用
#格式： def 函数名()： 例子：def mylen():
# 没有返回长度，只能单纯的打印
# return 返回值的重要性 定义了一个函数，建议都带一个返回值,不然无法进行赋值
#完整例子：def 函数名():
#            函数体
#            return 返回值

# #定义函数后，无返回值
# s = '杰瑞你好啊'
# def mylen():
#     n = 0
#     for i in s :
#         n += 1
#     print(n)
# mylen()
# len1 = mylen()
# print(len1)
#
# #定义函数后，有返回值
# s = '杰瑞你好啊'
# def mylen():
#     n = 0
#     for i in s :
#         n += 1
#     print(n)
#     return n
#
# len1 = mylen()
# print(len1)

#返回值
#返回值的三种情况
    # 没有返回值 ---当没有返回值的时候默认返回None
        # 不写return
        # 直接写return 不加值,结束一个函数的继续，即return后面的都不执行了
        # return None  --- 不常用
    # 返回1个值
        # 可以返回任意一种数据类型
        # 只要返回就可以接受到
        # 如果在一个程序种有多个retrun，那么只执行第一个
    # 返回多个值
        # 多个返回值用多个变量接收，有多少返回值就用多少变量接收。
        # 用一个变量接受：得到的是一元组，元组为不可以变数据类型

# 没有返回值
# def test():
#     l = ['jerry','tom']
#     for i in l:
#         print(i)
#         #return
#         #retrun None
# test()

#返回一个值
# def test():
#     l = ['jerry','tom']
#     a = {}
#     for i in l:
#         a.setdefault(i)
#     return a
#
# test = test()
# print(test)

#返回多个值
# def test():
#     l = ['jerry','tom']
#     a = {}
#     for i in l:
#         a.setdefault(i)
#     return a,l
#
# test = test()
# print(test)

# 小知识点：传递参数
# 定义一个函数并赋予参数
# 没定义参数时，只能计算指定的变量名
# 定义参数后，可以计算任意的值
# 没定义参数
# s = '你好啊'
# def my_len():
#     i = 0
#     for k in s:
#         i+=1
#     return i
#
# ret = my_len()
# print(ret)

#定义参数
# s1 = '你好哈'
# def my_len1(a):  # 自定义参数只需要0个参数，接受参数，形式参数：形参
#     i = 0
#     for k in a:  # a 必须和形参是一致的
#         i += 1
#     return i
#
# ret1 = my_len1(s1)  # 传递参数：传参，实际参数：实参
# ret2 = my_len1('你是谁啊')  # 传递参数
# print(ret1,ret2)

#参数的语法---写在括号内的值

#参数
    # 没有参数
        # 定义函数和调用函数时括号里都不写内容
    # 有一个参数
        # 传什么就是什么
    # 有多个参数
        # 位置参数
# 站在实参的角度上：
    # 按照位置传参
    # 按照关键字传参
    # 混着用也可以，但是必须先按照位置传参，再按照关键字传参，不能同时给一个变量传多个值

#典型传输多个参数：典型的位置参数
# def my_sum(a,b):
#     c = a + b
#     return c
#
# ret = my_sum(1,2)  # 位置传参
# ret2 = my_sum(a=2,b=1)  # 关键字传参
# print(ret,ret2)

# def classmate(name,sex='men'):  # 默认参数 sex = 'men'
#     print('%s : %s'%(name,sex))
#
# classmate('jerry')
# classmate('jerry')
# classmate('Amy','woman')  # 若有参数，则修改默认参数
# classmate('jerry')

# 站再形参的角度上：
    # 位置参数：必须传，且不能多传以及少传
    # 默认参数：可以不传，如果不写则使用默认参数，若写了就用设置的参数替换默认参数

# 只有调用函数的时候
    # 按照位置传：直接写参数的值
    # 按照关键字传： 关键字 = 值 如 open( file, encoding = 'utf-8')

# 定义函数的时候：
    # 位置参数：直接定义参数
    # 默认参数： 关键字参数: 参数名 = ‘默认值’
    # 动态参数： 可以接受任意多个参数
        # 在定义参数的时候 前面加多个*  例子：def my_len(*aaaa)
        # 约定俗成 都是以 *args 为动态参数
    # 顺序：先定义位置参数，*args，再设置默认参数，最后**kwargs
# 动态参数有两种
    # *args: 接收的是按照位置传参的值，组成一个元组
    # **kwargs:接收的是关键字传参的值，组曾一个字典

# 按照位置传参
# def classmate(*args):  # 默认参数 sex = 'men'
#     n = 0
#     for i in args:
#         n += i
#     return n
#
# print(classmate(1,2))
# print(classmate(1,2,3))
# print(classmate(1,2,3,4))

# 按照关键字传参
# def func(**kwargs):
#     print(kwargs)
#
# func(a = 1,b=2,c=3)
# func(b=2,c=3)
# func(c=3)

# 动态参数的另一种传参方式
# def func(*args):  # 站在形参的角度上，给变量加上*，就是组合所有传来的值
#     print(args)
#
# func(1,2,3,4,5,6)
# l = [2,1,3,6,5,2]
# func(*l)  # 站在实参的角度上，给一个序列加上*，就是将这个序列按照顺序打散

# def func(**kwargs):
#     print(kwargs)
#
# func(a=1,b=2)
# d = {'a':1,'b':2}
# func(**d)

#函数的注释
def func():
    '''
    这个函数实现了什么功能
    参数1：
    参数2：
    :return:
    '''
    pass

#默认参数的陷阱
#如果默认参数的的值是一个可变数据类型，那么每次调用函数时，如果不传值就公用这个 数据类型的资源
def test(l= []):
l.append(1)
print(l)

test()
test()
test()
test([])
test()

def test1(dic = {}):
dic['k'] = 'v'
print(dic)

test1()
test1()
test1()
test1()

def test1(k,dic = {}):
dic[k] = 'v'
print(dic)

test1(1)
test1(2)
test1(3)

test1(4)
 
原文：https://blog.csdn.net/chengyinman0078/article/details/85069663