python入门基础day06

## 08.01_Python基础语法(函数的参数的传递)(掌握)

> 具体的细分：
    可变对象和不可变对象（值传递，引用传递）

### A: 不可变对象参数的传递
* 不可变对象
    * 定义：表示该值不能发生变化
* 不可变的数据类型
     * String tuple  number

#
    """
    String
    tuple
    number
    """
    def add(num):
        num = num + 10
        return num
    
    d = 2
    e = add(d)
    print(d)#2
    print(e)#12
    
    def fun(num):
        print(id(num))
        num = 10
        print(id(num))
    temp = 20
    print(id(temp))
    fun(temp)
    print(temp)
    
    """
> 总结：
  在python中，对于不可变对象，调用自身的任意函数，并不会改变对象自身的内容

### B: 可变对象

* 定义：
   * 值发生改变
* 可变对象的数据类型有哪些？   
   * list dict  set

#   
    """
    list
    dict
    set
    """
    #以列表为例
    def change(num):
        num.append(1)
    d = [0]
    
    change(d)
    print(d)
    
    def fun(list):
        list[0] = 100
    
    li = [1,2,3,4,5]
    fun(li)
    print(li)
    
    
    a = 10
    b = 10
    b = 40
    print(id(a),id(b))
    
    c = 20
    d = 30
    print(id(c),id(d))
    
    d = c
    print(id(c),id(d))

> 总结

## 08.02_Pythony语言基础(关键字参数)(掌握)
### Python允许函数调用时参数顺序和定义时不一致
#
    def myPrint(str,age):
        print(str,age)
    
    myPrint("zhangsan","18")
    myPrint(age = 18,str = "张三")

#案例2：
#
       #关键字参数: **kw
    def person(name,age,**kw):
        print("name:",name,"age:",age,"other:",kw)
    
    person("zhangsan","12")
    person("zhangsan",12,city = "北京")
    person("张三",15,gender = "M",job = "engineer")

## 08.03_Pythony语言基础（默认参数/缺省参数)(掌握)
>概述：
    python为了简化函数的调用，提供默认参数机制，调用函数时，缺省参数的值如果没有传入，则会被认为是默认值
    
#
    #定义一个函数
    def printInfo(name,age = 35):
        print("name:",name)
        print("age:",age)
    
    printInfo("张三")
    printInfo(name = "张三")
    printInfo(age = 18,name = "haha")
    
    def pow(x ,n = 2):
        r = 1
        while n > 0:
            r *= x
            n -= 1
        return r   
    
    p = pow(2)
    print(p)
    
    def printInfo1(name,sex = "nam",age = 35):
        print(name,sex,age)
        
    printInfo1("张三","男")

>注意：

 
    #带有默认值的参数一定要位于参数列表的最后面
    #必选参数必须在前面
    #设置何种参数为默认值，一般将参数值变化较小的设置为默认参数

## 08.04_Pythony语言基础（不定长参数)(掌握)
>概述：
   一个函数能够处理比当初声明时更多的参数称为不定长参数，声明时一般不会命名
* 格式：

#
    def function(args,*args,**kwargs):
    加了一个*号的变量args会存放所有未命名的变量参数，相当于  元组
    加了**号，存放所有命名的变量参数，相当于表达式  key  =  value   kwargs为字典

#
    print("-" * 20)
    
    # 经典方式
    def fun(a, b, *args, **kwargs):
        print("a= ", a)
        print("b= ", b)
        print("args= ", args)
        print("kwargs= ", kwargs)
        print("*" * 30)
        for key, value in kwargs.items():
            print(key, "=", value)
    
    
    fun(1, 2, 3, 4, 5, 6, 6, 8, 9, m=6, n=7, p=8)
    
    # 另一种方式
    c = (3, 4, 5)
    d = {"m": 6, "n": 7, "p": 8}
    print("_" * 50)
    fun(1, 2, *c, **d)
    print("_" * 50)
    # 再一种方式
    fun(1, 2, c, d)
    
    
    def fun1(*args, **kwargs):
        print(args)
        print(kwargs)
    
    # fun1(1, 2, 3, 4, m=5)
运行输出结果：
#
    --------------------
    a=  1
    b=  2
    args=  (3, 4, 5, 6, 6, 8, 9)
    kwargs=  {'m': 6, 'n': 7, 'p': 8}
    ******************************
    m = 6
    n = 7
    p = 8
    __________________________________________________
    a=  1
    b=  2
    args=  (3, 4, 5)
    kwargs=  {'m': 6, 'n': 7, 'p': 8}
    ******************************
    m = 6
    n = 7
    p = 8
    __________________________________________________
    a=  1
    b=  2
    args=  ((3, 4, 5), {'m': 6, 'n': 7, 'p': 8})
    kwargs=  {}
    ******************************

## 08.05_Pythony语言基础（匿名函数)(熟练)
### 匿名函数概述
* 定义：
    * 不使用def这样语句来定义函数
    * 使用lambda来创建一个匿名函数
* 原则：
    * 用lambda关键字能够创建小型匿名函数，可以省略用def声明函数的标准步骤
* 格式：
   * lambda[args1,args2....]:expression
* 定义：
    * 不使用def这样语句来定义函数
    * 使用lambda来创建一个匿名函数
* 原则：
    * 用lambda关键字能够创建小型匿名函数，可以省略用def声明函数的标准步骤
* 格式：
   * lambda[args1,args2....]:expression

 匿名函数的基本定义
#
    a = 1
    sum = lambda args1,args2:args1 + args2
    print(sum(10,20))

>特点：

#
    1.lambda只是一个表达式，比函数def声明简单
    2.lambda的主体也是一个表达式，而不是代码块，只能在lambda表达式中封装简单的逻辑
    3.lambda函数有总计的命名空间，且不能访问自由参数列表以外或者全局命名空间的参数
    4.lambda函数能够接受任何数量的参数，只能返回一个表达式的值

## 08.06_Pythony语言基础（匿名函数的应用场景)(熟悉)
* 作为自定义函数的参数进行传递
    * 类似调用函数中传入的实参
* 匿名函数的应用场景（作为自定义函数的参数进行传递）
#
    def fun(a,b,opt):
        print(a)
        print(b)
        print(opt(10,20))
    fun(1,2,lambda x,y:x + y)

* 作为内置函数的参数
    * 字典存储姓名和年龄的数据，把字典内的元素按照姓名或年龄排序

## 08.07_Pythony语言基础（装饰器的概述)(熟悉)
* 装饰器的基本格式
    * @函数名

#
    # 第一波
    def foo():
        print("foo")
    
    
    # foo#表是函数
    foo()  # 表示执行foo函数

#
    # 第二波
    def foo():
        print("foo")
    
    
    foo = lambda x: x + 1
    
    foo()

* 定义：是一个闭包，把一个函数当作参数，
     * 返回一个替代的函数，一个本质返回函数的函数

* 简单的装饰器
#
    def fun01():
        print("fun01")
    
    def fun02(fun):
        def fun03():
            print("fun03")
            fun()
        return fun03
    f = fun02(fun01)
    f()
运行输出结果：
#
    fun03
    fun01

* 需求：
    * 初创公司有N个业务部门，1个基础平台部门，基础平台部门负责底层的功能
        * 如：数据库操作，redis调用，监控API等功能
    * 业务部门使用基础功能，只需要调用基础平台的功能即可

#
    # 定义基础平台的功能
    def f1():
        print("f1")
    
    
    def f2():
        print("f2")
    
    
    def f3():
        print("f3")
    
    
    def f4():
        print("f4")
    
    
    # 业务部门使用基础功能 业务部门第一组
    f1()
    f2()
    f3()
    f4()
    ##业务部门使用基础功能 业务部门第二组
    f1()
    f2()
    f3()
    f4()

    
    #老大将任务交给老王同志
    def f1():
        #验证1
        #验证2
        #验证3
        print("f1")
    def f2():
        #验证1
        #验证2
        #验证3
        print("f2")
    def f3():
        #验证1
        #验证2
        #验证3
        print("f3")
    def f4():
        #验证1
        #验证2
        #验证3
        print("f4")

    #业务部门，第一组
    f1()
    f2()
    f3()
    f4()
    #业务部门，第二组
    f1()
    f2()
    f3()
    f4()

    #小王

>只对基础平台的代码做重构，其他业务部门不动

#
    def check_login():
        # 验证1
        # 验证2
        # 验证3
        pass
    
    def f1():
        check_login()
        print("f1")
    def f2():
        check_login()
        print("f2")
    def f3():
        check_login()
        print("f3")
    def f4():
        check_login()
        print("f4")
    
    
    #小小王，

    #使用装饰器
    def w1(func):
        def inner():
            #验证1
            #验证2
            #验证3
            func()
        return inner

    @w1
    def f1():
        print("f1")
    
    @w1
    def f2():
        print("f2")
    @w1
    def f3():
        print("f3")
    @w1
    def f4():
        print("f4")

* @函数名（语法糖）《自行百度》

#
    将执行完的w1函数的返回值赋值给@w1下面f1,
    即及那个w1的返回值重新赋值给f1

    """
    # new_f1 = def inner():
    #              # 验证1
    #              # 验证2
    #              # 验证3
    #              func()
    #          return inner

    #定义一个函数，完成一个包裹的数据
    def makeBold(fn):
        def wrapped():
            return ""+fn()+""
        return wrapped
    
    #定义一个函数，完成一个包裹的数据
    def makeItalic(fn):
        def wrapped():
            return ""+fn()+""
        return wrapped
    @makeBold
    def test1():
        return "hello world-1"
    @makeItalic
    def test2():
        return "hello world-2"
    
    @makeBold
    @makeItalic
    def test3():
        return "hello world -3"
    
    
    # print(test1())
    # print(test2())
    print(test3())

