Python 学习笔记 函数装饰器 & 函数递归 & 栈和队列

一、函数装饰器:

在代码运行期间,可以动态增加函数功能的方式,被称为装饰器【Decorator】

也就是说,在不修改原函数的基础上,给原函数增加功能

好处:在团队开发中,如果两个或者两个以上的程序员会用到相同的功能,但是功能又有细微的差别,采用装饰器:相互不影响,代码简化

1.简单装饰器:

def test():
 print("拼搏到无能为力,坚持到感动自己")

#a.书写闭包
#b.给外部函数设置参数,fun表示的是原函数
def outer(fun):
 def inner():
     # d.给原函数增加功能
     print("hello")

     #c.调用原函数
     fun()
 return inner

#e.使用闭包
f = outer(test)   #f = inner
f()   #inner()
# 运行结果:
# hello
# 拼搏到无能为力,坚持到感动自己

#注意:增加的功能可以写在原函数调用的前面或者后面
#注意:outer函数就被称为装饰器

2.有参装饰器:

# 原函数
def getAge(age):
 print(age)

# 装饰器
def wrapper(fun):
 #注意:当原函数有参数,装饰器的作用是为了操作原函数中的参数,给inner设置参数
 def inner(num):
     #增加新功能:过滤负数
     if num < 0:
         num = 0

     #调用原函数
     fun(num)  #age = num
 return  inner

f = wrapper(getAge)
f(10)   #num = 10
f(-5)   #num = 0

3.装饰器简写:

#简化demo2中的操作:@装饰器的名称  应用到原函数中

#需求:在不修改原函数的基础上,进行数据的过滤:当用户输入age为负数的时候,则置为0
def wrapper(fun):
 #注意:当原函数有参数,装饰器的作用是为了操作原函数中的参数,给inner设置参数
 def inner(num):
     #增加新功能:过滤负数
     if num < 0:
         num = 0

     #调用原函数
     fun(num)  #age = num
 return  inner

#将wrapper装饰器应用在了getAge函数上,
@wrapper
def getAge(age):
 print(age)

getAge(10)
getAge(-5)

@wrapper

等价于

f = wrapper(getAge)
f(10) #num = 10

注意;当使用@的时候,在同一个文件中,装饰器必须出现的原函数的前面

4.不定长参数装饰器:

#应用场景:当同一个装饰器作用于不同函数的时候,这些函数的参数的个数是不相同的
def wrapper(fun):
 def inner(*args):
     print("hello")

     fun(*args)   #a = args[0]   b = args[1]

 return  inner

@wrapper
def fun1(a,b):
 print(a + b)

@wrapper
def fun2(a,b,c,d):
 print(a,b,c,d)

fun1(10,20)   #args = (10,20)
print()
fun2(1,2,3,4)

# 运行结果:
# hello
# 30

# hello
# 1 2 3 4

5.多个装饰器装饰一个函数:

def wrapper1(fun):
 def inner1():
     print("1~~~~")
     fun()
	
 return inner1

def wrapper2(fun):
 def inner2():
     print("2~~~~")
     fun()

 return inner2

@wrapper1
@wrapper2
def show():
 print("hello")

show()
"""
1~~~~
2~~~~
hello
"""

结论:多个装饰器作用于同一个函数的时候,从第一个装饰器开始,从上往下依次执行,但是,原函数只会被执行一次

二、函数递归:

1.概念:

递归函数:一个会调用自身的函数【在一个函数的内部,自己调用自己】

递归调用

递归中包含了一种隐式的循环,他会重复指定某段代码【函数体】,但这种循环不需要条件控制

使用递归解决问题思路:

a. 找到一个临界条件【临界值】

b. 找到相邻两次循环之间的关系

c. 一般情况下,会找到一个规律【公式】

2.使用:

案例一:
斐波那契数列:1,1,2,3,5,8,13,21,34,55,89…
解决问题:报一个数,输出数列中对应的数

"""
规律:
a.第一个位置和第二个位置上数是固定的,都是1
b.第n个位置上的数:第 n - 1 的数  +   第 n - 2 的数

r1 = func1(1)  ------>1
r2 = func1(2)  ------>1
r3 = fun1(3) ------>func1(1) + func1(2)----->1 + 1 = 2
r4 = fun1(4)------->fun1(3) + fun1(2) ----->func1(1) + func1(2) +  fun1(2) ---->1  + 1 + 1 = 3
r5 = fun1(5) ----->fun1(4) + fun1(3) ----->fun1(3) + fun1(2) + func1(1) + func1(2)--->func1(1) + func1(2) ++ fun1(2) + func1(1) + func1(2)--->5
.....
rn = fun1(n) ----->fun1(n- 1) + fun1(n - 2)
"""
def func1(num):
 #临界值
 if num == 1 or num == 2:
     return 1
 else:
 	# 返回通式子
     result = func1(num- 1) + func1(num - 2)    #result = func1(1) + func1(2)  --->1 + 1 =2
     return result

