python学习04

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