1.函数定义和调用

  • 定义函数的语法格式 
    1. def 函数名称(参数):
    2. 函数体代码
    3. return 返回值
    1. #定义函数
    2. def user_info():
    3. print("姓名：张三")
    4. print("性别：男")
    5. print("年龄：18")
    6. #函数调用
    7. user_info()

2.函数参数

  • 缺省参数：函数定义时，设置带有默认值的参数，调用时，缺省参数可以不传入，没传使用默认值，传了实参就使用实参
    ```python def sum(y,x=10): rs=x+y print(“{}+{}={}”.format(x,y,rs))

只传入一个参数y的值

sum(10)

传入缺省参数的实参20

sum(10,20)

  2. -  命名参数：指在调用带有参函数时，通过指定参数名称传入参数的值，并且可以不按照函数定义的参数顺序传入实参  
  3. ```python
  4. def sum(y,x):
  5.   rs=x+y
  6.   print("{}+{}={}".format(x,y,rs))
  8. # 不按照参数定义的顺序，通过指定参数名称传入，指定参数名称必须与定义的形参名称相同
  9. sum(x=10,y=20)
  10. sum(y=20,x=10)
  • 带参函数：函数定义时，可以在小括号内设置函数需要的参数，调用时安装顺序和个数传入
    ```python def user_info(name,sex,age): print(“姓名：”,name) print(“性别：”,sex) print(“年龄：”,age)

调用

name=”张三” sex=”男” age=18 user_info(name,sex,age)

  2. -  不定长参数 
  3.    -  带有一个*的不定长参数 <br />注：*args接受的任意参数会封装到元组中 
  4. ```python
  5. # 计算多个数字和
  6. def any_num_sum(*args):
  7.   print("args参数值：",args)
  8.   print("args参数类型：",type(args))
  9.   rs=0
  10.   if len(args)>0:
  11.     for arg in args:
  12.       rs += arg
  13.     print("总和："，rs)
  15. # 调用
  16. any_num_sum(10,20)
  17. any_num_sum(10,20,30,40)
  • 带有两个的不定长参数
    注：*kvargs 接受的参数将封装到字典中 ```python def su(base,    kvargs): print(“kvargs参数值：”，kvargs) print(“kvargs参数类型：”,type(kvargs)) x=kvargs.get(“x”) y=kvargs.get(“y”) su=base-x-y print(“计算值：”，su)

调用

su(10,x=4,y=5)

  2.    -  拆包<br />使用场景：当一个函数设置了不定长参数，想把已存在的元组、列表、字典传入到函数中，并且能够被不定长参数识别，就需要拆包  
  3. ```python
  4. # 求数字列表中所有元素和
  5. num_list=[1,2,3,4,5]
  7. #调用any_num_sum函数
  8. any_num_sum(*num_list)
  10. # 求字典中数字计算
  11. su_dict={"x":20,"y":30}
  13. #调su函数
  14. su(100,**su_dict)

3.函数返回值

  1. def x_num(base,**kvargs):
  2.   x1=kvargs.get("x1")
  3.   x2=kvargs.get("x2")
  4.   x_num=base*x1+base*x2
  5.   return x_num
  7. def y_num(yy):
  8.   if yy >0 and yy <= 10:
  9.     return 1
  10.   elif yy <= 0:
  11.     return 2
  12.   elif yy > 10 and yy <100 :
  13.     return 3
  14.   else:
  15.     return 4
  17. def su(base):
  18.   su_dict={"x1":10,"x2":20}
  19.   x=x_num(base,**su_dict)
  20.   yy=base+x
  21.   y=y_num(yy)
  22.   su=base+x+y
  23.   print("计算值：su={},x={},y={}".format(su,x,y))
  25. #调用
  26. su(60)

4.变量作用域

  • 局部变量：只能在某个特定的范围内使用
    ```python def info1():

    局部变量

    name=”张三” age=20 print(“姓名:{},年龄:{}”.format(name.age))

def info2():

局部变量

name=”李四” age=19 print(“姓名:{},年龄:{}”.format(name.age))

调用

info1() info2()

  2. -  全局变量：可以在全局范围内使用  
  3. ```python
  4. #全局变量
  5. base=100
  7. def sum1(x):
  8.   rs=base+x
  9.   print("{}与{}的和{}".format(x,base,rs))
  11. def sum2(y):
  12.   rs=base+y
  13.   print("{}与{}的和{}".format(y,base,rs))
  15. #调用
  16. sum1(10)
  17. sum2(20)

