资讯专栏INFORMATION COLUMN

Python 面向对象编程OOP (一) 类,对象,属性,访问权限

hiyayiji / 2456人阅读

摘要:面向对象编程之旅编程是什么大家好,作为小白,最近学习了很多编程的知识,因为脑容量有限,特此一一按照学习顺序记录下来,如果哪里有错误,还请大神尽快指出,以免误导他人。。。继承也允许把一个派生类的对象作为一个基类对象对待。

Python面向对象编程之旅 OOP编程是什么

大家好,作为小白,最近学习了很多Python OOP编程的知识,因为脑容量有限,特此一一按照学习顺序记录下来,如果哪里有错误,还请大神尽快指出,以免误导他人。。。

首先让我们简单了解一下何为面向对象编程:

把一组数据结构和处理它们的方法组成对象(object),把相同行为的对象归纳为类(class),通过类的封装(encapsulation)隐藏内部细节,通过继承(inheritance)实现类的特化(specialization)和泛化(generalization),通过多态(polymorphism)实现基于对象类型的动态分派。

这样一说貌似有些复杂,简单来看的话可以参考下面的解释:

常见概念一览
概念 解释
类(Class) 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例
类变量 类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用
数据成员 类变量或者实例变量, 用于处理类及其实例对象的相关的数据
方法重写 如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写
局部变量 定义在方法中的变量,只作用于当前实例的类
实例变量 在类的声明中,属性是用变量来表示的。这种变量就称为实例变量,是在类声明的内部但是在类的其他成员方法之外声明的
继承 即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如,有这样一个设计:一个Dog类型的对象派生自Animal类,这是模拟"是一个(is-a)"关系(例图,Dog是一个Animal)
实例化 创建一个类的实例,类的具体对象
方法 类中定义的函数
对象 通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法
定义一个类

下面让我们简单定义一个汽车类:

class Car:
    def __init__(self, color, model, year):

        self.color = color
        self.model = model
        self.year = year

这里我们创建了一个汽车类Car,它有三个公共属性,分别是color(颜色),model(型号),year(生产年份)

创建实例对象,访问属性

现在让我们新建一个对象my_car:

my_car = Car("yellow", "beetle", 1967)

查看一下my_car的属性

print(f" My {my_car.color} car {my_car.model} is made in {my_car.year}")
# My yellow car beetle is made in 1967
添加新属性

我们想要给my_car添加一个新属性wheels

my_car.wheels = 5
print(f"Wheels: {my_car.wheels}")
# Wheels: 5

使用dir(my_car)可以让我们确认一下属性是否存在:

dir(my_car)

Out:
["__class__",
 "__delattr__",
 "__dict__",
 "__dir__",
 "__doc__",
 "__eq__",
 "__format__",
 "__ge__",
 "__getattribute__",
 "__gt__",
 "__hash__",
 "__init__",
 "__init_subclass__",
 "__le__",
 "__lt__",
 "__module__",
 "__ne__",
 "__new__",
 "__reduce__",
 "__reduce_ex__",
 "__repr__",
 "__setattr__",
 "__sizeof__",
 "__str__",
 "__subclasshook__",
 "__weakref__",
 "color",
 "model",
 "wheels",     <====已经添加成功啦
 "year"]
类变量,修改类变量的值

在Python中,我们在类外声明一个类变量,下面让我们修改一下Car类:

class Car:
    wheels = 0
    def __init__(self, color, model, year):
        self.color = color
        self.model = model
        self.year = year

这样的话,我们在调用wheels这个变量时,可以通过实例,或者直接调用Car.wheels:

my_car = Car("yellow", "beetle", 1967)
print(f"My car is {my_car.color}")
print(f"It has {Car.wheels} wheels")
print(f"It has {my_car.wheels} wheels")

Out:
My car is yellow
It has 0 wheels
It has 0 wheels

这里需要注意一下,如果想要通过my_car.wheels =xxx来修改wheels的值,不会真正修改类变量wheels的值,我们来看一个具体的例子:

my_car = Car("yellow", "Beetle", "1966")
my_other_car = Car("red", "corvette", "1999")

print(f"My car is {my_car.color}")
print(f"It has {my_car.wheels} wheels")


print(f"My other car is {my_other_car.color}")
print(f"It has {my_other_car.wheels} wheels")

