1． 装饰器 decoratos （专业提高往篇）
什么是装饰器
装饰器是一个函数，主要作用是用来包装另一个函数或类（后面会讲）
作用：
是在不改变原函数名（或类名）的情况下改变被包装对象的行为
函数装饰器：
函数装饰器是指装饰器是一个函数，传入的是一个函数，返回的也是一个函数
语法：
def 装饰器函数名（参数）：
语句块
Return 函数对象
@装饰器函数名,< 换行>
def 函数名（形参列表）：
语句块
示例：
def mydeco(fn):
print('装饰器函数被调用了.....')
def fx():
print("fx被调用")
return fx
@ mydeco# 这里加装饰器和不加装饰器有何区别
def myfunc():
print("函数myfunc被调用")
myfunc()
myfunc()# 调用第二次
myfunc()# 调用第三次
结果为：
装饰器函数被调用了.....
fx被调用
fx被调用
fx被调用
在不改变原函数和调用者行为的情况下来改变原有函数功能
示例：
写一个操作数据的函数（此函数用来示意存钱操作）
#此示例示意在加一个装饰器用来添加余额变动提示功能:
#d 写
def send_message(fn):
def fy(name,x):
fn(name,x)#先办业务
print('发短信给',name,'办理了',x,'元')
return fy
#小赵写了一个装饰器函数：
def privillage_check(fn):
def fx(name,x):
print('正在检查权限．．．')
fn(name,x)#权限通过可以调用相应函数
return fx
#操作数据的函数（函数用来示意存钱操作）
@send_message#1
@privillage_check#2
def savemoney(name,x):#3
print(name,'存钱',x,'元')
#用来存钱a写
@privillage_check
def withdraw(name,x):
print(name,'取钱',x,'元')
#用来取钱b写
savemoney('xiaozhang',200)
savemoney('xiaoyuan',500)
withdraw('xiaoqi',400)
#c写的程序
结果为：
正在检查权限．．．
xiaozhang 存钱 200 元
发短信给 xiaozhang 办理了 200 元
正在检查权限．．．
xiaoyuan 存钱 500 元
发短信给 xiaoyuan 办理了 500 元
正在检查权限．．．
xiaoqi 取钱 400 元
2.函数的文档字符串
函数内第一次末赋值给任何变量的字符串是此函数的文档字符串
语法：
def 函数名（形参列表）：
’’’函数的文档字符串 ’’’
函数语句块
示例：
Def hello（）：
’’’此函数用来打招呼…
这是函数的文档字符串’’’
Pass
>>> help(hello)
说明：
1. 文档字符串通常用来说明本函数的功能和使用方法
2. 在交互模式下输入：hello（函数名）
可以查看函数文档字符串
函数的__doc__属性
__doc__属性用于记录文档字符串
函数的__name__属性
__name__用来记录函数的名称
3. 函数的定义语法：
@装饰器1
@装饰器2
…
Def 函数名（位置形参，*元组形参（或*），命名关键字形参，**字符形参）：
’’’文档字符串’’’
语句块
面试题 , 思考？
# L = [1,2,3]
# def (n=0,lst=[]):
# lst.append(n)
# print(lst)
# f(4,L)
# f(5,L)
# f(100)
# f(200)
# f(300)
结果为
[1, 2, 3, 4]
[1, 2, 3, 4, 5]
[100]
[100, 200]
[100, 200, 300]
如果 lst = None
L = [1,2,3]
def f(n=0,lst=None):
if lst is None:
lst = []
lst.append(n)
print(lst)
f(4,L)
f(5,L)
f(100)
f(200)
f(300)
结果为：
[1, 2, 3, 4]
[1, 2, 3, 4, 5]
[100]
[200]
[300]
模块 Module
什么是模块
模块是一个包含有一系列 数据，函数，类，等组成的程序组
模块是一个文件，模块文件名通常以.py结尾
模块的作用：
1， 让一些相关的数据，函数，类等有逻辑的组织在一起，使逻辑结构更加清晰
2， 模块中的变量，函数和类可提供给其他啊模块或程序使用
模块的分类：
1， 内置模块（builtins）在解析器的内部可以直接使用
2， 标准库模块,安装python时已安装具可直接使用
3， 第三方模块，（通常为开源）需要自己安装
4， 用户自己 编写的模块（可以作为其他人的第三方模块）
模块的导入 import
import 语句
语法：
Import 模块名1[as模块新名1]，模块名2[as模块新名2]，…
示例：
Import math #导入数学模块
Import sys，os #导入sys 和 os 模块
Import copy as cp
作用：
将一个模块整体导入到当前模块中
属性用法：
模块名·属性名
help（obj） 可以查看模块的文档字符串
练习：
1.输入一个圆的半径，打印出这个圆的面积
2.输入 一个圆的面积，打印出这个圆的半径
（要求用math模块内的函数和变量）
答案：
（1）
import math
# 1. 输入一个圆的半径，打印出这个圆的面积
r = int(input("请输入一个圆的半径: "))
area = math.pi * r ** 2
print("面积是: ", area)
# 2. 输入一个圆的面积，打印出这个圆的半径
area = float(input("请输入一个圆的面积: "))
r = math.sqrt(area / math.pi)
print("半径是: ", r)
（2）
import math as m
# 1. 输入一个圆的半径，打印出这个圆的面积
r = int(input("请输入一个圆的半径: "))
area = m.pi * r ** 2
print("面积是: ", area)
# 2. 输入一个圆的面积，打印出这个圆的半径
area = float(input("请输入一个圆的面积: "))
r = m.sqrt(area / m.pi)
print("半径是: ", r)
（3）
# import math as m
from math import pi, sqrt
# 1. 输入一个圆的半径，打印出这个圆的面积
r = int(input("请输入一个圆的半径: "))
area = pi * r ** 2
print("面积是: ", area)
# 2. 输入一个圆的面积，打印出这个圆的半径
area = float(input("请输入一个圆的面积: "))
r = sqrt(area / pi)
print("半径是: ", r)
from import 语句
语法：
from 模块名 import 模块属性名 [as 属性新名1]
模块属性名2 [as 属性新名2]
作用：
将某模块的一个或多个属性导入到当前模块的作用域
示例:
from math import pi
from math import sin
from math import factorial as fac
from import * 语句
语法：
from 模块名 import *
作用：
将某模块的所有属性导入到当前的模块
示例：
from math import *
dir 函数
dir ([对象]) 返回一个字符串列表
作用：
如果没有参数的调用，则返回当前作用域内所有变量的列表
如果给定一个对象作为参数，则返回这个对象的所在变量（属性）列表
1）对于一个模块，返回这个模块的全部变量
2）对于一个类对象，返回类对象的所有变量，并递归基类对象是所有变量
3）对于其它对象，返回所有变量，类变量和基变量
数学模块 math
数学模块用法：
import math
# 或
from math import *
变量 |
描述 |
math.e |
自然对数的底e |
math.pi |
圆周率pi |
函数名 |
描述 |
math.ceil(x) |
对x向上取整，比如x=1.2，返回2 |
math.floor(x) |
对x向下取整，比如x=1.2，返回1 |
math.sqrt(x) |
返回x的平方根 |
math.factorial(x) |
求x的阶乘 |
math.log(x[, base]) |
返回以base为底x的对数, 如果不给出base,则以自然对数e为底 |
math.log10(x) |
求以10为底x的对数 |
math.pow(x, y) |
返回 x**y (x的y次方) |
math.fabs(x) |
返回浮点数x的绝对值 |
角度和弧度degrees互换 |
|
math.degree(x) |
将弧度x转换为角度 |
math.radians(x) |
将角度x转换为弧度 |
三角函数 |
|
math.sin(x) |
返回x的正弦(x为弧度) |
math.cos(x) |
返回x的余弦(x为弧度) |
math.tan(x) |
返回x的正切(x为弧度) |
math.asin(x) |
返回x的反正弦(返回值为为弧度) |
math.acos(x) |
返回x的反余弦(返回值为为弧度) |
math.atan(x) |
返回x的反正切(返回值为为弧度) |
时间模块 time
此模块提供了时间相关的函数
时间模块用法：
import time
# 或
from time import xxx
# 或
from time import *
变量 |
描述 |
time.altzone |
夏令时时间与UTC时间差(秒为单位) |
time.daylight |
夏令时校正时间 |
time.timezone |
本地区时间与UTC时间差(秒为单位) |
time.tzname |
时区名字的元组， 第一个名字为未经夏令时修正的时区名, |
注： CST为中国标准时间(China Standard Time UTC+8:00)
函数名 |
描述 |
time.time() |
返回从计算机元年至当前时间的秒数的浮点数(UTC时间为准) |
time.sleep(secs) |
让程序按给定秒数的浮点数睡眠一段时间 |
time.gmtime([secs]) |
用给定秒数转换为用UTC表达的时间元组 |
time.asctime([tuple]) |
将时间元组转换为日期时间字符串 |
time.mktime(tuple) |
将本地日期时间元组转换为新纪元秒数时间(UTC为准) |
time.localtime([secs]) |
将UTC秒数时间转换为日期元组（以本地时间为准) |
练习：
1、写一个程序，输入您的出生日期
1） 算出你已经出生多少天？
2） 算出你出生的那天是星期几？
答案（1）
import time
# 1) 算出你已经出生多少天?
year = int(input("请输入年: "))
month = int(input("请输入月: "))
day = int(input("请输入日: "))
# 得到出生时距离1970年的秒数
birth_second = time.mktime((year,
month,
day,
0,
0,
0,
0,
0,
0))
cur_second = time.time() # 得到当前距离1970年的秒数
# 得到当前已生出多少秒
life_second = cur_second - birth_second
print("您已出生%d天" % (life_second / 60 / 60 // 24))
# 算出你出生的那天是星期几
birth_tuple = time.localtime(birth_second)
week = {0: "星期一",
1: "星期二",
2: "星期三",
3: "星期四",
4: "星期五",
5: "星期六",
6: "星期日"}
2、写一个程序，以电子时间格式显示时间：
HH:MM:SS
答案：
# import time
# def run_clock():
# while True:
# t = time.localtime() # 得到本地时间元组
# hms = t[3:6] # 切片取出时，分，秒
# print("%02d:%02d:%02d" % hms,end='\r') # hms 绑定有三个元素的元组
# time.sleep(1)
# if __name__ == '__main__':
# run_clock()
3、编写一个闹钟程序，启动时设置定时时间，到时间后打印‘时间到’然后退出
# import time
# def alarm(hour, minute):
# while True:
# t = time.localtime() # 得到元组
# hm = t[3:5] # 得到当前时间 的 小时和分钟
# print('%02d:%02d:%02d' % t[3:6],end='\r')
# if hm == (hour, minute):
# print("时间到! ")
# return
# time.sleep(0.01)
# if __name__ == '__main__':
# h = int(input("请输入定时的小时: "))
# m = int(input("请输入定时的分钟: "))
# alarm(h, m)
4、编写函数fun，其功能是求下列多项式的和:
Sn = 1+1！+1/2！+1/3！+1/4！+…1/n！
建议用数字模块中的math.factorial来求
当n为50时，Sn的值
答案：
# import math
# def fun(n):
# # 方法1
# # Sn = 0
# # for i in range(0, n + 1):
# # Sn += 1 / math.factorial(i)
# # return Sn
# # 方法2
# return sum(map(lambda x: 1/math.factorial(x), range(n + 1)))
# print(fun(50))