#在现实世界中，站在老男孩学校的角度：先有对象，再有类
对象1：李坦克特征:学校=oldboy姓名=李坦克性别=男年龄=18技能：学习吃饭睡觉对象2：王大炮特征:学校=oldboy姓名=王大炮性别=女年龄=38技能：学习吃饭睡觉对象3：牛榴弹特征:学校=oldboy姓名=牛榴弹性别=男年龄=78技能：学习吃饭睡觉现实中的老男孩学生类相似的特征:学校=oldboy相似的技能：学习吃饭睡觉

#在程序中，务必保证：先定义（类），后使用（产生对象）
PS:1. 在程序中特征用变量标识，技能用函数标识2. 因而类中最常见的无非是：变量和函数的定义#程序中的类
class OldboyStudent:school='oldboy'def learn(self):print('is learning')def eat(self):print('is eating')def sleep(self):print('is sleeping')#注意：1.类中可以有任意python代码，这些代码在类定义阶段便会执行2.因而会产生新的名称空间，用来存放类的变量名与函数名，可以通过OldboyStudent.__dict__查看3.对于经典类来说我们可以通过该字典操作类名称空间的名字（新式类有限制），但python为我们提供专门的.语法4.点是访问属性的语法，类中定义的名字，都是类的属性#程序中类的用法
.:专门用来访问属性，本质操作的就是__dict__
OldboyStudent.school #等于经典类的操作OldboyStudent.__dict__['school']
OldboyStudent.school='Oldboy' #等于经典类的操作OldboyStudent.__dict__['school']='Oldboy'
OldboyStudent.x=1 #等于经典类的操作OldboyStudent.__dict__['x']=1
del OldboyStudent.x #等于经典类的操作OldboyStudent.__dict__.pop('x')#程序中的对象
#调用类，或称为实例化，得到对象
s1=OldboyStudent()
s2=OldboyStudent()
s3=OldboyStudent()#如此，s1、s2、s3都一样了，而这三者除了相似的属性之外还各种不同的属性，这就用到了__init__
#注意：该方法是在对象产生之后才会执行，只用来为对象进行初始化操作，可以有任意代码，但一定不能有返回值
class OldboyStudent:......def __init__(self,name,age,sex):self.name=nameself.age=ageself.sex=sex......s1=OldboyStudent('李坦克','男',18) #先调用类产生空对象s1，然后调用OldboyStudent.__init__(s1,'李坦克','男',18)
s2=OldboyStudent('王大炮','女',38)
s3=OldboyStudent('牛榴弹','男',78)#程序中对象的用法
#执行__init__,s1.name='牛榴弹'，很明显也会产生对象的名称空间
s2.__dict__
{'name': '王大炮', 'age': '女', 'sex': 38}s2.name #s2.__dict__['name']
s2.name='王三炮' #s2.__dict__['name']='王三炮'
s2.course='python' #s2.__dict__['course']='python'
del s2.course #s2.__dict__.pop('course')

#方式一、为对象初始化自己独有的特征
class People:country='China'x=1def run(self):print('----->', self)# 实例化出三个空对象
obj1=People()
obj2=People()
obj3=People()# 为对象定制自己独有的特征
obj1.name='egon'
obj1.age=18
obj1.sex='male'obj2.name='lxx'
obj2.age=38
obj2.sex='female'obj3.name='alex'
obj3.age=38
obj3.sex='female'# print(obj1.__dict__)
# print(obj2.__dict__)
# print(obj3.__dict__)
# print(People.__dict__)#方式二、为对象初始化自己独有的特征
class People:country='China'x=1def run(self):print('----->', self)# 实例化出三个空对象
obj1=People()
obj2=People()
obj3=People()# 为对象定制自己独有的特征
def chu_shi_hua(obj, x, y, z): #obj=obj1,x='egon',y=18,z='male'obj.name = xobj.age = yobj.sex = zchu_shi_hua(obj1,'egon',18,'male')
chu_shi_hua(obj2,'lxx',38,'female')
chu_shi_hua(obj3,'alex',38,'female')#方式三、为对象初始化自己独有的特征
class People:country='China'x=1def chu_shi_hua(obj, x, y, z): #obj=obj1,x='egon',y=18,z='male'obj.name = xobj.age = yobj.sex = zdef run(self):print('----->', self)obj1=People()
# print(People.chu_shi_hua)
People.chu_shi_hua(obj1,'egon',18,'male')obj2=People()
People.chu_shi_hua(obj2,'lxx',38,'female')obj3=People()
People.chu_shi_hua(obj3,'alex',38,'female')# 方式四、为对象初始化自己独有的特征
class People:country='China'x=1def __init__(obj, x, y, z): #obj=obj1,x='egon',y=18,z='male'obj.name = xobj.age = yobj.sex = zdef run(self):print('----->', self)obj1=People('egon',18,'male') #People.__init__(obj1,'egon',18,'male')
obj2=People('lxx',38,'female') #People.__init__(obj2,'lxx',38,'female')
obj3=People('alex',38,'female') #People.__init__(obj3,'alex',38,'female')# __init__方法
# 强调：
#   1、该方法内可以有任意的python代码
#   2、一定不能有返回值
class People:country='China'x=1def __init__(obj, name, age, sex): #obj=obj1,x='egon',y=18,z='male'# if type(name) is not str:#     raise TypeError('名字必须是字符串类型')obj.name = nameobj.age = ageobj.sex = sexdef run(self):print('----->', self)# obj1=People('egon',18,'male')
obj1=People(3537,18,'male')# print(obj1.run)
# obj1.run() #People.run(obj1)
# print(People.run)

