面向对象编程

python中一切皆为对象，所谓对象：人是一个对象，电脑是一个对象

我们通过描述属性（特征）和行为来描述一个对象的。

什么是类

在python中，一个对象的特征也称为属性（attribute）。它所具有的行为也称为方法（method）

结论：对象=属性+方法

在python中，把具有相同属性和方法的对象归为一个类（class）

比如人，动物，植物等等，这些都是类的概念。

类是对象的模板或蓝图，类是对象的抽象化，对象是类的实例化。类不代表具体的事物，而对象表示

具体的事物。

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属

  性和方法。对象是类的实例。

• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常

  不作为实例变量使用。

• 数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。

• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆

  盖（override），也称为方法的重写。

• 实例变量：定义在方法中的变量，只作用于当前实例的类。

• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个

  派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal

• 类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。

• 实例化：创建一个类的实例，类的具体对象。

• 方法：类中定义的函数。

• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

使用class定义类

#类的最简形式
class Person():
    '着定义了一个类，但是没有什么功能'
    pass

someone = Person()

同函数一样，用pass 表示这个类是一个空类

class Person():
    def __init__(self):
        print ('女的，是个活的')
        pass

someone = Person()

当你在类声明里定义__init__() 方法时，第一个参数必须为self。尽管self 并不是一

个Python 保留字，但它很常用。没有人（包括你自己）在阅读你的代码时需要猜测使用self
的意图。

添加name 参数

class Person():
    def __init__(self,name):
        self.name = name

someone = Person('xiaohong')

print(someone.name)

第一种方法__init__()方法是一种特殊的

方法，被称为类的构造函数或初始化方法，当创
建了这个类的实例时就会调用该方法

class Person():
    def __init__(self,name,age):
        self.name = name
        self.age = age
        print('__init__函数执行了')

someone = Person('xiaohong',18)

print(someone.name)
print(someone.ega)

#记录类被实例化的次数，再加一个函数用于输出我们的类的属性
class Person():
    '这是一个人的类，可以为我们实例化对象'
    person_count = 0

    def __init__(self,name,age):
        self.name = name
        self.age = age
        Person.person_count +=1

    def display_person(self):
        print('姓名：%s,年龄：%s'%(self.name,self.age))

someone1 = Person('xiaohong','18')
someone2 = Person('xiaoli','19')

print(someone.name)
print(someone.age)
print(someone.display_person())
print(someone.person_count)

print(someone1.__class__)
print(someone1.__doc__)#获取类说明

类的继承

从已有类中衍生出新的类，添加或修改部分功能。

#继承

class Car():
    def car_print(self):
        print('''I'm drive a car!!!''')

class Benz(Car):
    pass

drive_car = Car()
drive_Benz = Benz()

print(drive_car.car_print())
print(drive_Benz.car_print())

覆盖方法（重写）

#重写
class Car():
    def car_print(self):
        print('''I'm drive a car!!!''')

class Benz(Car):
    def car_print(self):
        print("I'm drive a Benz car!!!")

drive_car = Car()
drive_Benz = Benz()

drive_car.car_print()
drive_Benz.car_print()

初始化函数重写

class Person():
    def __init__(self,name):
        self.name = name

class MLPerson(Person):
    def __init__(self,name):
        self.name = "我是漂亮的"+name

class SJRYPerson(Person):
    def __init__(self,name):
         self.name = "我是善解人意的"+name

someone1 = Person('laowang')
someone2 = MLPerson('xiaoli')
someone3 = SJRYPerson('xiaohong')

子类添加新方法

#子类里面添加新方法
class Car():
    def car_print(self):
        print('''I'm drive a car!!!''')

class Benz(Car):
    def car_print(self):
        print("I'm drive a Benz car!!!")
    def didi(self):
        print('didididid!!!')

drive_car = Car()
drive_Benz = Benz()

drive_car.car_print()
drive_Benz.car_print()
drive_Benz.didi()

使用super从父类得到方法

class Person():
    def __init__(self,name):
        self.name = name

class QQPerson(Person):
    def __init__(self,name,QQ):
        super().__init__(name)
        self.qq = QQ

someone = QQPerson('七喜小子','777777')
someone.name
someone.qq

属性（property）

#属性 property   ‘getter setter’

class Person():
    def __init__(self,first_name,last_name):
        self.first_name = first_name
        self.last_name = last_name

    def full_name(self):
        return '%s %s'%(self.first_name,self.last_name)

someone = Person('王','小红')
someone.first_name
someone.last_name
someone.full_name()

someone.first_name = '刘'

someone.full_name = '刘小红'
someone.full_name


#使用@property
class Person():
    def __init__(self,first_name,last_name):
        self.first_name = first_name
        self.last_name = last_name
    @property
    def full_name(self):
        return '%s %s'%(self.first_name,self.last_name)

someone = Person('王','小红')
someone.first_name
someone.last_name
someone.full_name = '刘晓红'  # @property将类中方法只读属性

#@property实现getter，seter方法

