015-Python 函数

话不多说，上代码，看结果。

import functools
print('1、###########################################################')
# 函数
# 重复使用的实现某个功能的代码块的集合体
# 作用是方便代码的重用

# 函数的定义
# def 函数名():
# 	函数体

# 函数的调用
# 函数名()


def test():
    print('123')


test()

print('#########################2、函数的参数##################################')
print('1、####单个参数#######')
# 函数的参数
# 单个参数
# 需要动态的调整函数体中某一个处理信息  则可以以参数的形式接收到相关数据
# def 函数名(参数名称):
# 	函数体   函数体中可以直接以变量的方式使用该参数
#
# 函数的调用   函数名(参数值)
# 上述函数定义中, "参数名称"即为形参    在调用函数的时候, 传递的真实数据, 即为实参


def test(a):    # 形参 a
    print(a + 2)


test(1)  # 实参 1
print('2、多个参数###########')
# 多个参数
# 需要动态的调整函数体中多个处理信息时 则可以以逗号做分割, 接收多个参数


def test(a, b):
    print(a, b)


test(1, 2)  # 形参和实参一一对应
test(b=2, a=1)    # 可以指明形参名称   称为"关键字参数"    不需要严格按照顺序
print('3、不定长参数-元组###########')
# 不定长参数
# 如果函数体中需要处理的数据不确定长度  则可以以不定长参数的方式接收数据
# 装包   把传递的参数, 包装成一个集合, 称之为"装包"
# 拆包    把集合参数, 再次分解成单独的个体, 称之为"拆包"
# 定义
# def 函数名(*args):     元组
# 	函数体 		函数体中, 可以直接以元组变量的方式使用该参数

# 使用
# 函数名(参数1, 参数2, 参数3...)


def test(*args):    # 装包
    print(args, type(args))
    for i in args:
        print(i)        # 拆包


test(1, 2, 3, 4, 5)
print('4、不定长函数-字典###########')
# def 函数名(**dic):     字典
# 	函数体    函数体中, 可以直接以字典变量的方式使用该参数

# 使用
# 函数名(参数名称1=参数1, 参数名称2=参数2...)


def test(**dic):
    print(dic, type(dic))


# test(name='computer', sex='男', '爱好'='女')  # SyntaxError: keyword can't be an expression
test(name='computer', sex='男', hobby='女')

print('5、缺省参数###########')
# 说句能听懂的
# cv2.imread(filename,flags)
# flags为图片的颜色类型，默认为1，灰度图像为0
# 里面的 1就是缺省参数， 平常都是默认值

# 定义
# def 函数名(变量名1=默认值1, 变量名2=默认值2):
# 	函数体     函数体中, 即使外界没有传递指定变量, 也可以使用, 只不过值是给定的默认值

# 使用
# 函数名(变量1, 变量2)   此处如果是缺省参数, 则可以不填写


def test(a=1, b=2):
    print(a, b)


test()
test(a=12)

# 参数注意
# 值传递和引用传递
# 值传递是指传递过来的是一个数据的副本,修改副本,对原件没有任何影响
# 引用传递是指传递过来的是一个变量的地址, 通过地址可以操作同一份原件
# Python中,只有引用传递(地址传递)
# 如果数据类型是可变类型, 则可以改变原件  如果是不可变类型, 则不可以改变原件
print('6、引用传递###########')


def test(c, d):
    print(id(c), id(d))  # 地址传递，a、c  b、d 地址一致
    c = 123
    d.append(123)
    print(id(c), id(d), a, b)


a = 1  # 不可变类型
b = [1, 2]  # 可变类型
print(id(a), id(b))
test(a, b)

print('#########################3、函数的返回值##################################')
# 通过某个函数处理好数据之后, 想要拿到处理的结果
# 处理的结果不想打印出来，还有别的操作，所以用return
# def 函数():
# 	函数体
# 	return 数据
# return 后续代码不会被执行
# 只能返回一次  如果想要返回多个数据, 可先把多个数据包装成一个集合, 整体返回


