## 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 "<b>"+fn()+"</b>"
return wrapped
#定义一个函数，完成一个包裹的数据
def makeItalic(fn):
def wrapped():
return "<i>"+fn()+"</i>"
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.编写“学生管理系统”，要求如下：
必须使用自定义函数，完成对程序的模块化
学生信息至少包含：姓名、年龄、学号，除此以外可以适当添加
必须完成的功能：添加、删除、修改、查询（单个查询/显示所有）、退出