一、背景
在学习函数之前，一直遵循：面向过程编程，即：根据业务逻辑从上到下实现功能，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，也就是将之前实现的代码块复制到现需功能处，如下：
while True： if cpu利用率 > 90%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 if 硬盘使用空间 > 90%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 if 内存占用 > 80%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接
腚眼一看上述代码，if条件语句下的内容可以被提取出来公用，如下：
def 发送邮件(内容) #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 while True： if cpu利用率 > 90%: 发送邮件('CPU报警') if 硬盘使用空间 > 90%: 发送邮件('硬盘报警') if 内存占用 > 80%:
对于上述的两种实现方式，第二次必然比第一次的重用性和可读性要好，其实这就是函数式编程和面向过程编程的区别：
- 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
- 面向对象：对函数进行分类和封装，让开发“更快更好更强...”
函数式编程最重要的是增强代码的重用性和可读性
二、定义和使用
def 函数名(参数): ... 函数体 ... 返回值
函数的定义主要有如下要点：
- 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 CPU报警邮件() #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 def 硬盘报警邮件() #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 def 内存报警邮件() #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 while True： if cpu利用率 > 90%: CPU报警邮件（） if 硬盘使用空间 > 90%: 硬盘报警邮件（） if 内存占用 > 80%: 内存报警邮件（） 无参数实现
函数的有三中不同的参数：
- 普通参数
- 默认参数
- 动态参数
# ######### 定义函数 ######### # name 叫做函数func的形式参数，简称：形参 def func(name): print name # ######### 执行函数 ######### # 'wupeiqi' 叫做函数func的实际参数，简称：实参 func('wupeiqi')
def func(name, age = 18): print "%s:%s" %(name,age) # 指定参数 func('wupeiqi', 19) # 使用默认参数 func('alex') 注：默认参数需要放在参数列表最后
def func(*args): print args # 执行方式一 func(11,33,4,4454,5) # 执行方式二 li = [11,2,2,3,3,4,54] func(*li)
def func(**kwargs): print args # 执行方式一 func(name＝'wupeiqi',age=18) # 执行方式二 li = {'name':'wupeiqi', age:18, 'gender':'male'} func(**li)
def func(*args, **kwargs): print args print kwargs
扩展：发送邮件实例
import smtplib from email.mime.text import MIMEText from email.utils import formataddr msg = MIMEText('邮件内容', 'plain', 'utf-8') msg['From'] = formataddr(["武沛齐",'wptawy@126.com']) msg['To'] = formataddr(["走人",'424662508@qq.com']) msg['Subject'] = "主题" server = smtplib.SMTP("smtp.126.com", 25) server.login("wptawy@126.com", "邮箱密码") server.sendmail('wptawy@126.com', ['424662508@qq.com',], msg.as_string()) server.quit()
内置函数
学习操作：
主要了解函数的类型：
1.普通参数
2.默认参数（如果要给某个参数设置默认参数，那么默认参数必须放到列表的后面）
3.指定参数
4.动态参数（在形式参数里面前面加个*）,全部放置在元组中
5.动态参数2（双**）
6.万能参数
所有的函数都应该有返回值，函数体在调用的时候才能使用
def f1(): print(123) return "456" #函数中只要执行了return 函数内的代码就不在执行！！！（函数会终止）。 print(789) r=f1() print(r) def f2(): print(123) #当没有设定return的时候如果对函数进行定义一个值得时候，会返回None r=f2() print(r)
普通参数,默认参数
def f1(dd):#dd形式参数 print(dd) return "Ok" s1={1,2,3,4,5,6,7,8,9,} df_s=f1(s1) #s1实际参数 print(df_s) def send(xxoo,cont,xx="Ok"): #xx在这里起到了个默认参数的作用 print(xxoo,cont,xx) return True send("wang","delong") send("wang","delong","dada") #dada这在里是传值参数，可以改变默认参数 def send(xxoo,cont): print(xxoo,cont) return True send(cont="delong",xxoo="wang") #不按照循序的时候可以使用指定参数，
指定参数
def send(xxoo,cont): print(xxoo,cont) return True send(cont="delong",xxoo="wang") #不按照循序的时候可以使用指定参数，
动态参数（在形式参数里面前面加个*）,全部放置在元组中
def f1(*chnu): #超能力,不管传什么参数都会成为元组 print(chnu,type(chnu)) f1(155,22,"wang","hhhde") li=[155,22,"wang","hhhde"] #会把列表作为一个元素传进了函数 f1(li,"laoda") f1(*li) #如果函数里面有*那么就有特殊的功能了（形式参数），实际是做个循环，把列表的元素循环传值
动态参数2（双**）
def f1(**chnu): #会形成字典，**形式参数为字典,只能使用指定参数，全部放置在字典中 print(chnu,type(chnu)) f1(n1="laoda") f1(n1="laoda",n2="18") dic={"k1":"v1","k2":"v2"} f1(kk=dic) f1(**dic)
完成参数
def f1(*top,**chnu): #万能参数，记住格式，有个星的必须在前面， #（*args,**kwargs） #标准使用，这个是潜规则，建议后期使用按照标准写 print(top,type(top)) print(chnu,type(chnu)) f1(333,"sdgwegew",k1="25411588",k2="1784164")
#定义一个函数 #1.def 关键字，创建函数 #2.函数名 #3.（）括号 #4.函数体 #5返回值 #def send def f1(): print(123) return "456" #函数中只要执行了return 函数内的代码就不在执行！！！（函数会终止）。 print(789) r=f1() print(r) def f2(): print(123) #当没有设定return的时候如果对函数进行定义一个值得时候，会返回None r=f2() print(r) def f1(dd):#dd形式参数 print(dd) return "Ok" s1={1,2,3,4,5,6,7,8,9,} df_s=f1(s1) #s1实际参数 print(df_s) def send(xxoo,cont,xx="Ok"): #xx在这里起到了个默认参数的作用 print(xxoo,cont,xx) return True send("wang","delong") send("wang","delong","dada") #dada这在里是传值参数，可以改变默认参数 def send(xxoo,cont): print(xxoo,cont) return True send(cont="delong",xxoo="wang") #不按照循序的时候可以使用指定参数， def f1(*chnu): #超能力,不管传什么参数都会成为元组 print(chnu,type(chnu)) f1(155,22,"wang","hhhde") li=[155,22,"wang","hhhde"] #会把列表作为一个元素传进了函数 f1(li,"laoda") f1(*li) #如果函数里面有*那么就有特殊的功能了（形式参数），实际是做个循环，把列表的元素循环传值 def f1(**chnu): #会形成字典，**形式参数为字典,只能使用指定参数，全部放置在字典中 print(chnu,type(chnu)) f1(n1="laoda") f1(n1="laoda",n2="18") dic={"k1":"v1","k2":"v2"} f1(kk=dic) f1(**dic) def f1(*top,**chnu): #万能参数，记住格式，有个星的必须在前面， #（*args,**kwargs） #标准使用，这个是潜规则，建议后期使用按照标准写 print(top,type(top)) print(chnu,type(chnu)) f1(333,"sdgwegew",k1="25411588",k2="1784164") 以上就是函数的函数的传值 #1.普通参数 #2.默认参数（如果要给莫个参数设置默认参数，那么默认参数必须放到列表的后面） #3.指定参数 #4.动态参数（在形式参数里面前面加个*）,全部放置在元组中 #5.动态参数2（双**） #6.万能参数
str.format("ddd") #格式化输出
s="我的名字：{0},年龄:{1}".format("wangdelong",30) #格式化传值 print(s) s="我的名字：{0},年龄:{1}".format(*["wangdelong",30]) #格式化传值,使用列表传值 print(s) s="我的名字：{name},年龄:{age}".format(age=30,name="wangdelong") #字典传值 print(s) dic={"name":"wangdelong","age":30} s="我的名字：{name},年龄:{age}".format(**dic) #利用字典传值 print(s)
s="我的名字：{0},年龄:{1}".format("wangdelong",30) #格式化传值 print(s) s="我的名字：{0},年龄:{1}".format(*["wangdelong",30]) #格式化传值,使用列表传值 print(s) s="我的名字：{name},年龄:{age}".format(age=30,name="wangdelong") #字典传值 print(s) dic={"name":"wangdelong","age":30} s="我的名字：{name},年龄:{age}".format(**dic) #利用字典传值 print(s) ''' ''' def f1(a1): a1.append(999) li=["sang"] f1(li) print(li) #传递的是个引用
global
#全局变量，所有的作用域都能用（可以读） #对全局变量，重新赋值，需要使用global #如果定义的变量是个列表（特殊的变量列表字典等），是可以修改不可以重新赋值 #在这说一个潜规则，所有的全局变量要全部都是大写，有利于代码规范。 name="wangdleong" def f1(): age=18 print(age,name) def f2(): age = 20 print(age, name) f1() f2() def f3(): age=18 global name #表示name是全局的变量，在函数内使用了global 重新给name定义为全局变量 name="liudahui" print(age,name) def f4(): age = 20 print(age, name) f3() f4()
三元运算，三目运算,是对if的简写
# 三元运算，三目运算,是对if的简写 if 1 == 1: name = "Wang" else: name = "SB" print(name) name = "wang" if 1 == 1 else "SB" # 三元运算，就一句话完成了多个判断 print(name) def f1(a1): return a1 + 100 f2 = lambda a1: a1 + 100 # lambda 是和上面的操作相同的，对于简单的函数来说，可以使用lambda 表达试来做 ret = f1(10) print(ret) ret = f2(100) print(ret)
内置函数：
n = abs(-1) print(n) # all() 接收有个可以被循环的对象，如果里面的内容都为真时候bool值就为真，如果有一个为假的时候bool值就为假 # any() 只要有真，就为真，于all() 相反 n = all(["wang","delong"]) print(n) n1 = all([1,2,3,4,5,6,7,8,9,10]) print(n1) n2 = all(["wang","delong",0]) print(n2) n3 = all([1,2,3,4,5,6,7,8,9,10,0]) print(n3) n4 = any([[],1]) print(n4) n5 = any([0,0,0,0]) print(n5) n6 = any([0,0,0,0,1]) print(n6)
# ascii() 自动执行对象的 _repr_方式 # bin() 转换二进制 # oct() 转换八进制 # hex() 转换十六进制 print(bin(5)) # 转换二进制 print(oct(9)) # 转换八进制 print(hex(17)) # 转换十六进制 # utf-8 一个汉字：三个字节 # gbk 一个汉字：两个字节 # bytes 指定一个字符串，转换一个字节类型 #utf-8 s = "德龙" # 一个字节八位，一个汉字三个字节 n = bytes(s,encoding="utf-8") # bytes(要转换的字符串，编码方式) print(n) n = bytes(s,encoding="gbk") print(n) # str 字节转换成一个字符串 n = str(bytes(s,encoding="utf-8"),encoding="utf-8") print(n)
# open() 打开一个文件 f = open("userdb","r") # 只读 f = open("userdb","w") # 只写写之前会清空文件 f = open("userdb","a") # 追加 f = open("userdb","x") # 如果文件存在报错，不存在创建并写入 f = open("userdb","r+") # 可以读可以写 f = open("userdb","w+") # 可以读可以写 f = open("userdb","a+") # 可以读可以写
# 操作文件,通过源码查看功能 f.read() # 无参数，读全部；有参数，b,按照字节,无b按照字符 f.tell() # 获取当前指针位置，按照字节查找 f.seek(1) # 指针跳转到指定的位置 f.write() # 数据，有b，按照字节写入，无b,按照字符写入 f.flush() # 强刷写入文件 f.fileno # 文件描述符，后期会用到 f.readable # 判断文件是否可读，可读返回True,否则返回False f.readline() # 按照行一行一行的读取 f.truncate() # 根据指针位置进行截断，按照的字节位置，后面的内容会全部清空 for 循环文件对象 f = open("ddd" ,"r")
# 关闭文件 f.close() with open("userdb") as f：# 开启加关闭 pass
f = open("userdb","r") # 加b就转换成了字节类型 date = f.read() # 按照行的方式打开 print(date,type(date)) f.close() # TODO 你好 f = open("userdb","r",encoding="utf-8") # 依照莫个字符集开启文件 date = f.read() print(date,type(date)) f.close() f = open("userdb","rb",encoding="utf-8") #按照字节打开 date = f.read() print(date,type(date)) f.close() f = open("userdb","ab") #按照字节打开,如果没有带b就按照python自己去出去里 f.write(bytes(" 王大一|123456",encoding="utf-8")) #依照字节类型写入 f.close() f = open("userdb","r+",encoding="utf-8") date = f.read(200) # 读取指针 print(date) f.seek(9) # 定位指针，如果是汉字的时候，按照字符集进行计算字节位置 f.write("82459") f.close() f = open("userdb","r+",encoding="utf-8") # 没有加b按照字符读取 date = f.read() print(date) print(f.tell()) # 定位前三个字符的字节位置（按照字节读取的），调整指针位置 f.seek(f.tell()) # 定位指针,永远按照字节的位置找位置，按照当前位置向后覆盖 f.write("AAA") # 按照上面的位置向后覆盖 f.close() f = open("userdb","a",encoding="utf-8") f.write("123456") f.flush() # 强制刷新到文件，不执行完成可以强制写入 input("请输入：") f.close() f = open("userdb","a") print(f.readable()) # 判断文件是否可读，可读返回True,否则返回False f = open("userdb", "r", encoding="utf-8") data = f.readline() # 按照行一行一行的读取 print(data) data = f.readline() print(data) f.close() f = open("userdb", "r+", encoding="utf-8") f.seek(9) f.truncate() # 根据指针位置进行截断，按照的字节位置，后面的内容会全部清空。 f.close() f = open("userdb", "r+", encoding="utf-8") for line in f: print(line) f.close() with函数 with open("userdb","r+") as f: pass with open("userdb","r+") as f1,open("userdb","a+") as f2: pass with open("userdb","r+",encoding="utf-8") as f1,open("userdb1","w",encoding="utf-8") as f2: for line in f1: new_name = line.replace("王德龙","老王") # 更新一个文件的内容 f2.write(new_name)