Python面向对象-day07

现实生活中：先有对象，再总结归纳出类；而程序中：先定义类，再实例化对象； 在python中，用变量表示特征，用函数表示技能； 因而类是变量与函数的结合体，对象是变量与方法（指向类的函数）的结合体； Python中，一切皆对象； Python3中，统一了类和类型的概念；

class 类名():
'''
类的注释
'''
类体

class People(): # 定义了一个类 People
country = 'China'
def __init__(self,name):
self.name = name
def talk(self):
print('%s comes from %s' % (self.name,self.country)) p1 = People('standby') # 实例化了一个对象 p1
p1.talk() # 对象p1 调用了People类的talk()函数，称之为向 p1 对象发送了一个消息，让p1去执行 talk()这个函数； ---
standby comes from China

C:\Users\Administrator>python
Python 3.5.2 (v3.5.2:4def2a2901a5, Jun 25 2016, 22:18:55) [MSC v.1900 64 bit (AM
D64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>> class People():
... country = 'China'
... def __init__(self,name):
... self.name = name
... def talk(self):
... print('%s comes from %s' % (self.name,self.country))
...
>>>
>>> p1 = People('standby') # 实例化一个对象 p1
>>> p2 = People('kunkun') # 实例化第二个对象 p2
>>>
>>> print(id(People.country)) # 类的数据属性是共享给所有对象的
11690984
>>> print(id(p1.country)) # p1.country 的id he p2.country 是同一个
11690984
>>> print(id(p2.country))
11690984
>>>
>>> print(People.talk) # 类的函数属性
<function People.talk at 0x0000000000B1F510>
>>> print(p1.talk) # 类的函数属性是绑定（bond）到类对象的
<bound method People.talk of <__main__.People object at 0x0000000000B26550>> # 注意：p1对象的talk()方法的内存地址 和p2对象的talk()方法地址不是一个；
>>> print(p2.talk)
<bound method People.talk of <__main__.People object at 0x0000000000B265F8>>
>>>
>>> print(id(People.talk))
11662608
>>> print(id(p1.talk)) # 虽然内存地址不是一个，但是用id()查看的时候有的时候是一样的，有的时候不一样；这是有id()做了一些内部的设置；
3590536
>>> print(id(p2.talk))
3590536
>>>
>>> id(People.talk)
11662608
>>> id(p1.talk)
3590536
>>> id(p2.talk)
3590536
>>>

def id(*args, **kwargs): # real signature unknown
"""
Return the identity of an object. This is guaranteed to be unique among simultaneously existing objects.
(CPython uses the object's memory address.)
"""
pass

class People():
country = 'China'
def __init__(self,name):
self.name = name
def talk(self):
print('%s comes from %s' % (self.name,self.country)) print(type(People.country))
print(People.talk)
print(People.__init__) ---
<class 'str'>
<function People.talk at 0x000000000071C488>
<function People.__init__ at 0x000000000071C400>

一：我们定义的类的属性到底存到哪里了？有两种方式查看
dir(类名)：查出的是一个名字列表
类名.__dict__:查出的是一个字典，key为属性名，value为属性值 二：特殊的类属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

名称空间是名称(标识符)到对象的映射； 向名称空间添加名称的操作过程涉及到绑定标识符到指定对象的操作(以及给该对象的引用计数加 1 )； 改变一个名字的绑定叫做重新绑定； 删除一个名字叫做解除绑定； 类和对象，要查看自己的命名空间，用 类名.__dict__ 和 对象名.__dict__

class Chinese:
country = 'China'
def __init__(self,name,age):
self.name = name
self.age = age
def talk(self):
print('Say chinese...') p1 = Chinese('egon',18)
print(Chinese.__dict__) # 类的名称空间包含 talk 和 __init__ （函数属性）、包含 country（数据属性）；
print(p1.__dict__) # 对象的名称空间只包含 name 和 age （只有数据属性） ---
{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'Chinese' objects>, 'talk': <function Chinese.talk at 0x0000000000A1C488>, '__init__': <function Chinese.__init__ at 0x0000000000A1C400>, 'country': 'China', '__doc__': None, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>}
{'name': 'egon', 'age': 18}

class People():
country = 'China'
def __init__(self,name):
self.name = name
def talk(self):
print('%s comes from %s' % (self.name,self.country)) p1 = People('standby') # 这一步实质上就是在执行： People.__init__(p1,'standby')；然后执行People类里的__init__函数里的赋值语句： p1.name = name (即：standby)
p1.talk() ---
standby comes from China

class People():
country = 'China'
def __init__(self,name):
self.name = name
def talk(self):
print('%s comes from %s' % (self.name,self.country)) print(People.country) # 引用类的数据属性，该属性与所有对象共享；
print(People.talk) # 引用类的函数属性； ---
China
<function People.talk at 0x0000000000A6C488>

class People():
country = 'China'
def __init__(self,name):
self.name = name
def talk(self):
print('%s comes from %s' % (self.name,self.country)) print(People.country)
print(People.__dict__) # 查看类的属性字典，或者说是名称空间
print(People.__dict__['country']) ---
China
{'talk': <function People.talk at 0x0000000000B4C488>, 'country': 'China', '__init__': <function People.__init__ at 0x0000000000B4C400>, '__doc__': None, '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__module__': '__main__'}
China

class People():
country = 'China'
def __init__(self,name):
self.name = name
def talk(self):
print('%s comes from %s' % (self.name,self.country)) p1 = People('standby')
print(p1.__dict__) # 查看对象的属性字典，或者说是名称空间
print(p1.name)
print(p1.__dict__['name']) ---
{'name': 'standby'}
standby
standby

定义在类内部的变量，是所有对象共有的，id全一样 定义在类内部的函数，是绑定到所有对象的，是给对象来用，obj.func() 会把obj本身当做第一个参数出入 绑定方法：绑定到谁身上，就是给谁用的，谁来调用就会自动把自己当做第一个参数传入 print(p1.x) #先从p1.__dict__，找不到再找People.__dict__，然后是父类，再找不到就会报错；

# 统计一共实例化了多少个对象
class Chinese:
count = 0
def __init__(self,name):
Chinese.count += 1
def talk(self):
print('--->> %d' % Chinese.count) p1 = Chinese('alex')
p2 = Chinese('egon')
print(Chinese.count)
print(p1.count)
print(p2.count) ---
2
2
2

# 定义学生类
class Student:
tag = 666
def __init__(self,ID,name,age,gender):
self.id = ID
self.name = name
self.age = age
self.gender = gender
def wailking(self):
print('{} is walking...'.format(self.name)) s1 = Student(1,'egon',18,'male')
s2 = Student(2,'alex',19,'female')
print(s1.id)
print(s1.name)
print(s1.age)
print(s1.gender)
print(s1.tag)
s1.wailking()
s2.wailking() ---
1
egon
18
male
666
egon is walking...
alex is walking...

#对象之间的交互
class Egon:
camp='London'
def __init__(self,nickname,life_value=200,aggressivity=100):
self.nickname=nickname
self.life_value=life_value
self.aggressivity=aggressivity
def attack(self,enemy):
enemy.life_value-=self.aggressivity class Alex:
camp = 'Florence'
def __init__(self, nickname, life_value=100, aggressivity=200):
self.nickname = nickname
self.life_value = life_value
self.aggressivity = aggressivity
def attack(self, enemy):
enemy.life_value -= self.aggressivity e1 = Egon('egon1')
a1 = Alex('alex1')
print(a1.life_value)
e1.attack(a1) #发送了一条消息，称为向g发送了attack指令
print(a1.life_value) ---
100
0

class ParentClass1:
pass
class ParentClass2:
pass
class SubClass1(ParentClass1):
pass
class SubClass2(ParentClass1,ParentClass2):
pass print(SubClass1.__bases__) # 单继承
print(SubClass2.__bases__) # Python中允许继承多个类，即多继承 ---
(<class '__main__.ParentClass1'>,)
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

print(ParentClass1.__bases__)
print(ParentClass2.__bases__) ---
(<class 'object'>,)
(<class 'object'>,)

class Foo(object):
pass

class Bar:
pass

class Foo:
pass print(Foo.__bases__) # 类名称.__bases__ 可以查看这个类的父类是什么； Python3 里面，默认就给经典类加上了 object父类/基类 ---
(<class 'object'>,)

抽象即抽取类似或者说比较像的部分。抽象分成两个层次： 1.将奥巴马和梅西这俩对象比较像的部分抽取成类； 2.将人，猪，狗这三个类比较像的部分抽取成父类。抽象最主要的作用是划分类别（可以隔离关注点，降低复杂度）抽象只是分析和设计的过程中，一个动作或者说一种技巧，通过抽象可以得到类；

是基于抽象的结果，通过编程语言去实现它；肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构；

class Animal: # 定义父类/基类
def __init__(self,name,age,sex): # 父类初始/实例化函数
self.name = name # 初始化父类的三个数据属性
self.age = age
self.sex = sex def talk(self): # 定义父类的函数属性
print("%s 发出奇怪的声音..." % self.name)
def eat(self):
print("%s eatting..." % self.name) class People(Animal): # 定义第一个子类，继承Animal父类
def __init__(self,name,age,sex,education): # 定义子类的初始化函数（重写了子类的初始化函数），覆盖了父类/基类的初始化函数
Animal.__init__(self,name,age,sex) # 先调用父类的初始化函数初始化 name age sex 这三个共有的属性
self.education = education # 再初始化子类私有的数据属性：education
def talk(self): # 定义子类的 talk() 函数，覆盖了父类的 talk() 函数
print("%s say hello" % self.name) class Pig(Animal): # 定义第二个子类：Pig
pass
class Dog(Animal): # 定义第三个子类：Dog
pass people1 = People('standby',23,'male','Bachelor') # 初始化 People的实例；等价于：People.__init__(people1,'standby',23,'male','Bachelor')； 派生
pig1 = Pig('alex',99,'female') # 初始化 Pig实例；等价于：Pig.__init__(pig1,'alex',99,'female')
dog1 = Dog('egon',18,'male') # 初始化 Dog实例
people1.talk() # People类对象people1调用talk()方法；注意：这个talk是子类的talk，而非父类的talk；
pig1.talk() # Pig类对象pig1调用talk()方法；Pig类没有重写 talk()函数，所以这个talk就是父类的talk;
dog1.talk() ---
standby say hello
alex 发出奇怪的声音...
egon 发出奇怪的声音...

# obj.name 的搜索顺序：
#
# 1.先找 obj.__dict__
#
# 2.再找obj所归属的类的属性字典，即：类名.__dict__
#
# 3.然后再找父类的属性字典，即：父类名.__dict__
#
# 父类也找不到的话就报错：AttributeError

class Parent:
def foo(self):
print('Parent.foo')
self.bar() #s.bar()
def bar(self):
print('Parent.bar') class Sub(Parent):
def bar(self):
print('Sub.bar') sub1 = Sub()
sub1.foo() # 等价于 foo(sub1) ，所以会去执行Sub类的 bar() 函数，也是一种派生；
print(sub1.__dict__)
print(Sub.__dict__)
print(Parent.__dict__) ---
Parent.foo
Sub.bar
{}
{'__module__': '__main__', 'bar': <function Sub.bar at 0x000000000110C598>, '__doc__': None}
{'__module__': '__main__', 'foo': <function Parent.foo at 0x000000000110C488>, '__doc__': None, '__weakref__': <attribute '__weakref__' of 'Parent' objects>, '__dict__': <attribute '__dict__' of 'Parent' objects>, 'bar': <function Parent.bar at 0x000000000110C510>}

class Cat():
def __init__(self,name):
self.name = name
def eat(self):
print("%s eatting..." % self.name)
def run(self):
print("%s running..." % self.name)
def talk(self):
print('Cat 喵喵喵...') class Dog():
def __init__(self, name):
self.name = name
def eat(self):
print("%s eatting..." % self.name)
def run(self):
print("%s running..." % self.name)
def talk(self):
print('Dog 汪汪汪...') cat = Cat('cat1')
dog = Dog('dog1')
cat.eat()
cat.run()
cat.talk()
dog.eat()
dog.run()
dog.talk() ---
cat1 eatting...
cat1 running...
Cat 喵喵喵...
dog1 eatting...
dog1 running...
Dog 汪汪汪...

class Animal():
def __init__(self,name):
self.name = name
def eat(self):
print("%s eatting..." % self.name)
def run(self):
print("%s running..." % self.name) class Cat(Animal):
def talk(self):
print('Cat 喵喵喵...')
class Dog(Animal):
def talk(self):
print('Dog 汪汪汪...') cat = Cat('cat1')
dog = Dog('dog1')
cat.eat()
cat.run()
cat.talk()
dog.eat()
dog.run()
dog.talk() ---
cat1 eatting...
cat1 running...
Cat 喵喵喵...
dog1 eatting...
dog1 running...
Dog 汪汪汪...

class People():
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex class Date:
def __init__(self,year,mon,day):
self.year=year
self.mon=mon
self.day=day
def tell(self):
print('%s-%s-%s' %(self.year,self.mon,self.day)) class Teacher(People):
def __init__(self,name,age,sex,salary,year,mon,day):
# self.name=name # 第一种方式
# self.age=age
# self.sex=sex
# People(name,age,sex) # 第二种方式
People.__init__(self,name,age,sex) # 第三种方式
self.salary=salary
self.birth=Date(year,mon,day) # Date类的对象作为 Teacher类的数据属性，成为类的组合；反映的是有的关系，即老师有生日；
# 如果再有学生类、家长类等，都可以通过组合的方式实现 有 的关系，减少代码的冗余；
t=Teacher('egon',18,'male',3000,1995,12,31)
t.birth.tell() ---
1995-12-31

继承有两种用途：
一：继承基类的方法，并且做出自己的改变或者扩展（代码重用）； 二：声明某个子类兼容于某基类，定义一个接口类Interface，接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能；

class File: # 定义接口Interface类来模仿接口的概念，python中压根就没有interface关键字来定义一个接口。
def read(self): # 定接口函数read
raise TypeError('类型错误')
def write(self): # 定义接口函数write
raise TypeError('类型错误') class Txt(File): #文本，具体实现read和write
def read(self):
print('文本数据的读取方法')
def write(self):
print('文本数据的写入方法')
class Sata(File): #磁盘，具体实现read和write
def read(self):
print('硬盘数据的读取方法')
def write(self):
print('硬盘数据的写入方法')
class Process(File): # 进程，具体实现read和write
def read(self):
print('进程数据的读取方法')
def write(self):
print('进程数据的写入方法')
p=Process()
t=Txt()
d=Sata() print(isinstance(t,File)) # 判断 t/p/d 这些对象是否是 File类的实例化对象；
print(isinstance(p,File))
print(isinstance(d,File)) t.read()
p.read()
d.read() ---
True
True
True
文本数据的读取方法
进程数据的读取方法
硬盘数据的读取方法

class File:
def read(self):
raise TypeError('类型错误')
def write(self):
raise TypeError('类型错误')

接口继承实质上是要求 “做出一个良好的抽象，这个抽象规定了一个兼容接口，
使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”
——这在程序设计上，叫做归一化。归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合；
就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕
当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定；

从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。从实现角度来看，抽象类与普通类的不同之处在于：
抽象类中只能有抽象方法（没有实现功能），该类不能被实例化，只能被继承，
且子类必须实现抽象方法。

class File:
def read(self):
raise TypeError('类型错误')
def write(self):
raise TypeError('类型错误') class Process(File): # 类似于这样，Process子类继承了File父类，但是也可以不去实现File父类里的read和write方法；
def du(self): # 这样在示例话Process对象的时候也是可以的，并不报错；
print('进程数据的读取方法')
def xie(self):
print('进程数据的写入方法') p=Process()

# 抽象类； 使用abc模块强制子类必须实现父类里定义的接口函数；
import abc
class File(metaclass=abc.ABCMeta):
@abc.abstractmethod # 定义抽象方法，无需实现功能；
def read(self): # 子类必须要实现这个抽象方法；
pass
@abc.abstractmethod # 定义抽象方法，无需实现功能
def write(self): # 子类必须要实现这个抽象方法
pass class Process(File):
def xie(self): # 如果子类没有实现父类定义的接口函数，就报出异常；
pass
def du(self):
pass
p=Process() ---
Traceback (most recent call last):
File "D:/soft/work/Python_17/day07/blog.py", line 185, in <module>
p=Process()
TypeError: Can't instantiate abstract class Process with abstract methods read, write

class A:
def test(self):
print('from A')
pass
class B(A):
def test(self):
print('from B')
pass
class C(A):
def test(self):
print('from C')
pass
class D(B):
def test(self):
print('from D')
pass
class E(C):
def test(self):
print('from E')
pass
class H(A):
def test(self):
print('from H')
pass
class F(D,E,H):
def test(self):
print('from F')
pass
f=F()
f.test()
print(F.mro()) # 可以通过 子类.mro() 的形式查看继承的顺序 ---
from F
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.H'>, <class '__main__.A'>, <class 'object'>]

# 经典类：深度优先，F->D->B->A->E->C->H
# 新式类：广度优先，F->D->B->E->C->H->A （Python3 都是新式类）

class Foo1:
def test(self):
print('from foo1.test')
pass
class Foo2:
def test(self):
print('from foo2.test')
class Bar(Foo1,Foo2):
def test(self):
Foo1.test(self) # 在子类中，使用 父类名.父类函数名 的方法调用父类；这种跟父类的耦合性太强，如果父类名字改了，就不能调用了；
Foo2.test(self)
print('bar')
print(Bar.mro())
b=Bar()
b.test() ---
[<class '__main__.Bar'>, <class '__main__.Foo1'>, <class '__main__.Foo2'>, <class 'object'>]
from foo1.test
from foo2.test
bar

class Foo1:
def test(self):
print('from foo1.test')
pass
class Foo2:
def test(self):
print('from foo2.test')
class Bar(Foo1,Foo2):
def test(self):
super().test() # 通过super()替代父类的名字；
print('bar')
print(Bar.mro())
b=Bar()
b.test() ---
[<class '__main__.Bar'>, <class '__main__.Foo1'>, <class '__main__.Foo2'>, <class 'object'>]
from foo1.test
bar

class Foo1:
pass
class Foo2:
def test(self):
print('from foo2.test')
class Bar(Foo1,Foo2):
def test(self):
# Foo1.test(self)
# Foo2.test(self)
super().test() # 继承了2个父类，如果第一个父类没有要调用的名字，就会去找第二个父类；
print('bar')
print(Bar.mro()) # Bar.mro() 等价于 Bar.__mro__
b=Bar()
b.test() ---
[<class '__main__.Bar'>, <class '__main__.Foo1'>, <class '__main__.Foo2'>, <class 'object'>]
from foo2.test
bar

import abc
class Animal(metaclass=abc.ABCMeta): # 同一类事物：动物
@abc.abstractmethod
def talk(self):
pass class Cat(Animal): # 动物形态之一：猫
def talk(self):
print('喵喵喵')
class Dog(Animal): # 动物形态之二：狗
def talk(self):
print('汪汪汪')
class Pig(Animal): # 动物形态之三：诸
def talk(self):
print('哼哼哼')

在面向对象方法中一般是这样表述多态性：
向不同的对象发送同一条消息（obj.func():是调用了obj的方法func，又称为向obj发送了一条消息func）
不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

import abc
class Animal(metaclass=abc.ABCMeta):
@abc.abstractmethod
def talk(self):
pass class Cat(Animal):
def talk(self):
print('喵喵喵')
class Dog(Animal):
def talk(self):
print('汪汪汪')
class Pig(Animal):
def talk(self):
print('哼哼哼') cat1 = Cat()
dog1 = Dog()
pig1 = Pig() def func(x):
x.talk() func(cat1)
func(dog1)
func(pig1) ---
喵喵喵
汪汪汪
哼哼哼

1.增加了程序的灵活性
以不变应万变，不论对象如何变化，使用者都用同一种方式去调用，如func(animal)2.增加了程序的可扩展性

封装其实分为两个层面，但无论哪种层面的封装，都要对外界提供好访问你内部隐藏内容的接口；接口可以理解为入口，有了这个入口，使用者无需且不能够直接访问到内部隐藏的细节，只能走接口；并且我们可以在接口的实现上附加更多的处理逻辑，从而严格控制使用者的访问；

class demo():
x = 10
def test(self):
print('from demo -> test')
d = demo()
print(demo.x)
print(d.x) ---
10
10

在python中用双下划线开头的方式实现隐藏属性（设置成私有的）；类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式；类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果；这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的；在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的；对于这一层面的封装（隐藏），我们需要在类中定义一个函数（接口函数）在它内部访问被隐藏的属性，然后外部就可以使用了；

class demo():
x = 10
def test(self):
print('from demo -> test') print(demo.x)
print(demo.__dict__)
print(demo.__dict__['x']) ---
10
{'__dict__': <attribute '__dict__' of 'demo' objects>, '__weakref__': <attribute '__weakref__' of 'demo' objects>, 'test': <function demo.test at 0x00000000007CC400>, '__module__': '__main__', '__doc__': None, 'x': 10}
10

class demo():
__x = 10
def test(self):
print('from demo -> test') # print(demo.__x) # 报错：AttributeError: type object 'demo' has no attribute '__x'
print(demo.__dict__)
print(demo.__dict__['_demo__x']) ---
{'test': <function demo.test at 0x000000000109C400>, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'demo' objects>, '_demo__x': 10, '__weakref__': <attribute '__weakref__' of 'demo' objects>, '__doc__': None}
10

class Parent():
def foo(self):
print('from Parent.foo')
self.bar() # 调用的是子类的方法
def bar(self):
print('from Parent.bar') class Son(Parent):
def bar(self):
print('from Son.bar') s = Son()
s.foo() ---
from Parent.foo
from Son.bar

class Parent():
def foo(self):
print('from Parent.foo')
self.__bar() # 只有在类内部才可以通过 .__bar() 访问到；因为这行在定义的阶段就会变形成： self._Parent__bar()
def __bar(self): # 调用的是父类的方法 ; 定义阶段就会变形成：def _Parent__bar()
print('from Parent.bar') class Son(Parent):
def __bar(self):
print('from Son.bar') s = Son()
s.foo() ---
from Parent.foo
from Parent.bar

这种机制也并没有真正意义上限制我们从外部直接访问属性；
知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N；变形的过程只在类的定义时发生一次；在定义后的赋值操作，不会变形；在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的；

class Parent():
def foo(self):
print('from Parent.foo')
self.__bar() # 在定义的时候就会变形成： self._Parent__bar()
def __bar(self): # def _Parent__bar()
print('from Parent.bar') class Son(Parent):
def __bar(self): # 在定义的时候就会变形：def _Son__bar()
print('from Son.bar') s = Son()
print(s.__dict__)
print(Son.__dict__)
print(Parent.__dict__)
s._Son__bar()
Son.__dict__['_Son__bar'](s)
s._Parent__bar()
Parent.__dict__['_Parent__bar'](s) ---
{}
{'_Son__bar': <function Son.__bar at 0x000000000110C510>, '__module__': '__main__', '__doc__': None}
{'__weakref__': <attribute '__weakref__' of 'Parent' objects>, '__dict__': <attribute '__dict__' of 'Parent' objects>, '_Parent__bar': <function Parent.__bar at 0x000000000110C488>, '__module__': '__main__', 'foo': <function Parent.foo at 0x000000000110C400>, '__doc__': None}
from Son.bar
from Son.bar
from Parent.bar
from Parent.bar

# 私有属性的查看和更改 + raise使用
class People():
def __init__(self,name,age):
self.__name = name
self.__age = age def get_info(self):
print('Name is %s, age is %s' % (self.__name,self.__age)) def set_info(self,name,age):
if not isinstance(name,str): # Python没有类型检查一说，所以需要自己提供类型检查；
raise TypeError('名字必须是字符串') # 如果用户输入的名字不是 str 类型就抛出类型错误；
if not isinstance(age,int):
raise TypeError('年龄必须是整数') # 如果用户输入的年龄不是 int 类型就抛出类型错误；
self.__name = name
self.__age = age p1 = People('Alex',18)
p1.get_info()
p1.set_info('egon',20)
p1.get_info()
p1.set_info('standby',21)
p1.get_info() ---
Name is Alex, age is 18
Name is egon, age is 20
Name is standby, age is 21

装饰器本身可以是任意可调用对象（包括函数、类...）

class Foo():
def test(self):
print('from Foo.test')
# test = property(test) f = Foo()
f.test() ---
from Foo.test

class Foo():
def test(self):
print('from Foo.test')
test = property(test) # property是一个类 f = Foo()
f.test # 不用加 () 执行 ---
from Foo.test

class Foo():
@property # 属性装饰器
def test(self):
print('from Foo.test') f = Foo()
f.test # 不用加 () 执行 ---
from Foo.test

import math
class Circle():
def __init__(self,radius):
self.radius = radius
@property
def perimeter(self):
return math.pi * self.radius * 2
@property
def area(self):
return math.pi * self.radius ** 2 c = Circle(5)
print(c.perimeter) # 可以向访问数据属性一样去访问perimeter，会触发一个函数的执行，动态计算出一个值；
print(c.area) # 同上 ---
31.41592653589793
78.53981633974483

class People():
def __init__(self,name,permmission=False):
self.__name = name
self.permmission = permmission @property
def name(self): # 属性装饰器，让对象可以像访问数据属性一样去访问name，实际上访问的是 _Peopel__name
return self.__name # 可以理解为 _People__name 的get方法
@name.setter
def name(self,name): # 设置针对 _People__name 的set方法
if not isinstance(name,str):
raise TypeError('名字必须是字符串类型')
self.__name = name
@name.deleter
def name(self): # 设置 _People__name 的del方法
if not self.permmission:
raise PermissionError('不允许的操作！')
del self.__name p1 = People('standby')
print(p1.name)
p1.name = 'alex'
print(p1.name)
del p1.name ---
standby
alex
Traceback (most recent call last):
File "D:/soft/work/Python_17/day07/blog.py", line 326, in <module>
del p1.name
File "D:/soft/work/Python_17/day07/blog.py", line 319, in name
raise PermissionError('不允许的操作！')
PermissionError: 不允许的操作！

class People():
def __init__(self,name,permmission=False):
self.__name = name
self.permmission = permmission @property
def name(self):
return self.__name
@name.setter
def name(self,name):
if not isinstance(name,str):
raise TypeError('名字必须是字符串类型')
self.__name = name
@name.deleter
def name(self):
if not self.permmission:
raise PermissionError('不允许的操作！')
del self.__name p1 = People('standby')
print(p1.name)
p1.name = 'alex'
print(p1.name)
p1.permmission = True # 设置删除权限为 True
del p1.name # 删除操作
print(p1.name) ---
standby
alex
Traceback (most recent call last):
File "D:/soft/work/Python_17/day07/blog.py", line 328, in <module>
print(p1.name)
File "D:/soft/work/Python_17/day07/blog.py", line 310, in name
return self.__name
AttributeError: 'People' object has no attribute '_People__name'

class People():
def __init__(self,name,permmission=False):
self.__name = name
self.permmission = permmission def get_name(self):
return self.__name
def set_name(self,name):
if not isinstance(name,str):
raise TypeError('名字必须是字符串类型')
self.__name = name
def del_name(self):
if not self.permmission:
raise PermissionError('不允许的操作！')
del self.__name
name = property(get_name,set_name,del_name) # 按照顺序； 与上面的例子是同样的效果； p1 = People('standby')
print(p1.name)
p1.name = 'alex'
print(p1.name)
p1.permmission = True
del p1.name
print(p1.name)

于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。

class Foo():
def test1(self):
print('test1, ',self) f = Foo()
print(Foo.test1) # test1 对于类 Foo来说就是一个函数
print(f.test1) # 对于对象f来说就是一个 绑定方法（bound method）
f.test1() # test1函数绑定到对象 f上，f 在调用的时候就会自动把自己当做第一个参数传进去； ---
<function Foo.test1 at 0x00000000010CC400>
<bound method Foo.test1 of <__main__.Foo object at 0x00000000010CA908>>
test1, <__main__.Foo object at 0x00000000010CA908>

class Foo():
def test1(): # 类Foo中定义的函数没有参数
print('test1, ') f = Foo()
f.test1() # 根据绑定方法的定义，对象 f 在调用的时候就会把自己当做第一个参数传进去；所以会报错； ---
Traceback (most recent call last):
File "D:/soft/work/Python_17/day07/blog.py", line 396, in <module>
f.test1()
TypeError: test1() takes 0 positional arguments but 1 was given

class Foo:
@classmethod # 定义绑定到类的方法
def test(cls):
print(cls) print(Foo)
Foo.test() # 绑定到类的方法，类在调用的时候就会把自己当做第一个参数传进去； ---
<class '__main__.Foo'>
<class '__main__.Foo'>

class Foo:
@staticmethod
def test():
print('test...') f = Foo()
print(Foo)
print(f)
Foo.test()
f.test()
print(Foo.test)
print(f.test)
print(Foo.__dict__) ---
<class '__main__.Foo'>
<__main__.Foo object at 0x00000000010F2390>
test...
test...
<function Foo.test at 0x00000000010EC400>
<function Foo.test at 0x00000000010EC400>
{'test': <staticmethod object at 0x00000000010EA860>, '__doc__': None, '__module__': '__main__', '__dict__': <attribute '__dict__' of 'Foo' objects>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>}

class Foo:
def test1(self):
pass
@classmethod
def test2(cls):
print(cls)
@staticmethod
def test3():
pass f=Foo()
print(f.test1) # 绑定到对象的方法
print(Foo.test2) # 绑定到类的方法
print(Foo.test3) # 谁也不绑定的方法，只是类的函数属性
print(f.test3) # 谁也不绑定的方法，只是类的函数属性 ---
<bound method Foo.test1 of <__main__.Foo object at 0x0000000000A32470>>
<bound method Foo.test2 of <class '__main__.Foo'>>
<function Foo.test3 at 0x0000000000A2C510>
<function Foo.test3 at 0x0000000000A2C510>

class MySQL:
def __init__(self,host,port):
self.host=host
self.port=port
print('conneting...')
def select(self): #绑定到对象的方法
print(self)
print('select function') conn=MySQL('192.168.1.3',3306)
conn.select() ---
conneting...
<__main__.MySQL object at 0x0000000000B2A860>
select function

# settings.py
HOST='127.0.0.1'
PORT=3306 # 执行文件
import settings
class MySQL:
def __init__(self,host,port):
self.host=host
self.port=port
print('conneting...')
@classmethod
def from_conf(cls):
return cls(settings.HOST,settings.PORT) # 等价于 MySQL('127.0.0.1',3306)，即间接调用类的 __init__()函数
def select(self): #绑定到对象的方法
print(self)
print('select function') conn = MySQL.from_conf() # 等价于把 MySQL当做第一个参数传给类的方法 from_conf()
conn.select() ---
conneting...
<__main__.MySQL object at 0x00000000010E2470>
select function

time.time()

time.clock()

# 生成一个唯一的id
import time, hashlib def create_id():
m = hashlib.md5(str(time.time()).encode('utf-8'))
return m.hexdigest()
print(create_id())
print(create_id())
print(create_id()) ---
23e5f91da003f794b3e0b35681f0e91e
23e5f91da003f794b3e0b35681f0e91e
23e5f91da003f794b3e0b35681f0e91e

import time, hashlib def create_id():
m = hashlib.md5(str(time.clock()).encode('utf-8'))
return m.hexdigest()
print(create_id())
print(create_id())
print(create_id()) ---
362dc18e003ee03d1c64f35aef957966
0069e3d295dd493495db0adfd8008df1
31dded025da89a196a05a40db3d50e5f

# settings.py
HOST='127.0.0.1'
PORT=3306 # 执行文件
import hashlib
import time
import settings
class MySQL:
def __init__(self,host,port):
self.id=self.create_id()
self.host=host
self.port=port
print('conneting...') @staticmethod
def create_id(): #非绑定方法，就是类中的普通工具包
m=hashlib.md5(str(time.clock()).encode('utf-8'))
return m.hexdigest()
@classmethod
def from_conf(cls):
return cls(settings.HOST,settings.PORT) #MySQL('127.0.0.1',3306)
def select(self): #绑定到对象的方法
print('%s --> select function' % self.id) conn1=MySQL.from_conf()
conn2=MySQL.from_conf()
conn3=MySQL.from_conf()
conn4=MySQL.from_conf()
conn1.select()
conn2.select()
conn3.select()
conn4.select() ---
conneting...
conneting...
conneting...
conneting...
362dc18e003ee03d1c64f35aef957966 --> select function
7067177e6221914604cc0711d39524b2 --> select function
daef6092a8bfdbed7c6ebae5d8991c50 --> select function
e035b6f811ff8e7604f25d2f637fa08d --> select function

class Foo():
def __init__(self):
print('Foo.__init__ function...')
def __str__(self): # 重写 __str__ 函数
return 'Foo.__str__ function...' f = Foo() # 等价于：Foo.__init__(f)
print(f)
print(f.__str__())
print(Foo.__str__) ---
Foo.__init__ function...
Foo.__str__ function...
Foo.__str__ function...
<function Foo.__str__ at 0x00000000006EC488>

class People:
def __init__(self,name,age):
self.name=name
self.age=age
def __str__(self):
# print('run __str__')
return 'name:%s age:%s' %(self.name,self.age) p1=People('egon1',18)
p2=People('egon2',28)
print(p1)
print(p2) ---
name:egon1 age:18
name:egon2 age:28

import settings
class MySql():
def __init__(self,host,port):
self.host = host
self.port = port
print('Connecting...')
@staticmethod
def from_conf():
return MySql(settings.HOST, settings.PORT)
def __str__(self): # 重写 __str__ 函数
print('from MySql.__str__()')
return ('MySql...')
class Mariadb(MySql):
def __str__(self):
print('from Mariadb.__str__()')
return 'Host: %s, Port: %s' % (self.host, self.port) conn = Mariadb.from_conf() # 子类没有 from_conf() 函数，所以去父类找，父类的from_conf是一个staticmethod，并且返回了一个 MySQL对象
print(conn) # 所以conn实际上是父类的对象，即执行父类里的 __str__函数

---
Connecting...
from MySql.__str__()
MySql...

import settings
class MySql():
def __init__(self,host,port):
self.host = host
self.port = port
print('Connecting...')
@classmethod
def from_conf(cls):
return cls(settings.HOST,settings.PORT)
def __str__(self): # 重写 __str__ 函数
print('from MySql.__str__()')
return ('MySql...')
class Mariadb(MySql):
def __str__(self):
print('from Mariadb.__str__()')
return 'Host: %s, Port: %s' % (self.host, self.port) conn = Mariadb.from_conf() # 继承父类的from_conf函数，但父类的from_conf是一个绑定到类的方法，是子类在调用，所以传进去的参数是子类；
print(conn) # 所以conn是子类的对象，故执行的是子类的 __str__函数； ---
Connecting...
from Mariadb.__str__()
Host: 127.0.0.1, Port: 3306

练习2（学生自己写）：定义MySQL类1.对象有id、host、port三个属性2.定义工具create_id，在实例化时为每个对象随机生成id，保证id唯一3.提供两种实例化方式，方式一：用户传入host和port 方式二：从配置文件中读取host和port进行实例化4.为对象定制方法，save和get，save能自动将对象序列化到文件中，文件名为id号，文件路径为配置文件中DB_PATH;get方法用来从文件中反序列化出对象

# settings
HOST = '127.0.0.1'
PORT = 3306
DB_PATH = r"D:\soft\work\Python_17\day07\MySql\account" # MySql.py
import settings
import pickle
import os,time,hashlib class MySql():
def __init__(self,host,port):
self.id = self.create_id()
self.host = host
self.port = port
print('Connecting...')
@classmethod
def from_conf(cls):
return cls(settings.HOST,settings.PORT)
@staticmethod
def create_id():
m = hashlib.md5(str(time.clock()).encode('utf-8'))
return m.hexdigest()
def save(self):
file_path = r"%s%s%s" % (settings.DB_PATH, os.sep, self.id)
pickle.dump(self,open(file_path,'wb'))
def get(self):
file_path = r"%s%s%s" % (settings.DB_PATH, os.sep, self.id)
return pickle.load(open(file_path,'rb')) conn1 = MySql('10.0.0.2','')
conn2 = MySql.from_conf()
print(conn1,conn1.id,conn1.host,conn1.port)
print(conn2,conn2.id,conn2.host,conn2.port)
conn1.save()
conn2.save()
res1 = conn1.get()
res2 = conn2.get()
print(res1,res1.id,res1.host,res1.port)
print(res2,res2.id,res2.host,res2.port) ---
Connecting...
Connecting...
<__main__.MySql object at 0x00000000011B8CC0> 437656776fa5cd96c6a670bef33e81e4 10.0.0.2 22
<__main__.MySql object at 0x00000000011AC208> 5b18e65260ecafe8aa8d34881721f166 127.0.0.1 3306
<__main__.MySql object at 0x00000000011AC668> 437656776fa5cd96c6a670bef33e81e4 10.0.0.2 22
<__main__.MySql object at 0x00000000011AC3C8> 5b18e65260ecafe8aa8d34881721f166 127.0.0.1 3306

class Chinese:
country='China'
def __init__(self,name,age):
self.name=name
self.age=age print(Chinese.country) # Chinese.__dict__['country'] p=Chinese('egon',18)
print(p.name) # p.__dict__['name'] ---
China
egon

import sys
class Chinese:
country='China'
def __init__(self,name,age):
self.name=name
self.age=age m = sys.modules[__name__] # 获取并打印当前模块
print(m)
if hasattr(m,'Chinese'): # 判断当前模块是否包含 'Chinese' 名字
res = getattr(m,'Chinese') # 有的话就获取该属性；
print(res)
obj = res('standby','') # 获取的是一个类，所以就可以实例化一个对象
print(obj.name,obj.age) # 打印该对象的名字和年纪 ---
<module '__main__' from 'D:/soft/work/Python_17/day07/blog.py'>
<class '__main__.Chinese'>
standby 23

class FtpCLient:
def __init__(self,host):
self.host=host
print('Connecting...')
def run(self):
while True:
inp=input('>>>: ').strip()
inp_l=inp.split()
if 'Q' == inp_l[0].upper():
print('Bye...')
break
if hasattr(self,inp_l[0]):
func=getattr(self,inp_l[0])
func(inp_l)
def get(self,arg):
print('download file',arg[1])
def put(self,arg):
print('Upload file: %s' % arg[1]) f=FtpCLient('10.0.0.9')
f.run()

p.name # 本质就是 p.__dict__['name']getattr(p,'name') # 本质就是 p.__dict__['name']

自省也称作反射，这个性质展示了某对象是如何在运行期取得自身信息的。如果传一个对象给你,你可以查出它有什么能力,这是一项强大的特性。如果Python不支持某种形式的自省功能,dir和type内建函数,将很难正常工作。还有那些特殊属性,像__dict__,__name__及__doc__

hasattr(object,name)：用于判断一个对象里中是否存在name这一特性．setattr(object, name, value):该函数给对象中的属性赋值，该属性若不存在，则会在对象里创建新的属性getattr(object, name[, default]),object为对象名，name为对象属性（必须是字符串），
default为name属性不存在时指定的返回内容（可以是字符串，也可以是部分指令），
若对象中存在该属性，则函数返回object.name，
否则返回default中的内容，若省略default,则返回 AttributeError．delattr(object, name):删除指定对象的属性，可以配合hasattr使用

delattr

hasattr

getattr

class Foo(object):
def __init__(self):
self.name = 'abc' def func(self):
return 'ok'
obj = Foo()
ret = getattr(obj, 'func') # 获取的是个对象
print(type(ret),ret)
res = ret()
print(res)
ret = hasattr(obj, 'func') # 因为有func方法所以返回True
print(ret)
print(obj.name)
ret = setattr(obj, 'name', 'standby')
print(obj.name)
delattr(obj, 'name') # 删除指定属性
# print(obj.name) # 报错：AttributeError: 'Foo' object has no attribute 'name'---
<class 'method'> <bound method Foo.func of <__main__.Foo object at 0x00000000010D34E0>>
ok
True
abc
standby

#!/usr/bin/python
# -*- coding:utf-8 -*-# class Foo:
# pass
#
# class Bar(Foo):
# pass
#
# print(issubclass(Bar,Foo))#反射
class Chinese:
country='China'
def __init__(self,name,age):
self.name=name
self.age=age# print(Chinese.county) #Chinese.__dict__['country']p=Chinese('egon',18)
# print(p.name) #p.__dict__['name']
#
# print(hasattr(p,'name')) # 判断对象p是否有name属性
# print(hasattr(Chinese,'country')) # 判断类Chinese是否有country属性# p.x=1
# print(p.__dict__)
# print(p.x)
# setattr(p,'x',1231231231231) # 设置对象p的x属性的值为 1231231231231
# print(p.__dict__)
# print(p.x)# print(getattr(p,'x','not exist'))
# print(getattr(p,'name','not exist')) # 获取对象p的name属性，如果不存在则返回 'not exist'# setattr(p,'x',123123123123123)
# if hasattr(p,'x'):
# res=getattr(p,'x')
# print(res)# print(Chinese.country)
# delattr(Chinese,'country') # 删除类的country属性
# print(Chinese.country)
# print(p.country)
# p1=Chinese('aaaaa',18)
# print(p1.country)# import sys
# m=sys.modules[__name__]
# # print(m)
#
# if hasattr(m,'Chinese'):
# res=getattr(m,'Chinese')
# # print(res)
# obj=res('egon',18)
# print(obj.name)p.name #p.__dict__['name']
getattr(p,'name') #p.__dict__['name']

import sys

以字符串的形式导入对应模块：
m = __import__('sys')
print(m) import importlib
importlib.import_module('sys')

os.sepos.listdiros.walkos.getcwdos.cpu_count()os.path.abspath()
os.path.abspath(__file__)os.path.basename()os.path.dirname()os.path.join()os.path.normpath()sys.models

# !/usr/bin/python3.4
# -*- coding: utf-8 -*-import os# 字节bytes转化kb\m\g
def formatSize(bytes):
try:
bytes = float(bytes)
kb = bytes / 1024
except:
print("传入的字节格式不对")
return "Error"
if kb >= 1024:
M = kb / 1024
if M >= 1024:
G = M / 1024
return "%fG" % (G)
else:
return "%fM" % (M)
else:
return "%fkb" % (kb)# 获取文件大小
def getDocSize(path):
try:
size = os.path.getsize(path)
return formatSize(size)
except Exception as err:
print(err)
# 获取文件夹大小
def getFileSize(path):
sumsize = 0
try:
filename = os.walk(path) # 注意os.walk()的返回值
for root, dirs, files in filename:
for fle in files:
size = os.path.getsize(path + fle)
sumsize += size
return formatSize(sumsize)
except Exception as err:
print(err)if __name__ == "__main__":
print(getDocSize("../detailhtml/20161103112313.html"))
# 1006.142578kb
print(getFileSize("../data/"))
# 111.856756M

import os print(os.getcwd()) # 获取当前路径
res = os.listdir(os.getcwd()) # 获取当前路径下所有的文件
print(res) ---
D:\soft\work\Python_17\day07
['blog.py', 'exercise.py', 'homework', 'id.txt', 'MySql', 's1.py', 'settings.py', '__pycache__', '上节课回顾', '本节内容']

'''
关联：一对多、多对多
school course 一对多
course classes 一对多
classes student 一对多course teacher 多对多 可以用 中间类 的形式实现多对多学校
课程 -> 学校
班级 -> 学校 -> 课程学生 <-> 班级
老师 <-> 课程 （关联）
'''

代码结构

#!/usr/bin/python
# -*- coding:utf-8 -*-
import os,sys
parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(parent_dir)
from core.models import *
from core.services import admin,student,teacher
from conf.settings import *if __name__ == '__main__':
print('+++++++++++++++++++++++++++++++')
print('+Welcome to CourseSelected SYS+')
print('+++++++++++++++++++++++++++++++')
role_selected = {
'0':admin.initializate,
'1':student.login,
'2':teacher.login,
'3':admin.login,
'4':exit
}
while True:
print(WELCOME_INFO)
option = input('Select your role and begin >>>\t').strip()
if option not in role_selected:
continue
role_selected[option]()

#!/usr/bin/python
# -*- coding:utf-8 -*-'''
关联：一对多、多对多school course 一对多
course classes 一对多
classes student 一对多course teacher 多对多 可以用 中间类 的形式实现多对多学校
课程 -> 学校
班级 -> 学校 -> 课程学生 <-> 班级
老师 <-> 课程 （关联）
'''import os,sys,time,hashlib,pickle
parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(parent_dir)
from conf import settingsclass BaseModel():
def save(self):
file_path = r"%s%s%s" % (self.db_path,os.sep,self.uid.uid)
pickle.dump(self,open(file_path,'wb'))
@classmethod
def get_all_obj_list(cls):
# base_path = settings.PATH_DICT[cls.__name__]
base_path = cls.db_path
ret = []
for file_name in os.listdir(base_path):
path = r'%s%s%s' % (base_path,os.sep,file_name)
obj = pickle.load(open(path,'rb'))
ret.append(obj)
return retclass UUID():
def __init__(self,db_path):
self.uid = UUID.create_id()
self.db_path = db_path
def get_obj_by_uid(self):
# path = r'%s%s%s' % (self.db_path,os.sep,self.uid)
file_path = os.path.join(self.db_path,self.uid)
return pickle.load(open(file_path,'rb'))
@staticmethod
def create_id():
m = hashlib.md5(str(time.clock()).encode('utf-8'))
return m.hexdigest()class Admin(BaseModel):
db_path = settings.ADMIN_DB
def __init__(self,name,password):
self.uid = UUID(self.db_path)
self.name = name
self.password = password
self.create_time = time.strftime('%Y-%m-%d %X')class School(BaseModel):
db_path = settings.SCHOOL_DB
def __init__(self,name,addr):
self.uid = UUID(self.db_path) # 返回的是一个UUID类的对象
self.name = name
self.addr = addr
self.__income = 0 # 学校的收入，应该是隐私的
self.create_time = time.strftime('%Y-%m-%d %X')
def __str__(self):
return self.nameclass Course(BaseModel):
db_path = settings.COURSE_DB
def __init__(self,name,price,period,school_uid):
self.uid = UUID(self.db_path)
self.name = name
self.price = price
self.period = period
self.school_uid = school_uid
self.create_time = time.strftime('%Y-%m-%d %X')
def __str__(self):
return self.nameclass Classes(BaseModel):
db_path = settings.CLASSES_DB
def __init__(self,name,sch_uid,cour_uid):
self.uid = UUID(self.db_path)
self.name = name
self.sch_uid = sch_uid
self.cour_uid = cour_uid
self.create_time = time.strftime('%Y-%m-%d %X')
def __str__(self):
return self.nameclass Teacher(BaseModel):
db_path = settings.TEACHER_DB
def __init__(self,name,password):
self.uid = UUID(self.db_path)
self.name = name
self.password = password
self.__account = 0 # 老师的账户信息，应该是隐私的
self.create_time = time.strftime('%Y-%m-%d %X')
def __str__(self):
return self.name# 老师 和 课程 是多对多的关系
class Course_to_teacher(BaseModel):
db_path = settings.COURSE_TO_TEACHER_DB
def __init__(self,course_uid,teacher_uid):
self.uid = UUID(self.db_path)
self.course_uid = course_uid
self.teacher_uid = teacher_uidclass Student(BaseModel):
db_path = settings.STUDENT_DB
def __init__(self,name,password,class_uid,qq):
self.uid = UUID(self.db_path)
self.name = name
self.password = password
self.class_uid = class_uid
self.qq = qq
self.create_time = time.strftime('%Y-%m-%d %X')
def __str__(self):
return self.name

#!/usr/bin/python
# -*- coding:utf-8 -*-__all__ = ['School','Corese','Teacher','Student']

#!/usr/bin/python
# -*- coding:utf-8 -*-import os
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
SCHOOL_DB = os.path.join(BASE_DIR,'db','school')
COURSE_DB = os.path.join(BASE_DIR,'db','course')
TEACHER_DB = os.path.join(BASE_DIR,'db','teacher')
ADMIN_DB = os.path.join(BASE_DIR,'db','admin')
CLASSES_DB = os.path.join(BASE_DIR,'db','class')
STUDENT_DB = os.path.join(BASE_DIR,'db','student')
COURSE_TO_TEACHER_DB = os.path.join(BASE_DIR,'db','course_to_teacher')WELCOME_INFO = '''
0.initializate
1.student
2.teacher
3.admin
4.exit
'''
ADMIN_INFO = '''
0.查看可操作选项
1.创建学校
2.查看已有学校
3.创建课程
4.查看已有课程
5.创建班级
6.查看已有班级
7.创建老师
8.查看已有老师
9.关联老师与课程
10.查看老师与课程的关联关系
11.创建学生
12.查看已有学生
13.退出
'''
STUDENT_INFO = '''
0.更改密码
1.查看所属课程及班级信息
2.查看任课教师
3.退出
'''
TEACHER_INFO = '''
0.更改密码
1.查看教授的课程
2.查看指定班级的学生名单
3.退出
'''

pickle序列化之后存储的目录结构

services

'''
path = r'D:\soft\work\Python_17\day07\homework\Course\core\services'
选课系统有三个角色：
1.学生
2.老师
3.管理员这个services目录就是存放这三个角色的主要业务逻辑
'''

#!/usr/bin/python
# -*- coding:utf-8 -*-from conf.settings import ADMIN_DB,ADMIN_INFO
from core.models import *def initializate():
print('Start to create admin account...')
name = input('Input name>>>\t').strip()
password = input('Input password>>>\t').strip()
if not isinstance(name,str):
print('Admin name must be a str obj.')
return
admin_obj_list = Admin.get_all_obj_list()
admin_obj_name_list = []
for obj in admin_obj_list:
if obj.name not in admin_obj_name_list:
admin_obj_name_list.append(obj.name)
if name in admin_obj_name_list:
print('Admin name: %s already exist.' % name)
return
admin_obj = Admin(name,password)
admin_obj.save()
print('\033[46m初始化管理员成功！\033[0m')def login():
name = input('姓名>>>\t').strip()
password = input('密码>>>\t').strip()
user_obj_list = Admin.get_all_obj_list()
for user_obj in user_obj_list:
if name == user_obj.name:
if password == user_obj.password:
print('管理员：%s 登录成功！' % name)
break
else:
print('用户名或密码错误！')
return
# do_something...
admin_func()def show_notice():
print(ADMIN_INFO)def create_school():
name = input('请输入学校名>>>\t').strip()
addr = input('请输入学校地址>>>\t').strip()
school_obj_list = School.get_all_obj_list()
for school_obj in school_obj_list:
if name == school_obj.name and addr == school_obj.addr:
print('\033[41m%s-%s已经存在，不能重复创建！\033[0m' % (name,addr))
return
school_obj = School(name,addr)
school_obj.save()
print('\033[46m学校创建成功！\033[0m')
def show_school_list():
school_obj_list = School.get_all_obj_list()
print('+++++++++++++++++++++++++++')
for school in school_obj_list:
out_str = '学校名字：%s'.ljust(10,' ') % school.name + '地址：%s'.ljust(10,' ') % school.addr + '成立时间：%s' % school.create_time
print(out_str)
print('+++++++++++++++++++++++++++')
def create_course():
school_obj_list = School.get_all_obj_list()
print('+++++++++++++++++++++++++++')
for index, sch in enumerate(school_obj_list, 1):
print('%s\t%s - %s' % (index, sch.name, sch.addr))
print('+++++++++++++++++++++++++++')
school_index = input('请输入课程所属的学校id>>>\t').strip()
for index, sch in enumerate(school_obj_list, 1):
if index == int(school_index):
school_uid = sch.uid
course_name = input('请输入课程名字>>>\t').strip()
course_price = input('请输入课程价格>>>\t').strip()
course_period = input('请输入课程周期>>>\t').strip()
course_obj_list = Course.get_all_obj_list()
for course_obj in course_obj_list:
if course_name == course_obj.name:
print('\033[41m课程：%s 已经存在，不能重复创建！\033[0m' % course_name)
return
course_obj = Course(course_name,course_price,course_period,school_uid)
course_obj.save()
print('\033[46m课程创建成功！\033[0m')
def show_course_list():
course_obj_list = Course.get_all_obj_list()
print('+++++++++++++++++++++++++++')
for course in course_obj_list:
out_str = '课程名字：%s, 价格：%s, 周期：%s, 归属：%s - %s, 创建时间：%s' % \
(course.name,course.price,course.period,course.school_uid.get_obj_by_uid().name,course.school_uid.get_obj_by_uid().addr,course.create_time)
print(out_str)
print('+++++++++++++++++++++++++++')
def create_teacher():
name = input('请输入老师姓名>>>\t').strip()
password = input('设置老师登录默认密码>>>\t').strip()
teacher_obj_list = Teacher.get_all_obj_list()
for teacher_obj in teacher_obj_list:
if name == teacher_obj.name:
print('\033[41m老师：%s 已经存在，不能重复创建！\033[0m' % name)
return
teacher_obj = Teacher(name,password)
teacher_obj.save()
print('\033[46m老师创建成功！\033[0m')def show_teacher_list():
teacher_obj_list = Teacher.get_all_obj_list()
print('+++++++++++++++++++++++++++')
for teacher in teacher_obj_list:
print('教师名字：%s\t创建时间：%s' % (teacher.name,teacher.create_time))
print('+++++++++++++++++++++++++++')
def course_to_teacher():
course_obj_list = Course.get_all_obj_list()
print('+++++++++++++++++++++++++++')
for index, course in enumerate(course_obj_list, 1):
print('%s\t%s' % (index, course.name))
print('+++++++++++++++++++++++++++')
course_index = input('请输入要进行关联的课程id>>>\t').strip()
for index, course in enumerate(course_obj_list, 1):
if index == int(course_index):
course_uid = course.uid
teacher_obj_list = Teacher.get_all_obj_list()
print('+++++++++++++++++++++++++++')
for index, teacher in enumerate(teacher_obj_list, 1):
print('%s\t%s' % (index, teacher.name))
print('+++++++++++++++++++++++++++')
teacher_index = input('请输入要进行关联的老师id>>>\t').strip()
for index, teacher in enumerate(teacher_obj_list, 1):
if index == int(teacher_index):
teacher_uid = teacher.uid
course_to_teacher = Course_to_teacher(course_uid,teacher_uid)
course_to_teacher.save()
print('\033[46m课程：%s 关联老师：%s 成功！\033[0m' % (course_uid.get_obj_by_uid().name,teacher_uid.get_obj_by_uid().name))def show_course_to_teacher():
relation_list = Course_to_teacher.get_all_obj_list()
print('+++++++++++++++++++++++++++')
for relation in relation_list:
print('课程：%s\t教师：%s' % (relation.course_uid.get_obj_by_uid().name,\
relation.teacher_uid.get_obj_by_uid().name))
print('+++++++++++++++++++++++++++')def create_class():
school_obj_list = School.get_all_obj_list()
print('+++++++++++++++++++++++++++')
for index, sch in enumerate(school_obj_list, 1):
print('%s\t%s - %s' % (index, sch.name, sch.addr))
print('+++++++++++++++++++++++++++')
school_index = input('请输入班级所属的学校id>>>\t').strip()
for index, sch in enumerate(school_obj_list, 1):
if index == int(school_index):
school_uid = sch.uid
course_obj_list = Course.get_all_obj_list()
optional_corese_list = []
for course_obj in course_obj_list:
if course_obj.school_uid.uid == school_uid.uid:
optional_corese_list.append(course_obj)
print('+++++++++++++++++++++++++++')
for index, course in enumerate(optional_corese_list, 1):
out_str = '%s\t课程名字：%s, 价格：%s, 周期：%s, 归属学校：%s - %s' % \
(index,course.name, course.price, course.period, course.school_uid.get_obj_by_uid().name,
course.school_uid.get_obj_by_uid().addr)
print(out_str)
print('+++++++++++++++++++++++++++')
course_index = input('请输入班级所属的课程序号>>>\t').strip()
for index, course in enumerate(optional_corese_list, 1):
if index == int(course_index):
course_uid = course.uid
class_name = input('请输入班级名称>>>\t').strip()
classes_obj_list = Classes.get_all_obj_list()
for classes_obj in classes_obj_list:
if class_name == classes_obj.name:
print('\033[41m班级：%s 已经存在，不能重复创建！\033[0m' % class_name)
return
class_obj = Classes(class_name,school_uid,course_uid)
class_obj.save()
print('\033[46m班级创建成功！\033[0m')def show_class_list():
class_obj_list = Classes.get_all_obj_list()
print('+++++++++++++++++++++++++++')
for classes in class_obj_list:
out_str = '班级名称：%s, 归属课程：%s, 归属学校：%s - %s, 创建时间：%s' % \
(classes.name, classes.cour_uid.get_obj_by_uid().name,classes.sch_uid.get_obj_by_uid().name,classes.sch_uid.get_obj_by_uid().addr,classes.create_time)
print(out_str)
print('+++++++++++++++++++++++++++')
def create_student():
class_obj_list = Classes.get_all_obj_list()
print('+++++++++++++++++++++++++++')
for index, classes in enumerate(class_obj_list, 1):
out_str = '%s\t学校：%s - %s, 课程：%s, 班级名称：%s' % \
(index,classes.sch_uid.get_obj_by_uid().name,classes.sch_uid.get_obj_by_uid().addr,\
classes.cour_uid.get_obj_by_uid().name,classes.name)
print(out_str)
print('+++++++++++++++++++++++++++')
class_index = input('请输入新学员所关联的班级序号>>>\t').strip()
for index, classes in enumerate(class_obj_list, 1):
if index == int(class_index):
class_uid = classes.uid
name = input('请输入学生名字>>>\t').strip()
password = input('请输入学生默认密码>>>\t').strip()
qq = input('请输入学生的QQ号码>>>\t').strip()
student_obj_list = Student.get_all_obj_list()
for student_obj in student_obj_list:
if qq == student_obj.qq:
print('\033[41m学生账户：%s QQ：%s 已经存在，不能重复创建！\033[0m' % (student_obj.name,student_obj.qq))
return
student_obj = Student(name,password,class_uid,qq)
student_obj.save()
print('\033[46m学生创建成功！\033[0m')
def show_student_list():
student_obj_list = Student.get_all_obj_list()
print('+++++++++++++++++++++++++++')
for student in student_obj_list:
print('学生名字：%s, QQ：%s, 报名班级：%s, 创建时间：%s' % (student.name,student.qq,\
student.class_uid.get_obj_by_uid().name,student.create_time))
print('+++++++++++++++++++++++++++')def admin_func():
option_selected = {
'0':show_notice,
'1':create_school,
'2':show_school_list,
'3':create_course,
'4':show_course_list,
'5':create_class,
'6':show_class_list,
'7':create_teacher,
'8':show_teacher_list,
'9':course_to_teacher,
'10':show_course_to_teacher,
'11':create_student,
'12':show_student_list,
'13':exit
}
while True:
print(ADMIN_INFO)
option = input('Select your option and begin >>>\t').strip()
if option not in option_selected:
continue
option_selected[option]()

#!/usr/bin/python
# -*- coding:utf-8 -*-from conf.settings import STUDENT_DB,STUDENT_INFO
from core.models import Student,Course_to_teacherdef login():
qq = input('QQ>>>\t').strip()
password = input('密码>>>\t').strip()
user_obj_list = Student.get_all_obj_list()
for user_obj in user_obj_list:
if qq == user_obj.qq:
if password == user_obj.password:
print('学生：%s, QQ：%s 登录成功！' % (user_obj.name,user_obj.qq))
student_func(user_obj)
break
else:
print('用户名或密码错误！')
return
def show_class(student_obj):
class_name = student_obj.class_uid.get_obj_by_uid().name
school_name = student_obj.class_uid.get_obj_by_uid().sch_uid.get_obj_by_uid().name
school_addr = student_obj.class_uid.get_obj_by_uid().sch_uid.get_obj_by_uid().addr
course_price = student_obj.class_uid.get_obj_by_uid().cour_uid.get_obj_by_uid().price
course_name = student_obj.class_uid.get_obj_by_uid().cour_uid.get_obj_by_uid().name
course_period = student_obj.class_uid.get_obj_by_uid().cour_uid.get_obj_by_uid().period
class_start_time = student_obj.class_uid.get_obj_by_uid().create_time
out_str = '已报名班级：%s\n归属学校：%s-%s\n课程：%s（价格：%s, 周期：%s）\n开课时间：%s' % \
(class_name,school_name,school_addr,course_name,course_price,course_period,class_start_time)
print(out_str)
def show_teacher(student_obj):
class_name = student_obj.class_uid.get_obj_by_uid().name
course_name = student_obj.class_uid.get_obj_by_uid().cour_uid.get_obj_by_uid().name
course_obj = student_obj.class_uid.get_obj_by_uid().cour_uid.get_obj_by_uid()
relation_list = Course_to_teacher.get_all_obj_list()
for relation in relation_list:
if course_obj.uid.uid == relation.course_uid.uid:
teacher_name = relation.teacher_uid.get_obj_by_uid().name
break
print('班级名称：%s\n课程名称：%s\n任课教师：%s' % (class_name,course_name,teacher_name))def change_password(student_obj):
old_pass = input('请输入当前密码>>>\t').strip()
if old_pass == student_obj.password:
new_pass = input('请输入新密码>>>\t').strip()
option = input('确定要更改密码？(y/Y)').strip()
if 'Y' == option.upper():
student_obj.password = new_pass
student_obj.save()
print('\033[46m更改密码成功！\033[0m')
else:
print('密码错误！')def bye(student_obj):
print('See you %s' % student_obj.name)
exit(0)def student_func(student_obj):
option_selected = {
'0':change_password,
'1':show_class,
'2':show_teacher,
'3':bye,
}
while True:
print(STUDENT_INFO)
option = input('Select your option and begin >>>\t').strip()
if option not in option_selected:
continue
option_selected[option](student_obj)

#!/usr/bin/python
# -*- coding:utf-8 -*-from conf.settings import TEACHER_DB,TEACHER_INFO
from core.models import Teacher,Course_to_teacher,Classes,Studentdef login():
name = input('姓名>>>\t').strip()
password = input('密码>>>\t').strip()
user_obj_list = Teacher.get_all_obj_list()
for user_obj in user_obj_list:
if name == user_obj.name:
if password == user_obj.password:
print('教师：%s 登录成功！' % user_obj.name)
teacher_func(user_obj)
break
else:
print('用户名或密码错误！')
returndef change_password(teacher_obj):
old_pass = input('请输入当前密码>>>\t').strip()
if old_pass == teacher_obj.password:
new_pass = input('请输入新密码>>>\t').strip()
option = input('确定要更改密码？(y/Y)').strip()
if 'Y' == option.upper():
teacher_obj.password = new_pass
teacher_obj.save()
print('\033[46m更改密码成功！\033[0m')
else:
print('密码错误！')def show_course_list(teacher_obj):
course_obj_list = []
relation_list = Course_to_teacher.get_all_obj_list()
for relation in relation_list:
if teacher_obj.uid.uid == relation.teacher_uid.uid:
course_obj_list.append(relation.course_uid.get_obj_by_uid())
for course_obj in course_obj_list:
print('课程名称：%s\t课程周期：%s\t价格：%s\t归属学校：%s-%s' % \
(course_obj.name,course_obj.period,course_obj.price,\
course_obj.school_uid.get_obj_by_uid().name,course_obj.school_uid.get_obj_by_uid().addr))def show_students_by_class(teacher_obj):
course_obj_list = []
relation_list = Course_to_teacher.get_all_obj_list()
for relation in relation_list:
if teacher_obj.uid.uid == relation.teacher_uid.uid:
course_obj_list.append(relation.course_uid.get_obj_by_uid())
class_list = Classes.get_all_obj_list()
class_obj_list = []
for course in course_obj_list:
for classes in class_list:
if course.uid.uid == classes.cour_uid.uid:
class_obj_list.append(classes)
print('%s 教授的班级如下：' % teacher_obj.name)
print('+++++++++++++++++++++++++++')
for index, classes in enumerate(class_obj_list, 1):
print('%s\t%s' % (index, classes.name))
print('+++++++++++++++++++++++++++')
classes_index = input('请输入要进行查找的班级序号>>>\t').strip()
for index, classes in enumerate(class_obj_list, 1):
if index == int(classes_index):
classes_uid = classes.uid
student_obj_list = Student.get_all_obj_list()
for student_obj in student_obj_list:
if student_obj.class_uid.uid == classes_uid.uid:
print('学生名字：%s, QQ：%s, 报名班级：%s, 创建时间：%s' %\
(student_obj.name,student_obj.qq,student_obj.class_uid.get_obj_by_uid().name, student_obj.create_time))def bye(teacher_obj):
print('See you %s' % teacher_obj.name)
exit(0)def teacher_func(teacher_obj):
option_selected = {
'0':change_password,
'1':show_course_list,
'2':show_students_by_class,
'3':bye,
}
while True:
print(TEACHER_INFO)
option = input('Select your option and begin >>>\t').strip()
if option not in option_selected:
continue
option_selected[option](teacher_obj)