#python为类内置的特殊属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类(在讲继承时会讲)
类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

#1、在没有学习类这个概念时，数据与功能是分离的
def exc1(host,port,db,charset):conn=connect(host,port,db,charset)conn.execute(sql)return xxxdef exc2(host,port,db,charset,proc_name)conn=connect(host,port,db,charset)conn.call_proc(sql)return xxx#每次调用都需要重复传入一堆参数
exc1('127.0.0.1',3306,'db1','utf8','select * from tb1;')
exc2('127.0.0.1',3306,'db1','utf8','存储过程的名字')#2、我们能想到的解决方法是，把这些变量都定义成全局变量
HOST=‘127.0.0.1’
PORT=3306
DB=‘db1’
CHARSET=‘utf8’def exc1(host,port,db,charset):conn=connect(host,port,db,charset)conn.execute(sql)return xxxdef exc2(host,port,db,charset,proc_name)conn=connect(host,port,db,charset)conn.call_proc(sql)return xxxexc1(HOST,PORT,DB,CHARSET,'select * from tb1;')
exc2(HOST,PORT,DB,CHARSET,'存储过程的名字')#3、但是2的解决方法也是有问题的，按照2的思路，我们将会定义一大堆全局变量，这些全局变量并没有做任何区分，即能够被所有功能使用，然而事实上只有HOST，PORT，DB，CHARSET是给exc1和exc2这两个功能用的。言外之意：我们必须找出一种能够将数据与操作数据的方法组合到一起的解决方法，这就是我们说的类了class MySQLHandler:def __init__(self,host,port,db,charset='utf8'):self.host=hostself.port=portself.db=dbself.charset=charsetdef exc1(self,sql):conn=connect(self.host,self.port,self.db,self.charset)res=conn.execute(sql)return resdef exc2(self,sql):conn=connect(self.host,self.port,self.db,self.charset)res=conn.call_proc(sql)return resobj=MySQLHandler('127.0.0.1',3306,'db1')
obj.exc1('select * from tb1;')
obj.exc2('存储过程的名字')#改进
class MySQLHandler:def __init__(self,host,port,db,charset='utf8'):self.host=hostself.port=portself.db=dbself.charset=charsetself.conn=connect(self.host,self.port,self.db,self.charset)def exc1(self,sql):return self.conn.execute(sql)def exc2(self,sql):return self.conn.call_proc(sql)obj=MySQLHandler('127.0.0.1',3306,'db1')
obj.exc1('select * from tb1;')
obj.exc2('存储过程的名字')

#类的数据属性是所有对象共享的,id都一样
print(id(OldboyStudent.school))print(id(s1.school))
print(id(s2.school))
print(id(s3.school))'''
4377347328
4377347328
4377347328
4377347328
'''#类的函数属性是绑定给对象使用的,obj.method称为绑定方法,内存地址都不一样
#ps:id是python的实现机制,并不能真实反映内存地址,如果有内存地址,还是以内存地址为准
print(OldboyStudent.learn)
print(s1.learn)
print(s2.learn)
print(s3.learn)
'''
<function OldboyStudent.learn at 0x1021329d8>
<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x1021466d8>>
<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x102146710>>
<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x102146748>>
'''

阅读目录

• 基于面向对象设计一个对战游戏

class Riven:camp='Noxus'def __init__(self,nickname,aggressivity=54,life_value=414,money=1001,armor=3):self.nickname=nicknameself.aggressivity=aggressivityself.life_value=life_valueself.money=moneyself.armor=armordef attack(self,enemy):damage_value=self.aggressivity-enemy.armorenemy.life_value-=damage_value

