面向对象

概念

一个类可以类比现实世界的一个抽象实体，可以创建一种类型（type）

对象就是类的实例， Instance

属性包括字段 field 和方法 method,
字段代表的对象或类的变量，
方法则是类和对象拥有的方法

实例变量也就是对象拥有的变量
类变量也就是类拥有的变量。

语法

class

class Person:
    pass

p = Person()
print(p)

class Person:申明Person类 p = Person()， 创建对象 p

self

类方法与普通函数只有一种特定的区别——前者必须多加一个参数在参数列表开头，这个名 字必须添加到参数列表的开头， 但是你不用在你调用这个功能时为这个参数赋值，Python 会 为它提供。 这种特定的变量引用的是对象本身，按照惯例，它被赋予 self 这一名称。

你一定会在想 Python 是如何给 self 赋值的，以及为什么你不必给它一个值。一个例子或许会让这些疑问得到解答。

假设你有一个 MyClass 的类，这个类下有一个实例 myobject 。
当你调用一个这个对象的方法， 如 myobject.method(arg1, arg2) 时，
Python 将会自动将其转换成 MyClass.method(myobject, arg1, arg2) ——这就是 self 的全部特殊之处所在。
这同时意味着，如果你有一个没有参数的方法，你依旧必须拥有一个参数—— self 。

__init__方法

__init__ 方法会在类的对象被实例化（Instantiated）时立即运行。
这一方法可以对任何你想进行操作的目标对象进行初始化（Initialization）操作。
这里你要注意在 init 前后加上的双下划线__init__。

class Person:
    def __init__(self, name):
        '''
         __init__方法会在类实例化对象时立即执行
        :param name:
        '''
        self.name = name;

    def sayHello(self):
        print('evening,{0}'.format(self.name))

p = Person('lv')
p.sayHello()

self.name = name 对象上的 name 属性 p.sayHello() 调用对象的 sayHello 方法

类变量与对象变量

类变量（Class Variable）是共享的（Shared）——它们可以被属于该类的所有实例访问。 该类变量只拥有一个副本，当任何一个对象对类变量作出改变时，发生的变动将在其它所有 实例中都会得到体现。

对象变量（Object variable）由类的每一个独立的对象或实例所拥有。在这种情况下，每个对象都拥有属于它自己的字段的副本，也就是说，它们不会被共享，也不会以任何方式与其 它不同实例中的相同名称的字段产生关联。

class Robot:
    """robot 机器人类"""

    count = 0   ## count, 类变量,使用Robot.count
    def __init__(self, name):
        ## name 对象变量
        self.name = name
        Robot.count +=1


    def die(self):
        print('{0} is dieing'.format(self.name))
        Robot.count -= 1

        if(Robot.count == 0):
            print('{0} is the last one'.format(self.name))
        else:
            print('there are still {0} working'.format(Robot.count))

    def say_hi(self):
        print('hi, my mater, robot {0} is working'.format(self.name))

    @classmethod
    def how_many(cls):
        """ 类方法, 装饰器"""
        print('we have {:d} robots'.format(cls.count))


##   开始使用类
droid1 = Robot('R2-D2')
droid1.say_hi()
Robot.how_many()

droid2 = Robot('R2-D2')
droid2.say_hi()
Robot.how_many()

droid2.die()
droid1.die()
Robot.how_many()

count 是一个类变量， 通过 Robot.count 来访问，name 是 对象变量，通过 self.name 访问。 如果在变量前使用 双下滑线 __privatevariable，那么这个变量就会变成私有变量

私有属性

class Student():

    def __init__(self, name, score):
        ## 私有变量， 以__开头
        self.__name = name
        self.__score = score

    def print(self):
        print('student name: {}, score:{}'.format(self.__name, self.__score))

    ## 私有属性的读或写
    def set__name(self, name):
        self.__name = name

    def set__score(self, score):
        self.__score = score

    def get__name(self):
        return self.__name

    def get__score(self):
        return self.__score

s1 = Student('lv', 95)
s1.print()
s2 = Student('wang', 96)
s2.print()
## 直接读私有属性会报错
## print(s1.__name)
## print(s1.__score)

print(s1.get__name())
print(s2.get__name())
s1.set__name('lv123')
s2.set__name('wang123')
print(s1.get__name())
print(s2.get__name())

1. __name和 __score 是对象的私有属性， 私有属性以 __ 开头
2. 私有属性不能直接读或写， 只能通过方法来进行读或写 get__name 和 set__name

type()

import types
## type()
class Person:
    pass


def fn():
    pass


p = Person()
p1 = Person()
a = 1
print(type(a))
## 判断基础类型
print('判断基础类型',type(a) == int)
## 判断函数
print('判断函数',type(fn) == types.FunctionType)
## 判断类
print('判断类',type(p) == type(p1))

isinstance()

class Animal(object):
    pass


class Dog(Animal):
    pass


class Husky(Dog):
    pass


## object -> Animal -> Dog -> Husky
a = Animal()
d = Dog()
h = Husky()
## h 对象
print(isinstance(h, Husky))     ## True
print(isinstance(h, Dog))     ## True
print(isinstance(h, Animal))     ## True
## d 对象
print(isinstance(d, Dog))     ## True
print(isinstance(d, Animal))     ## True
print(isinstance(d, Husky))     ## True, Husky 是子类