Day06

2018-05-13

# 复习

# 常用模块
# http://www.cnblogs.com/Eva-J/articles/7228075.html

# collection模块
# 有序字典 orderddict
# 默认字典 defaultdict
# 可命名元组 namedtuple

# 时间模块
# 三种时间格式 时间戳时间 结构化时间 格式化时间
# 计算时间差
    # 两个时间都转换成时间戳
    # 时间戳之间相减 以秒为单位的小数差
    # 将小数差转换成结构化时间 元组 1970 1.3
    # 用当前结构化的时间 减去 1970 1 1 0:0:0

# random模块
    # 发红包 发200的红包，发5个 —— 代码
        #(0,200)取4个点
        # 后一个数减前一个数的差值就是每个红包的数量
import random
t = random.sample(range(200),4)
print(t)
    # 验证码
        #从数字中选一个 09
        # 从a-z选一个
        # 到底是字母还是数字也是随机的（字母用asc码做随机然后转换）

# os模块 —— 操作系统打交道
    # 文件相关
    # 文件夹相关
    # 和执行系统命令相关
    # 和路径相关的

# sys模块 ——　和解释器相关的
    # sys.path
    # sys.argv 执行py脚本的时候传入的参数

# 正则模块
    # 正则表达式
        # 能够判断 邮箱 手机号常用的注册要求
    # re模块

# 函数 基础数据类型 循环 文件处理 模块
# 游戏公司
# 人狗大战
# 两个角色 人 狗
# 人
    # 属性：
    # 昵称
    # 性别
    # 生命值
    # 战斗力
    # 背包
#dic_person = {'name':'alex','sex':'不详','hp':250,'dps':5,'bag':[]}
# 使用函数订立属性规范
def Person(name,sex,hp,dps):    # 人模子
    dic = {'name': name, 'sex': sex, 'hp': hp, 'dps': dps, 'bag': []}
    def attack(dog):    # 只有人才能调用攻击函数
        dog['hp'] -= dic['dps']
        print('%s打了%s,%s掉了%s点血，剩余%s点血' % (dic['name'], dog['name'], dog['name'], dic['dps'], dog['hp']))
    dic['attack'] = attack
    return dic
# 狗
    # 属性：
    # 昵称
    # 品种
    # 生命值
    # 战斗力
#dic_dog = {'name':'wangcai','kind':'藏獒','hp':15000,'dps':200}
def Dog(name,kind,hp,dps):    # 狗模子
    dic = {'name': name, 'kind': kind, 'hp': hp, 'dps': dps}
    def bite(person):
        person['hp'] -= dic['dps']
        print('%s咬了%s,%s掉了%s点血，剩余%s点血' % (dic['name'], person['name'], person['name'], dic['dps'], person['hp']))
    dic['bite'] = bite
    return dic
alex = Person('alex','不详',250,5)
ha2 = Dog('哈士奇','藏獒',15000,200)

# 人打狗
print(alex)
print(ha2)
print(alex['attack'])
alex['attack'](ha2)
print(ha2)
# 狗咬人
print(alex)
print(ha2)
print(ha2['bite'])
ha2['bite'](alex)
print(alex)

# 面向对象的编程思想
# 人狗大战
# 创建一个人
# 创建一只狗
# 人打狗 —— 函数
# 狗咬人 —— 函数

# 造模子 —— 面向对象

# 类： 具有相同属性和相同动作的一类事物 组成一个类
    # 抽象的
    # 类被创造出来 就是模子 是用来描述对象的
#类的语法：
class 类名:
    静态属性 = None # （变量）任何数据类型
    def 动态属性(self):pass # 函数    在类中的方法的一个默认的参数，但也只是一个形式参数，约定必须叫self

# 只要是写在类名中的名字 不管是变量还是函数名 都不能在类的外部直接调用
# 只能通过类名来使用它

# 类名的第一个功能是 —— 查看静态属性
print(类名.静态属性)  # 对静态属性的查看
类名.静态属性 =456    # 对静态属性的修改
print(类名.静态属性)
类名.静态属性2 = 'abc'    # 对静态属性的增加
print(类名.静态属性2)
#del 类名.静态属性2    # 对静态属性的删除
#print(类名.静态属性2)
print(类名.__dict__)  # 类中必要的默认值之外 还记录了程序员在类中定义的所有名字

# 类名可以查看某个方法，但是一般情况下 我们不直接使用类名来调用方法
print(类名.动态属性)
类名.动态属性(1)

# 类的第二个功能 —— 实例化（创造对象）
class Person:pass