class Garen:camp='Demacia'def __init__(self,nickname,aggressivity=58,life_value=455,money=100,armor=10):self.nickname=nicknameself.aggressivity=aggressivityself.life_value=life_valueself.money=moneyself.armor=armordef attack(self,enemy):damage_value=self.aggressivity-enemy.armorenemy.life_value-=damage_value

class BlackCleaver:def __init__(self,price=475,aggrev=9,life_value=100):self.price=priceself.aggrev=aggrevself.life_value=life_valuedef update(self,obj):obj.money-=self.price #减钱obj.aggressivity+=self.aggrev #加攻击obj.life_value+=self.life_value #加生命值def fire(self,obj): #这是该装备的主动技能,喷火,烧死对方obj.life_value-=1000 #假设火烧的攻击力是1000

r1=Riven('草丛伦')
g1=Garen('盖文')
b1=BlackCleaver()print(r1.aggressivity,r1.life_value,r1.money) #r1的攻击力,生命值,护甲if r1.money > b1.price:r1.b1=b1b1.update(r1)print(r1.aggressivity,r1.life_value,r1.money) #r1的攻击力,生命值,护甲print(g1.life_value)
r1.attack(g1) #普通攻击
print(g1.life_value)
r1.b1.fire(g1) #用装备攻击
print(g1.life_value) #g1的生命值小于0就死了 

阅读目录

• 一 初识继承
• 二 继承与抽象（先抽象再继承）
• 三 继承与重用性
• 四 派生
• 五 组合与重用性
• 六 接口与归一化设计
• 七 抽象类
• 八 继承实现的原理（可恶的菱形问题）
• 九 子类中调用父类的方法

class ParentClass1: #定义父类passclass ParentClass2: #定义父类passclass SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClasspassclass SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类pass

>>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
(<class '__main__.ParentClass1'>,)
>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

1.只有在python2中才分新式类和经典类，python3中统一都是新式类
2.在python2中，没有显式的继承object类的类，以及该类的子类，都是经典类
3.在python2中，显式地声明继承object的类，以及该类的子类，都是新式类
3.在python3中，无论是否继承object，都默认继承object，即python3中所有类均为新式类
#关于新式类与经典类的区别，我们稍后讨论

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

class Riven(Hero):camp='Noxus'def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类print('from riven')def fly(self): #在自己这里定义新的print('%s is flying' %self.nickname)

class Riven(Hero):camp='Noxus'def __init__(self,nickname,aggressivity,life_value,skin):Hero.__init__(self,nickname,aggressivity,life_value) #调用父类功能self.skin=skin #新属性def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类Hero.attack(self,enemy) #调用功能print('from riven')def fly(self): #在自己这里定义新的print('%s is flying' %self.nickname)r1=Riven('锐雯雯',57,200,'比基尼')
r1.fly()
print(r1.skin)'''
运行结果
锐雯雯 is flying
比基尼'''

>>> class Equip: #武器装备类
...     def fire(self):
...         print('release Fire skill')
...
>>> class Riven: #英雄Riven的类,一个英雄需要有装备,因而需要组合Equip类
...     camp='Noxus'
...     def __init__(self,nickname):
...         self.nickname=nickname
...         self.equip=Equip() #用Equip类产生一个装备,赋值给实例的equip属性
...
>>> r1=Riven('锐雯雯')
>>> r1.equip.fire() #可以使用组合的类产生的对象所持有的方法
release Fire skill

>>> F.mro() #等同于F.__mro__
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

阅读目录

• 一 多态
• 二 多态性

import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物@abc.abstractmethoddef talk(self):passclass People(Animal): #动物的形态之一:人def talk(self):print('say hello')class Dog(Animal): #动物的形态之二:狗def talk(self):print('say wangwang')class Pig(Animal): #动物的形态之三:猪def talk(self):print('say aoao')

import abc
class File(metaclass=abc.ABCMeta): #同一类事物:文件@abc.abstractmethoddef click(self):passclass Text(File): #文件的形态之一:文本文件def click(self):print('open file')class ExeFile(File): #文件的形态之二:可执行文件def click(self):print('execute file')

peo=People()
dog=Dog()
pig=Pig()#peo、dog、pig都是动物,只要是动物肯定有talk方法
#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
peo.talk()
dog.talk()
pig.talk()#更进一步,我们可以定义一个统一的接口来使用
def func(obj):obj.talk()