print(func1(10))

案例二:
使用递归计算1~某个数之间的和

"""
add(1) = 1   :临界值
add(2) = add(1) + 2
add(3) = add(2) + 3 ---->add(1) + 2 + 3 = 1 + 2 + 3
add(4) = add(3) + 4---->add(2) + 3 + 4 ---->add(1) + 2 + 3 + 4---->1 + 2 + 3 + 4
....
add(n) = add(n - 1) + n
"""
def add(num):

 #使用递归实现
 if num == 1:
     return 1
 else:
     return add(num - 1) + num

print(add(100))

注意:以后在实际项目中尽量少用递归,如果隐式循环的次数太多,会导致内存泄漏【栈溢出】

优点:简化代码,逻辑清晰

三、栈和队列:

用于存储数据的线性表

栈:在表的一端进行插入和删除

队列:在表的一端进行插入,在表的另一端进行数据的删除

1.栈:

Stack

开口向上的容器:先进后出,后进先出

#list的底层维护了一个栈的线性表

myStack = []

#插入数据
#数据入栈【压栈】
myStack.append(1)
print(myStack)
myStack.append(2)
print(myStack)
myStack.append(3)
print(myStack)
myStack.append(4)
print(myStack)   #[1,2,3,4]

#出栈
myStack.pop()
print(myStack)
myStack.pop()
print(myStack)
myStack.pop()
print(myStack)
myStack.pop()
print(myStack)

# 运行结果
'''
[1]
[1, 2]
[1, 2, 3]
[1, 2, 3, 4]
[1, 2, 3]
[1, 2]
[1]
[]
'''

2.队列:

queue

水平放置的水管:先进先出,后进后出

import  collections   #数据结构的集合

queue  = collections.deque([1,2,3,4])
print(queue)

#入队【存储数据】
queue.append(5)
print(queue)
queue.append(6)
print(queue)

#出队【获取数据】
queue.popleft()
print(queue)
queue.popleft()
print(queue)
queue.popleft()
print(queue)

# 运行结果:
'''
deque([1, 2, 3, 4])
deque([1, 2, 3, 4, 5])
deque([1, 2, 3, 4, 5, 6])
deque([2, 3, 4, 5, 6])
deque([3, 4, 5, 6])
deque([4, 5, 6])
'''

四、习题:

  1. 写一个装饰器来统计函数运行的时间
  2. 使用Python写一个按照下面方式调用都能正常工作的 my_sum() 方法
  3. 封装一个函数random_color,该函数的返回值为随机十六进制颜色。
    说明: 十六进制颜色#开头后面接6个十六进制数, 例: #FFFFFF, #000000, #0033CC
  4. 封装函数,第一个函数create_persons(), 创建并返回包含5个字典(例如:{“name”:“xx”,“age”:xx, “faceValue”:100})的列表
    其中name的值:从[“张三”,“李四”,“王五”,“赵六”,“钱七”]依次取
    其中age的值:10-100之间的随机整数
    其中faceValue的值:0-100之间的随机整数
    第二个函数get_old(), 传入第一个函数创建的列表, 找出列表中年龄最大的人,并将其所有信息打印
    第三个函数sort_facevalue(), 传入第一个函数创建的列表, 根据颜值升序排列,并打印排序后的信息
    提示: colors = ‘0123456789ABCDEF’
    random模块

五、上期习题答案:

  1. 写一个函数,识别字符串是否符合python语法的变量名
    数字字母下划线,且不能以数字开头,不能使用关键字
    提示: 关键字获取使用
    import keyword
    keyword.kwlist
def var(str):
    import keyword
    import re
    l = keyword.kwlist

    l1 = str.replace('_', '')
    a = 0
    if str not in l and (not str[0].isdigit()) and l1.isalnum(): 
        return True
    else:
        return False

print(var('a$bc'))

  1. 封装函数,传入不定个数的数字,返回所有数字的和, 提示: *args
def sm(*args):

    sm1 = 0
    for n in args:
        sm1 = sm1 + n
    return sm1


print(sm(1, 2, 3, 4, 5))

  1. 年月日分别为自定义函数的参数,判断某一个日期是否为合法的日期;
    如: 2018年12月33日不是合法的日期
    2018年11月13日是合法的日期
def fn3(year, month, day):
    # 判断是否是闰年
    if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
        a = 1
    else:
        a = 0
    # 判断月份确定该月的最大值
    if month == 2:
        b = 28 + a
    elif (month < 8 and month % 2 == 0) or (month > 8 and month % 2 != 0):
        b = 30
    else:
        b = 31
    # 判断输入日期是否超过最大值
    if month > 12 or month < 1 or day > b:
        return False

    return True


print(fn3(2020, 2, 30))

  1. 封装函数,判断一个年份是不是闰年
def dly(year):
    if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
        return True
    else:
        return False

print(dly(2000))

你可能感兴趣的:(学习笔记,函数,栈与队列,python,队列)