alex = Person()
# 对象 = 类名()
print(alex) # object
#print(Person)
# alex name hp dps bag sex
print(alex.__dict__)
# 给alex对象添加属性（创建字典数据）
alex.__dict__['name'] = 'alex'
alex.__dict__['sex'] = '不详'
alex.__dict__['hp'] = 250
alex.__dict__['bag'] = []
print(alex.__dict__)
# 上面简化可以写成如下格式
alex.name = 'alex'
alex.hp = 250
alex.sex = '不详'
alex.bag = []
print(alex.__dict__)

class Person:
    def __init__(self):
        print('-->',self)
alex = Person()
print('alex:',alex)
# self就是alex，一个对象


# 为什么会执行init中的内容
# self到底是什么

# 实例化的过程
# 类名()就是实例化
# 在实例化的过程中 发生了很多事情是外部看不到的
# 1.创建了一个对象
# 2.自动调用__init__方法
# 这个被创造的对象会被当作实际参数 传到__init__方法中，并且传给第一个参数self
# 3.执行init方法中的内容
# 自动的把self作为返回值

class Person:
    def __init__(self,name,hp,dps,sex):
        self.name = name
        self.hp = hp
        self.dps = dps
        self.sex = sex
        self.bag = []
    def attack(self,dog):
        dog.hp -= self.dps
        print('%s打了%s,%s掉了%s点血，剩余%s点血' % (self.name, dog.name, dog.name, self.dps, dog.hp))

class Dog:
    def __init__(self,name,kind,hp,dps):
        self.name =  name
        self.hp = hp
        self.dps = dps
        self.kind = kind
    def bite(self,person):
        person.hp -= self.dps
        print('%s咬了%s,%s掉了%s点血，剩余%s点血' % (self.name, person.name, person.name, self.dps, person.hp))

alex = Person('alex',250,5,'N/A')
ha2 = Dog('哈士奇','藏獒',15000,200)

alex.attack(ha2)   # 相当于 Person.attack(alex) alex是形参的第一个参数，即self
alex.attack(ha2)   # 相当于 Person.attack(alex)
alex.attack(ha2)   # 相当于 Person.attack(alex)
print(ha2.hp)
ha2.bite(alex)
ha2.bite(alex)
ha2.bite(alex)
print(alex.hp)
# print('alex:',alex)
# print(alex.__dict__)
# print(alex.name)

# 对象名.方法名 相当于调用一个函数，这个函数默认把对象名作为第一个参数传入函数
# 剩余的其它参数根据我的需求可以随意传，一一对应

# 练习题
# 已知半径 计算圆形的面积和周长 面向对象的思想完成
# 类抽象 圆
# 属性 半径
# pi * r ** 2
# 2*pi*r

from math import  pi
print(pi)

class Circle:
    def __init__(self,r):
        self.r = r
    def area(self):
        return pi * self.r ** 2
    def perimeter(self):
        return 2 * pi * self.r

c1 = Circle(5)
ret = c1.area()
print(ret)
ret = c1.perimeter()
print(ret)

# 每一个角色都有属于自己的属性和方法
# 高可扩展性 可读性 规范性
# 缺点 结局不可控

# 类有自己的命名空间
# 对象也有自己的命名空间
# 对象能不能访问类的命名空间？
# 类能不能访问对象的命名空间？
class Person:
    COUNTRY = '中国人'     # 静态属性
    def __init__(self,name):
        self.name = name
    def eat(self):
        print('%s在吃泔水'%self.name)
alex = Person('alex')
egon = Person('egon')

# 类对象指针
# 当一个类在创建一个实例的时候 就产生了一个这个实例和类之间的联系
# 可以通过实例 对象 找到实例化它的类
# 但是 类不能找到他的
# so 对象可以访问类的命名空间，类不能访问对象的命名空间

print(alex.COUNTRY)
alex.COUNTRY = '印度人'
print(alex.COUNTRY)
print(egon.COUNTRY)
print(Person.COUNTRY)
# 在访问变量的时候，都先使用自己命名空间中的，如果自己的空间中没有，再到类的空间中去找
# 在使用对象修改静态变量的过程中，相当于在自己的空间中创建了一个新的变量

print('=======================================')
class Person:
    COUNTRY = ['中国人']     # 静态属性
    def __init__(self,name):
        self.name = name
    def eat(self):
        print('%s在吃泔水'%self.name)
alex = Person('alex')
egon = Person('egon')
print(alex.COUNTRY)
alex.COUNTRY[0] = '印度人'
print(alex.COUNTRY)
print(egon.COUNTRY)
print(Person.COUNTRY)
# 在类的静态变量的操作中 应该使用类名来直接进行操作 就不会出现乌龙问题