>>> class Cat(Animal): #属于动物的另外一种形态：猫
...     def talk(self):
...         print('say miao')
...
>>> def func(animal): #对于使用者来说，自己的代码根本无需改动
...     animal.talk()
...
>>> cat1=Cat() #实例出一只猫
>>> func(cat1) #甚至连调用方式也无需改变，就能调用猫的talk功能
say miao'''
这样我们新增了一个形态Cat，由Cat类产生的实例cat1，使用者可以在完全不需要修改自己代码的情况下。使用和人、狗、猪一样的方式调用cat1的talk方法，即func(cat1)
'''

阅读目录

• 一 引子
• 二 先看如何隐藏
• 三 封装不是单纯意义的隐藏
• 四 特性(property)
• 五 封装与扩展性

#其实这仅仅这是一种变形操作且仅仅只在类定义阶段发生变形
#类中所有双下划线开头的名称如__x都会在类定义时自动变形成：_类名__x的形式：class A:__N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__Ndef __init__(self):self.__X=10 #变形为self._A__Xdef __foo(self): #变形为_A__fooprint('from A')def bar(self):self.__foo() #只有在类内部才可以通过__foo的形式访问到.#A._A__N是可以访问到的，#这种，在外部是无法通过__x这个名字访问到。

#注意：此时的特性arear和perimeter不能被赋值
c.area=3 #为特性area赋值
'''
抛出异常:
AttributeError: can't set attribute
'''

ps：面向对象的封装有三种方式:
【public】
这种其实就是不封装,是对外公开的
【protected】
这种封装方式对外不公开,但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家 不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开
【private】
这种封装对谁都不公开

class Foo:def __init__(self,val):self.__NAME=val #将所有的数据属性都隐藏起来@propertydef name(self):return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置)@name.setterdef name(self,value):if not isinstance(value,str):  #在设定值之前进行类型检查raise TypeError('%s must be str' %value)self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME@name.deleterdef name(self):raise TypeError('Can not delete')f=Foo('egon')
print(f.name)
# f.name=10 #抛出异常'TypeError: 10 must be str'
del f.name #抛出异常'TypeError: Can not delete'

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

一 类中定义的函数分成两大类

一：绑定方法（绑定给谁，谁来调用就自动将它本身当作第一个参数传入）：

　　　　1. 绑定到类的方法：用classmethod装饰器装饰的方法。

                为类量身定制

                类.boud_method(),自动将类当作第一个参数传入

              （其实对象也可调用，但仍将类当作第一个参数传入）

　　　　2. 绑定到对象的方法：没有被任何装饰器装饰的方法。

               为对象量身定制

               对象.boud_method(),自动将对象当作第一个参数传入

             （属于类的函数，类可以调用，但是必须按照函数的规则来，没有自动传值那么一说）

二：非绑定方法：用staticmethod装饰器装饰的方法

　　      1. 不与类或对象绑定，类和对象都可以调用，但是没有自动传值那么一说。就是一个普通工具而已

　　　　注意：与绑定到对象方法区分开，在类中直接定义的函数，没有被任何装饰器装饰的，都是绑定到对象的方法，可不是普通函数，对象调用该方法会自动传值，而staticmethod装饰的方法，不管谁来调用，都没有自动传值一说

二 绑定方法

绑定给对象的方法（略）

绑定给类的方法（classmethod）

　　classmehtod是给类用的，即绑定到类，类在使用时会将类本身当做参数传给类方法的第一个参数（即便是对象来调用也会将类当作第一个参数传入），python为我们内置了函数classmethod来把类中的函数定义成类方法

HOST='127.0.0.1'
PORT=3306
DB_PATH=r'C:\Users\Administrator\PycharmProjects\test\面向对象编程\test1\db'

import settings
class MySQL:def __init__(self,host,port):self.host=hostself.port=port@classmethoddef from_conf(cls):print(cls)return cls(settings.HOST,settings.PORT)print(MySQL.from_conf) #<bound method MySQL.from_conf of <class '__main__.MySQL'>>
conn=MySQL.from_conf()conn.from_conf() #对象也可以调用，但是默认传的第一个参数仍然是类

三 非绑定方法

在类内部用staticmethod装饰的函数即非绑定方法，就是普通函数

statimethod不与类或对象绑定，谁都可以调用，没有自动传值效果

