Python 面向对象基础

zoukankan html css js c++ java

Python 面向对象基础
Python 面向对象基础

Python从设计之初就已经是一门面向对象的语言，正因如此，在Python中创建类和对象是很容易的。首先，我们需要简单了解下面向对象的一些基本特征：
面向对象简介
- 类(Class)：用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法，对象是类的实例。可以理解为"模板"；
- 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用；
- 数据成员：类变量或实例变量用于处理类及其实例对象的相关数据；
- 方法重写：如果从父类继承的方法不能满足子类的要求，可以对其进行改写，这个过程叫方法的覆盖(override)，也称为方法的重写；
- 实例变量：定义在方法中的变量，只作用于当前实例的类；
- 继承：即派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如：有这样一个设计，一个Dog类型的对象派生自Animal类，这是模拟"是一个(is-a)"关系(例如，Dog是一个Animal)；
- 实例化：创建一个类的实例，类的具体对象；
- 方法：类中定义的函数；
- 对象：通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法；
和其它编程语言相比，Python在尽可能不增加新的语法和语义的情况下加入了类机制。Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法，对象可以包含任意数量和类型的数据。

类定义
语法格式：
```
class ClassName:
    <statement-1>
    .
    .
    .<statement-N>
```
类实例化后，可以使用其属性，实际上创建一个类之后，可以通过类名访问其属性。

