# -*- coding:utf-8 -*-

# Author: Colin Yao

class Dog(object): #类

    def __init__(self,name):#构造函数、构造方法 ==初始化方法

            self.NAME = name

    def sayhi(self):   #类的方法

        print("hello, i am a dog. my name is ",self.NAME)

    def food(self,food):

        print('%s is eat %s' %(self.NAME,food))

#函数注重过程、函数是模板、需要实例化

d = Dog("A")  #实例  #,Dog(d,"Alex") 实例化后缠上的对象、叫实例（当前Dog类的实例） self = d self就是实例本身

d2 = Dog("lin")

# d.sayhi()  #调用类

d.food(food='gouliang')

class Role(object):

    nationlity = 'CN'  #公有属性

    def __init__(self, name, role, weapon, life_value=100, money=15000):

        self.name = name  #成员属性

        self.role = role

        self.weapon = weapon

        self.life_value = life_value

        self.money = money

        self.__heart = "Nomal" #私有属性一般不能直接被实例调用

    def shot(self):

        print("%s shooting..." %self.name)

        self.__heart = "Die"

        print(self.__heart)

    def get_heart(self):

        return self.__heart

r1 = Role('Alex', 'police', 'AK47') #生成一个角色

r2 = Role('Jack', 'terrorist', 'B22')  #生成一个角色

r3 = Role('lichuang','警犬','B13')

print("如果你想访问私有属性、不能修改、就需要添加代码def get_heart(self):return self.__heart----->私有属性为：",r1.get_heart())  #

print(r1.nationlity,'相当与在成员属性里添加了nationlity')  #公有属性在类里直接定义的

#!/usr/bin/env python

# -*- coding:utf-8 -*-

# Author: Colin Yao

class Person(object):   #父类

    def __init__(self,name,age):

        self.name = name  #self = b self.name =b.name

        self.age = age

        self.sex = "noraml"

    def talk(self):

        print("persion is talking")

class  BlackPerson(Person):#子类

    def __init__(self,name,age,strength):#这时候如果重新写就会覆盖父类的方法、所以我门需要先继承，在重构

        Person.__init__(self,name,age) #调用还没有实例化的类，self 传的是BlackPerson的类

        self.strength = strength

      #  print(self.name,self.age,self.sex)

    def talk(self):

        print("Black person is blaba....")

    def walk(self):

        print("is walking")

class WhitePerson(Person):

    pass

b = BlackPerson("Weiersmith","","strong")

b.talk()

在python中继承中的一些特点：

1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。有别于C#

2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数

3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

如果在继承元组中列了一个以上的类，那么它就被称作“多重继承” 。

例如（这里的基类相当与父类）：

多级继承

#!/usr/bin/env python

# -*- coding:utf-8 -*-

# Author: Colin Yao

msg = '''

class Person(object): #new style

 super

class Person(object) #classical style

 ParentClass.__init__()

大家主要写新式类的 object

 继承顺序的区别、多级继承

'''

class A:#经典类

 def __init__(self):

self.n ="A"

class B(A):

#def __init__(self):

 # self.n ="B"

 pass

class C(A):

# def __init__(self):

 # self.n ="C"

 pass

class D(B,C):

# def __init__(self):

 # self.n ="D"

pass

d = D()

print(d.n)

这里会涉及到新式类和经典类的一个区别：

大概的查找顺序是： py3里新式类和经典类都是横向查找，py2里新式类的查找方式是横向的，例如class D(B,C): 先找B再找C最后找A ，但是经典类则是先找B，在找A不会找C

#多态是同一种事物的多种形态

class Animal:

    def talk(self):

            print('正在叫')

class People(Animal):

    def talk(self):

        print('say hello')

class Pig(Animal):

    def talk(self):

        print('哼哼哼')

class Dog(Animal):

    def talk(self):

        print('wangwangwang')

class Cat(Animal):

    def talk(self):

        print('喵喵喵')

peo1=People()

pig1=Pig()

dog1=Dog()

cat1=Cat()

#多态性

peo1.talk()

dog1.talk()

pig1.talk()

def func(x):

    x.talk()

func(dog1)

say hello

哼哼哼
wangwangwang
喵喵喵