import hashlib
import time
class MySQL:def __init__(self,host,port):self.id=self.create_id()self.host=hostself.port=port@staticmethoddef create_id(): #就是一个普通工具m=hashlib.md5(str(time.time()).encode('utf-8'))return m.hexdigest()print(MySQL.create_id) #<function MySQL.create_id at 0x0000000001E6B9D8> #查看结果为普通函数
conn=MySQL('127.0.0.1',3306)
print(conn.create_id) #<function MySQL.create_id at 0x00000000026FB9D8> #查看结果为普通函数

四 classmethod与staticmethod的区别

import settings
class MySQL:def __init__(self,host,port):self.host=hostself.port=port@staticmethoddef from_conf():return MySQL(settings.HOST,settings.PORT)# @classmethod #哪个类来调用,就将哪个类当做第一个参数传入# def from_conf(cls):#     return cls(settings.HOST,settings.PORT)def __str__(self):return '就不告诉你'class Mariadb(MySQL):def __str__(self):return '<%s:%s>' %(self.host,self.port)m=Mariadb.from_conf()
print(m) #我们的意图是想触发Mariadb.__str__,但是结果触发了MySQL.__str__的执行，打印就不告诉你：

五 练习

定义MySQL类

　　1.对象有id、host、port三个属性

　　2.定义工具create_id，在实例化时为每个对象随机生成id，保证id唯一

　　3.提供两种实例化方式，方式一：用户传入host和port 方式二：从配置文件中读取host和port进行实例化

　　4.为对象定制方法，save和get_obj_by_id，save能自动将对象序列化到文件中，文件路径为配置文件中DB_PATH,文件名为id号，保存之前验证对象是否已经存在，若存在则抛出异常，;get_obj_by_id方法用来从文件中反序列化出对象

原文链接：http://www.cnblogs.com/dkblog/archive/2011/10/10/2205200.htmlPython官方Doc：《20.15. uuid — UUID objects according to RFC 4122》UUID的算法介绍：《A Universally Unique IDentifier (UUID) URN Namespace》概述：UUID是128位的全局唯一标识符，通常由32字节的字符串表示。它可以保证时间和空间的唯一性，也称为GUID，全称为：UUID —— Universally Unique IDentifier      Python 中叫 UUIDGUID —— Globally Unique IDentifier          C#  中叫 GUID它通过MAC地址、时间戳、命名空间、随机数、伪随机数来保证生成ID的唯一性。UUID主要有五个算法，也就是五种方法来实现：1、uuid1()——基于时间戳由MAC地址、当前时间戳、随机数生成。可以保证全球范围内的唯一性，但MAC的使用同时带来安全性问题，局域网中可以使用IP来代替MAC。2、uuid2()——基于分布式计算环境DCE（Python中没有这个函数）算法与uuid1相同，不同的是把时间戳的前4位置换为POSIX的UID。实际中很少用到该方法。3、uuid3()——基于名字的MD5散列值通过计算名字和命名空间的MD5散列值得到，保证了同一命名空间中不同名字的唯一性，和不同命名空间的唯一性，但同一命名空间的同一名字生成相同的uuid。    4、uuid4()——基于随机数由伪随机数得到，有一定的重复概率，该概率可以计算出来。5、uuid5()——基于名字的SHA-1散列值算法与uuid3相同，不同的是使用 Secure Hash Algorithm 1 算法使用方面：首先，Python中没有基于DCE的，所以uuid2可以忽略；其次，uuid4存在概率性重复，由无映射性，最好不用；再次，若在Global的分布式计算环境下，最好用uuid1；最后，若有名字的唯一性要求，最好用uuid3或uuid5。编码方法：# -*- coding: utf-8 -*-import uuidname = "test_name"namespace = "test_namespace"print uuid.uuid1()  # 带参的方法参见Python Docprint uuid.uuid3(namespace, name)print uuid.uuid4()print uuid.uuid5(namespace, name)

#settings.py内容
'''
HOST='127.0.0.1'
PORT=3306
DB_PATH=r'E:\CMS\aaa\db'
'''
import settings
import uuid
import pickle
import os
class MySQL:def __init__(self,host,port):self.id=self.create_id()self.host=hostself.port=portdef save(self):if not self.is_exists:raise PermissionError('对象已存在')file_path=r'%s%s%s' %(settings.DB_PATH,os.sep,self.id)pickle.dump(self,open(file_path,'wb'))@propertydef is_exists(self):tag=Truefiles=os.listdir(settings.DB_PATH)for file in files:file_abspath=r'%s%s%s' %(settings.DB_PATH,os.sep,file)obj=pickle.load(open(file_abspath,'rb'))if self.host == obj.host and self.port == obj.port:tag=Falsebreakreturn tag@staticmethoddef get_obj_by_id(id):file_abspath = r'%s%s%s' % (settings.DB_PATH, os.sep, id)return pickle.load(open(file_abspath,'rb'))@staticmethoddef create_id():return str(uuid.uuid1())@classmethoddef from_conf(cls):print(cls)return cls(settings.HOST,settings.PORT)# print(MySQL.from_conf) #<bound method MySQL.from_conf of <class '__main__.MySQL'>>
conn=MySQL.from_conf()
conn.save()conn1=MySQL('127.0.0.1',3306)
conn1.save() #抛出异常PermissionError: 对象已存在obj=MySQL.get_obj_by_id('7e6c5ec0-7e9f-11e7-9acc-408d5c2f84ca')
print(obj.host)