类对象
类对象支持两种操作：属性引用和实例化；
属性引用使用和Python中所有的属性引用一样的标准语法：obj.name；
类对象创建后，类命名空间中所有的命名都是有效属性名，如下类定义：
```
class MyClass:
    """一个简单的类定义"""
    number = 12345

    def func(self):
        return "Hello World!"


# 实例化类
my_class = MyClass()

# 访问类的属性和方法
print("MyClass 类的属性 number 为：", my_class.number)
print("MyClass 类的方法 func 输出为：", my_class.func())
```
以上创建了一个新的类实例并将该对象赋值给局部变量my_class，my_class为空对象。
运行输出结果为：
```
MyClass 类的属性 number 为： 12345
MyClass 类的方法 func 输出为： Hello World!
```
很多类都倾向于将对象创建为有初始状态的。因此类可能会定义一个名为__init__()的特数方法(构造方法：初始化对象)，如下：
```
def __init__(self):
    self.data = []
```
定义了__init__()方法的话，类的实例化操作会自动调用__init__()方法。所以，在下例中，可以这样创建一个新的实例：
```
my = MyClass()
```
当然，init()方法可以有参数，参数通过__init__()传递到类的实例化操作上。例如：
```
class Complex:
    def __init__(self, realpart, imagpart):
        self.real = realpart
        self.imag = imagpart


com = Complex(3.0, -4.5)
print(com.real, com.imag)       # 3.0 -4.5
```
self代表类的实例，而非类
类的方法与普通的函数只有一个特别的区别：他们必须有一个额外的第一个参数名称，按照管理它的名称是self(类的实例)；
```
class Test:
    def part(self):
        print(self)     # <__main__.Test object at 0x0000028F5A2B72E8>
        print(self.__class__)       # <class '__main__.Test'>


t = Test()
t.part()
```
从执行结果可以很明显的看出，self代表的是类的实例，代表当前对象的地址，而self.__class__则指向类。
self不是Python的关键字，我们把它换成any也是可以正常执行的：
```
class Test:
    def part(any):
        print(any)     # <__main__.Test object at 0x0000020AE29272E8>
        print(any.__class__)       # <class '__main__.Test'>


t = Test()
t.part()
```
类的方法
在类的内部，使用def关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数self，且为第一个参数，self代表的是类的实例。
```
# 类定义
class People:
    # 定义类属性
    name = ""
    age = 0

    # 定义私有属性，私有属性在类外部无法直接访问
    __weight = 0

    # 定义构造方法，实例化类时进行类的初始化
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print("%s 说：我 %d 岁。" % (self.name, self.age))


people = People("Jack", 22, 40)
people.speak()      # Jack 说：我 22 岁。
```
继承
Python同样支持类的继承，如果一种语言不支持继承，类就没有什么意义。派生类的定义如下：
```
class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>
```
需要注意圆括号中基类的顺序，若是基类中有相同的方法名，而在子类使用时未指定，Python从左至右搜索即方法在子类中未找到时，从左到右查找基类中是否包含该方法。BaseClassName(示例中的基类名)必须与派生类定义在一个作用域内，除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用：
```
class DerivedClassName(modname.BaseClassName):
```
```
# 类定义
class People:
    # 定义类属性
    name = ""
    age = 0

    # 定义私有属性，私有属性在类外部无法直接访问
    __weight = 0

    # 定义构造方法，实例化类时进行类的初始化
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print("%s 说：我 %d 岁。" % (self.name, self.age))


# 单继承示例
class Student(People):
    grade = ""

    def __init__(self, n, a, w, g):
        # 调用父类的构造函数
        People.__init__(self, n, a, w)
        self.grade = g

    # 覆写父类的方法
    def speak(self):
        print("%s 说：我 %d 岁了，我在读 %d 年级。" % (self.name, self.age, self.grade))


student = Student("Pony", 10, 30, 7)
student.speak()     # Pony 说：我 10 岁了，我在读 7 年级。
```
多继承
Python同样有限的支持多继承，多继承的类定义形式如下：
```
class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>
```
需要注意的是：圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，Python从左至右搜索即方法在子类中未找到时，从左至右查找父类中是否包含该方法(Python3多继承广度优先；Python2经典类深度优先，新式类广度优先(继承自object))：
```
# 类定义
class People:
    # 定义类属性
    name = ""
    age = 0

    # 定义私有属性，私有属性在类外部无法直接访问
    __weight = 0

    # 定义构造方法，实例化类时进行类的初始化
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print("%s 说：我 %d 岁。" % (self.name, self.age))


# 单继承示例
class Student(People):
    grade = ""

    def __init__(self, n, a, w, g):
        # 调用父类的构造函数
        People.__init__(self, n, a, w)
        self.grade = g

    # 覆写父类的方法
    def speak(self):
        print("%s 说：我 %d 岁了，我在读 %d 年级。" % (self.name, self.age, self.grade))


# 另一个类，多继承之前的准备
class Speaker:
    topic = ""
    name = ""

    def __init__(self, t, n):
        self.topic = t
        self.name = n

    def speak(self):
        print("我叫 %s ，我是一个演讲家，我演讲的主题是 %s 。" % (self.name, self.topic))


# 多重继承
class Sample(Speaker, Student):
    a = ""

    def __init__(self, n, a, w, g, t):
        Student.__init__(self, n, a, w, g)
        Speaker.__init__(self, t, n)


test = Sample("Tim", 15, 60, 9, "Python")
test.speak()        # 我叫 Tim ，我是一个演讲家，我演讲的主题是 Python 。
```
方法重写
如果父类的方法和功能不能满足要求，可以在子类中重写父类的方法，如下所示：
```
class Parent:       # 定义父类

    def my_method(self):
        print("调用父类方法。")


class Child(Parent):        # 定义子类
    def my_method(self):
        print("调用子类方法。")


child = Child()     # 子类实例
child.my_method()       # 子类调用重写方法
super(Child, child).my_method()     # 用子类对象调用父类已被覆盖的方法
```
运行输出结果为：
```
调用子类方法。
调用父类方法。
```
super()函数是用于调用父类(超类)的一个方法。
super()函数
super()函数是用于调用弗雷(超类)的一个方法，super()函数是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题。MRO就是类的方法解析顺序表，其实也就是继承父类方法时的顺序表，其语法为：
```
super(type[, object-or-type])
```
参数：
- type：类；
- object-or-type：类实例，一般是self；
Python3和Python2的一个区别是：Python3可以直接使用super().xxx代替super(Class, self).xxx：
```
# Python3实例
class A:
    pass
class B(A):
    def add(self, x):
        super().add(x)
```
```
# Python2实例
class A(object):   # Python2 记得继承 object
    pass
class B(A):
    def add(self, x):
        super(B, self).add(x)
```
该函数无返回值，如下示例：
```
class FooParent:
    def __init__(self):
        self.parent = "I'm the parent."
        print("Parent.")

    def bar(self, message):
        print("%s for Parent." % message)


class FooChild(FooParent):
    def __init__(self):
        # super()首先找到FooChild的父类(FooParent)，然后把类对象FooChild转换成FooParent对象
        super().__init__()      # in Python3
        # super(FooChild, self).__init__()    # in Python2
        print("Child.")

    def bar(self, message):
        super().bar(message)        # in Python3
        # super(FooChild, self).bar(message)      # in Python2
        print("Child bar function.")
        print(self.parent)


foo_child = FooChild()
foo_child.bar("Hello World!")
```
运行输出结果为：
```
Parent.
Child.
Hello World! for Parent.
Child bar function.
I'm the parent.
```
类属性与方法
- 类的私有属性：__private_attrs，两个下划线开头，声明该属性为私有，不能再类的外部被使用或直接访问，在类内部的方法中使用时self.__private_attrs；
- 类的方法：在类的内部，使用def关键字来定义的一个方法，与一般函数不同，类方法必须包含参数self，且为第一个参数，self代表的是类的实例；self的名字并不是规定死的，也可以用this，但最好还是按照约定使用self；
- 类的私有方法：__private_methods，两个下划线开头，声明该方法为私有方法，只能在类的内部调用，不能在类的外部调用，self.__private_methods；
```
# 类的私有属性
class JustCounter:
    __secret_counter = 0        # 私有属性
    public_counter = 0      # 公有属性

    def count(self):
        self.__secret_counter += 1
        self.public_counter += 1
        print(self.__secret_counter)


counter = JustCounter()
counter.count()
counter.count()
print(counter.public_counter)
print(counter.__secret_counter)
```
运行结果为：
```
1
2
2
Traceback (most recent call last):
  File "D:/PythonCode/oop directory/junior.py", line 116, in <module>
    print(counter.__secret_counter)        # 报错，实例不能访问私有属性
AttributeError: 'JustCounter' object has no attribute '__secret_counter'
```
无法访问私有属性的原因是：Python对私有属性的名字进行了改写(重写)，这样做的好处是：防止子类修改基类的属性或者方法。现在我们遍历dir(实例对象)查看类的内置方法和属性：
```
print(dir(counter))
```
运行结果为：
```
['_JustCounter__secret_counter', '__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__', 'count', 'public_counter']
```
可以发现，Python将内部私有__secret_counter修改成了"_JustCounter__secret_counter"(_类名__属性名)，这就是我们无法直接访问私有属性或者方法的原因，那么既然知道了这个原因，根据修改名便可以访问它了：
```
print(counter._JustCounter__secret_counter)        # 2
```
不建议使用这种方式直接访问类的私有属性，这样做不安全也不友好。
```
# 类的私有方法
class Site:
    def __init__(self, name, url):
        self.name = name        # 共有属性--实例
        self.__url = url        # 私有属性--实例

    def who(self):
        print("name : ", self.name)
        print("url : ", self.__url)

    def __foo(self):        # 私有方法
        print("这是私有方法。")
    
    def foo(self):      # 公有方法
        print("这是共有方法。")
        self.__foo()


site = Site("百度", "www.baidu.com")
site.who()      # 正常输出
site.foo()      # 正常输出
site.__foo()        # 报错
```
运行输出结果为：
```
name :  百度
url :  www.baidu.com
这是共有方法。
这是私有方法。
Traceback (most recent call last):
  File "D:/PythonCode/oop directory/junior.py", line 140, in <module>
    site.__foo()        # 报错
AttributeError: 'Site' object has no attribute '__foo'
```
面向对象特点
- 封装：把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏；
- 继承：可以使用现有类的所有功能，并在无需重现编写原来的类的情况下对这些功能进行扩展；
- 多态：简单理解为"一个接口，多种实现"，指一个基类派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对基类的方法做了不同的实现，这就是同一种事物表现出的多种形态；
领域模型---面向对象分析和设计过程的利剑
领域模型是对领域内的概念类或现实世界中对象的可视化表示，又称概念模型、领域对象模型、分析对象模型。它专注于分析问题领域本身，发掘重要的业务领域概念，并建立业务领域概念之间的关系。

