对象呢？

类：把一类事物的相同的特征和动作整合到一起就是类

　　类是一个抽象的概念

对象：就是基于类而创建的一个具体的事物（具体存在的）

　　　也是特征和动作整合到一起

什么叫实例化：由类生产对象的过程叫实例化，类实例化的结果就是一个对象，或者叫做一个实例（实例=对象）

学校类：

特征：name，addr，type

动作：考试，招生，开除学生

整合特征和动作

我的对象  

类：     print()查看    赋值：增加、修改    dle：删除

print(China.dang)  #查看类

China.dang="党" # 修改 类   增加 类

del China.dang #删除 类

print(p1.__dict__) #查看实例， 以字典的方式显示

函数：

增加

def eat_food(self,food):
    print("%s正在吃%s“,%(self.food))
China.eat=eat_food
p1.eat("饭)

修改

def test(self):
    print("test")
China.reproduction=test
pl.reproduction()
>>>test

实例： 如果找不到就到类去找

p1=China("szw")
print(p1.__dict__)#查看实例

print(p1.name)   #查看

p1.age=18#增加  也可以修改

del p1.age#删除

.函数又作用域的概念，其实类也有作用域的概念，二者一样

.你可以把class当做最外层的函数，是一个作用域

#定义一个类，只当一个作用域去用，类似于c语言中的结构体
class MyData:
    pass

x=10
y=20
MyData.x=1
MyData.y=2

print(x,y)
print(MyData.x,MyData.y)
print(MyData.x+MyData.y)

 实例没有就去类修改

country="中国"
class China:
    dang="共产"
    country="中国-------"
    l=["a","b"]
    def __init__(self,name,age):
        self.name=name
        print(country)
        self.age=age
    def reproduction(self):
        print("shen%s"% self.age)
p1=China("alex",18)
p1.l.append("c")
print(p1.l)
>>>中国
>>>['a', 'b', 'c']

 静态属性、类方法、静态方法

@property           把 函数属性 变成 静态属性 的样式        return一个值

class Room:
    def __init__(self,name,owner,width,lenght,heigh):
        self.name=name
        self.owner=owner
        self.width=width
        self.lenght=lenght
        self.heigh=heigh
    @property
    def cal_area(self):
        print("%s住的%s总体积%s"%(self.name,self.owner,self.width*self.lenght*self.heigh))
        return self.width*self.lenght*self.heigh
sl=Room("alex","厕所",1,1,1)
print(sl.cal_area)
print(sl.name)
>>>alex住的厕所总体积1
>>>1
>>>alex

@classmethod      只用类方法  不用实例

classmethod类方法只是给类使用(不管是否存在实例)，只能访问实例变量

class Room:
    bag=1
    def __init__(self,name,owner,width,lenght,heigh):
        self.name=name
        self.owner=owner
        self.width=width
        self.lenght=lenght
        self.heigh=heigh13     @classmethod
    def cal_info(cls,s):
        print(Room)
        print("---->",cls.bag,s)
Room.cal_info(10)
>>><class '__main__.Room'>
>>>----> 1 10

@staticmethod          不用类 不用实例

静态方法只是名义上的归属类管理，不能使用类变量和实例变量,是类的工具包

class Room:
    bag=1
    def __init__(self,name,owner,width,lenght,heigh):
        self.name=name
        self.owner=owner
        self.width=width
        self.lenght=lenght
        self.heigh=heigh
    @staticmethod
    def wash_body(x):
        print("opoupgjsjgosgo",x)
Room.wash_body(10)
>>>opoupgjsjgosgo 10

组合

1：做关联

2：小的组成大的

基本成型

class School:
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr
    def zhao_sheng(self):
        print("%s正在招生"%self.name)

class Course:
    def __init__(self,name,price,period,school):
        self.name=name
        self.price=price
        self.period=period
        self.school=school

class Teacher:
    def __init__(self,name,school,course):
        self.name=name
        self.school=school
        self.course=course

sl=School("alex","北京")
cl=Course("python",10,"1h",sl)   #添加
tl=Teacher("海峰",sl,cl)         #添加
print(tl.school.name,tl.school.addr)
print(tl.course.name,tl.course.price,tl.course.period)
print(cl.school.name,cl.school.addr)
>>>alex 北京
>>>python 10 1h
>>>alex 北京

 与用户交互 

class School:
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr
    def zhao_sheng(self):
        print("%s正在招生"%self.name)

class Course:
    def __init__(self,name,price,period,school):
        self.name=name
        self.price=price
        self.period=period
        self.school=school

s1=School("alex","北京")
s2=School("alex","南京")
s3=School("alex","东京")

msg='''
1 老男孩 北京校区
2 老男孩 南京校区
3 老男孩 东京校区
'''
while True:
    print(msg)
    menu={
        '1':s1,
        '2':s2,
        '3':s3
    }
    choice=input("选择学校>>>")
    school_obj=menu[choice]
    name=input("课程名>>>")
    price=input("课程费用>>>")
    period=input("课程周期>>>")
    new_course=Course(name,price,period,school_obj)
    print("课程%s属于%s学校"%(new_course.name,new_course.school.name))

继承

继承父类

class Dad:
    '这个是父类'
    money=10
    def __init__(self,name):
        print("父")
        self.name=name
    def hit_son(self):
        print("%s正在打儿子"%self.name)
class Son(Dad):
    money = 1000003
print(Dad.__dict__)
print(Son.__dict__)
sl=Son("alex")
sl.hit_son()
print(sl.name)
print(Dad.money)
>>>{'__doc__': '这个是父类', 'hit_son': <function Dad.hit_son at 0x0124C348>, 'money': 10, '__init__': <function Dad.__init__ at 0x0124C390>, '__weakref__': <attribute '__weakref__' of 'Dad' objects>, '__dict__': <attribute '__dict__' of 'Dad' objects>, '__module__': '__main__'}
>>>{'__doc__': None, 'money': 1000003, '__module__': '__main__'}
>>>父
>>>alex正在打儿子
>>>alex
>>>10

继承 的统一性

import abc
class All_file(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def read(self):
        pass
    @abc.abstractmethod
    def write(self):
        pass
class Cdrom(All_file):
    def read(self):
        print("cdrom read")
    def write(self):
        print("cdrom write")
class Mem(All_file):
    def read(self):
        print("mem read")
    def write(self):
        print("mem write")
cl=Cdrom()
cl.read()
cl.write()

继承顺序：python2深度优先、python3广度优先。

class A:
    def test(self):
        print("a")
    pass
class B(A):
    # def test(self):
    #     print("B")
    pass
class C(A):
    # def test(self):
    #     print("C")
    pass
class D(B):
    # def test(self):
    #     print("D")
    pass
class E(C):
    # def test(self):
    #     print("e")
    pass
class F(D,E):
    # def test(self):
    #     print("F")
    pass
fl=F()
fl.test()

print(F.__mro__)
>>>a
>>>(<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

子调父

class Vehicle: #定义交通工具类
    Country='China'
    def __init__(self,name,speed,load,power):
        self.name=name
        self.speed=speed
        self.load=load
        self.power=power
    def run(self):
        print("开动了")
        print("开动了")
        print("开动了")
        print("开动了")
        print("开动了")
class Subway(Vehicle):
    def __init__(self,name,speed,load,power,line):
        Vehicle.__init__(self,name,speed,load,power)
        self.line=line
    def run(self):
        Vehicle.run(self)
        print("%s %s开动了"%(self.name,self.line))


line13=Subway("中国地铁","180m/s",1000000000000,"电","13号线")
line13.run()
>>>开动了
>>>开动了
>>>开动了
>>>开动了
>>>开动了
>>>中国地铁 13号线开动了

子调父的优化

super().__init__(name,speed,load,power)

super(Subway, self).run()

class Vehicle: #定义交通工具类
    Country='China'
    def __init__(self,name,speed,load,power):
        self.name=name
        self.speed=speed
        self.load=load
        self.power=power
    def run(self):
        print("开动了")
        print("开动了")
        print("开动了")
        print("开动了")
        print("开动了")
class Subway(Vehicle):
    def __init__(self,name,speed,load,power,line):
        super(Subway, self).__init__(name,speed,load,power)
        self.line=line
    def run(self):
        super(Subway, self).run()
        print("%s %s开动了"%(self.name,self.line))
line13=Subway("中国地铁","180m/s",1000000000000,"电","13号线")
line13.run()
>>>开动了
>>>开动了
>>>开动了
>>>开动了
>>>开动了
>>>中国地铁 13号线开动了

 多态

什么是多态：

类的继承有两层意义：1.改变 2.扩展

多态就是类的这两层意义的一个具体的实现机制 即，调用不同的类实例化得对象下的相同的方法，实现的过程不一样

多态：   多态反应的是运行时候的状态

class H20:
    def __init__(self,name,temperature):
        self.name=name
        self.temperature=temperature
    def turn_ice(self):
        if self.temperature<0:
            print('%s温度太低结冰了'%self.name)
        elif self.temperature>0 and self.temperature<100:
            print('%s液化成水'%self.name)
        elif self.temperature>100:
            print('%s温度太高变成水蒸气'%self.name)
class Water(H20):
    pass
class Ice(H20):
    pass
class Steam(H20):
    pass
w1=Water('水',25)
i1=Ice("冰",-20)
s1=Steam("蒸汽",3000)
def func(obj):
    obj.turn_ice()
func(w1)
func(i1)
>>>水液化成水
>>>冰温度太低结冰了

封装

python不依赖语言特性去实现第二层面的封装,而是通过遵循一定的数据属性和函数属性的命名约定来达到封的效果

约定一:任何以单下划线开头的名字都应该是内部的,私有的

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'

class People:
    _star='earth'
    def __init__(self,id,name,age,salary):
        self.id=id
        self.name=name
        self._age=age
        self._salary=salary

    def _get_id(self):
        print('我是私有方法啊,我找到的id是[%s]' %self.id)
#我们明明约定好了的,只要属性前加一个单下划线,那他就属于内部的属性,不能被外部调用了啊,为何还能调用???
print(People._star)
p1=People('3706861900121221212','alex',28,10)

print(p1._age,p1._salary)
p1._get_id()

约定二：双下划线开头的名字 python会 默认 重命名   __类名+双下划线的变量

class People:
    __star="earth"
    def __init__(self,id,name,age,salary):
        self.id=id
        self.name=name
        self.age=age
        self.salary=salary
    def get_id(self):
        print("我是私有发放呀，我找到的id是%s"%self.id)
p1=People("213132","alex","18",10000)
print(People.__dict__)
print(p1._People__star)
>>>{'get_id': <function People.get_id at 0x013AD300>, '__init__': <function People.__init__ at 0x013AD348>, '__doc__': None, '_People__star': 'earth', '__dict__': <attribute '__dict__' of 'People' objects>, '__module__': '__main__', '__weakref__': <attribute '__weakref__' of 'People' objects>}
>>>earth

 峰

http://www.cnblogs.com/linhaifeng/articles/6182264.html#_label14