其他练习

class Date:def __init__(self,year,month,day):self.year=yearself.month=monthself.day=day@staticmethoddef now(): #用Date.now()的形式去产生实例,该实例用的是当前时间t=time.localtime() #获取结构化的时间格式return Date(t.tm_year,t.tm_mon,t.tm_mday) #新建实例并且返回@staticmethoddef tomorrow():#用Date.tomorrow()的形式去产生实例,该实例用的是明天的时间t=time.localtime(time.time()+86400)return Date(t.tm_year,t.tm_mon,t.tm_mday)a=Date('1987',11,27) #自己定义时间
b=Date.now() #采用当前时间
c=Date.tomorrow() #采用明天的时间print(a.year,a.month,a.day)
print(b.year,b.month,b.day)
print(c.year,c.month,c.day)#分割线==============================
import time
class Date:def __init__(self,year,month,day):self.year=yearself.month=monthself.day=day@staticmethoddef now():t=time.localtime()return Date(t.tm_year,t.tm_mon,t.tm_mday)class EuroDate(Date):def __str__(self):return 'year:%s month:%s day:%s' %(self.year,self.month,self.day)e=EuroDate.now()
print(e) #我们的意图是想触发EuroDate.__str__,但是结果为
'''
输出结果:
<__main__.Date object at 0x1013f9d68>
'''
因为e就是用Date类产生的,所以根本不会触发EuroDate.__str__,解决方法就是用classmethodimport time
class Date:def __init__(self,year,month,day):self.year=yearself.month=monthself.day=day# @staticmethod# def now():#     t=time.localtime()#     return Date(t.tm_year,t.tm_mon,t.tm_mday)@classmethod #改成类方法def now(cls):t=time.localtime()return cls(t.tm_year,t.tm_mon,t.tm_mday) #哪个类来调用,即用哪个类cls来实例化class EuroDate(Date):def __str__(self):return 'year:%s month:%s day:%s' %(self.year,self.month,self.day)e=EuroDate.now()
print(e) #我们的意图是想触发EuroDate.__str__,此时e就是由EuroDate产生的,所以会如我们所愿
'''
输出结果:
year:2017 month:3 day:3
'''

多态指的是同一种事物的多种状态：水这种事物有多种不同的状态：冰，水蒸气

多态性的概念指出了对象如何通过他们共同的属性和动作来操作及访问,而不需考虑他们具体的类。

冰，水蒸气，都继承于水，它们都有一个同名的方法就是变成云，但是冰.变云(),与水蒸气.变云()是截然不同的过程，虽然调用的方法都一样

一 引子

学完了面向对象的基础知识后，很明显你还是不知该如何下手，凡是都得有个章法

此刻有经验的人可能会想到瀑布模型、螺旋模型、迭代开发、敏捷、RUP等一堆软件工程相关的软件开发流程，但对于大部分人来说这些流程仅仅只是项目管理上的流程

本节我们就带大家来了解下，作为一名程序员基于面向对象开发程序的开发流程：

需求模型->领域模型->设计模型->实现模型

二 需求模型之5w1h8c

1. 需求VS功能

需求：客户想要的效果，对客户有价值的事情
功能：系统为了实现客户的价值而提供的能力/功能

举例：
汽车：驾驶是需求，刹车、加速、转弯是功能
打印机：打印是需求，进纸、设定、与电脑连接等是功能

　　pos机：买单是需求，商品扫描、金额汇总、收银等是功能

2. 需求的重要性

1/3的项目失败或陷入困境是因为需求原因导致的
garbage in，garbage out
屎上了生产饼干的流水线，最后产出的是像饼干一样的屎

修复需求错误的问题成本极高

1 编码阶段修复发现一个错误耗费人类是1个单位
2 测试阶段修复需求错误的成本是5-10倍
3 维护阶段（产品上线后），修复需求错误成本是20倍
ps：在需求阶段修复错误，成本只需要0.1-0.2即可
结论：需求错了，几乎要把软件项目重做一遍

