内置函数
如何查看Python内置函数？
方式一：官方文档查看
方式二：所有内置函数：dir(__builtin__)
查看某个内置函数的用法：help(函数名）,比如：help(str)
查看某个函数的位置：random.__file__
random.__file__
'd:\\pytho3.6\\lib\\random.py'
文件IO操作
1.打印到屏幕 print
2.读取键盘输入 input
3.打开和关闭文件
打开文件：open 函数
"你必须先用Python内置的open()函数打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。"
语法：
file object = open(file_name [, access_mode][, buffering])
各个参数的细节如下：
file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。
access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。
不同模式打开文件的完全列表：模式 描述
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
以下是和file对象相关的所有属性的列表：
属性 描述
file.closed 返回true如果文件已被关闭，否则返回false。
file.mode 返回被打开文件的访问模式。
file.name 返回文件的名称。
"""
关闭文件： close()方法
File 对象的 close（）方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。
当一个文件对象的引用被重新指定给另一个文件时，Python 会关闭之前的文件。用 close（）方法关闭文件是一个很好的习惯。
语法：
fileObject.close()
4.读写文件
4.1 write()方法
write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。
write()方法不会在字符串的结尾添加换行符('\n')：
语法：
fileObject.write(string)
在这里，被传递的参数是要写入到已打开文件的内容。
例子：
f = open(file,'w',encoding='utf-8')
f.write('ip_type,ip,port,speed,position,live_time,update_time\n')
# 关闭打开的文件
fo.close()
4.2 read（）方法:
"从一个打开的文件中读取一个字符串。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。"
语法：
fileObject.read([count])
在这里，被传递的参数是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入，如果没有传入count，它会尝试尽可能多地读取更多的内容，很可能是直到文件的末尾。
# 打开一个文件
fo = open("foo.txt", "r+")
str = fo.read(10)
print("读取的字符串是 : ", str)
# 关闭打开的文件
fo.close()
以上实例输出结果：
读取的字符串是 : www.runoob
4.3 readline()方法：一次读取一行
4.4 readlines()方法：读取所有内容，以列表形式返回，每一行作为列表中的一个元素。
4.5 文件位置：
文件定位
tell()方法告诉你文件内的当前位置, 换句话说，下一次的读写会发生在文件开头这么多字节之后。
seek（offset [,from]）方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。
如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。
Python的os模块给我们提供执行文件处理操作的方法
5.删除文件
remove()方法
你可以用remove()方法删除文件，需要提供要删除的文件名作为参数。
语法：
os.remove(file_name)
例子：
下例将删除一个已经存在的文件test2.txt。
import os
# 删除一个已经存在的文件test2.txt
os.remove("test2.txt")
6.文件重命名
rename()方法需要两个参数，当前的文件名和新文件名。
语法：
os.rename(current_file_name, new_file_name)
例子：
下例将重命名一个已经存在的文件test1.txt。
import os
# 重命名文件test1.txt到test2.txt。
os.rename( "test1.txt", "test2.txt" )
7.创建和删除文件夹
创建文件夹
mkdir()方法
可以使用os模块的mkdir()方法在当前目录下创建新的目录们。你需要提供一个包含了要创建的目录名称的参数。
语法：
os.mkdir("newdir")
例子：
下例将在当前目录下创建一个新目录test。
import os
# 创建目录test
os.mkdir("test")
删除文件夹
r、mdir()方法
rmdir()方法删除目录，目录名称以参数传递。
在删除这个目录之前，它的所有内容应该先被清除。
语法：
os.rmdir('dirname')
例子：
以下是删除" /tmp/test"目录的例子。目录的完全合规的名称必须被给出，否则会在当前目录下搜索该目录。
import os
# 删除”/tmp/test”目录
os.rmdir( "/tmp/test" )
8.获取和切换目录
获取当前目录
getcwd()方法：
getcwd()方法显示当前的工作目录。
语法：
os.getcwd()
切换指定目录
chdir()方法
可以用chdir()方法来改变当前的目录。chdir()方法需要的一个参数是你想设成当前目录的目录名称。
语法：
os.chdir("newdir")
9.获取当前目录下的所有文件列表
获取当前目录下所有文件列表
os.listdir()os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]])
自定义函数
一、为什么要有函数
1 while True：
2 if cpu利用率 > 90%:
3 #发送邮件提醒
4 连接邮箱服务器
5 发送邮件
6 关闭连接
7
8 if 硬盘使用空间 > 90%:
9 #发送邮件提醒
10 连接邮箱服务器
11 发送邮件
12 关闭连接
13
14 if 内存占用 > 80%:
15 #发送邮件提醒
16 连接邮箱服务器
17 发送邮件
18 关闭连接
我们发现，if下面的相同的内容被被多次调用，代码很冗余，于是，我们可以这样写
1 def 发送邮件(内容)
2 #发送邮件提醒
3 连接邮箱服务器
4 发送邮件
5 关闭连接
6
7 while True：
8
9 if cpu利用率 > 90%:
10 发送邮件('CPU报警')
11
12 if 硬盘使用空间 > 90%:
13 发送邮件('硬盘报警')
14
15 if 内存占用 > 80%:
上述的两种实现方式，第二次必然比第一次的重用性和可读性要好，其实这就是函数式编程和面向过程编程的区别：
- 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
- 面向对象：对函数进行分类和封装，让开发“更快更好更强...”
函数式编程最重要的是增强代码的重用性和可读性
二、函数的定义和调用
函数定义 def 函数名（参数）:
函数体
return 返回值
函数调用 函数名（）
函数的定义主要有如下要点：
def：表示函数的关键字
函数名：函数的名称，日后根据函数名调用函数
函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
参数：为函数体提供数据
返回值：当函数执行完毕后，可以给调用者返回数据。
以上要点中，比较重要有参数和返回值：
1.返回值：函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。
def 发送短信():
发送短信的代码...
if 发送成功:
return True
else:
return False
while True:
# 每次执行发送短信函数，都会将返回值自动赋值给result
# 之后，可以根据result来写日志，或重发等操作
result = 发送短信()
if result == False:
记录日志，短信发送失败...
2.参数
·为什么要有参数？
def CPU报警邮件()
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
def 硬盘报警邮件()
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
def 内存报警邮件()
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
while True：
if cpu利用率 > 90%:
CPU报警邮件（）
if 硬盘使用空间 > 90%:
硬盘报警邮件（）
if 内存占用 > 80%:
内存报警邮件（）
上例，无参数实现
上例，无参数实现
def 发送邮件(邮件内容)
#发送邮件提醒
连接邮箱服务器
发送邮件
关闭连接
while True：
if cpu利用率 > 90%:
发送邮件("CPU报警了。")
if 硬盘使用空间 > 90%:
发送邮件("硬盘报警了。")
if 内存占用 > 80%:
发送邮件("内存报警了。")
上列，有参数实现
上例，有参数实现
函数的有三中不同的参数：
- 普通参数
- 默认参数
- 动态参数
def sum_2_nums(a,b):
#a = 10
#b = 20
result = a+b
print("%d + %d = %d"%(a,b,result))
num1 = int(input("请输入第一个数字:"))
num2 = int(input("请输入第二个数字:"))
#调用函数
sum_2_nums(num1,num2)
普通参数
def test(a,d,b=22,c=33):
result = a+b+c
print(a)
print(b)
print(c)
print(d)
print("result=%d"%result)
test(11,22,b=12)
test(33,33)
test(d=44,a=11,c=44)
缺省参数
def sum_2_nums(a,b,c=33,*args,**kwargs):
print("-"*30)
print(a)
print(b)
print(c)
print(args)
print(kwargs)
#result = a+b+args
#print("result=%d"%result)
sum_2_nums(11,22,33,44,55,66,77,task=99,done=89)
#sum_2_nums(11)#错误,因为形参中至少要2个实参
不定长参数
def test(a,b,c=33,*args,**kwargs):
print("-"*30)
print(a)
print(b)
print(c)
print(args)
print(kwargs)
#result = a+b+args
#print("result=%d"%result)
#test(11,22,33,44,55,66,77,task=99,done=89)
A=(44,55,66)
B={"name":"laowang","age":18}
test(11,22,33,*A,**B)
#sum_2_nums(11)#错误,因为形参中至少要2个实参
拆包、元组和字典
def test_kwargs(actions=None, **kwargs):
print('actions:', actions)
print('kwargs:', kwargs)
def test_args(actions=None, *args):
print('actions:', actions)
print('args:', args)
test_args([1,2,3])
# actions: [1, 2, 3]
# args: ()
test_args(1,2,3)
# actions: 1
# args: (2, 3)
test_args(*[1, 2, 3])
# actions: 1
# args: (2, 3)
test_kwargs({'get':'list', 'post': 'create'})
# actions: {'get': 'list', 'post': 'create'}
# kwargs: {}
test_kwargs(get='list', post='create')
# actions: None
# kwargs: {'get': 'list', 'post': 'create'}
test_kwargs(**{'get':'list', 'post': 'create'})
# actions: None
# kwargs: {'get': 'list', 'post': 'create'}
args和kwargs
实例：打印佛祖
def print_fuzu():
print(" _ooOoo_ ")
print(" o8888888o ")
print(" 88 . 88 ")
print(" (| -_- |) ")
print(" O\\ = /O ")
print(" ____/`---'\\____ ")
print(" . ' \\| |// `. ")
print(" / \\||| : |||// \\ ")
print(" / _||||| -:- |||||- \\ ")
print(" | | \\\\\\ - /// | | ")
print(" | \\_| ''\\---/'' | | ")
print(" \\ .-\\__ `-` ___/-. / ")
print(" ___`. .' /--.--\\ `. . __ ")
print(" ."" '< `.___\\_<|>_/___.' >'"". ")
print(" | | : `- \\`.;`\\ _ /`;.`/ - ` : | | ")
print(" \\ \\ `-. \\_ __\\ /__ _/ .-` / / ")
print(" ======`-.____`-.___\\_____/___.-`____.-'====== ")
print(" `=---=' ")
print(" ")
print(" ............................................. ")
print(" 佛祖镇楼 BUG辟易 ")
print(" 佛曰: ")
print(" 写字楼里写字间，写字间里程序员； ")
print(" 程序人员写程序，又拿程序换酒钱。 ")
print(" 酒醒只在网上坐，酒醉还来网下眠； ")
print(" 酒醉酒醒日复日，网上网下年复年。 ")
print(" 但愿老死电脑间，不愿鞠躬老板前； ")
print(" 奔驰宝马贵者趣，公交自行程序员。 ")
print(" 别人笑我忒疯癫，我笑自己命太贱； ")
print(" 不见满街漂亮妹，哪个归得程序员？")
print_fuzu()
打印佛祖
扩展：发送邮件实例
1 import smtplib
2 from email.mime.text import MIMEText
3 from email.utils import formataddr
4
5
6 msg = MIMEText('邮件内容', 'plain', 'utf-8')
7 msg['From'] = formataddr(["张亚飞",'1271570224@qq.com'])
8 msg['To'] = formataddr(["走人",'2464392538@qq.com'])
9 msg['Subject'] = "主题"
10
11 server = smtplib.SMTP_SSL("smtp.qq.com", 465)
12 server.login("1271570224@qq.com", "euvtrglugggubagj")
13 server.sendmail('1271570224@qq.com', ['2464392538@qq.com',], msg.as_string())
14 server.quit()
lambda表达式
匿名函数：lambda 参数:式子
作用：书写比较简单，不需要声明函数的名称，当功能为一些比较简单的加加减减时，用lambda匿名函数，否则用def
注：匿名函数默认带有返回值
实例：对字母排序
s = 'string'
s = "".join((lambda x: (x.sort(), x)[1])(list(s)))
s
Out[4]: 'ginrst'
应用：列表元素为字典时按照字典的value值排序，list.sort(key x:x['age'])
实例：
def test(a,b,func):
result = func(a,b)
print(result)
test(11,22,lambda x,y:x+y)
匿名函数
lambda存在意义就是对简单函数的简洁表示
Python高级函数
1.map
求一个序列或者多个序列进行函数映射(遍历）之后的值，就该想到map这个函数，它是python自带的函数，在python3.*之后返回的是迭代器，同filter，需要进行列表转换.
调用： map(function,iterable1,iterable2)，function中的参数值不一定是一个x，也可以是x和y，甚至多个；后面的iterable表示需要参与function运算中的参数值，有几个参数值
就传入几个iterable
map函数的原型是map(function, iterable, …)，它的返回结果是一个列表。
参数function传的是一个函数名，可以是python内置的，也可以是自定义的。
参数iterable传的是一个可以迭代的对象，例如列表，元组，字符串这样的。
这个函数的意思就是将function应用于iterable的每一个元素，结果以列表的形式返回。注意到没有，iterable后面还有省略号，意思就是可以传很多个iterable，如果有额外的
iterable参数，并行的从这些参数中取元素，并调用function。如果一个iterable参数比另外的iterable参数要短，将以None扩展该参数元素。
map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
# 1.map自定义函数
def f(x):
return x*x
a = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
list(a)
# 2.map复杂函数
list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
== [str(x) for x in [1,2,3,4,5,6,7,8,9]]
# 3.实例
def add(x,y,z):
return x,y,z
list1 = [1,2,3]
list2 = [1,2,3,4]
list3 = [1,2,3,4,5]
list4 = [1,2,3,4,5,6]
res = map(add, list1, list2, list3)
list(res)
def add(x,y,z):
return x+y+z
list1=[1,2,3]
list2=[1,2,3]
list3=[1,2,3]
list(map(add,list1,list2,list3))
func = lambda x,y,z:x+y+z
func(list1,list2,list3)
def format_name(s):
return s.capitalize()
list(map(lambda x:x.capitalize(), ['adam', 'LISA', 'barT']))
foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]
list(map(lambda x: x * 2 + 10, foo))
print ([x * 2 + 10 for x in foo])
map实例
2.filter
filter的功能是过滤掉序列中不符合函数条件的元素，当序列中要删减的元素可以用某些函数描述时，就应该想起filter函数。
调用： filter（function，sequence），function可以是匿名函数或者自定义函数，它会对后面的sequence序列的每个元素判定是否符合函数条件，返回TRUE或者FALSE，从而只留下TRUE
的元素；sequence可以是列表、元组或者字符串
Python内建的filter()函数用于过滤序列。和map()类似，filter()也接收一个函数和一个序列。和map()不同的时，filter()把传入的函数依次作用于每个元素，然后根据返回值是True
还是False决定保留还是丢弃该元素。
例1，在一个list中，删掉偶数，只保留奇数，可以这么写：
def is_old(x):
return x%2 == 0
list(filter(is_old,[1,2,3,4,5,6,7,8,9,10]))
print([x for x in foo if x%3==0])
例2：在一个list中，只保留能被三整除的数字
list(filter(lambda x: x % 3 == 0, foo)))
print ([x for x in foo if x % 3 == 0])
filter实例
3.reduce
对一个序列进行压缩运算，得到一个值。但是reduce在python2的时候是内置函数，到了python3移到了functools模块，所以使用之前需要 from functools import reduce
调用： reduce（function，iterable），其中function必须传入两个参数，iterable可以是列表或者元组
reduce() 函数会对参数序列中元素进行累积。
函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给 reduce 中的函数
function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数
据用 function 函数运算，最后得到一个结果。
reduce(function, iterable[, initializer])
function -- 函数，有两个参数
iterable -- 可迭代对象
initializer -- 可选，初始参数
from functools import reduce
print (reduce(lambda x, y: x + y, foo))
def char2num(s):
return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
def str2int(s):
return reduce(lambda x,y: x*10+y, map(char2num, s))
print(str2int('12345'))
def kfactorial(k):
"""求k的阶乘"""
if k == 0 or k == 1:
return 1
from functools import reduce
return reduce(lambda x,y:x*y,list(range(1,k+1)))
def kfactorial2(k):
a = 1
for i in range(1,k+1):
a *= i
return a
def kfactorial3(k):
if k == 0 or k == 1:
return 1
else:
return kfactorial3(k-1)
kfactorial(5)
kfactorial2(6)
kfactorial3(7) reduce实例
闭包
定义：在函数内部再定义⼀个函数， 并且这个函数⽤到了外边函数的变量， 那么将这个函数成为闭包
例1
def test(number):
print("-----1------")
#在函数内部再定义⼀个函数， 并且这个函数⽤到了外边函数的变量， 那么将这个函数成为闭包
def test_in(number2):
print("-----2-----")
print(number+number2)
print("---3---")
#其实这⾥返回的就是闭包的结果
return test_in
#给test函数赋值， 这个100就是给参数number
ret = test(100)
print("-"*30)
#注意这⾥的1其实给参数number2
ret(1)
ret(100)
ret(200)
def test(a,b):
def test_in(x):
print(a*x+b)
return test_in
line1 =test(1,1)
line1(0)
line2 = test(10,4)
line2(0)
line1(0) 闭包案例
"""闭包中修改外部函数变量应声明nonlocal"""
def test():
x = 10
def test_in():
nonlocal x
x += 1
print(x)
return test_in
c = test()
c()
# 不声明nonlocal UnboundLocalError: local variable 'x' referenced before assignment
# 声明之后 11 闭包中修改外部函数变量应声明nonlocal
装饰器
装饰器是函数，只不过该函数可以具有特殊的含义，装饰器用来装饰函数或类，使用装饰器可以在函数执行前和执行后添加相应操作。换句话说，Decorator 通过返回包装对象实现间接调用,以此插入额外逻辑。应该算是言简意赅了。
def w1(func):
def inner():
print("---正在验证权限---")
if True:
func()
else:
print("没有权限")
return inner
@w1
def f1():
print("---f1---")
@w1
def f2():
print("---f2---")
#innerFunc = w1(f1)
#innerFunc()
#f1 = w1(f1)
f1()
f2() 普通装饰器
#定义函数： 完成包裹数据
def makeBold(fn):
def wrapped():
print("-----1-----")
return "<b>" + fn() + "</b>"
return wrapped
#定义函数： 完成包裹数据
def makeItalic(fn):
def wrapped():
print("-------2-----")
return "<i>" + fn() + "</i>"
return wrapped
@makeBold
@makeItalic
def test3():
print("-------3------")
return "hello world-3"
print(test3()) 多个装饰器
def w1(func):
print("----正在装饰1----")
def wrpped():
print("----正在验证权限1------")
return func()
return wrpped
def w2(func):
print("----正在装饰2----")
def wrpped():
print("----正在验证权限2------")
return func()
return wrpped
#只要python解释器执行到了这个代码,那么就会自动的进行装饰,而不是等到调用的时候才装饰的
@w1 #f1 = w1(w2(f1()))
@w2 #f1 = w2(f1())
def f1():
print("-----f1-----")
#在调用f1之前,已经进行装饰了
f1() 什么时候执行
def func(functionName):
print("-----func---1----")
def func_in():
print("----func_in---1--")
functionName()
print("---func_in---2---")
print("----func---2---")
return func_in
@func
def test():
print("---test---")
#test = func(test)
test() 装饰器对无参数的函数装饰
def func(functionName):
print("-----func---1----")
def func_in(a,b):
print("----func_in---1--")
functionName(a,b)
print("---func_in---2---")
print("----func---2---")
return func_in
@func
def test(a,b):
print("---test- a=%d,b=%d---"%(a,b))
#test = func(test)
test(11,22) 有参数
def func(functionName):
print("-----func---1----")
def func_in(*args,**kwargs):
print("----func_in---1--")
functionName(*args,**kwargs)
print("---func_in---2---")
print("----func---2---")
return func_in
@func
def test(a,b,c):
print("---test- a=%d,b=%d,c=%d---"%(a,b,c))
@func
def test1(a,b,c,d):
print("---test- a=%d,b=%d,c=%d,d=%d---"%(a,b,c,d))
#test = func(test) 不定长参数
def func(functionName):
print("-----func---1----")
def func_in():
print("----func_in---1--")
return functionName()
print("---func_in---2---")
print("----func---2---")
return func_in
@func
def test():
print("---test----")
return "haha"
ret = test()
print("test return value is %s"%ret) 有返回值
def func(functionName):
def func_in(*args,**kwargs):
print("---记录日志------")
ret = functionName(*args,**kwargs)
return ret
return func_in
@func
def test():
print("---test----")
return "haha"
@func
def test2():
print("----test2---")
@func
def test3(a):
print("----test3--a=%d--"%a)
ret = test()
print("test return value is %s"%ret)
a = test2()
print("test2 return value is %s"%a)
test3(11) 通用装饰器
def func_arg(arg):
def func(functionName):
def func_in():
print("---记录日志--arg=%s----"%arg)
if arg=="heihei":
functionName()
functionName()
else:
functionName()
return func_in
return func
#1.先执行func_arg("heihei")函数，这个函数return 的结果是func这个函数的引用
#2.@func
#3使用@func对test进行装饰
@func_arg("heihei")
def test():
print("---test----")
@func_arg("haha")
def test2():
print("-----test2------")
test()
test2() 带有参数的装饰器
class Eat(object):
# 装饰器 Eta
# :return
def __init__(self,func):
self.func = func
def __call__(self, *args, **kwargs):
print('i am eating')
return self.func(*args,**kwargs)
@Eat
def wash():
# 洗手
# :return:
print('i am washing')
wash()
print(wash.__class__)
#
# class Eat(object):
# """
# 装饰器 Eta
# :return
# """
# def __call__(self, func):
# @wraps(func)
# def eat(*args,**kwargs):
# print('i am eating')
# return func(*args,**kwargs)
# return eat
#
#
# @Eat()
# def wash():
# """
# 洗手
# :return:
# """
# print('i am washing')
#
#
# wash()
# print(wash.__name__) 类装饰器
from functools import wraps
def decorator_name(f):
@wraps(f)
def decorated(*args, **kwargs):
if not can_run:
return "Function will not run"
return f(*args, **kwargs)
return decorated
@decorator_name
def func():
return("Function is running")
can_run = True
print(func())
# Output: Function is running
can_run = False
print(func())
# Output: Function will not run 保留原对象指定属性信息
from functools import wraps
def auth(func):
@wraps(func) # 伪装的更彻底
def inner(*args,**kwargs):
print('前')
ret = func(*args,**kwargs)
print('后')
return ret
return inner
@auth
def index():
print('index')
@auth
def detail():
print('index')
print(index.__name__)
print(detail.__name__) 装饰器通用写法
import time
import functools
def timeit(fun):
@functools.wraps(fun)
def wrapper(*args, **kwargs):
start_time = time.time()
res = fun(*args, **kwargs)
end_time = time.time()
print('运行时间为%.6f' % (end_time - start_time))
return res
return wrapper
@timeit #time1 = timeit(time)
def time1(n):
return [i * 2 for i in range(n)]
print(time1(20)) 自定义timeit装饰器
递归
利用函数编写如下数列：
斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368
def func(arg1,arg2):
if arg1 == 0:
print(arg1, arg2)
arg3 = arg1 + arg2
print(arg3)
func(arg2, arg3)
func(0,1)
可变、不可变类型
可变类型：字典，列表
不可变类型：数字，字符串，元组，集合
注：字典中的key值可以位数字，字母，元组，但不可为列表，不符合哈希函数规则
案例
#用来存储名片(列表)
card_infors = []
def print_menu():
"""完成打印功能菜单"""
print("="*50)
print(" 名片管理系统 v0.1")
print(" 1.添加一个名片")
print(" 2.删除一个名片")
print(" 3.修改一个名片")
print(" 4.查询一个名片")
print(" 5.显示所有名片")
print(" 6.保存信息")
print(" 7.退出系统")
print("="*50)
def add_new_card_infor():
"""完成添加一个新的名片"""
new_name = input("请输入新的名字:")
new_qq = input("请输入新的qq:")
new_weixin = input("请输入新的微信:")
new_addr = input("请输入新的住址:")
#定义一个新的字典，用来存储一个新的名片
new_infor ={}
new_infor['name'] = new_name
new_infor['qq'] = new_qq
new_infor['weixin'] = new_weixin
new_infor['addr'] = new_addr
#将一个字典添加到列表中
global card_infors
card_infors.append(new_infor)
print(card_infors)
def del_card_infor():
"""用来查询一个名片"""
global card_infors
find_flag=0
del_name = input("删除的姓名是：")
for temp in card_infors:
if del_name == temp['name']:
card_infors.remove(temp)
find_flag = 1
print(card_infors)
break
#判断是否找到了
if find_flag==0:
print("查无此人")
def show_all_infor():
"""显示所有的名片信息"""
global card_infors
print("姓名\tQQ\t微信\t住址")
for temp in card_infors:
print("%s\t%s\t%s\t%s\t"%(temp['name'],temp['qq'],temp['weixin'],temp['addr']))
def chang_card_infor():
"""完成对名片信息的修改"""
global card_infors
find_flag=0
name = input("你要修改的名片的姓名是：")
for temp in card_infors:
if name==temp['name']:
temp['name'] = input("姓名:")
temp['qq'] = input("qq:")
temp['weixin'] = input("微信:")
temp['addr'] = input("地址:")
print("姓名\tQQ\t微信\t住址")
print("%s\t%s\t%s\t%s\t"%(temp['name'],temp['qq'],temp['weixin'],temp['addr']))
find_flag=1
break
if find_flag==0:
print("查无此人")
def find_card_infor():
"""查找名片上的信息"""
global card_infors
find_name = input("请输入要查找的名字：")
find_flag = 0 #默认表示没有找到
for temp in card_infors:
if find_name == temp['name']:
print("%s\t%s\t%s\t%s\t"%(temp['name'],temp['qq'],temp['weixin'],temp['addr']))
find_flag = 1
break
#else:
#print("查无此人")
#p判断是否找到了
if find_flag==0:
print("查无此人")
def save_2_file():
"""把已经添加的信息保存到文件中"""
#f = open("backup.data","w")
f = open("backup.data", "w")
#f.write(str(card_infors)
f.write(str(card_infors))
f.close()
def load_infor():
global card_infors
try:
f = open("backup.data","r")
card_infors = eval（f.read())
f.close()
except Exception:
pass
def main():
"""完成对整个程序的控制"""
#恢复（加载）之前的数据到程序中
load_infor()
#1. 打印功能提示
print_menu()
while True:
#2.获取用户的输入
num = int(input("请输入操作序列："))
#3.根据用户的输入执行相应的功能
if num==1:
add_new_card_infor()
elif num==2:
del_card_infor()
elif num==3:
chang_card_infor()
elif num==4:
find_card_infor()
elif num==5:
show_all_infor()
elif num==6:
save_2_file()
elif num==7:
break
else:
print("你输入的信息有误，请重新输入！")
if __name__=="__main__":
main() 名片管理系统文件版
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
