一. 面向对象进阶与实例
dic = {'k': 'v' }
对象：存储 属性 和 调用方法
dic['k'] = 'v'
class Foo:
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
def __getitem__(self, item):
if hasattr(self, item):
return self.__dict__[item]
def __setitem__(self, key, value):
self.__dict__[key] = value
def __delitem__(self, key):
del self.__dict__[key]
f = Foo('egon', 22, '男')
print(f['a'])
print(f['name'])
f['hobby'] = '男'
print(f.hobby,f['hobby'])
print(f.__dict__)
del f.hobby # object 原生支持 __delattr__
print(f.__dict__)
print(f.__dict__)
del f['hobby'] # 通过自己实现
print(f.__dict__)__init__ ：初始化方法
构造方法：创建一个对象 class A:
def __init__(self):
self.x = 1
print('in init function')
def __new__(cls, *args, **kwargs):
print('in new function')
return object.__new__(A, *args, **kwargs) a = A()
print(a.x)
设计模式：23 种
1. 单例模式：一个类始终只有一个实例
当第一次实例化这个类的时候，就创建一个实例化的对象
当之后再来实例化的时候，就用之前创建的那个对象 class A:
__instance = False
def __init__(self, name, age):
self.name = name
self.age = age
def __new__(cls, *args, **kwargs):
if cls.__instance:
return cls.__instance
else:
cls.__instance = object.__new__(A)
return cls.__instance
egon = A('egon',22)
egon.cloth = '小花袄'
nezha = A('nezha',32)
print(nezha)
print(egon) # 内存地址一样
print(nezha.name) # nezha
print(egon.name) # nezha
print(nezha.cloth) # 小花袄
__eq__
class A:
def __init__(self, name):
self.name = name def __eq__(self,other):
if self.name == other.name:
return True
else:
return False
obj1 = A('egon')
obj2 = A('egn')
print(obj1 == obj2) # 不实现__eq__时，默认比较内存地址 Flase
# __hash__ hash()
class A:
def __init__(self,name,sex):
self.name = name
self.sex = sex def __hash__(self):
return hash(self.name+self.sex)
a = A('egon','男')
b = A('egon','男')
print(hash(a))
print(hash(b)) a = A('egon','男')
b = A('egn','男')
print(hash(a))
print(hash(b))
实例
import json
from collections import namedtuple
Card = namedtuple('Card',['rank','suit']) # rank 牌的大小，suit 牌的花色
# c1 = Card(2,'红桃')
# print(c1)
# print(c1.suit)
class FranchDeck:
ranks = [str(n) for n in range(2,11)] + list('JQKA') # 2 - A
suits = ['红桃', '方块', '梅花', '黑桃'] def __init__(self):
self.__cards = [Card(rank, suit) for rank in FranchDeck.ranks
for suit in FranchDeck.suits]
def __len__(self):
return len(self.__cards)
def __getitem__(self, item):
return self.__cards[item]
def __setitem__(self, key, value):
self.__cards[key] = value
def __str__(self):
return json.dumps(self.__cards, ensure_ascii=False)
deck = FranchDeck()
print(deck[10])
from random import choice
print(choice(deck))
from random import shuffle
shuffle(deck)
print(deck[10])
print(deck)
print(deck[:4])
扑克牌
# 内置函数 内置的模块 内置的基础类型 ，都和类的内置方法有联系
# 一道面试题：有一个类，这个类有100个对象，其中有很多对象，名字和性别相同，但年龄不同，就认为是同一个对象，实现去重
class A:
def __init__(self, name, sex, age):
self.name = name
self.sex = sex
self.age = age
def __eq__(self, other):
return self.name == other.name and self.sex == other.sex
def __hash__(self):
return hash(self.name + self.sex)
a = A('egon', '男',22)
b = A('egon', '男',23)
print(set((a,b))) # set 依赖对象的 hash eq
二. hashlib
非常非常重要 非常非常重要 非常非常重要
登录认证
摘要算法
import hashlib # 提供摘要算法的模块
md5 = hashlib.md5()
md5.update(b'alex3714')
print(md5.hexdigest()) # 结果不会变 不管算法多么不同，摘要的功能始终不变
对于相同的字符串使用同一个算法进行摘要，得到的值总是不变的
使用不同算法对相同的字符串进行摘要，得到的值应该不同
不管使用什么算法，hashlib的方式永远不变 import hashlib
paw = hashlib.sha1()
paw.update(b'alex3714')
print(paw.hexdigest()) sha 算法, 随着算法复杂程度的增加, 摘要的时间成本 空间成本都会增加 摘要算法
密码的密文存储
文件的一致性验证
在下载时，会检查下载的文件和远程服务器上的文件是否一致
两台机器上的两个文件，想检查这两个文件是否相等 用户注册
用户输入用户名
用户输入密码
确认密码
明文的密码进行摘要，拿到一个密文的密码写到文件里 用户登录 import hashlib
user = input('请输入用户名：')
password = input('请输入密码：')
with open('userInfo',encoding='utf-8') as f:
for line in f:
user,passwd,job = line.split('|')
md5 = hashlib.md5()
md5.update(bytes(password,encoding='utf-8'))
md5_password = md5.hexdigest()
if user == user and md5_password == passwd:
print('登录成功') 撞库 加盐 import hashlib
md5 = hashlib.md5(bytes('salt',encoding='utf-8'))
md5 = hashlib.md5()
md5.update(b'')
print(md5.hexdigest()) 动态加盐
用户名 密码
使用用户名的一部分作为盐 import hashlib
md5 = hashlib.md5(bytes('salt',encoding='utf-8') + b'')
md5.update(b'')
print(md5.hexdigest()) 摘要算法：做摘要计算的，把字节类型的内容进行摘要处理
md5 sha1
md5加密方式 正常的md5算法、加盐的、动态加盐 文件的一致性校验
文件的一致性校验这里不需要加盐 import hashlib
md5 = hashlib.md5()
md5.update(b'alex')
md5.update(b'') # md5.update(b'alex3714') 一样的
print(md5.hexdigest())