python学习04

叁歲伎倆 2022-04-25 01:18 217阅读 0赞

class Room:
        def __init__(self,name,length,width):
            self.name=name
            self.length=length
            self.width=width
        def area(self):
             return self.__length*self.__width
        def get_name(self):
            return self.__name
        def set_name(self,newName):
            if type(newName) is str and newName.isdigit() ==False:
                self.__name=newName
            else:
                print('please input vaild  newName')
    jin=Room('jin',2,1)
    print(jin.area())
    jin.set_name('')
    #假设父类的私有属性 bu能被子类调用
    class Foo:
        __key='123'
    class Son(Foo):
        print(Foo._key)
    #property
    #内置装饰器函数，只在面向对象中使用
    from math import  pi
    class Circle:
        def __init__(self,r):
            self.r=r
        @property
        def perimeter(self):
             return 2*pi*self.r
    
        @property#名词是个属性 通过计算得到 不能传任何参数   把fangfa其伪装成方法
        def area(self):
             return  self.r**2*pi
    c1=Circle(5)
    print(c1.area())
    print(c1.area)#去掉括号
    class Person:
        def __init__(self,name,high,weight):
            self.name=name
            self.high=high
            self.weight=weight
        @property
        def bmi(self):
            return self.weight/self.high**2
    class Person:
        def __init__(self,name):
            self.__name = name
        @property
        def name(self):
            return self.__name+'sb'
        @name.setter
        def name(self,new_name):
            self.__name=new_name
        @name.deleter
        def name(self):
            del self.__name
    class Goods:
        discount=0.5
        def __init__(self,name,price):
             self.name=name
             self.price=price
        @property
        def price(self):
             return self.__price*Goods.discount
    #method
    staticmethod
    classmethod
    class Goods:
        __discount=0.5
        def __init__(self,name,price):
             self.name=name
             self.price=price
        @property
        def price(self):
             return self.__price*Goods.__discount
        def change_discount(self,new_discount):
               Goods.__discount=new_discount
    
    class Login:
        def __init__(self,name,password):
            self.name = name
            self.pwd=password
        def login(self):pass
        @staticmethod
        def get_usr_pwd():
            usr=input('username:')
            pwd=input('password:')
            Login(usr,pwd)
    Login.get_usr_pwd()
    #在完全面向对象的程序中，如果一个函数 既和对象没有关系  也和类没有关系 那么就用staticmethod方法
    #类方法 有一个默认的参数cls  代表这个类cls
    #静态方法 没有默认参数就像函数一样
    #反射
    name='alex'
    'name'
    class Teacher:
        dic={'查看学生信息':'','查看讲师信息':''}
        def show_student(self):
            print('show_student')
        def show_teacher(self):
            print('show_teacher')
        @classmethod
        def func(cls):
            print('hahahhah')
    alex=Teacher()
    for k in Teacher.dic:
        print(k)
    key=input('输入需求:')
    print(Teacher.dic[key])
    if hasattr(alex,Teacher.dic[key]):
        func=getattr(alex,Teacher.dic[key])
        func()
    #三个反射函数  hasatrr getattr delattr
    #反射：洋浦个字符串类型的命名空间类型的名字 通过他们得到
    ret=getattr(Teacher,'dic')#类也是对象Teacher.dic
    print(ret)
    ret2=getattr(Teacher,'func')#类.方法Teacher.func
    print(ret2)
    menu=Teacher.dic
    for k in menu:
        print(k)
    #命名空间：类和对象分别存在不同的命名空间中 且对象能找到类 类找不到对象 对象调用类
    #继承 单继承 经典类和新式类  深度优先 广度优先
    #super根据mro广度优先顺序找上一个类
    #多态  鸭子类型
    封装：私有的 双下划线 只在类的内部调用 子类都无法继承
    #三个装饰器 @property @staticmethod@classmethod:当一个类只使用了类的静态变量时  就给这个方法加上@classmethod装饰器 默认传cls参数
    class Goods:
        __discount=0.09
        @classmethod
        def change_discount(cls):
             cls.__discount=0.4
    Goods.change_discount()
    
     isinstance(obj,cls)检查Obj是否是类cls的对象
    class Foo(object):
        pass
    obj=Foo()
    isinstance(obj,Foo)
    issubclass(sub,super)检查sub类是否是super类的派生类
    class Foo(object):
        pass
    class Bar(Foo):
         pass
    issubclass(Bar,Foo)#子类前面
    #反射：用字符串类型的名字  去操作变量
    eval('print(name)')#安全隐患
    #反射：没有安全隐患
    name='alex'
    #反射对象中的属性和方法
    class A:
        def func(self):
            print('in func')
    a=A()
    a,name='alex'
    #反射对象的属性
    ret=getattr(a,'name')#t通过变量名的字符串形式取到的值 对象 属性字符串
    变量名=input('>>>')
    print(getattr(a,'变量名'))
    a.__dic__[变量名]
    #反射对象的 方法
    #a.func()
    ret=getattr(a,'func')
    ret()
    #反射类的属性
    class A:
        price=20
        def func(self):
            print('in func')
    #A.price
    print(getattr(A,'price')) #反射类属性
    #反射类的方法：classmethod staticmethod
    class A:
        price=20
        @classmethod
        def func(cls):
            print('in func')
    #A.func()
    print(getattr(A,'func'))
    ret=getattr(A,'func')
    ret()
    ret=getattr(A,'func')()
    if hasattr(A, 'func'):
         getattr(A, 'func')()
    
    #反射模块的属性
    my.py
    day='Monday'#周一
    def wahaha():
        print('waaaaaaaaa')
    import my
    #print(my.day)
    print(getattr(my,'day'))
    #反射模块的方法
    print(getattr(my,'wahaha')())
    #内置模块
    # 反射自己模块中的变量
    def qqxng():
        print('qqxing')
     year=2018
    import sys
    print(sys.modules['__main__'].yeaar)
    getattr(sys.modules['__main__'],'qqxing')#反射自己模块中的变量
    print(getattr(sys.modules['__main__'],'year'))
    #反射自己模块中的函数方法
    getattr(sys.modules['__main__'],'qqxing')()
    # 双下方法
    # __str__
    # __repr__
    print(repr(1))
    print(repr('1'))
    class Teacher:
        def __init__(self,name,salary):
            self.name=name
            self.salary=salary
    
        def __str__(self):
            return "Teacher's object:%s"%self.name
            return 'A''s object'
        def __repr__(self):
            return str(self.__dict__)
    
        def func(self):
            return 'wahaha'
        ##pass
        def func(self):
            return 'wahaha'
    print('%s:%s'%('A',a))
    bazha=Teacher('NAZHA',250)
    a=A()
    print((repr(nezha)))
    print('>>>%r'%nezha)
    #object里有一个_str__，一旦被调用，就返回调用这个方法的对象的内存地址
    l=[1,2,3,4,7,5,6]
    __call__
    class A:
        def __call__(self, *args, **kwargs):
            '''
    
            :param args:
            :param kwargs:
            :return:
            '''
            for k in self.__dict__：
    
            print('zhixing')
    a=A('alex')
    a()
    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',38,'man')
    print(f['name'])
    f['hobby']='man'
    print(f.hobby,f['hobby'])
    del f.hobby
    del f['hobby']
    print(f.__dict__)
    
    
    #__init__初始化方法
    #__new__构造方法：创建一个对象
    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)
    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__(A)
            return cls.__instance
    class A:
        def __init__(self,name):
            self.name=name
        def __eq__(self, other):
           print(self.other)
           if self.name==other.name:
               return True
           else:
               return False
    
    obj1=A('egon')
    obj2=A('egg')
    print(obj1==obj2)
    __hash__
    class A:
        def __init__(self,name):
            self.name=name
    a=A('egon')
    b=A('egon')
    print(hash(a))
    print(hash(b))
    import json
    from collections import namedtuple
    Card=namedtuple('Card',['rank','suit'])
    class FranchDeck:
        ranks = [str(n) for n in range(2,11)] +list('JQKA')
    
        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_assii=False)
    deck=FranchDeck()
    print(deck[10])
    from random import choice
    print(choice(deck))
    from random import  shuffle
    shuffle(deck)
    print(deck[:5])
    class A:
        def __init__(self,name,sex,age):
            self.name=name
            self.sex=sex
            self.age=age
        def __eq__(self, other):
            if self.name==other.name and self.sex==other.sex:
                return True
            return False
        def __hash__(self):
            return hash(self.name+self.sex)
    
    a=A('agewa','man',38)
    a=A('agewa','man',37)
    print(set((a,b)))
    #set 依赖对象的hash eq方法
    # hashilib
    #登陆认证 密码
    #摘要算法
    import hashlib
    md5=hashlib.md5()
    sha=hashlib.shal()
    sha=hashlib.shal3_512()
    md5.update(b'alex31274')
    print(md5.hexdigest())
    print(sha.hexdigest())
    hashlib.md5()
    #不管算法多么的不同，摘要的功能始终不变
    #对于相同的字符串使用同一个算法进行摘要，得到的值总是不变的
    #sha算法随着算法时间复杂度增加  时间成本空间成本增加
    密码的密文存储
    文件的一致性验证
       #下载的时候  检查我们下载的文件和远程服务器上的文件是否一致
       #两台机器上的连个文件 你想检查者两个文件是否相等
    
    #用户输入用户名
    # 用户输入密码
    # 明文的密码进行摘要 拿到一个密文密码
    # 写入文件
    
    # 用户登陆
    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=hashlib.md5(bytes('salt',encoding='utf-8'))
    md5=hashlib.md5(bytes('盐',encoding='utf-8'+b''))
    sha=hashlib.shal()
    sha=hashlib.shal3_512()
    md5.update(b'alex31274')
    print(md5.hexdigest())
    print(sha.hexdigest())
    hashlib.md5()
    md5=hashlib.md5()
    # configparser模块
    #start文件 配置文件 经常会用的的功能封装
    from os import getcwd,path
    from sys import path as sys_path
    sys_path.inser(0,path.dirname(getcwd()))
    from core import main
    if __name__ == '__main__':
            main.main()
    def login():
        '''
        登陆函数，应该先到conf.config文件中读取userinfo的文件路径
        读取usessrinfo文件中的信息，对用户和密码进行查验
        登陆成功之后，查看这个人的身份，来确定进入哪一个视图
    
        :return:
        '''
        usr=input('username:')
        pwd=input('password:')
        with open(userinfo) as f：
          for line in f:
            usrname,passwd,rple=line.strip().split('|')
            if usrname==usr and passwd==pwd:
                print('\033[1;32m登陆成功！\033[0m')
                return {'username':usr,'role':role}
            else:
                print('\033[1;31m登录失败！\033[0m')
    def main():
      """
      打印欢迎信息
      login:得到返回值：用户的姓名 和身份
      打印用户身份对应的功能菜单
      #如果用户想调用任何方法应该通过角色对象调用，跳转到对应的对象的方法里
      :return:
      """
      print('\033[1;42m欢迎您登陆选课系统|033[0m')
      ret=login()
      if ret:
          role_class=getattr(sysmodules[__name__],ret['role'])
          obj=role_class(ret['username'])
          for i,j in enumerate(role_class.menu,1):
              print(i,j[0])
          try:
              ret=int(input('请输入操作序号：'))
              getattr(obj,role_class.meu[ret-1][1])()
          except:
              print('对不起，您输入的内容有误')
    from conf.config import *
    from core.Teacher import Teacher
    from core.my_pickle import MyPickle
    class Manger:
        menu=[('创建讲师账号','creatTeacher'),('创建学生账号','creatStudent',
                                         ('创建课程','creatCourse'),('查看课程','showCourse'),
                                         ('创建班级','createClasses'),('查看班级','showClasses'),
                                         ('绑定班级','boundClass'),('退出',''))]
        def __init__(self,name):
            self.name=name
            self.teacher_pickle_obj=MyPickle(teacher_obj)
        @staticmethod
        def userinfo_handle(content):
            with open(userinfo,'a') as f:
                f.write('\n%s'%content)
    
        def creatTeacher(self):
    
    import pickle
    class MyPickle:
       def __init__(self,filename):
           self.filename=filename
    
        def deum(self,obj):
            with open(self.filename,'ab') as f:
                pickle.dump(obj,f)
        def loaditer(self):
            with open(self.filename,'rb') as f:
                for obj in pickle.load(f)
                    yield obj