Python基础教程-面向对象

发表于 更新于 分类于
Python学习

[TOC]

面向对象

Python是一门面向对象（OO）的语言。

面向对象编程——Object Oriented Programming，简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，

面向对象最重要的概念就是类（Class）和对象（Object）。
面向对象有3大特性：封装、继承、多态。

基本概念

类和对象: OO将有共同特性的事物抽象为类。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

数据成员： 类中定义的数据(变量，常量等等)。

方法成员： 类中定义的函数。

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

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

继承： 一个派生类（derived class）继承基类（base class）的字段和方法。。例如，一个Dog类型的对象派生自Animal类。

方法重写： 如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

类与对象

），必须牢记类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。

我们接下来将明确类对象和实例对象。

类定义

语法格式如下：

1
2
3
4
class ClassName:
    <statement-1>
    ....
    <statement-N>

类对象

类对象支持两种操作：属性引用和实例化。

1
2
3
4
5
6
7
8
9
10
11
12
13
class MyClass:
    """一个简单的类实例""" ## 类描述信息
    i = 12345  ## 类变量
    
    def f(self):  ## 方法
        return 'hello world'

# 实例化类
x = MyClass()
 
# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())

构造方法

和其它语言不同，Python没有专门的构造函数。相反，Python创建对象后，使用__init__方法初始化类，包括定义实例属性。
因此。我们类会定义一个名为 init() 的特殊方法（构造方法）

1
2
def __init__(self):
    self.data = []

我们定义了__init__方法，并为类创建了一个实例睡醒data.

上面我们使用了一个self。self代表类的当前实例，类似java,c++中的this. 而非类。

定义方法

在类地内部，使用def关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的当前实例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#类定义
class people:
    #类定义基本属性
    name = ''
    age = 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))
 
# 实例化类
p = people('runoob',10,30)
p.speak()

继承

面向对象都支持继承。语法如下：

1
2
3
4
5
class DerivedClassName(BaseClassName1):
    <statement-1>
    .

    <statement-N>

Python同样有限的支持多继承形式。多继承的类定义形如下例:

1
2
3
4
5
class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
 
    <statement-N>

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。

多继承会造成很多问题，不推荐使用多继承，

方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法，实例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法

super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

super() 函数是用于调用父类(超类)的一个方法。

访问控制-类属性与方法

java,c++中有 private, public, protected等控制对类的访问，
Python使用__来控制对私有属性的访问。

类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类地外部调用。self.__private_methods。

类的方法
在类地内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量

    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print (self.__secretCount)

    def __private_count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print (self.__secretCount)


counter = JustCounter()
counter.count()
counter.__private_count()      # 报错，实例不能访问
print (counter.publicCount)
print (counter.__secretCount)  # 报错，实例不能访问私有变量

类的专有方法

  • init : 构造函数，在生成对象时调用
  • del : 析构函数，释放对象时使用
  • repr : 打印，转换
  • str : 打印，类似java toString()
  • setitem : 按照索引赋值
  • getitem: 按照索引获取值
  • len: 获得长度
  • cmp: 比较运算
  • call: 函数调用
  • add: 加运算
  • sub: 减运算
  • mul: 乘运算
  • div: 除运算
  • mod: 求余运算
  • pow: 乘方

获取对象信息

type

当我们拿到一个对象的引用时，如何知道这个对象是什么类型、有哪些方法呢？ 使用type()

首先，我们来判断对象类型，使用type()函数：

基本类型都可以用type()判断：

1
2
3
4
5
6
7
8
9
10
11
>>> type(123)
<class 'int'>
>>> type('str')
<class 'str'>
>>> type(None)
<type(None) 'NoneType'>
如果一个变量指向函数或者类，也可以用type()判断：

>>> type(abs)
<class 'builtin_function_or_method'>
>>> type(a)

<class ‘__main__.Animal’>

isinstance()

对于class的继承关系来说，使用type()就很不方便。我们要判断class的类型，可以使用isinstance()函数。

如果继承关系是：

1
object -> Animal -> Dog -> Husky

那么，isinstance()就可以告诉我们，一个对象是否是某种类型。先创建3种类型的对象：

1
2
3
4
5
6
7
>>> a = Animal()
>>> d = Dog()
>>> h = Husky()
然后，判断：

>>> isinstance(h, Husky)
True

dir()

如果要获得一个对象的所有属性和方法，可以使用dir()函数，它返回一个包含字符串的list，比如，获得一个str对象的所有属性和方法：

1
2
>>> dir('ABC')
['__add__', '__class__',..., '__subclasshook__', 'capitalize', 'casefold',..., 'zfill']