3. 需求分析的目的

1 记录员，记录客户的需求
2 分析员，和客户一起分析，完善需求
3 引导员，能够引导客户的需求

4. 需求分析的方法

需求分析518方法，简称我要发，具体就是5w1h8c
5w：
when:用户想在什么时间用，例如半夜备份的任务，很明显我们得知该需求需要自动化执行
where：用户想在什么地方用，例如垃圾桶室内和室外的区别，同样的事物放到不同地方用肯定不一样
who：用户想让谁来用，不仅是人，也可以是一个系统
what：用户想要我们程序的输出结果是什么，如图片，文档，系统
why：问一问用户为什么要这么做，（你不问，他基本不说），包括客户所有觉得不爽的事情
ps：why是核心

1h：how
用例方法

8c：8个constraint约束
性能performance

性能是系统提供相应服务的效率。主要包括响应时间、吞吐量
性能是很多系统架构设计的关键约束条件之一
例如，同样一个web网站，虽然都是提供信息给用户流量，设计一个日访问量1w的网站与日访问量10亿的网站，二者的设计截然不同

成本cost

成本指为了实现系统而需要付出的代价
成本也是很多系统架构设计的关键约束之一
例如客户只愿意花100w，而我们却设计了一个耗费1000w的系统

时间time

指客户要求什么时候交付

可靠性reliability

　　指系统长时间正确运行的能力，银行、证券、电信这些公司，对宕机时间要求很严格

安全security

指对信息安全的保护能力，涉及到钱、身份证、社会保险号等需求对这个要求很高

合规性compliance

　　指满足各种行业标准、法律法规、规范等，例如3C、SOX、3GPP，ITUT

技术性technology

有的客户可能要求我们采用某种技术
例如客户现在都是windows服务器，要求我们基于windows平台开发

兼容性compatibility

指我们的产品与客户其他已有的产品或系统的兼容能力，要知道现在很少有产品是孤立运行的，特别是在大企业、大公司中，多个系统都是相互交互、互相配合的。新的系统必须能够和已有的系统配合，否则将无法运行

ps：
5w+1h属于功能属性
8c属于质量属性

三 需求模型之用例的写法

写用例的技巧

三段法：NEA
1 正常处理（normal):分析正常流程
2 异常处理(exception)：分析每一步异常情况和对应的处理
3 替代处理(alternative)：分析每一步是否有其他替代方法，以及如何做

用例的书写格式

#1. 用例名称
一般情况下，用例名称即需求名称#2. 场景
场景即用例发生的环境，正好对应5w中的：when，where，who#3. 用例描述
描述详细的用例内容，对应5w中的what和how
即用户应该怎样做，以及每个步骤中的输出，但不要求每个步骤都有一定的输出，可以有也可以没有，也可以有多个#4. 用例价值
描述用例对应的客户价值，对应5w中的why#5. 约束和限制
即真个需求流程中相关的约束和限制条件，对应518方法中的8C

用例编写案例

#用例名答题系统#场景：when：8.10开始where：老男孩who：linux学院，网络客户#用例描述：1 linux学院提供50道题2 每个客户无需输入任何个人信息就可以参与答题，随机选择20道题，给客户回答，每道题5分，3.答题结束后，输入手机号，提交，算总分4 60分参与抽奖，<60分赠送基础视频#用户价值：答题有奖，答题提交时输入自己的手机号获取成绩，获得潜在客户的联系方式，为后期将客户转成学员做准备#约束：暂无

四 领域模型

需求分析阶段不区分面向对象还是面向过程

领域模型是完成从需求分析到面向对象设计的一座桥梁

#定义：领域模型是对领域内的概念或现实世界中对象的可视化表示，又称为观念模型，领域对象模型，分析对象模型
#它专注于分析问题领域本身，发掘重要的业务领域概念，并建立业务领域概念之间的关系

领域模型主要两个作用：

#1 发掘重要的业务领域概念
#2 建立业务领域概念之间的关系

归纳领域建模的方法就是：

#1 从用例中找名词（找完后需要删除不是领域对象的名词，具体删除什么，与不同领域有关，没有统一标准，靠经验）
#2 加属性（有些属性并没有在用例中明确给出，靠行业经验自己添加）
#3 连关系（画UML图）

五 设计模型

面向对象类设计的具体步骤第一步：领域类映射（不是全盘拷贝）类筛选：并不是每个领域类都会出现在软件中名称映射：对应属性映射：对应，照搬提炼方法：领域类中并没有方法，在用例中找动词第二步：应用设计原则和设计模式第三步：拆分辅助类（领域类可以在实现阶段拆分为几个类）

