day018反射及区分函数和方法，md5加密
本节主要内容：
1. isinstance, type, issubclass 三个面向对象的内置函数
2. 区分函数和方法
3. 反射（重点）
4. md5加密（数字签名、电子签章的原理）一、三个关于面向对象的内置函数
1、issubclass()
作用：判断xxx是否是yyy类型的子类
object是所有类的根，是面向对象的祖宗fe:
class Foo(object):
pass
class Bar(Foo):
pass
class FooBar(Bar):
pass
print(issubclass(Bar, Foo)) # True
print(issubclass(Foo, Bar)) # False
print(issubclass(FooBar, Foo)) # True 可以隔代判断
print(issubclass(Foo, object))
print(issubclass(Bar, object))
print(issubclass(FooBar, object))
object是所有类的根. 面向对象的祖宗2、type
作用： 精准的返回该对象的类型fe1:判断数据类型
print(type("你好")) # <class 'str'> 返回该对象的数据类型
class Animal:
pass
class Cat(Animal):
pass
c = Cat()
print(type(c)) # 可以精准的返回数据类型fe2: 计算a+b的结果 数学运算
def cul(a, b):
if (type(a) == int or type(a) == float) and (type(b) == int or type(b) == float):
return a + b
else:
print("不行. 不能帮你计算")
print(cul(10, "胡辣汤"))3、isinstance()
作用：判断xxx是否是yyy类型的数据，包括父类
只能向上fe1:
class Animal:
pass
class cat(Animal):
pass
class BoSiCat(cat):
pass
c = cat()
print(isinstance(c, Animal)) # 判断这个对象是否是 xxx的一种，包括父类
print(isinstance(c, BoSiCat)) # 报错，只能向上判断，不能向下
print(type(c, Animal)) # 只能精准判断属于cat, 不能找到父类fe2: 判断是否是迭代器类型的数据
from collections import Iterator # 引入
lst = []
it = lst.__iter__() # list_iterator
print(isinstance(it, Iterator)) # True二、区分函数和方法（面向对象中）
1、野路子判断
通过打印fe1：
查看类中的方法和函数
class Car:
def run(self): # 实例方法
print("我是车, 我会跑")
@staticmethod
def cul():
print("我会计算")
@classmethod
def jump(cls):
print("我会jump")
# 实例方法 <bound method Car.run of <__main__.Car object at 0x000001E9166B73C8>>
c = Car()
1
"str"
print(c.run) # <bound method Car.run of <__main__.Car object at 0x000001E9166B73C8>>
Car.run(c) # 通过类名也可以访问实例方法. 不要这么干
print(Car.run) # <function Car.run at 0x000002454C748AE8>
# 实例方法:
# 1. 用对象.方法 方法
# 2. 类名.方法 函数
#
# 静态方法
# 都是函数
print(c.cul) # <function Car.cul at 0x0000024BA2658BF8>
print(Car.cul) # <function Car.cul at 0x0000024BA2658BF8>
# 类方法都是方法
print(c.jump) # <bound method Car.jump of <class '__main__.Car'>>
print(Car.jump) # <bound method Car.jump of <class '__main__.Car'>>
# 对象.方法
# 万事万物皆为对象
# 我们写的类. 也是对象. 可以创建对象2、官方的办法
用程序来分辨
from types import FunctionType, MethodType
print(isinstance(xx, FunctionType)))
print(isinstance(xx, MethodType)))
所有的方法都是MethodType
所有的函数都是FunctionTypefe：
from types import FunctionType, MethodType
class Car:
def run(self): # 实例方法
print("我是车, 我会跑")
@staticmethod
def cul():
print("我会计算")
@classmethod
def jump(cls):
print("我会jump")
# 实例方法:
# 1. 用对象.方法 方法
# 2. 类名.方法 函数
c = Car()
# print(isinstance(c.run, FunctionType)) # False
# print(isinstance(Car.run, FunctionType)) # True
# print(isinstance(c.run, MethodType)) # True
# print(isinstance(Car.run, MethodType)) # False
# 静态方法 都是函数
# print(isinstance(c.cul, FunctionType)) # True
# print(isinstance(Car.cul, FunctionType)) # True
# print(isinstance(c.cul, MethodType)) # False
# print(isinstance(Car.cul, MethodType)) # False
# 类方法都是方法
print(isinstance(c.jump, FunctionType)) # False
print(isinstance(Car.jump, FunctionType)) # False
print(isinstance(c.jump, MethodType)) # True
print(isinstance(Car.jump, MethodType)) # True
# FunctionType:所有的函数
# MethodType: 所有的方法3、区分函数和方法的结论
1. 实例方法:
用类名访问. 函数
用对象访问. 方法2. 静态方法
都是函数3. 类方法
都是方法三、反射
常用（掌握）：
hasattr(对象, 属性(字符串)) 判断是否有这个属性，返回True或者False, # 判断 xxx中是否有 xxx
getattr(对象, 属性(字符串)) 从对象中获取到xxx属性
不太常用：
setattr(对象, 属性, 值) 设置，原来有就修改，没有就修改
delattr(对象, 属性) 从对象中删除xxx属性fe1:
反射
import master # 引入模块，在自己这边开辟内存，存放master模块（一个写好的py文件）
def chi():
print("大牛说的不对，我要换")
setattr(master, "chi", chi) # 给xxx模块的chi替换成我的chi，跟字典一样，在自己这边的内存，修改函数
setattr(master, "haha", chi) # 没有就新增，新增haha函数
delattr(master, "name") # 删除"name"这个变量
print(master.name)
setattr(master, "wife", "皮蛋") # 有就是修改，没有就新增
print(master.wife) # 模块名.变量名 或 函数名 或其他，就是调用
while 1:
s = input("请输入你要测试的功能：") # 输入函数名
if hasattr(master, s): # 判断 xxx中是否有 xxx
fn = getattr(master, s) # 在 xxx中获取到 xxx
fn()
else:
print("没有这个功能喔")
普通的获取方法
lst = ["chi", "he", "shui"]
for k, item in enumerate(lst): # 枚举，enumerate(枚举的对象)
print(k, item)fe2: 属性存储在对象里，方法存储在类里
class Car:
def __init__(self, cloro, pai, price):
self.cloro =cloro
self.pai = pai
self.price = price
def fly(self):
print("车在飞")
c = Car("大红色", "宝马", 1000000)
setattr(Car, "fly", lambda self: print("我让他飞的，不是他自己飞") ) # 方法存在类里，所以用类来操作
c.fly()
setattr(c, "cloro", "黑色") # 属性存在对象里，所以用对象来进行操作修改
print(c.cloro)
# print(getattr(c, "cloro")) # 属性存在对象里，所以要用对象去拿
# print(getattr(Car, "cloro")) # 报错 类中不存属性
# print(c.cloro)
# delattr(Car, "fly")
# delattr(c,"cloro") # 可以操作我们的类或者对象四、md5加密
md5特点: 不可逆的一种加密方式
最多用在密码加密上1、步骤
import hashlib # 引入
obj = hashlib.md5(加盐) # 加盐=二次加密，md5出来太久，可以被查询，二次加密后就无法查询到了
obj.update(铭文的bytes)
obj.hexdigest() 获取密文2、md5的使用
import hashlib
def jiami(content):
obj = hashlib.md5(SALT) # 创建md5对象，并进行加密
obj.update(content.encode("utf-8")) # 给obj设置铭文
return obj.hexdigest() # 获取到密文fe1: 使用实例，注册和登录的实例
import hashlib
SALT = b"abcdefghijklmnjklsfdafjklsdjfklsjdak"
# 创建md5的对象
obj = hashlib.md5(SALT) # 加盐
# 给obj设置铭文
obj.update("alex".encode("utf-8"))
# 获取到密文
miwen = obj.hexdigest()
# f4c17d1de5723a61286172fd4df5cb83
# 534b44a19bf18d20b71ecc4eb77c572f
print(miwen) # 534b44a19bf18d20b71ecc4eb77c572ffe2: 注册和登录的实例
import hashlib
SALT = b"abcdefghijklmnjklsfdafjklsdjfklsjdak" # 一定要byte类型的加盐
# 注册
# username = input("请输入你的用户名:") # alex
# password = input("请输入你的密码:")
# password = jiami(password) # c3d4fe3dce88533a8b50cf2e9387c66d
# print(password)
# 登录
uname = "alex"
upwd = "c3d4fe3dce88533a8b50cf2e9387c66d"
username = input("请输入你的用户名:")
password = input("请输入你的密码:")
if uname == username and upwd == jiami(password):
print("登录成功")
else:
print("失败")
