python 历险记（二）— python 的面向对象

目录

• 前言
• 类和对象
  • 如何定义和实例化类?
  • 如何定义和使用属性？
  • 什么是方法？
    • 静态方法和普通方法
    • 构造函数该怎么写？
    • str 方法怎么写？
    • 多态是什么？
  • 继承性和 java 是一样的吗？
    • 父类和子类的初始化函数调用
      • 第一种情况,
      • 第二种情况
      • 第三种情况
    • super 有哪些用法？
• 结语

前言

想学爬虫还是 python 专业啊，之前一直在用 java， 现在决定尝尝鲜，使用 python及爬虫框架来完成网络数据采集。

编程语言之间都是相通的，比如都需要模块化，引入其他文件来实现功能，使用列表等容器来处理数据，都要使用 json 或 xml 来解析和传输数据。

你会发现 通过类比的方式，带着问题去学习，会走的很快

而且我认为 代码示例的作用是异常强大的, 我会尽量使用代码示例的方式来展示，以满足同学快速学习的需要，也备后续查询。

在上篇文章 中，讨论了 python 3 中 string, 数据结构(Dict, List, 元组)等重要的主题。

今天我会继续探险，去征服 python 3 中的面向对象， let's go 让我们出发吧!

类和对象

刚接触 python 中的类和对象，我也和大多数小伙伴一样迷茫，不知道它和我所熟知的 java 都有什么异同点，为此我还提出了一大堆问题

1. 如何创建和实例化类?
2. 是否和 java 一样有访问修饰符，分为几个级别？
3. 构造函数该怎么写？
4. 怎么进行 class 的继承？

下面就一一来探索这些疑惑。

如何定义和实例化类?

在 java 中要创建一个类就必须要使用 class 关键字，要将类实例化，创建一个对象，可以使用 new 关键字。在 python 中是怎么样的呢？

先看代码

class Person():
  """这个叫做定义体，用来解释类的用途"""

print(Person) #  <class '__main__.Person'>
# 由于是在程序顶层定义的，它的全名就是 '__main__.Person'

person = Person()
print(person) #  <__main__.Person object at 0x000000000219A1D0>

要定义一个类(class) 只要将 class 关键字放在前面即可，类内部也可以像 java 似的定义变量和函数，这个后面再看。

实例化一个类，也就是创建一个对象,并不需要使用 new 关键字，只需将 class 当做函数来调用就可以啦，是不是比 java 简洁不少。

了解了定义和实例化类，还有两个问题：

1. 要判断一个对象是不是某个类的实例该怎么做呢?用 isinstance

print(isinstance (person, Person)) # True

1. 判断对象是什么类型，该怎么做？ 用 type

print(type(person)) # <class '__main__.Person'>

如何定义和使用属性？

上面的代码，光有一个空对象是干不了任何事情的，我们也要像 java 一样为其定义属性和方法。

java 是不能动态定义一个变量的，必须要把它放在 class 中预先定义好才可以用；而在 python 中这却不是问题，不信看代码~

class Person():
  """这个叫做定义体，用来解释类的用途"""

person = Person()
person.age = 5
print(person.age)

虽然在对 Person class 定义时没有任何属性的声明，但在实例化后依然可以添加 age 属性，而且也并没有看到如 java 中 public, private 等访问修饰符的存在， python 中有没有这些概念呢？还真有，变量默认就是 public 公有的，如果 在变量名前添加两个下划线，这样就会认为是 private 私有变量了，直接访问是不可以的。看下面代码

class Person():
  """这个叫做定义体，用来解释类的用途"""
  gender = 'male'
  __age = 5

person = Person()
print(person.gender) # male
print(person.__age) # AttributeError: 'Person' object has no attribute '__age'

上面代码中，在打印 __age 时会报错，告知没有找到这个属性，其实就是 由于使用双下划线做前缀使其变成私有变量了。

那 函数名是不是也有私有函数，是不是也在前面加双下划线呢 ？猜的没错，这个我们后面再了解。

既然 python 对象的属性操作如此灵活，可以动态添加，那用户在使用时就可能会碰到一些异常。

比较典型的就是，访问一个不存在的属性，会抛出 AttributeError。对这种情况有两种方式可以处理：

1. 预先使用内置函数 hasattr 判定对象是否拥有该属性(记住，只对公有变量有效哦~)
2. 使用 try 语句处理

class Person():
  """这个叫做定义体，用来解释类的用途"""
  gender = 'male'
  __age = 5

person = Person() 