Out:
My car is yellow
It has 0 wheels
My other car is red
It has 0 wheels

我们首先创建两个实例my_car 和my_other_car ,默认的wheels=0,下面我们首先直接通过Car这个类来修改类变量的值:

# Change the class variable value

Car.wheels = 4

print(f"My car has {my_car.wheels} wheels")
print(f"My other car has {my_other_car.wheels} wheels")

Out:
My car has 4 wheels
My other car has 4 wheels

可以看到这样修改的话,Car类拥有的所有实例中的wheels值会被全部修改,如果我们通过my_other_car 来修改呢?

# Change the instance variable value for my_car

my_car.wheels = 5
print(f"My car has {my_car.wheels} wheels")
print(f"My other car has {my_other_car.wheels} wheels")

Out:
My car has 5 wheels
My other car has 4 wheels

现在大家可以发现区别了,仅仅是修改了my_car中wheels的值,对类本身不会造成影响

私有和公有属性

在Python中的所有属性都是public,可能有c++和java的同学觉得神奇,其实python最初规定了一种特殊的命名方式来区分public还是private,那就是下划线_

我还是拿一样的例子说明:

class Car:
    wheels = 0
    def __init__(self, color, model, year):
        self.color = color
        self.model = model
        self.year = year
        self._cupholders = 6

my_car = Car("yellow", "Beetle", "1969")
print(f"It was built in {my_car.year}")

Out:
It was built in 1969

这里Car类中的杯托 _cupholders就是“私有“属性,为什么我这里加上了引号,是因为Python只是名义上规定这种写法,但是在实际访问上没啥卵用,依然可以直接用._cupholders来访问:

my_car.year = 1966
print(f"It was built in {my_car.year}")
print(f"It has {my_car._cupholders} cupholders.")

Out:
It was built in 1966
It has 6 cupholders.

后来Python决定使用双下划线__来替换单下划线,这样可以最大程度避免“意外访问“,然而还是没有卵用,再来展示一下新方案:

class Car:
    wheels = 0
    def __init__(self, color, model, year):
        self.color = color
        self.model = model
        self.year = year
        self.__cupholders = 6

其实某种程度上,这回效果还是很明显的,如果我们还像刚才一样尝试调用my_car.cupholders 会报错:

my_car = Car("yellow", "Beetle", "1969")
print(f"It was built in {my_car.year}")
print(f"It has {my_car.__cupholders} cupholders.")


Out:
It was built in 1969

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
 in 
 1 my_car = Car("yellow", "Beetle", "1969")
 2 print(f"It was built in {my_car.year}")
----> 3  print(f"It has {my_car.__cupholders} cupholders.")

AttributeError: "Car" object has no attribute "__cupholders"

这个错误很有意思,为什么会说cupholders这个变量不存在呢 ? 因为当Python看到__ 时,会自动在cupholders前面补上一个下划线_和所属类名,也就是说,这里我们尝试用my_car.__cupholders 来调用时,Python默认的正确写法是
my_car._Car__cupholders,现在再试一下:

print(f"It has {my_car._Car__cupholders} cupholders")
Out: It has 6 cupholders

看见没,依然没拦住。。。。
不过我个人认为这种规定公有私有变量的方式也是好处多多,这里就仁者见仁,智者见智了~

访问权限管理

就像刚刚提到的,Python所有的东西都是公有的,我们可以随意的新增,修改,甚至删除变量:

my_car = Car("yellow", "beetle", 1969)
print(f"My car was built in {my_car.year}")

my_car.year = 2003
print(f"It was built in {my_car.year}")

del my_car.year
print(f"It was built in {my_car.year}")

Out:
My car was built in 1969
It was built in 2003

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
 in 
 6 
 7 del my_car.year
----> 8  print(f"It was built in {my_car.year}")

AttributeError: "Car" object has no attribute "year"

那我们如何才能控制属性的访问权限呢?Python给出的答案是装饰器 @property,这个类似于Java中的setter和getter,现在我们试试:

class Car:
    def __init__(self, color, model, year):
        self.color = color
        self.model = model
        self.year = year
        self._voltage = 12

    @property
    def voltage(self):
        return self._voltage

    @voltage.setter
    def voltage(self, volts):
        print("Warning: this can cause problems!")
        self._voltage = volts

    @voltage.deleter
    def voltage(self):
        print("Warning: the radio will stop working!")
        del self._voltage