# 延伸复习变量内存地址学习点

# 创建一个类 能够自动计算这个类有创建了多少个实例
class Foo:
    count = 0
    def __init__(self):
        Foo.count += 1

f1 = Foo()
print(Foo.count)
[Foo() for i in range(10)]
print(Foo.count)




# 对象：具体的某一个具有实际属性 和具体动作的一个实体
    # 具体的

# 组合
# 一个类的对象作为另外一个类对象的属性

class Person:
    def __init__(self,name,sex,hp,dps):
        self.name = name
        self.hp = hp
        self.dps = dps
        self.sex = sex
        self.bag = []
    def attack(self,dog):
        dog.hp -= self.dps
        print('%s打了%s,%s掉了%s点血，剩余%s点血' % (self.name, dog.name, dog.name, self.dps, dog.hp))

class Dog:
    def __init__(self,name,kind,hp,dps):
        self.name =  name
        self.hp = hp
        self.dps = dps
        self.kind = kind
    def bite(self,person):
        person.hp -= self.dps
        print('%s咬了%s,%s掉了%s点血，剩余%s点血' % (self.name, person.name, person.name, self.dps, person.hp))
# 基础数据类型 都是类
# 'alex':str的对象
# alex.name = 'alex' 组合：'alex'这个字符串对象是alex对象name的属性
# alex.name.startswith('a')

# 练习
# 给alex装备一个武器
# 建一个武器类
class Weapon:
    def __init__(self,name,price,dps):
        self.name =  name
        self.price = price
        self.dps = dps
    def kill(self,dog):
        dog.hp -= self.dps
alex = Person('alex','N/A',250,5)
ha2 = Dog('哈士奇','藏獒',15000,200)
print(alex.name)
roubaozi = Weapon('肉包子',600000,10000)
alex.money = 1000000
if alex.money >= roubaozi.price:
    alex.weapon = roubaozi
    alex.weapon.kill(ha2)
    print(ha2.hp)

# 圆形类 --> 圆环类
# 已知圆形类的基础上 运用组合 求圆环的面积和周长
from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    def area(self):
        return pi * self.r ** 2
    def perimeter(self):
        return 2 * pi * self.r
class Ring:
    def __init__(self,outside_r,inside_r):
        self.out_circle = Circle(outside_r)
        self.in_circle = Circle(inside_r)
    def area(self): # 返回大圆面积-小圆面积
        return self.out_circle.area() - self.in_circle.area()
    def perimeter(self):
        return self.out_circle.perimeter() + self.in_circle.perimeter()

r = Ring(10,5)
print(r.area())
print(r.perimeter())

# 组合 是描述了一种 什么有什么的关系 圆环有圆 人有武器

'''
初识面向对象回顾
    类的相关知识
        如何创建一个类
        实例化 —— 类() --> 实例化
        实例和对象是一回事
        self
    对象的相关知识
        对象调用方法
        类调用静态属性
        __init__
    类的组合用法
        人有武器
        圆有圆环

'''

# 继承
# 为什么会有继承？
# 为了解决代码冗余的问题
# 如何继承


# 单继承
class Parent:pass
class Son(Parent):pass # Son类 继承 Parent 类
# 名词解释
# 父类 基类 超类 —— Parent类
# 子类 派生类 —— Son类

# 多继承
class Parent1:pass
class Parent2:pass
class Son(Parent1,Parent2):pass

# python支持多继承

# 继承与抽象（先抽象再继承）

class Animal:
    def __init__(self,name,hp,dps):
        self.name = name
        self.hp = hp
        self.dps = dps

class Person(Animal):pass
class Dog(Animal):pass

alex = Person('alex',250,5)
ha2 = Dog('哈士奇',15000,200)
print(alex.__dict__)
print(ha2.__dict__)

# 实例化发生的时候
    # 1.创建了一个对象
    # 2.把我创建的对象传给__init__(父类的init)
    # 3.把子类创建的对象传给父类init的self
    # 4.执行init
    # 5.把self返回给alex

# 继承的特点 本级有init先使用本级的 逐级向上
# 对象的内存空间 — 创建这个对象的类的内存空间 — 父类空间

class Animal:
    def __init__(self,name,hp,dps):
        self.name = name
        self.hp = hp
        self.dps = dps

class Person(Animal):
    def __init__(self,name,hp,dps,sex):
        Animal.__init__(self,name,hp,dps)
        self.sex =  sex     # 派生属性