class Duck():
    def __init__(self,input_name):
        self.hidden_name = input_name
    @property
    def name(self):
        print('insder the getter')
        return self.hidden_name
    @name.setter
    def name(self,input_name):
        print('insder the setter')
        self.hidden_name = input_name

duck = Duck('tanglaoye')

duck.name
duck.name ='米老鼠'
duck.hidden_name='唐老鸭'

名称重整

#名称重整
class Duck():
    def __init__(self,input_name):
        self.__name = input_name
    @property
    def name(self):
        print('insder the getter')
        return self.__name
    @name.setter
    def name(self,input_name):
        print('insder the setter')
        self.__name = input_name

duck = Duck('tanglaoye')

duck.name='唐老鸭'
duck.name
duck.__name

duck._Duck__name = '米老鼠'

方法的类型

以self 作为第一个参数的方法都是实例方法（instance method）。上面已经对实例方法做了说明，这里就不再累述。

与之相对，类方法（class method）会作用于整个类，对类作出的任何改变会对它的所有实例对象产生影响。在类定义内部，用前缀修饰符@classmethod 指定的方法都是类方法。与实例方法类似，类方法的第一个参数是类本身。在Python 中，这个参数常被写作cls，因为全称class 是保留字，在这里我们无法使用。

class Person():
    '类方法的演示'
    count = 0
    def __init__(self):
        Person.count += 1

    @classmethod
    def my_count(cls):
        print('Person类被实例化了%s次'%cls.count)

someone =Person()
someone1 =Person()
someone2 =Person()
someone.my_count()
Person.my_count()

静态方法

类定义中的方法还存在着第三种类型，它既不会影响类也不会影响类的对象。它们出现在类的定义中仅仅是为了方便，否则它们只能孤零零地出现在代码的其他地方，这会影响代码的逻辑性。这种类型的方法被称作静态方法（static method），用@staticmethod 修饰，它既不需要self 参数也不需要class 参数。

@staticmethod

class Person():
    @staticmethod
    def saying():
        print('有朋自远方来，不亦说乎！')


Person.saying()

鸭子类型

Python 对实现多态（polymorphism）要求得十分宽松，这意味着我们可以对不同对象调用同名的操作，甚至不用管这些对象的类型是什么。

#创建三个类，分别是地瓜、土豆，吃瓜群众

class TD():
    def __init__(self,person,words):
        self.person  = person
        self.words = words
    def who(self):
        return self.person
    def says(self):
        return self.words + " 。"

class DG(TD):
    def says(self):
        return self.words + "!"
class CG(TD):
    def says(self):
        return self.words + "......"

td = TD('土豆','地瓜地瓜，我是土豆')
dg = DG('地瓜','你叫谁地瓜呢')
cg = CG('吃瓜群众','哈哈哈哈哈')

td.who()
td.says()

dg.who()
dg.says()

cg.who()
cg.says()

class Duck():
    def who(self):
        return '唐老鸭'
    def says(self):
        return 'gagaga……'

duck = Duck()

#这里我们要演示一下动态类型
def who_say(obj):
    print(obj.who() ,'saying:',obj.says())

who_say(td)
who_say(dg)
who_say(cg)

who_say(duck)

这种方式有时被称作鸭子类型（duck typing），这个命名源自一句名言：

如果它像鸭子一样走路，像鸭子一样叫，那么它就是一只鸭子。

特殊方法

到目前为止，你已经能创建并使用基本对象了。现在再往深钻研一些。当我们输入像a = 3 + 8 这样的式子时，整数3 和8 是怎么知道如何实现+ 的？同样，a又是怎么知道如何使用= 来获取计算结果的？你可以使用Python 的特殊方法（specialmethod），有时也被称作魔术方法（magic method），来实现这些操作符的功能。别担心，不需要甘道夫8 的帮助，它们一点也不复杂。

这些特殊方法的名称以双下划线（__）开头和结束。没错，你已经见过其中一个：__init__，它根据类的定义以及传入的参数对新创建的对象进行初始化。假设你有一个简单的Word 类，现在想要添加一个equals() 方法来比较两个词是否一致，忽略大小写。也就是说，一个包含值'ha' 的Word 对象与包含'HA' 的是相同的。下面的代码是第一次尝试，创建一个普通方法equals()。self.text 是当前Word 对象所包含的字符串文本，equals() 方法将该字符串与word2（另一个Word 对象）所包含的字符串做比较

#传统方式
class Word():
    def __init__(self,text):
        self.text = text

    def equals(self,word2):
        return self.text.lower() == word2.text.lower()

ha1 = Word('Ha')
ha2 = Word('ha')
he = Word('he')

ha1.equals(ha2)
ha1.equals(he)
#ha1 == ha2

#魔法方法
class Word():
    def __init__(self,text):
        self.text = text

    def __eq__(self,word2):
        return self.text.lower() == word2.text.lower()

ha1 = Word('Ha')
ha2 = Word('ha')
he = Word('he')

ha1 == ha2