我们新增了voltage(电压)这个属性,并用property来控制外部的访问权限,这里我们定义了三个方法,利用setter方法可以改变voltage的值,利用getter方法来访问,利用deleter方法实现删除,接下来让我们新建实例来看看propert是如何工作的:

my_car = Car("yellow", "beetle", 1969)
print(f"My car uses {my_car.voltage} volts")

my_car.voltage = 6
print(f"My car now uses {my_car.voltage} volts")

del my_car.voltage

Out:
My car uses 12 volts
Warning: this can cause problems!
My car now uses 6 volts
Warning: the radio will stop working!

可以发现,我们这里直接使用.voltage 而不是._voltage,这样就告诉python去使用property装饰的方法,我们可以通过使用@.setter and @.deleter 使属性变为read-only(只读),从而保护voltage不会被随意修改和删除

总结

今天主要总结了OOP编程中的类,对象,属性,公有私有属性,访问权限这些基础概念,下一篇文章会进一步深入,如果本文有哪些语言使用不当,希望大家可以指出,让我们一起进步!

我之前的一些文章已经放到了Github上,如果感兴趣的朋友可以去看看,链接如下:

Python 精品练习题100道

Python 实用技巧汇总

Python Pandas教程

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/45174.html

相关文章

  • Python理解面向对象

    摘要:面向对象编程,简称,是一种程序设计思想。面向过程与面向对象面向过程的程序设计把函数作为程序的基本单元。以上是在计算机世界里认识面向对象和面向过程,接下来给大家举个生活中的例子就拿你早上想吃鸡蛋灌饼为例。 面向对象编程——Object Oriented Programming,简称OOP,是一种程序设计思想。OOP把对象作为程序的基本单元,一个对象包含了数据和操作数据的函数。 面向过程 ...

    hatlonely 评论0 收藏0
  • Python OOP 面向对象编程

    摘要:时代,如果需要手动继承,如多态多态是指,不同的子类对象调用相同的父类方法,会产生多态多样结果的编程特性。 参考:黑马程序员教程 - Python基础 面向对象 OOP三大特性,且三个特性是有顺序的: 封装 继承 多态 封装 指的就是把现实世界的事务,封装、抽象成编程里的对象,包括各种属性和方法。这个一般都很简单,不需要多讲。 唯一要注意的就是:推荐从小往大开始封装、开发类。比如手枪...

    weknow619 评论0 收藏0
  • Python面向对象编程 - 和实例

    摘要:一面向对象编程。是一门面向对象的编程语言,通过对象实现对方法的调用。面向过程的程序设计把计算机程序视为一系列的命令集合,即一组函数的顺序执行。对于面向对象语言,重要的概念是类和实例。 一、preface 面向对象编程OOP:object oriented programming。OOP把对象作为程序的基本单元,一个对象包含了数据和操作数据的函数。Python是一门面向对象的编程语言,...

    Elle 评论0 收藏0
  • [零基础学python]关于的初步认识

    摘要:反对者在某些领域对此予以否认。下面再引用一段来自维基百科中关于的历史。类的更严格的定义是由某种特定的元数据所组成的内聚的包。类还可以有运行时表示形式元对象,它为操作与类相关的元数据提供了运行时支持。 在开始部分,请看官非常非常耐心地阅读下面几个枯燥的术语解释,本来这不符合本教程的风格,但是,请看官谅解,因为列位将来一定要阅读枯燥的东西的。这些枯燥的属于解释,均来自维基百科。 1、问题...

    王岩威 评论0 收藏0
  • 【数据科学系统学习】Python # 编程基础[三]

    摘要:新的称为子类,而被继承的称为基类父类或超类。继承最大的好处是子类获得了父类的全部功能。在继承关系中,如果一个实例的数据类型是某个子类,那它的数据类型也可以被看做是父类。 在上一篇中我们介绍了模块和数据结构,这一篇将介绍面向对象编程。 面向对象编程 面向对象编程——Object Oriented Programming,简称 OOP,是一种程序设计思想。OOP 把对象作为程序的基本单元...

    molyzzx 评论0 收藏0

发表评论

0条评论

最新活动
阅读需要支付1元查看
<