print(hasattr(person, 'gender')) # True
print(hasattr(person, 'name')) # False
print(hasattr(person, '__age')) # False

try:
  name = person.name
except AttributeError:
  name = 'unknown'

print(name)

什么是方法？

什么是方法？方法和函数有什么区别？在上一篇我就介绍了好多 string 的方法，为什么叫做方法，而不叫做 string 的函数呢?一起来了解下~

• 函数是指可以执行某种运算，可以通过名字来调用的一段语句的组合
• 方法是特殊的函数，是跟一个对象或类相关联的
• 方法是书写在类的定义之中,明确表示和类之间关系的
• 在调用方法时，前面需要加上类名（函数调用语法）或者实例化的对象名（方法调用语法)

静态方法和普通方法

调用方法分为两种形式，分别是

• 函数调用语法(静态方法)
• 普通方法(动态方法)

先看第一种函数调用语法，这其实和 java 中的静态方法是一样的，只是前面不需要 static 关键字。

class Person:
  def print_person(person):
    print('name: %s, gender%s, age:%d' % (person.name, person.gender, person.age))

person = Person()
person.name = 'Tom'
person.gender = 'male'
person.age = 10

Person.print_person(person)

函数调用语法的方式其实和单纯的函数调用，区别是不大的，因为方法前面的 class 对它没起什么作用，活动主体 依然是方法。

再看另外一种 方法调用语法,而这次的主体则是调用该方法的 对象

class Person:
  __name = 'Tom'
  __gender = 'male'
  __age = 10

  def print_person(self):
    print('name: %s, gender:%s, age:%d' % (self.__name, self.__gender, self.__age))

person = Person()
person.print_person()

细心的同学会发现这里在定义方法时形参为 self, 而在调用方法时却没有任何入参。

那这个 self 是什么呢？

如果类比 java 的话，这个 self 可以看作是 this, 其实就是对当前对象的引用。 java 中定义方法时不必将其做入参。而这个 self 在 python 中则是必须声明的，在调用的时候则不必传入。

注意，这个 self 可不是关键字哦，只要占据方法形参的头把交椅，你可以用任何名字。

构造函数该怎么写？

在 java 中构造函数是与类同名的，而且会伴随着实例化的动作而执行。在 python 中呢？

python 中的构造函数叫做 init 方法，全名是 __init__

具体看下面代码

class Person():
  __gender = 'male'
  __age = '0'

  def __init__(self, gender='male', age=0):
    self.__gender = gender
    self.__age = age

person1 = Person('female', 10)
person2 = Person()
person2 = Person('male')

作为实例方法， self 入参当然少不了，其他参数就按照顺序排开，若参数不够，就用默认值来代替。

str 方法怎么写？

在java 中， 我们一般会覆盖 toString() 方法来返回对象中包含的值得关注的信息。 python 中也有这样一个方法,叫做 __str__。

class Person:
  __name = 'Tom'
  __gender = 'male'
  __age = 10

  def __str__(self):
    return ('name: %s, gender:%s, age:%d' % (self.__name, self.__gender, self.__age))

person = Person()
print(person)

作为最佳实践的一部分，建议你在每个创建的类中都覆盖这个方法。

多态是什么？

还记得面向对象的几个特征吗?封装性，继承性，多态性。嗯，来聊下 python 对多态的实现。

什么叫做多态？

在 java 中，如果在一个 class 中有多个函数，函数名相同而参数不同（个数或类型不同），就叫做多态。

而在 python 中, 多态的概念则更进一步，对于同一个函数，如果能够处理多种类型的数据，也叫做多态。

tuple_list = [(1, 2,), (2, 3,), (4, 5)]
list = [1, 2, 3, 4]
dict1 = {
  'a' : 1,
  'b' : 2
}

def printSomething(something):
  for i in something:
      print(i)

print(tuple_list)
print(dict1)
print(list)

printSomething 一个函数可以同时打印元组，列表以及字典，充分发挥代码复用的功效，是不是很方便。

继承性和 java 是一样的吗？

聊完了多态，再来看看面向对象的另一个特征：继承性。

什么是继承？继承就是定义好了一个类 A(父类);再定义一个新类 B（子类），类 B 拥有类 A 的方法和属性，并且又定义了新的属性和方法。类 A 称为父类，类 B 称为子类。

java 中定义两个类的继承关系，使用 extends 关键字实现，在 python 中呢？

class Father:
  """ 这是一个父类 """
  __age = 45

class Son(Father):
  """ 这是一个子类 """