## 08.08_Python语言基础(装饰器的应用场景)(掌握)

#
    1.引入日志
    2.函数的执行时间统计
    3.执行函数前的预备处理
    4.函数执行后的清理工作
    5.权限的校验
    6.缓存

## 08.09_Python语言基础(装饰器的示例)(掌握)
#
    from time import ctime, sleep
    
    无参数的函数
    
    
    def timeFun(func):
        def wrapped():
            print("%s called at %s" % (func.__name__, ctime()))
            func()
    
        return wrapped
    
    
    @timeFun
    def foo():
        print("i am foo")
    
    
    # foo()
    # sleep(2)
    # foo()
    
    f = timeFun(foo)
    f()

    #被装饰的函数有参数
    
    def timeFun(func):
        def wrapped(a, b):
            print("%s called at %s" % (func.__name__, ctime()))
            func(a, b)
    
        return wrapped
    
    
    @timeFun
    def foo(a, b):
        print(a + b)
    
    
    foo(3, 5)
    
    sleep(2)
    foo(2, 4)
    
    
    # 3.被修饰的函数有不定长参数
    def timeFun(func):
        def wrapped(*args, **kwargs):
            print("%s called at %s" % (func.__name__, ctime()))
            func(*args, **kwargs)
    
        return wrapped
    
    
    @timeFun
    def foo(a, b, c):
        print(a + b + c)
    
    
    foo(3, 5, 7)
    
    #装饰器中的return
    def timeFun(func):
        def wrapped():
            print("%s called at %s" % (func.__name__, ctime()))
            func()
        return wrapped
    @timeFun
    def foo():
        print("i am foo")
    @timeFun
    def getInfo():
        return "---haha----"
    
    
    foo()
    print(getInfo())

## 08.10_Python语言基础(作业)
#
    1.用函数编写计算器，要求可以计算多个值的加减乘除
      多个值的加减乘除，应当使用不定长参数，
      可以设置不定长参数的**args部分表达符号

#  
    2.编写“学生管理系统”，要求如下：
    必须使用自定义函数，完成对程序的模块化
    学生信息至少包含：姓名、年龄、学号，除此以外可以适当添加
    必须完成的功能：添加、删除、修改、查询（单个查询/显示所有）、退出