python 2.04 函数基础篇 传参的多样式，返回值
目录
函数的定义
什么是函数
具备有某一种功能的 函数
为何要有函数
1、程序组织结构差，可读性差
2、如果要用到重复的功能，只能拷贝功能的实现代码。代码冗余
3、可扩展性差
怎么用函数
定义函数： 申请内存空间把函数体代码保存下来，然后把内存地址绑定给函数名， 函数名== 函数的内存地址
调用函数 函数名加括号 触发函数体的运行
def 关键字
func 函数名(数据） 放参数的位置，也是可以说是 数据
在函数体内的代码就是实现功能的代码
return 函数的返回值， 函数的执行完的结果进行返回
def func():
# 注释 解释这个函数的功能和使用
print("123")
return #返回值
func()
x= 10
print(x)
def sayhi():
print('123')
print('123')
print('123')
print(sayhi) # 打印一个函数名、
sayhi() # python 解释器通过（）语法定位到 函数名的内存地址，把内存地址所对应的代码运行起来了
函数的定义 3种格式
无参函数
没有参数的函数 取决于函数体代码需不需要传参，也就是说函数体代码没有参数能不能运行,
def longin():
inp_name = input("name:").strip()
inp_passwd = input("passwd:").strip()
if inp_name == "zhangsan" and inp_passwd == "123":
print('loging success')
else:
print('error')
longin()
有参函数
取决于 定义函数有参数，调用函数一定要有参数。
定义函数的参数，就是变量名
需求 打印字符的样式自定义，显示多少个自定义
def sayhi(x,y):
print(x*y)
sayhi('**',10)
比较2个数的大小
def max(x,y):
if x >y:
print(x)
else:
print(y)
max(11,10)
空函数
作用：提高效率
def func():
... # ... 和 pass 功能一致
pass
func()
函数的返回值
返回值 return 的特性
1、函数内可以有多个return ，但是只要执行一次，函数就立刻结束 ，
def func():
print('1')
return 1
print('2')
return 2
print('3')
return 3
res = func() # 把函数的返回值反馈出来
print(res)
2 返回值的多样性
return后的值 当做本次函数的返回值 ,也可以是多个值
def func():
print('1')
return 1,'aa',['123','dgfd','jjj']
res = func()
print(res)
3、 也可以返回 None 空 ，不写return 也返回空
def func():
print('1')
# return
# return None
res = func()
print(res)
需求 比较2个人的月薪，取出来，算一下年薪
def max(x,y):
if x >y:
return x
else:
return y
res = max(11,100)
print(res*12)
如果 不需要用到函数执行后的结果，就不需要返回值
函数的调用
调用函数的 3种方式
函数的调用 函数名+() 就能调用 ，返回值的概念
1、 函数调用的 语句形式 ，就是单纯的调用
def max():
print("123")
max()
2、函数调用的 表达式形式把函数调用 放到了一个运算中了
def max(x,y):
if x >y:
return x
else:
return y
res = max(11,100)
print(res*12)
3、 函数的调用 当做一个值 传给另一个函数
def max(x, y):
if x > y:
return x
else:
return y
print(max(19,20)*20)
函数的逻辑和语法检测
函数体代码 在定义阶段，会检测语法错误 ：：： 语法检查，不执行代码
函数体代码 在调用阶段，会检查逻辑错误 ：：： 执行代码
语法错误
def func()
print('1')
逻辑错误
def func():
xxx
下面程序是否能运行？
def func():
print('12')
bar()
func()
答：语法检测没有错误，但是逻辑错误，没有定义bra函数
实例1
def bar():
print('bar')
def func():
print('func')
bar()
func()
实例2 下面程序是否报错
def func():
print('func')
bra()
def bra():
print('bar')
func()
答 不会报错，因为程序是先定义后调用的。 所以调用bar 的时候，就已经在内存中定义过了。
无论函数体代码在哪，只要定义没有错误，那么就能调用
帮助
查看一个函数的帮忙页面 函数名不要加（） 切记
help(index)
1. 初识函数
函数到底是个什么东西？
函数，可以当做是一大堆功能代码的集合。
def 函数名():
函数内编写代码
...
...
函数名()
例如：
# 定义名字叫info的函数
def info():
print("第一行")
print("第二行")
print("第n行...")
info()
什么时候会用到函数？
什么时候会用到函数呢？一般在项目开发中有会有两种应用场景：
-
有重复代码，用函数增加代码的重用性。
def send_email(): # 10行代码 print("欢迎使用计算机监控系统") if CPU占用率 > 90%: send_email() if 硬盘使用率 > 99%: send_email() if 内存使用率 > 98%: send_email() ... -
代码太长，用函数增强代码的可读性。
def calculate_same_num_rule(): """判断是否是豹子""" pass def calculate_same_color_rule(): """判断是否是同花""" pass def calculate_straight_rule(): """判断是否顺子""" pass def calculate_double_card_rule(poke_list): """判断是否对子""" pass def calculate_single_card_rule(): """判断是否单牌""" pass # 1. 生成一副扑克牌 card_color_list = ["红桃", "黑桃", "方片", "梅花"] card_nums = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] # A all_card_list = [[color, num] for color in card_color_list for num in card_nums] # 2.洗牌 random.shuffle(all_card_list) # 3.给玩家发牌 ... # 4.判断牌是：豹子？同花顺？顺子？对子？单点？ calculate_same_num_rule() calculate_same_color_rule() calculate_straight_rule() ...
以前我们变成是按照业务逻辑从上到下逐步完成，称为：面向过程编程；现在学了函数之后，利用函数编程称为：函数式编程。
2. 函数的参数
函数的定义 不应该对除了自身空间以外的空间产生影响，
- 形参 在定义函数时，括号内定义的变量名，称之为形式参数
关键字形参，默认形参
def func(x,y): # 形参
print(x,y)
默认形参
在函数定义阶段 就已经为某个形参赋值，称之为 默认形参
可以不用传值，有实参传值，就用实参的值，没有实参传值，就用默认值。
默认形参应该放在位置形参的后面
def func(x=1,x):
print(x)
print(y)
func()
默认形参的值通常应该是不可变类型 比如 性别 ，单位
因为列表的是可变类型，不建议使用列表作为形参，多次调用会影响下次的使用
l = []
def func(name,hobby,hobbies=l):
hobbies.append(hobby)
print('%s ===%s'%(name,hobbies))
func('jace','567')
func('hhh','789')
func('li','001')
需求表示 这个值需要是一个 可变类型，一下方法可以解决黏连的办法。
def func(name,hobby,hobbies=None):
if hobbies is None:
hobbies=[]
hobbies.append(hobby)
print('%s ===%s'%(name,hobbies))
func('jace','567')
func('hhh','789')
func('li','001')
- 实参 在调用函数时，括号内参入的值，称之为实际参数
def func(x,y):
print(x,y)
func(1,2) # 实参
函数的形参和实参在定义阶段 绑定，在函数结束后回收
#参数的种类
1、位置参数
函数定义阶段 按照从左到右依次写的参数，就是位置形参。收值
def func(x,y):
print(x,y)
func(1,2)
函数调用阶段 按照从左到右依次写的参数（传入的变量值），就是位置实参。传值
特点是位置实参必须被传值,不能多不能少
def func(x,y):
print(x,y)
func(1,2)
2 关键字实参数
实参的特性，可以不按照顺序进行排列，仍然能够指名道姓为形参传值
def func(name,age):
print(name,age)
func(name=1,age=2)
可以混用关键字实参和位置实参,
1、位置实参必须放在关键字实参的前面
2、不能为一个形参进行多重赋值
def func(name,age,salary):
print(name)
print(age)
print(salary)
# func('zhangsan',age=12,salary=10)
func('zhangsan',12,salary=10)
func('zhangsan',12,123,salary=10)
之前说了很好多次发送邮件的案例，下面就来教大家用python发邮件，然后再由此引出函数的参数。
- 注册邮箱
- 基础配置
- 授权码
- SMTP服务器: smtp.126.com
- 代码发送邮件
以下是我为大家提供的发邮件的一个函数。
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
# ### 1.邮件内容配置 ###
msg = MIMEText("约吗", 'html', 'utf-8')
msg['From'] = formataddr(["武沛齐", "yangliangran@126.com"])
msg['Subject'] = "180一晚"
# ### 2.发送邮件 ###
server = smtplib.SMTP_SSL("smtp.126.com")
server.login("yangliangran@126.com", "LAYEVIAPWQAVVDEP")
server.sendmail("yangliangran@126.com", "424662508@qq.com", msg.as_string())
server.quit()
那么需求来了，请求大家提一个需求：根据上述代码实现给3个用户发邮件。
v1 = "424662508@qq.com"
v2 = "424662509@qq.com"
v3 = "wupeiqi@live.com"
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
def send_email(xx):
# ### 1.邮件内容配置 ###
msg = MIMEText("约吗", 'html', 'utf-8')
msg['From'] = formataddr(["武沛齐", "yangliangran@126.com"])
msg['Subject'] = "180一晚"
# ### 2.发送邮件 ###
server = smtplib.SMTP_SSL("smtp.126.com")
server.login("yangliangran@126.com", "LAYEVIAPWQAVVDEP")
server.sendmail("yangliangran@126.com", xx, msg.as_string())
server.quit()
send_email("424662508@qq.com")
send_email("424662509@qq.com")
send_email("wupeiqi@live.com")
-
思路1
def send_email1(): # ### 1.邮件内容配置 ### # 邮件文本 msg = MIMEText("约吗", 'html', 'utf-8') # 邮件上显示的发件人 msg['From'] = formataddr(["武沛齐", "wptawy@126.com"]) # 邮件上显示的主题 msg['Subject'] = "邮件主题" # ### 2.发送邮件 ### server = smtplib.SMTP_SSL("smtp.126.com") server.login("wptawy@126.com", "WIYSAILOVUKPQGHY") server.sendmail("wptawy@126.com", "424662508@qq.com", msg.as_string()) server.quit() def send_email2(): # ### 1.邮件内容配置 ### # 邮件文本 msg = MIMEText("约吗", 'html', 'utf-8') # 邮件上显示的发件人 msg['From'] = formataddr(["武沛齐", "wptawy@126.com"]) # 邮件上显示的主题 msg['Subject'] = "邮件主题" # ### 2.发送邮件 ### server = smtplib.SMTP_SSL("smtp.126.com") server.login("wptawy@126.com", "WIYSAILOVUKPQGHY") server.sendmail("wptawy@126.com", "424662509@qq.com", msg.as_string()) server.quit() def send_email3(): # ### 1.邮件内容配置 ### # 邮件文本 msg = MIMEText("约吗", 'html', 'utf-8') # 邮件上显示的发件人 msg['From'] = formataddr(["武沛齐", "wptawy@126.com"]) # 邮件上显示的主题 msg['Subject'] = "邮件主题" # ### 2.发送邮件 ### server = smtplib.SMTP_SSL("smtp.126.com") server.login("wptawy@126.com", "WIYSAILOVUKPQGHY") server.sendmail("wptawy@126.com", "wupeiqi@live.com", msg.as_string()) server.quit() send_email1() send_email2() send_email3() -
思路2，基于函数的参数（将代码中动态部分提取到参数位置，让函数可以充分被重用）
def send_email(email): # ### 1.邮件内容配置 ### # 邮件文本 msg = MIMEText("约吗", 'html', 'utf-8') # 邮件上显示的发件人 msg['From'] = formataddr(["武沛齐", "wptawy@126.com"]) # 邮件上显示的主题 msg['Subject'] = "邮件主题" # ### 2.发送邮件 ### server = smtplib.SMTP_SSL("smtp.126.com") server.login("wptawy@126.com", "WIYSAILOVUKPQGHY") server.sendmail("wptawy@126.com", email, msg.as_string()) server.quit() v1 = "424662508@qq.com" send_email(v1) v2 = "424662509@qq.com" send_email(v2) v3 = "wupeiqi@live.com" send_email(v3)
2.1 参数
在定义函数时，如果在括号中添加变量，我们称它为函数的形式参数：
# ###### 定义有三个参数的函数（a1/a2/a3一般称为形式参数-形参） #####
def func(a1,a2,a3):
print(a1+a2+a3)
# 执行函数并传入参数（执行函数传值时一般称为实际参数-实参）
func(11,22,33)
# 执行函数并传入参数
func(9,2,103)
-
位置传参
def add(n1,n2): print(n1+n2) add(1,22) -
关键字传参
def add(n1,n2): print(n1+n2) add(n1=1,n2=22)
"""
1. 形参
2. 实参
3. 位置传参
4. 关键字传参
"""
# ###### 定义有三个参数的函数（a1/a2/a3一般称为形式参数-形参） #####
def func(a1, a2, a3):
print(a1 + a2 + a3)
# 执行函数并传入参数（执行函数传值时一般称为实际参数-实参）
func(11, 22, 33)
# 执行函数并传入参数
func(9, 2, 103)
# 执行函数
func(a1=99, a2=88, a3=1)
func(a1=99, a3=1, a2=88)
2.2 默认参数
def func(a1, a2, a3=10):
print(a1 + a2 + a3)
# 位置传参
func(8, 19)
func(1, 2, 99)
# 关键字传参（位置和关键混合时，关键字传参要在后面）
func(12, 9, a3=90)
func(12, a2=9, a3=90)
func(a1=12, a2=9, a3=90)
file_object = open("xxx.txt")
2.3 动态参数
-
def func(*args): print(args) # 元组类型 (22,) (22,33,99,) () # 只能按照位置传参 func(22) func(22,33) func(22,33,99) func() -
**
def func(**kwargs): print(kwargs) # 字典类型 {"n1":"武沛齐"} {"n1":"武沛齐","age":"18","email":"xxxx"} {} # 只能按关键字传参 func(n1="武沛齐") func(n1="武沛齐",age=18) func(n1="武沛齐",age=18,email="xx@live.com") -
,*
def func(*args,**kwargs): print(args,kwargs) # (22,33,99) {} func(22,33,99) func(n1="武沛齐",age=18) func(22,33,99,n1="武沛齐",age=18) func()提示：是否还记得字符串格式化时的format功能。
v1 = "我叫{},今年{},性别{}".format("武沛齐",18,"男") v2 = "我叫{name},今年{age},性别{gender}".format(name="武沛齐",age=18,gender="男")
注意事项（不重要，听过一遍即可）
# 1. ** 必须放在 * 的后面
def func1(*args, **kwargs):
print(args, **kwargs)
# 2. 参数和动态参数混合时，动态参数只能放在最后。
def func2(a1, a2, a3, *args, **kwargs):
print(a1, a2, a3, args, **kwargs)
# 3. 默认值参数和动态参数同时存在
def func3(a1, a2, a3, a4=10, *args, a5=20, **kwargs):
print(a1, a2, a3, a4, a5, args, kwargs)
func3(11, 22, 33, 44, 55, 66, 77, a5=10, a10=123)
可变长参数，实参个数不固定，形参个数也应该不固定，那么如何接收不确定个数的形式哪？
def func(name): # 形参只能接收一个参数，溢出的实参如何处理。
print(name)
func('zhangsan','lisi','wangwu')
func('zhangsan','lisi')
func('zhangsan')
- 形参的使用
解决 位置参数的解决办法 ,另一个形参前加* ，溢出的位置实参给到了一个元组内，然后赋值给形参名
def func(name,*names):
print(name)
print(names)
func('zhangsan','lisi','wangwu')
func('zhangsan','lisi')
func('zhangsan')
解决 关键字参数的解决办法 另一个形参前加** ，溢出的位置实参给到了一个字典内，然后赋值给形参名
def func(name,**names):
print(name)
print(names)
func(name='zhangsan',name1='lisi',name2='wangwu')
func(name='zhangsan',name1='lisi')
func(name='zhangsan')
应用场景 累加几个数的和
def add(*num):
res =0
for nums in num:
res +=nums
print(res)
add(1,2,3)
- 实参的使用
在实参前加* ，*会把其后的值，打散成位置实参, 适用于 列表 ,字符串，如果是字典是key
def func(x,y,z): #
print(x,y,z)
list = [1,2,3]
func(*list)
如果是字典是key
def func(x,y,z): #
print(x,y,z)
list = {'a':'123','b':'456','c':'789'}
func(*list)
在实参前加** ，**会把其后的值，打散成关键字实参, 适用于 字典，
def func(x,y,z): #
print(x,y,z)
list = {'x':'123','y':'456','z':'789'}
func(**list)
总结
实参中带 * ** 是为了解压操作
形参中带 * ** 是为了汇总操作
- 在实参和形参中混用 * **
规范的写法 *args **kwargs
def index(*args,**kwargs): #4 index 形参收值汇总
print(args,kwargs) # 5 解压打印
def wrapper(*args,**kwargs): # 2 wrapper形参收值汇总
# print(args)
# print(kwargs)
index(*args,**kwargs) # 3 index 实参解压传值
wrapper(1,23,55,a='1',b='123',c='456') # 1 wrapper 实参解压传值给到形参
以上五个步骤达到了 通过传参一次 能够调用2个函数的功能。
应用场景 在调一个外层函数的过程，把参数传给外层函数的内层函数
命名关键字形参 ，在 * 和** 之间的关键字
def func(x,y=222,*args,n='abc',m,**kwargs):
print(x)
print(y)
print(args)
print('-------%s'%m)
print(kwargs)
func(1,2,3,4,5,m='123444')
m形参 必须已关键字实参的方式传值
n=123 也是关键字命名形参，有了默认值，可以传值，也必须用关键字传参，也可以不传 ，但是不叫默认形参
3. 函数返回值
在开发过程中，我们希望函数可以帮助我们实现某个功能，但让函数实现某功能之后有时也需要有一些结果需要反馈给我们，例如：
import requests
from xml.etree import ElementTree as ET
def xml_to_list(city):
data_list = []
url = "http://ws.webxml.com.cn//WebServices/WeatherWebService.asmx/getWeatherbyCityName?theCityName={}".format(city)
res = requests.get(url=url)
root = ET.XML(res.text)
for node in root:
data_list.append(node.text)
return data_list
result = xml_to_list("北京")
print(result)
def func():
return 666
res = func()
print(res) # 666
def magic(num):
result = num + 1000
return result
data = magic(9)
print(data) # 1009
在了解了返回值的基本使用之后，接下来在学3个关键知识：
-
返回值可以是任意类型，如果函数中没写return，则默认返回None
def func(): return [1,True,(11,22,33)] result = func() print(result)def func(): value = 1 + 1 ret = func() print(ret) # None当在函数中
未写返回值或return或return None，执行函数获取的返回值都是None。def func(): value = 1 + 1 return # 或 return None ret = func() print(ret) # None -
return后面的值如果有逗号，则默认会将返回值转换成元组再返回。
def func(): return 1,2,3 value = func() print(value) # (1,2,3) -
函数一旦遇到return就会立即退出函数（终止函数中的所有代码）
def func(): print(1) return "结束吧" print(2) ret = func() print(ret)def func(): print(1) for i in range(10): print(i) return 999 print(2) result = func() print(result) # 输出 1 0 999def func(): print(1) for i in range(10): print(i) for j in range(100): print(j) return print(2) result = func() print(result) # 输出 1 0 0 None
小结：
-
完成某个结果并希望的到结果。
def send_email(): ... return True v1 = send_email()def encrypt(old): ... return "密文..." data = encrypt("武沛齐") print(data) -
基于return控制让函数终止执行
def func(name): with open("xxx.txt",mode='r',encoding="utf-8") as file_object: for line in file_object: if name in line: return True data = func("武沛齐") if data: print("存在") else: print("不存在")def foo(): while True: num = input("请输入数字（Q）：") if num.upper() == "Q": return num = int(num) if num == 99: print("猜对了") else: print("猜错了，请继续！") print("....") foo()
总结
-
如何定义一个函数？
-
函数名的规范。（同变量名规范）
-
规范
-
建议
def change_num(): pass
-
-
函数的注释，说明函数的作用。
def encrypt(origin): """ 用于数据加密和xxx """ pass -
定义函数时，参数一般有以下情况（形式参数）
-
情景1
def func(a1,a2): pass -
情景2：
def func(a1,a2=123): pass -
情景2：
def func(*args,**kwargs): pass
-
-
函数的返回值，一般用于将函数执行的返回给调用者。
- 默认返回None
- 遇到return则函数执行完毕
作业
-
请定义一个函数，用于计算一个字符串中字符
a出现的次数并通过return返回。-
参数，字符串。
-
返回值，字符串中 a 出现的次数。
def check_num(letter): count = 0 for i in letter: if i !='a': continue count+=1 return count print(check_num('aaaaaabb')) -
-
写函数，判断用户传入的一个值（字符串或列表或元组任意）长度是否大于5，并返回真假。
def check_length(letter): if len(letter) > 5: return True else: return False def check_length(letter): if len(letter) > 5: return True return False print(check_length('fghjkjhghjklkjhg')) print(check_length([11,22])) print(check_length((1,2,3,4,5,6,))) -
写函数，接收两个数字参数，返回比较大的那个数字（等于时返回两个中的任意一个都可以）。
def letter(a, b): if a >= b: return a return b print(letter(a=1,b=2)) -
写函数，函数接收四个参数分别是：姓名，性别，年龄，学历，然后将这四个值通过"*"拼接起来并追加到一个student_msg.txt文件中.
def student_info(name, age, education,gender='男',): with open('student_msg.txt', mode='wt', encoding='utf-8') as file_object: date = f'{name}*{gender}*{age}*{education}' file_object.write(date) student_info(name='stone', age='18', education='小学') student_info('stone', '18', '小学',gender='女') def student_info(*xargs): with open('student_msg.txt', mode='wt', encoding='utf-8') as file_object: date = f'{xargs[0]}*{xargs[1]}*{xargs[2]}*{xargs[3]}' file_object.write(date) student_info('stone', '19', '小学','女') -
补充代码，实现如下功能：
- 【位置1】读取文件中的每一行数据，将包含特定关键的数据筛选出来，并以列表的形式返回。
- 【位置1】文件不存在，则返回None
- 【位置2】文件不存在，输出 "文件不存在"，否则循环输出匹配成功的每一行数据。
def select_content(file_path,key): # 补充代码【位置1】 result = select_content("files/xxx.txt","股票") # 补充代码【位置2】 import os.path def select_content(file_path, key): if not os.path.exists(file_path): return None list_key = [] with open(file_path, mode='rt', encoding='utf-8') as file_object: for line in file_object: if key not in line: continue list_key.append(line.strip()) return list_key result = select_content("files/user.txt", "股票") # print(result) if result == None: print('文件不存在') print(result) -
补充代码，实现敏感词替换的功能。
def change_string(origin): # 补充代码，将字符串origin中中的敏感词替换为 **，最后将替换好的值返回。 data_list = ["苍老师","波多老师","大桥"] text = input("请输入内容：") result = change_string(text) print(result) def change_string(origin): # 补充代码，将字符串origin中的敏感词替换为 **，最后将替换好的值返回。 data_list = ["苍老师", "波多老师", "大桥"] for item in data_list: origin = origin.replace(item,'**') return origin text = input("请输入内容：") result = change_string(text) print(result) -
基于函数实现用户认证，要求：
-
写函数，读取的用户信息并构造为字典（用户信息存放在
files/user.xlsx文件中）# 构造的字典格式如下 user_dict = { "用户名":"密码" ... } -
用户输入用户名和密码，进行校验。（且密码都是密文，所以，需要将用户输入的密码进行加密，然后再与Excel中的密文密码进行比较）
import hashlib def encrypt(origin): origin_bytes = origin.encode('utf-8') md5_object = hashlib.md5() md5_object.update(origin_bytes) return md5_object.hexdigest() p1 = encrypt('admin') print(p1) # "21232f297a57a5a743894a0e4a801fc3" p2 = encrypt('123123') print(p2) # "4297f44b13955235245b2497399d7a93" p3 = encrypt('123456') print(p3) # "e10adc3949ba59abbe56e057f20f883e"
import os
import sys
import hashlib
from openpyxl import load_workbook
# 判断判断文件是否存在
Base_dir = os.path.dirname(os.path.abspath(__file__))
if not os.path.exists(os.path.join(Base_dir,'files')):
sys.exit()
def excel_user_dict(filename):
__doc__= 'Excel内的用户名和密码插入到字典中，return 返回'
wb = load_workbook(filename)
sheet_name = wb.worksheets[0]
user_dict = {}
for line in sheet_name.rows:
if line[0].value =='ID':
continue
user_dict.update({line[1].value:line[2].value})
return user_dict
def encrypt(origin):
# 接收的字符串 return hash
origin_bytes = origin.encode('utf-8')
md5_object = hashlib.md5()
md5_object.update(origin_bytes)
return md5_object.hexdigest()
def user_passwd(dict_user):
# 校验用户名或者密码
key_name = input('请输入用户名：').strip()
key_passwd = input('请输入密码：').strip()
for line in dict_user:
if key_name == line and dict_user.get(line) == encrypt(key_passwd):
return True
return False
user_dict = excel_user_dict(os.path.join(Base_dir,'files','user.xlsx'))
if user_passwd(user_dict):
print('登录成功')
else:
print('登录失败')
扩展：密码都不是明文。
-
注册京东，京东存储：用户名和密码（密文）
-
登录京东：用户名& 密码。
# 注册京东，京东存储：用户名和密码（密文） import os import sys import hashlib from openpyxl import load_workbook # 判断判断文件是否存在 Base_dir = os.path.dirname(os.path.abspath(__file__)) if not os.path.exists(os.path.join(Base_dir, 'files')): sys.exit() userfile = os.path.join(Base_dir, 'files', 'user.xlsx') def encrypt(origin): # 接收的字符串 return hash origin_bytes = origin.encode('utf-8') md5_object = hashlib.md5() md5_object.update(origin_bytes) return md5_object.hexdigest() def excel_write(): key_name = input('请输入注册用户名：').strip() key_passwd = input('请输入注册密码：').strip() hash_passwd = encrypt(key_passwd) wb = load_workbook(userfile) sheet = wb.worksheets[0] num = 1 for line in sheet.rows: num += 1 sheet[f'A{num}'] = num - 1 sheet[f'B{num}'] = key_name sheet[f'C{num}'] = hash_passwd wb.save(userfile) print('注册成功') def excel_user_dict(filename): __doc__ = 'Excel内的用户名和密码插入到字典中，return 返回' wb = load_workbook(filename) sheet_name = wb.worksheets[0] user_dict = {} for line in sheet_name.rows: if line[0].value == 'ID': continue user_dict.update({line[1].value: line[2].value}) return user_dict def user_passwd(): # 校验用户名或者密码 key_name = input('请输入用户名：').strip() key_passwd = input('请输入密码：').strip() dict_user = excel_user_dict(userfile) state = False for line in dict_user: if key_name == line and dict_user.get(line) == encrypt(key_passwd): state = True if state: print('登录成功') return state choose_dict = {'1': ['注册', excel_write], '2': ['登陆', user_passwd]} while True: for items in choose_dict: print(f'{items}:{choose_dict.get(items)[0]}') print(f'0:退出') choose = input('请输入你选择的序号： ') if choose=='0': break elif choose in choose_dict: choose_dict[choose][1]() else: print('输入的指令不在')
浙公网安备 33010602011771号