初识函数

学习来源： 程序媛
编程方式：
1、面向对象 ----> 类 ----> class
2、面向过程 ----> 过程 ----> def
3、函数式编程 ----> 函数 ----> def

一、函数定义

def mylen():              # 定义函数。
    s = "hello world"
    length = 0
    for i in s:
        length = length+1
    print(length)

a = mylen()               # 调用函数。
print(a)                  # 并没有返回值，仅仅打印一次。
> 11
> none    

函数的好处（减少重复代码，一致性，容易扩展）

二、函数返回值

def mylen(s):                 # 定义参数
    length = 0
    for i in s:
        length = length + 1
    return length             # 返回值

s = "hello world"
print(mylen(s))               # 传参，打印返回值

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

三、函数参数

实参形参

def my_sum(a, b):
    res = a+b
    return res

ret = my_sum(1,2)
print(ret)
> 3

站在实参的角度上：
    按照位置传参
    按照关键字传参
    混着用可以:但是 必须先按照位置传参，再按照关键字传参数
             不能给同一个变量传多个值

站在形参的角度上
    位置参数：必须传,且有几个参数就传几个值
    默认参数: 可以不传，如果不传就是用默认的参数，如果传了就用传的

def classmate(name,sex='男'):
    print('%s : %s'%(name,sex))

classmate('二哥')
classmate('小孟')
classmate('大猛')
classmate('朗哥','女')

默认参数 – 陷阱

def qqxing(k,l = {}):
    # l.append(1)
    l[k] = 'v'
    print(l)

qqxing(1)     #[1]
qqxing(2)     #[1,1]
qqxing(3)     #[1,1,1]

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

四、动态参数

动态参数有两种：可以接受任意个参数
    *args   ： 接收的是按照位置传参的值，组织成一个元组
    **kwargs： 接受的是按照关键字传参的值，组织成一个字典
    args必须在kwargs之前

*args

def my_sum(*args):
    n = 0
    for i in args:
        n += i
    return n

a = my_sum(1,2,3,4)
print(a)
>  (1,2,3,4)    # 元组

**kwargs

def my_sum(**kwargs):
    print(kwargs)

my_sum(a = 1, b =2)
> {'a': 1, 'b': 2}  # 字典

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

def func(*args):#站在形参的角度上，给变量加上*，就是组合所有传来的值。
    print(args)

func(1,2,3,4,5)
l = [1,2,3,4,5]
func(*l)  #站在实参的角度上，给一个序列加上*，就是将这个序列按照顺序打散

def func(**kwargs):
    print(kwargs)

func(a=1,b=2)
d = {'a':1,'b':2} #定义一个字典d
func(**d)

五、总结

定义函数的时候：

位置参数 ：直接定义参数

默认参数 ：形参的时候直接赋值

1、连接数据库：def  coon(host，port=3006):

关键字参数 ：参数名 = ‘默认的值’

动态参数 : 可以接受任意多个参数

            参数名之前加*，习惯参数名args，
            参数名之前加**，习惯参数名kwargs

参数顺序：位置参数，*args，关键字参数，**kwargs

内容回顾

文件的修改
函数
1.函数的定义 def
2.函数的调用
3.函数的返回值 return
4.函数的参数
形参：
位置参数 ： 必须传
*args：可以接收任意多个 位置参数（返回字典）
默认参数 ： 可以不传 —— 陷阱
**kwargs ： 可以接收多个 关键字参数（返回元组）
实参：按照位置传参，按照关键字传参

高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

a.把一个函数名当做实参传给另一个函数
b.返回值中包含函数名

import time
def func():
    time.sleep(1)
    print('in  the func')
def timmer(f):
    start = time.time()
    f()
    end = time.time()
    print('the func run time is %s' %(end-start))
    return f
func =timmer(func)

func()

def add(a,b,f):       # 接收另一个函数
    return f(a)+f(b)  
                      
res = add(3,-6,abs)   # 取绝对值
print(res)