python：面向对象进阶

import sys
print(getattr(sys.modules['__main__'],'year'))
getattr(sys.modules['__main__'],'qqxing')()

class A:

　　pass

setattr(A,'name','alex')

print(A,name)

delattr(a,'name')

# 双下方法
# obj.__str__  str(obj)
# obj.__repr__ repr(obj)

class Teacher:
    def __init__(self,name,salary):
        self.name =name
        self.salary =salary
    def __str__(self):
        return "Teacher's object :%s"%self.name
    def __repr__(self):
        return str(self.__dict__)
    def func(self):
        return 'wahaha'
nezha =Teacher('nazha',250)
print(nazha)
print(repr(nezha))
print('>>> %r'%nezha)

#object  里有一个__str__，一旦被调用，就返回调用这个方法的#对象的内存地址
l = [1,2,3,4,5]   # 实例化 实例化了一个列表类的对象
print(l)
# %s str()  直接打印 实际上都是走的__str__
# %r repr()  实际上都是走的__repr__
# repr 是str的备胎，但str不能做repr的备胎
# print(obj)/'%s'%obj/str(obj)的时候，实际上是内部调用了obj.__str__方法，如果str方法有，那么他返回的必定是一个字符串
# 如果没有__str__方法，会先找本类中的__repr__方法，再没有再找父类中的__str__。
# repr(),只会找__repr__,如果没有找父类的

class Classes:
    def __init__(self,name):
        self.name = name
        self.student = []
    def __len__(self):
        return len(self.student)
    def __str__(self):
        return 'classes'
py_s9= Classes('python全栈9期')
py_s9.student.append('二哥')
py_s9.student.append('泰哥')
print(len(py_s9))
print(py_s9)

#__del__
class A:
    def __del__(self):   # 析构函数: 在删除一个对象之前进行一些收尾工作
        self.f.close()
a = A()
a.f = open()   # 打开文件 第一 在操作系统中打开了一个文件 拿到了文件操作符存在了内存中
del a          # a.f 拿到了文件操作符消失在了内存中
del a   # del 既执行了这个方法，又删除了变量

# __call__

#对象后面加括号，触发执行。

#注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

class A:
    def __init__(self,name):
        self.name = name
    def __call__(self):
        '''
        打印这个对象中的所有属性
        :return:
        '''
        for k in self.__dict__:
            print(k,self.__dict__[k])
a = A('alex')()

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)

a1 = A()
a2 = A()
a3 = A()
print(a1)
print(a2)
print(a3)

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
        cls.__instance = object.__new__(cls)
        return cls.__instance

egon = A('egg',38)
egon.cloth = '小花袄'
nezha = A('nazha',25)
print(nezha)
print(egon)
print(nezha.name)
print(egon.name)
print(nezha.cloth)

class A:
    def __init__(self,name):
        self.name = name

    def __eq__(self, other):
        if self.__dict__ == other.__dict__:
            return True
        else:
            return False

ob1 = A('egon')
ob2 = A('egg')
print(ob1 == ob2)

import hashlib#提供摘要算法的模块
md5 =hashlib.md5()
md5.update(b'alex3714')
print(md5.hexdigest())

#用户的登录
import hashlib
usr = input('username :')
pwd = input('password : ')
with open('userinfo') as f:
    for line in f:
        user,passwd,role = line.split('|')
        md5 = hashlib.md5()
        md5.update(bytes(pwd,encoding='utf-8'))
        md5_pwd = md5.hexdigest()
        if usr == user and md5_pwd == passwd:
            print('登录成功')

import hashlib
md5 = hashlib.md5()
md5.update(b'alex')
md5.update(b'3714')
print(md5.hexdigest())
# 文件的一致性校验这里不需要加盐