领域建模三字经：找名词、加属性、连关系。举个简单例子说明：假设我们要为小卖部设计一套进销存系统，她为我们提供的业务描述是：每天凌晨从水果批发市场买苹果、梨、葡萄、橘子、香蕉、荔枝、核桃等等，反正哪些好卖她就买回来卖。葡萄、荔枝不能长久保存，一般要当天卖出去....。
针对上面这段业务描述，我们使用上面的三字经进行领域模型设计：
- 总结业务描述中的名词，首先建一个名词表，把涉及到的名词列出来，序号名词备注：
  1.水果批发市场
  2.买东西的人是一个隐含的名词，每天凌晨从水果批发市场拿货
  3.苹果
  4.梨
  5.葡萄
  6.橘子
  7.香蕉
  8.荔枝
  9.核桃
  10.顾客是一个隐含的名词，买回来卖的对象
  11.凌晨、当天时间名词，与实体及角色无关
  这个名词列表包括了业务的行为主体：角色，以及业务过程中的操作实体：模型，对我们接下来的用例描述、领域模型分析、需求分析很有帮助，当然这个名词列表需要经过进一步分析提炼，称为领域模型
- 确定业务实体：序号名词描述
  1.水果批发市场：不是本业务的一个实体
  2.买东西的人：是本业务的一个角色
  3.苹果：是一个实体
  4.梨：是一个实体
  5.葡萄：是一个实体
  6.橘子：是一个实体
  7.香蕉：是一个实体
  8.荔枝：是一个实体
  9.核桃：是一个实体
  10.顾客：是本业务的一个角色
  11.凌晨、当天时间名词，与实体及角色无关
  经过分析，我们得出的实体是：苹果、梨、葡萄、橘子、香蕉、荔枝、核桃，这些是不是模型呢？应该说还不是，还要经过进一步分析：在我们分析的业务领域内，它们有没有共性？苹果、梨、葡萄、橘子、香蕉、荔枝属于水果，核桃属于干果，它们都是果品的一个具体实例。而在水果中葡萄和荔枝属于不宜保存水果，通过这样进一步的分析得出如下的领域模型：
  果品进销存领域模型：这个领域模型不但能反映当前的经营实体，同时给我们需求分析人员和系统功能提供了一定的扩展视野：将来会不会经营食品，短期保持水果采取什么利润空间来促销，长期保存的水果会不会因为保存成本而导致利润下降。
连关系：用UML提供的方法和图例进行领域模型设计、确定模型之间的关系。领域模型是需求分析人员与用户交流的有力工具，是需求分析人员与用户共同理解的概念，是彼此之间交流的语言。而数据模型是系统设计、实现的一部分，描述的是对用户需求在数据结构上的实现，仅此而已。当然数据模型中的概念模型设计与领域模型类似，缺乏的是实体之间更广泛的关系描述。通常大家会考虑数据怎么存放的问题，我的理解是领域模型设计期间不用考虑数据的存放问题，只考虑业务描述中涉及的实体以及实体之间的关系。实体之间的关系，很多书都讲了，无非是泛化、依赖和关联，关联又分了一般关联、聚合、组合等等，这里就不再罗列了。
查看全文

相关阅读:
QT学习——dialog、widget、mainwindow的区别和选择
 剑指offer——二叉树的深度
 位运算实现加减乘除四则运算
 剑指offer——求两个整数和
 C++常用设计模式
 从编程实现角度学习 Faster R-CNN（附极简实现）
剑指offer——最小的k个数
 剑指offer——对称二叉树
 java 定时器
 rocketmq consumer接收到的MessageExt中各个字段的说明

原文地址：https://www.cnblogs.com/love9527/p/9024935.html