六 实现模型

选取一种支持面向对象的语言实现我们的设计

七 答题系统案例

第一步：需求分析（写用例）

#用例名答题系统#场景：when：8.10开始where：老男孩who：linux学院，网络客户#用例描述：1 linux学院提供50道题2 每个客户无需输入任何个人信息就可以参与答题，随机选择20道题，给客户回答，每道题5分，3.答题结束后，输入手机号，提交，算总分4 60分参与抽奖，<60分赠送基础视频#用户价值：答题有奖，答题提交时输入自己的手机号获取成绩，获得潜在客户的联系方式，为后期将客户转成学员做准备#约束：暂无

第二步：领域模型（找名词，加属性，连关系=>出图）

#找名词：
linux学院，题，客户，得分，奖，视频
#筛选：去掉与领域无关的名词。视频应该算作一种奖品
linux学院，题，客户，得分，奖

#加属性
加属性
名词         属性                        备注
linux学院    NA                       对于答题系统来说，并不需要linux学院的属性，因此在领域模型中，linux学院是没有属性的
题          题目编号，题目类型，题目描述，答题选项，正确答案，分数
客户        客户编号，姓名，性别，年龄，手机号
答题记录     记录编号，客户编号，题目编号列表，总分数，时间     通过答题记录就可以知道用户是谁，以及用户答过的题目
奖品        奖品编号，奖品名字                    

#连关系：画图
1：答题记录是客户与题的关系类，而客户与奖品之间可以建一个关系类，这样以后单查关系类就可以知道谁得了什么奖品
2：找动词：创建题目随机选择题目答题提交算总分抽奖

第三步：设计模型（略）

第四部：实现模型

链接: https://pan.baidu.com/s/1jHYFKWI 密码: wimc

第八 UML图

待整理

类图中通过加号(+)来表示 public 
通过减号(-)表示 private
通过井号(#)表示 protected

第九 作业

角色:学校、学员、课程、讲师
要求:
1. 创建北京、上海 2 所学校
2. 创建linux , python , go 3个课程 ， linux\py 在北京开， go 在上海开
3. 课程包含，周期，价格，通过学校创建课程
4. 通过学校创建班级， 班级关联课程、讲师
5. 创建学员时，选择学校，关联班级
5. 创建讲师角色时要关联学校，
6. 提供两个角色接口
6.1 学员视图， 可以注册， 交学费， 选择班级，
6.2 讲师视图， 讲师可管理自己的班级， 上课时选择班级， 查看班级学员列表 ， 修改所管理的学员的成绩
6.3 管理视图，创建讲师， 创建班级，创建课程7. 上面的操作产生的数据都通过pickle序列化保存到文件里

思路：

一：选课系统用例

#用例名称
选课
#场景
who：学生，老师，管理员
where：老男孩
when：任意时间#用例描述（用户怎么做，或者说用户想怎么用）：
1. 管理员创建学校：北京和上海两个校区
2. 管理员创建课程：python，go，linux
3. 管理员创建班级：python周末18期，python脱产7期，linux架构35期
4. 管理员创建学员：小晴，花野真衣，川岛芳子
5. 管理员创建讲师：alex，egon，wupeiqi，yuanhao
6. 讲师创建上课记录：python周末班18期day7
7. 讲师为day7这节课所有学生批改作业，为每个学生打分
8. 学员杨磊查看自己的详细信息：所在学校，报名课程，所在班级
9. 学员杨磊在python18期day7提交了作业
10.学员杨磊查看了自己在day7作业的成绩列表，然后自杀了
11.学员小晴跟egon表白了，当天下午就去领了结婚证#用例价值帮老男孩解决课程管理问题
#约束暂无

二：找名词：

管理员，学校，课程，班级，学员讲师，上课记录，作业，分数，学员详细信息，成绩列表，结婚证
筛选：去掉与行业或者说领域无关的名词
管理员，学校，课程，班级，学员，讲师，上课记录，作业，分数，学员详细信息，成绩列表

三： 加属性：

名字                属性      备注
管理员             NA        具备所有权限，对于选课系统来说，并不需要管理员的属性，因此在领域模型中，管理员是没有属性的
学校               学校名，地址，课程列表，班级列表
课程               课程名，周期，价钱，大纲
班级               班级名，所属学校，课程
学员               学员名，
讲师               讲师名
上课记录          班级，课程节次，日期

四：连关系

五：实现吧亲