python-复盘-面向对象编程

面向对象编程


类和实例

类是创建实例的模板,而实例则是一个一个具体的对象,各个实例拥有的数据都互相独立,互不影响;

方法就是与实例绑定的函数,和普通函数不同,方法可以直接访问实例的数据

通过在实例上调用方法,我们就直接操作了对象内部的数据,但无需知道方法内部的实现细节。

和静态语言不同,Python允许对实例变量绑定任何数据,也就是说,对于两个实例变量,虽然它们都是同一个类的不同实例,但拥有的变量名称都可能不同


访问权限

如果要让内部属性不被外部访问,可以把属性的名称前加上两个下划线__,在Python中,实例的变量名如果以__开头,就变成了一个私有变量(private),只有内部可以访问,外部不能访问
以之前的Student类,name score 属性为例:
如果外部代码要获取name和score怎么办?可以给Student类增加get_nameget_score这样的方法:

class Student(object):
    ...

    def get_name(self):
        return self.__name

    def get_score(self):
        return self.__score

如果又要允许外部代码修改score怎么办?可以再给Student类增加set_score方法:

class Student(object):
    ...

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

在Python中,变量名类似__xxx__的,也就是以双下划线开头,并且以双下划线结尾的,是特殊变量,特殊变量是可以直接访问的

__xxx 是私有变量,_xxx 是公有变量,但约定俗成,最好当成私有变量,不要随意访问


获取对象信息

type()
isinstance()
用在class判断继承关系上方便
dir()
获得一个对象的所有属性和方法,可以使用dir()函数,它返回一个包含字符串的list

getattr()

>>> getattr(obj, 'y') # 获取属性'y'
19

setattr()

>>> setattr(obj, 'y', 19)    # 设置一个属性'y'
>>> hasattr(obj, 'y')    # 有属性'y'吗?
True

hasattr()

>>> hasattr(obj, 'x')    # 有属性'x'吗?
True

通过内置的一系列函数,我们可以对任意一个Python对象进行剖析,拿到其内部的数据。要注意的是,只有在不知道对象信息的时候,我们才会去获取对象信息。



实例属性和类属性

由于Python是动态语言,根据类创建的实例可以任意绑定属性。

给实例绑定属性的方法是通过实例变量,或者通过self变量

class Student(object):  #  给实例绑定属性的方法是通过实例变量,或者通过self变量
    def __init__(self, name,score):
        self.name = name
        self.score = score

s = Student('Bob', 90)    # 这里init定义2个参数,所以这里必须输入2个参数,否则报错 
s.name 
# 输出结果: 'Bob'
s.score 
#  输出结果:90
In [204]: class Student(object):
     ...:     sex = 'girl'   # 类属性
     ...:     def __init__(self, name, score):   # 实例属性
     ...:         self.name = name
     ...:         self.score = score
     ...:

In [205]: s = Student('lily',99)

In [206]: s.name
Out[206]: 'lily'

In [207]: s.score
Out[207]: 99

In [208]: instance = Student()     # 必须传入2参数
TypeError: __init__() missing 2 required positional arguments: 'name' and 'score'

In [209]: instance = Student('lily',99)
In [210]: instance.sex    # sex是类属性,但该类的实例同样可以访问它
Out[210]: 'girl'

但是,如果Student类本身需要绑定一个属性呢?可以直接在class中定义属性,这种属性是类属性,归Student类所有:

class Student(object):    #  类属性
    name = 'Student'

类属性虽然归类所有,但类的所有实例都可以访问到

>>> class Student(object):
...     name = 'Student'
...
>>> s = Student()   # 创建实例s
>>> print(s.name)   # 打印name属性,因为实例并没有name属性,所以会继续查找class的name属性
Student
>>> print(Student.name)   # 打印类的name属性
Student
>>> s.name = 'Michael'   # 给实例绑定name属性
>>> print(s.name)   # 由于实例属性优先级比类属性高,因此,它会屏蔽掉类的name属性
Michael
>>> print(Student.name)   # 但是类属性并未消失,用Student.name仍然可以访问
Student
>>> del s.name   # 如果删除实例的name属性
>>> print(s.name)   # 再次调用s.name,由于实例的name属性没有找到,类的name属性就显示出来了
Student

⚠️注意:从上面的例子可以看出,在编写程序的时候,千万不要把实例属性和类属性使用相同的名字,因为相同名称的实例属性将屏蔽掉类属性,但是当你删除实例属性后,再使用相同的名称,访问到的将是类属性

python-复盘-面向对象编程_第1张图片



对类 子类 继承 类属性 类方法 的实验

class Model(object):
    def __init__(self, high, sex):
        self.high = high
        self.sex = sex

    weight = 100   # 类属性

    def love(self,x):   # 实例属性
        print(x, ': i love you~')

class Man(Model):
    def __init__(self, age):
        self.age = age

    state = 'china'   # 类属性

    def miss(self,y):   # 实例属性
        print(y, ': i miss you much~')

def what_the_fuck(z):
    print(z.love('kobe'), ':tell me duck type, what the fuck~')


# 测试 Model
test = Model(180, 'male')   # test 为Model类的实例
test1 = Model(high = 180, sex = 'male')   # 在ORM章节,定义有这样的参数输入,本质等价
print( test,test1 )   # 结果一样: <__main__.Model object at 0x1070609b0> #
print( test.high, test.sex )   # 结果: 180 male #
print( Model.weight, test.weight )   # 结果: 100 100  # weight是类属性,所以类与实例均可调用
print(  test.love('lily')  )  # 结果: lily : i love you~  # 其他方式均报错

# 测试 Man,继承自 Model
jack = Man(18)     # 只能输入一个age参数,父类的 high sex 不影响它
                   #  除非用 super()方法去继承,这样父类里的__init__(self, *args,**kwargs)才能被继承作为子类生成实例时必须输入的参数
print(  jack, jack.age, jack.miss('lily'), jack.love('lily') ) # 运行正常,第一个提示为对象;可识别父类的 love 方法
print( jack.high )  # 报错,不识别父类的 high
print( jack.state, Man.state, jack.weight, Man.weight )   # 结果 china china 100 100  # 也是就是说子类的类和实例 都 可以继承父类的类属性

# 测试鸭子类型
z = Man(18)
print( what_the_fuck(z) )  # 结果: kobe : i love you~ kobe : i love you~  # 这就是鸭子类型,把类实例作为函数的参数,函数中正好有该类实例的自身的函数,可自动识别

你可能感兴趣的:(python-复盘-面向对象编程)