class Dog(Animal):
    def __init__(self,name,hp,dps,kind):
        Animal.__init__(self, name, hp,dps)
        self.kind = kind    # 派生属性

alex = Person('alex',250,5,'N/A')
ha2 = Dog('哈士奇',15000,200,'藏獒')
print(alex.__dict__)
print(ha2.__dict__)

# 派生属性
# 在父类基础上，新生成类自己的属性

# 简化版
class Animal:
    def __init__(self,name,hp,dps):
        self.name = name
        self.hp = hp
        self.dps = dps
    def eat(self):
        print('%s吃药回血了'%self.name)

class Person(Animal):
    def __init__(self,name,hp,dps,sex):
        # Animal.__init__(self,name,hp.dps)
        super().__init__(name, hp,dps)
        self.sex =  sex     # 派生属性
    def attack(self, dog):
        dog.hp -= self.dps
        print('%s打了%s,%s掉了%s点血，剩余%s点血' % (self.name, dog.name, dog.name, self.dps, dog.hp))

class Dog(Animal):
    def __init__(self,name,hp,dps,kind):
        #Animal.__init__(self, name, hp,dps)
        super().__init__(name, hp,dps)
        self.kind = kind    # 派生属性
    def bite(self, person):
        person.hp -= self.dps
        print('%s咬了%s,%s掉了%s点血，剩余%s点血' % (self.name, person.name, person.name, self.dps, person.hp))

alex = Person('alex',250,5,'N/A')
ha2 = Dog('哈士奇',15000,200,'藏獒')
print(alex.__dict__)
print(ha2.__dict__)
ha2.eat()
alex.eat()
ha2.bite(alex)
alex.attack(ha2)


# 要注意self是哪一层
class Foo:
    def __init__(self):
        self.func()
    def func(self):
        print('in Foo')

class Son(Foo):
    def __init__(self):
        print('in Son')
Son()

# python两种类
    # 经典类 py3已经灭绝了，在python2里还存在，py2中只要程序员不主动继承object，这个类就是经典类 —— 深度优先
    # 新式类 python3所有的类都是新式类，所有的新式类都继承自object —— 在多继承中遵循广度优先算法
    # object是类祖宗

# 钻石继承
'''
A类
B类继承A类 C类继承A类
D类继承 B类和C类
'''
class A:
    def f(self):
        print('in A')

class B(A):
    def f(self):
        print('in B')

class C(A):
    def f(self):
        print('in C')

class D(B,C):
    def f(self):
        print('in D')
d = D()
d.f()


# 小乌龟继承

class A:
    def f(self):
        print('in A')

class B(A):
    def f(self):
        print('in B')

class C(A):
    def f(self):
        print('in C')

class D(B):
    def f(self):
        print('in D')

class E(C):
    def f(self):
        print('in E')

class F(D,E):
    def f(self):
        print('in F')
print(F.mro())

# 广度优先算法
# 在python3所有的类都遵循广度优先算法
# 图9


class A:
    def f(self):
        print('in A')

class B(A):
    def f(self):
        print('in B')
        super().f()

class C(A):
    def f(self):
        print('in C')
        super().f()

class D(B,C):
    def f(self):
        print('in D')
        super().f()
d = D()
d.f()

# super和找父类这件事是两回事
# 在单继承中 super就是找父类
# 在多继承中 super的轨迹 是根据整个模型的起始点而展开的一个广度优先顺序 遵循mro规则

# 多态
# 在python中处处都是多态

# java 强数据类型的语言 相比java paython是弱数据类型
class Person():pass

alex = Person()
print(type(alex))   # <class '__main__.Person'> 对象数据类型：Person

class Animal:
    pass

'''
作业：
角色:
学校、学员、课程、讲师

要求:
1. 创建北京、上海 2 所学校

2. 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开

3. 课程包含，周期，价格

4. 班级关联课程、讲师

5. 创建学员时，选择学校，关联班级

5. 创建讲师角色时要关联学校

6. 提供三个角色视图

　　6.1 学员视图， 登陆， 查看课程、查看班级

　　6.2 讲师视图， 讲师可查看自己教学的班级、课程。

　　　　　　　　　 进阶需求：可管理自己的班级， 查看班级学员列表 ， 修改所管理的学员的成绩

　　6.3 管理视图，创建讲师， 创建班级，创建课程

7. 上面的操作产生的数据都通过pickle序列化保存到文件里


继承 什么是什么的关系
组合 什么有什么的关系

作业要求：
通读整篇博客
类：属性 方法 都写好

登录：输入用户名和密码
自动切换到你的视图下
和身份相关的登录

从管理员视图开始完成代码



'''