python 中不需要加关键字来说明继承关系，只需要将父类的名称放在括号中就可以了,看起来要比 java 简洁一些。

父类和子类的初始化函数调用

前面讲过， python class 中可以定义自己的初始化函数，在实例化的时会被调用。那如果父类和子类都有初始化函数或者父类有而子类没有，那初始化函数该如何执行呢？这里分为三种情况来说明，先来看第一种。

第一种情况,

父类有 init 而子类没有, 这时父类的初始化函数会被默认调用

class Father():
  """ 这是一个父类 """
  def __init__(self, age):
    print("Father's init function invoke")
    self.__age = age

class Son(Father):
  """ 这是一个子类 """

son = Son(5)

这里要注意，父类中需要的 age 参数一定要传进去哦，要不然会报错的。

第二种情况

父类，子类都有 init ，而子类没有显式调用父类的 init 方法时，父类初始化函数是不会被调用的

class Father():
  """ 这是一个父类 """
  def __init__(self, age):
    print("Father's init function invoke")
    self.__age = age

  def get_age(self):
    return self.__age

class Son(Father):
  """ 这是一个子类 """
  def __init__(self, age):
    print("Son's init function invoke")
    self.__age = age

son = Son(5) # Son's init function invoke
print(son.get_age()) # AttributeError: 'Son' object has no attribute '_Father__age'

细心的同学会发现，代码中的最后一句报错了，表示 Son 对象没有 Father 类的 __age 变量。这是因为

• 父类的初始化函数没有执行，父类的 __age 变量则没有初始化
• get_age 函数是被子类从父类继承来的，返回的是父类的 __age 变量

那我要是想解决这个错误，该怎么做呢？有两种方法

1. 在子类 Son 的初始化函数中显式调用父类 Father 的初始化函数
2. 在子类 Son 中重新定义个 get_age 方法，这样就会覆盖父类的同名方法，返回的是子类的 _age 变量

第二种方法就不贴代码了，感兴趣的话可以试试。重点来看第一种方法，这就引出了第 3 种情况。

第三种情况

子类在自己定义的 init 方法中,显式调用父类的 init 方法，父类和子类的属性都会被初始化

class Father():
  """ 这是一个父类 """
  def __init__(self, age):
    print("Father's init function invoke")
    self.__age = age 

  def get_age(self):
    return self.__age

class Son(Father):
  """ 这是一个子类 """
  def __init__(self, age):
    print("Son's init function invoke")
    self.__age = age
    super(Son, self).__init__(age + 25)

  def get_age(self):
    return self.__age

  def get_father_age(self):
    return super(Son, self).get_age()
son = Son(5)
# Son's init function invoke
# Father's init function invoke
print(son.get_father_age()) # 30
print(son.get_age()) # 5

看到代码中是怎么调用父类的初始化函数吗？ 对，用的是 super。

java 中也有 super 关键字,表示对父类的指代， python 的 super 是怎么用的，原理是什么？我们来看下。

super 有哪些用法？

下面说明的只针对 python 单继承的情况，多继承这里暂不涉及，有兴趣的同学可以自行充电。

在单继承中，super 也可以看做对其父类的指代，它的使用场合就是用来调用父类的方法:

1. 调用父类的 __init__方法
2. 实现了和父类相同的功能，还需要调用父类的方法

它的写法是 super(Son,self).xxx, 当然也可以写成 super() 这种简写的形式。

来看代码

class Father():
  """ 这是一个父类 """
  def __init__(self, age):
    print("Father's init function invoke")
    self.__age = age 

  def get_age(self):
    return self.__age

class Son(Father):
  """ 这是一个子类 """
  def __init__(self, age):
    print("Son's init function invoke")
    self.__age = age
    super(Son, self).__init__(age + 25)

  def get_age(self):
    return self.__age

  def get_father_age(self):
    return super(Son, self).get_age()
son = Son(5)
# Son's init function invoke
# Father's init function invoke
print(son.get_father_age()) # 30
print(son.get_age()) # 5

通过代码来窥探下它的执行原理，以 super(Son, self).get_age() 为例

1. self 是 Son 的一个实例， super 把 self 转化为父类 Father 的一个实例对象
2. 因为 self 经过了转化， 那它得到的 __age, 也是父类初始化时得到的 __age

结语

看到这里，不知您对 python 的面向对象有了多少理解，反正我是理解了不少，哈哈。如果有疑问和建议，欢迎留言交流，我将仔细阅读，认真回复。

下篇文章中会涉及到 文件， json xml 处理 处理等主题，敬请期待~