def test(x, y):
    result = x + y
    result1 = x - y
    return [result, result1]


res = test(1, 2)
print(res)
print(res[0], res[1])

print('#########################4、函数的使用描述##################################')
# 编写的三方函数为了方便他人使用,就需要描述所写的函数功能以及使用方式等信息
# 定义格式
# 直接在函数体的最上面, 添加三个双引号对注释
# def 函数():
# 	''' 这里写帮助信息 '''

# 查看函数使用文档  help(函数)
# 一般函数的描述, 需要说明如下几个信息
# 函数的功能
# 参数  含义  类型  是否可以省略  默认值
# 返回值  含义  类型


def he(g, h=12):
    """
        计算两个数的和
    :param g:  加数 ， 数值类型， 不可省略，无默认值
    :param h: 加数， 数值类型， 可省略， 默认值为12
    :return:  返回加法的结果  数值类型
    """
    i = g + h
    return i


j = he(10, 20)
print(j)
help(he)

print('#########################5、偏函数##################################')
# 一个参数比较多的函数,如果有的参数大多数情况下都是某一个固定值
# 那么为了简化使用,就可以创建一个新函数,指定要使用的函数的某个参数为某个固定的值,这个新函数就是"偏函数"
# 借助functools模块的partial函数
# import functools    newFunc = functools.partial(函数, 特定参数=偏爱值)
# 举个例子
# for i in range(0, 2):
#     print(i)
#
# for i in range(1, 3):
#     print(i)
#
# for i in range(2, 5):
#     print(i)
# 如果上面几个for循环想要横向输出，print(i, end='\t')就行， 但是有三个print()，挨个改麻烦，所以用偏函数

newFunc = functools.partial(print, end='\t')
for i in range(0, 10):
    newFunc(i)
print()
for i in range(1, 15):
    newFunc(i)
print()
for i in range(2, 20):
    newFunc(i)
print()

print('#########################6、高阶函数##################################')
# 当一个函数A的参数, 接收的又是另一个函数时, 则把这个函数A成为是"高阶函数"
# def jia(jiashu1, jiashu2):
#     jiaguo = jiashu1 + jiashu2
#     print(jiaguo)
# def cheng(chengshu1, chengshu2):
#     chengguo = chengshu1 * chengshu2
#     print(chengguo)
# jia(10, 20)
# cheng(10, 2)
# 现在想用jia()计算两个数的和，其中一个加数是cheng()计算出来的结果

# Python中,只有引用传递(地址传递)
# jiashu1, jiashu2 形参,  也是变量
# 传递数据就是给变量赋值
# 函数本身, 也可以作为数据, 传递给另外一个变量


def jia(jiashu1, jiashu2):
    jiaguo = jiashu1 + jiashu2
    print(jiaguo)


def cheng(chengshu1, chengshu2):
    chengguo = chengshu1 * chengshu2
    return chengguo


jia(10, cheng(10, 5))

print('#########################7、返回函数##################################')
# 一个函数内部, 它返回的数据是另外一个函数，这就是返回函数


def yunsuan(flag):
    def jia(jiashu1, jiashu2):
        jiaguo = jiashu1 + jiashu2
        return jiaguo

    def cheng(chengshu1, chengshu2):
        chengguo = chengshu1 * chengshu2
        return chengguo

    if flag == 1:
        return jia
    elif flag == 2:
        return cheng


res = yunsuan(1)
print(res(1, 2))

print('#########################8、匿名函数##################################')
# 也称为 "lambda函数"  顾名思义, 就是指没有名字的函数
# lambda 参数1, 参数2.. : 表达式
# 只能写一个表达式   不能直接return
# 表达式的结果就是返回值
# 只适用于一些简单的操作处理

var = lambda a, b: a + b
print(var(1, 2))

先这样，明天再补充。