5.递归函数

  1.     说明：一个函数在其函数体内调用函数自身，这样的函数就是递归函数
  1. # 计算3的阶乘
  2. def factorial(num):
  3.   if num > 1:
  4.     return num*factorial(num-1)
  5.   else:
  6.     return num
  8. #调用
  9. factorial(3)

6.匿名函数

  • 匿名函数语法格式 

    1. lambda 参数列表:表达式

  • 匿名函数作为普通函数的参数 

    1. sum=lambda x,y:x+y
    2. #调用
    3. print(sum(10,20))

  • 将匿名函数赋值给变量，通过变量名调用匿名函数
    ```python def x_y_compute(x,y,func): print(“x={},y={}”.format(x,y)) result=func(x,y) print(“result={}”.format(result))

调用

x_y_compute(10,20,lambda x,y:x+y) x_y_compute(10,20,lambda x,y:x*y)

  2. <a name="JSRWI"></a>
  3. ### 7.闭包
  5.        说明：所谓闭包就是指当一个嵌套函数的内部函数引用了外部函数的变量，外部函数的返回值是内部函数的引用，这种函数的表达方式就是闭包
  7. ```python
  8. # 普通函数，求和
  9. def sum(x,y):
  10.   return x+y
  12. sum(10,20)
  14. # 闭包求和
  16. # 1.外部函数
  17. def sum_closure(x):
  18.   #2.内部函数
  19.   def sum_inner(y):
  20.     #3.调用外部函数的变量x
  21.     return x+y
  22.   #4.外部函数返回值是内部函数的引用
  23.   return sum_inner
  25. rs_func=sum_closure(10)
  26. print("rs_func: {}".format(rs_func))
  27. print("rs_func类型: {}".format(type(rs_func)))
  29. #闭包使用
  30. print(rs_func(2))
  1. # 闭包计数器
  2. def counter_w(base=0):
  3.   cnt_base=[base]
  4.   def counter(step=1):
  5.     cnt_base[0]+=step
  6.     return cnt_base[0]
  7.   return counter
  9. counter=counter_w()
  11. print("当前计数器值:{}".format(counter()))
  12. print("当前计数器值:{}".format(counter()))
  13. print("当前计数器值:{}".format(counter()))

8.装饰器

  • 装饰器介绍：
    就是用于拓展原来函数功能的一种函数，目的是在不改变原函数名(或类名)的情况下，给函数增加新的功能。
    这个函数的特殊之处在于它的返回值也是一个函数，这个函数是内嵌原函数的函数。 

    1. 语法：在被装饰函数前面加 “@装饰器名称”

  • 初步使用

    • 有参函数添加装饰器 ```python

      计算程序执行耗时

      def time(func): def counter(x,y): start_time=time.time() print(“开始时间:”,start_time) func(x,y) end_time=time.time() print(“结束时间:”,end_time) print(“程序运行耗时时间:”,end_time-start_time) return counter

@time # 装饰器 def sum(x,y): time.sleep(5) print(“{}+{}={}”.format(x,y,x+y))

调用

sum(1,2)

  2.    - 不定长参数函数添加装饰器
  3. ```python
  4. # 计算程序执行耗时
  5. def time(func):
  6.   def counter(*args):
  7.     start_time=time.time()
  8.     print("开始时间:",start_time)
  9.     func(*args)
  10.     end_time=time.time()
  11.     print("结束时间:",end_time)
  12.     print("程序运行耗时时间:",end_time-start_time)
  13.   return counter
  15. @time
  16. def sum(x,y):
  17.   time.sleep(5)
  18.   print("{}+{}={}".format(x,y,x+y))
  20. @time  
  21. def multi(x,y,z):
  22.   time.sleep(5)
  23.   print("{}*{}*{}={}".format(x,y,z,x*y*z))
  25. #调用
  26. sum(10,20)
  27. multi(10,20,30)
  • 当才华还配不上野心，就静下来学习