数据结构与算法(Python)-Python快速入门篇3
Posted The fool
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了数据结构与算法(Python)-Python快速入门篇3相关的知识,希望对你有一定的参考价值。
写在前面
对于简单的任务,我们可以利用一些函数,按照任务处理的流程书写代码来完成需求,这种方式称之为过程式编程(procedural programming);但是对于复杂的系统,如何有条理的将每个模块的代码内聚起来,如何清晰和简洁地表达各个模块之间的交互,就需要一种新的指导思想,面向对象编程(object-oriented programming)。OOP强调的就是为独立模块构造对象,对象之间通过消息通信来完成复杂的功能。OOP主题是复杂的,本节只对有限主题进行学习,知识结构如下图所示:
面向对象编程(OOP)
1)类的定义
在Python每个变量实际上都是指向对象的一个引用,这在前面已经说明过了。我们使用class关键字定义类,就像使用def关键字定义函数一样。在Python中,支持两种定义类的写法:
#python2.x
class MyClass: # old-style
class MyClass(object): # new-style class
#python3.x
class MyClass(object): # new-style class
class MyClass: # new-style class (implicitly inherits from object)
上面的两种定义方式是受到历史原因引起的,在此我们不去深究。一种合理的方式是,在python2.x中总是显式使用:
class MyClass(object):
pass
这种方式;在python3.x中如果为了兼容2.x代码则也是用这种方式,否则没有区别。
2)类的成员变量和方法
OOP与面向过程编程一个很大的区别在于,对象可以附加属性(包含哪些数据)和方法(支持哪些操作,也是一种函数),通过将数据和函数内聚到对象身上,我们使对象的概念更加清晰,与系统其它部分的交互更加明确。例如下面定义一个圆形类:
class Circle():
pi = 3.141592
def __init__(self, radius=1): #初始化函数 类似C++构造函数
self.radius = radius
def area(self): # 求面积操作
return self.radius * self.radius * Circle.pi
def setRadius(self, radius):
self.radius = radius
def getRadius(self):
return self.radius
# 创建一个对象
c = Circle()
c.setRadius(5)
print(c.getRadius())
print(c.area())
在上面的例子中,我们定义了一个简单的圆形类,这个圆形类包含一个属性即半径,用radius存储,这称之为类的成员变量(member variables);同时包含3个方法分别用来计算圆的面积,设置和获取圆形的半径,这些称之为类的成员方法(member methods)。定义一个类之后,我们一般无法直接操作类,而是实例化类的一个具体对象(instance object)来操作,就好比你说开车,应该是开的某一辆具体车型的汽车。
在上面的例子中,我们也看到了一个self关键字,这个关键字用来表示对象本身的引用,类似于c++之中的this指针。当我们调用方法:
print(c.area()) # 通过对象调用成员方法
的时候,实际上对象c将会作为参数传入类成员函数area,此时self就绑定到了这个具体对象,那么函数实际操作的数据就是这个对象c的数据了。实际上也可以这样调用函数:
print(Circle.area(c)) # 通过显式传入对象 调用类的方法
这里我们实际上将c显式的传入了,而不是由解释器替我们传入。如果这样调用:
print(Circle.area()) # TypeError 缺少实例对象
将会产生:
TypeError: unbound method area() must be called with Circle instance as first argument (got nothing instead)
的错误,原因在于,没能正确传入一个实例变量作为第一个参数调用函数。
在Python中主要包括三种类型的成员变量和函数,他们之间都有区别,列出如下:
2.1)实例级别的成员 (instance -level members)
实例级别的成员就是属于每个对象自身的数据和函数,例如上例中的radius和另外三个成员函数。实例级别的成员变量,一般在_init_函数中进行初始化。例如:
class Foo(object):
def hello(self): # 注意这里需要传入实例对象给self
print("hello from %s" % self.__class__.__name__)
调用方式:
obj= Foo()
obj.hello() # 方式一
#>> "hello from Foo"
Foo.hello(obj) # 方式二
#>> "hello from Foo"
2.2)类级别的成员(class-level members)
类级别的成员,不属于某个具体的对象,而是由类来保持的数据或者函数。例如某个类需要保持对象创建数量的计数,这个计数就定义为类变量。上面例子中的pi就是类成员变量,类成员变量定义在init函数之外。
class Foo(object):
@classmethod
def hello(cls): # 注意这里传入的为类对象 而不是某个实例对象
print("hello from %s" % cls.__name__)
# 调用方式
Foo.hello() # 对于类成员函数 使用类名字调用更清晰
#>> "hello from Foo"
Foo().hello()
#>> "hello from Foo"
注意上面代码中使用了”@classmethod“这种标记,在Python中称之为Decorators,感兴趣地可以了解。
2.3)静态成员(static members)
静态成员是一种类里面为了某些操作的方便而包含在类里面的函数,这些函数在使用时不需要任何类或者实例的信息,实际上主要是为了便于管理,将它包含在类定义里面,实际应用得比较少。
class Foo(object):
@staticmethod
def hello(): # 不需要传入实例或者类对象作为参数
print("hello from FOO static")
Foo.hello()
#>> hello from FOO static
在类的成员函数中,有一类特殊函数,这类函数以双下划线开始和结尾,用来表示特定行为,例如str,函数用来将对象转换为字符串,这个字符串将在print等函数中用来输出对象的表示。
class Book(object):
def __init__(self, title, author, pages):
print("A book is created")
self.title = title
self.author = author
self.pages = pages
def __str__(self):
return "Title:0 , author:1, pages:2 ".format(
self.title, self.author, self.pages)
def __len__(self):
return self.pages
def __del__(self):
print("A book is destroyed")
book = Book("Inside Steve's Brain", "Leander Kahney", 304)
print(book)
print(len(book))
del book
#>> A book is created
#>>Title:Inside Steve's Brain , author:Leander Kahney,pages:304
#>>304
#>> A book is destroyed
这种机制类似于C++的操作符重载,Python中可以重载的函数还有add() ,sub() 等。
3)面向对象三要素
面向对象编程包含三大要素,分别是封装(encapsulation )、继承(inheritance)、多态(Polymorphism)。下面从这三个角度看下Python如何处理的,因为面向对象编程本身是个复杂主题,这里只提供一个基本思路,详细可以参考其他资料。
3.1 封装性
封装涉及的任务是如何设计类的接口供用户使用,重点是类的访问控制(access-control),避免用户有意或者无意破坏数据。需要注意的是,Python设计上不支持private变量和方法,通用的做法是用两个连续下划线表明这个成员应当被视为私有,不应该在类外使用。下面这个例子来自SO How to do encapsulation in Python?
class C(object):
def __init__(self):
self.a = 123 # OK to access directly
self._a = 123 # should be considered private
self.__a = 123 # considered private, name mangled
>>> c = C()
>>> c.a
123
>>> c._a
123
>>> c.__a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'C' object has no attribute '__a'
>>> c._C__a
123
在上面例子中,__a 方法被重写了(name mangling )为 _C__a,但实际上也能访问,这只是Python的一种提示方式,Python设计上不支持private。
3.2 继承性
继承是一个类对另一个类共同行为的复用机制,被继承的类称之为父类或者基类(base classes),从父类继承而来的类称之为子类或者派生类(derived classes)。子类不仅具有父类的成员变量和函数,同时也能修改父类的成员函数(overriding)和添加新的成员函数。
定义一个普通的银行账户,再定义一个最低额度的银行账户,如下:
class BankAccount(object):
def __init__(self):
self.balance = 0
def withdraw(self, amount):
self.balance -= amount
return self.balance
def deposit(self, amount):
self.balance += amount
return self.balance
class MinimumBalanceAccount(BankAccount):
def __init__(self, minimum_balance):
BankAccount.__init__(self) # call super class init method
self.minimum_balance = minimum_balance
def withdraw(self, amount): # overriding
if self.balance - amount < self.minimum_balance:
print 'Sorry, minimum balance must be maintained.'
else:
return BankAccount.withdraw(self, amount)
a = BankAccount()
b = MinimumBalanceAccount(100)
a.deposit(100)
b.deposit(100)
print(a.withdraw(10)) # >> 90
print(b.withdraw(10)) # >> Sorry, minimum balance must be maintained.None
在上面的例子中,MinimumBalanceAccount的定义中,括号里书写了
父类类名字BankAccount,从父类继承了balance 成员和其他函数,同时子类MinimumBalanceAccount添加了一个最低额度的minimum_balance成员,同时重写了withdraw方法。
需要注意的是子类调用父类的方法有两种:
super(SubClass, instance).method(args)
SuperClass.method(instance, args)
关于两种方式的好坏,可以参考Python super method and calling alternatives。
上面的例子中,我们使用:
BankAccount.withdraw(self, amount)
可以替换为:
super(MinimumBalanceAccount,self).withdraw(amount)
3.3 多态性
多态性是指利用父类的引用类型可以指向父类和子类任意对象,在运行时根据实际指向的对象类型来动态决定如何操作的行为。例如:
>>> a = "alfa"
>>> b = (1, 2, 3, 4)
>>> c = ['o', 'm', 'e', 'g', 'a']
>>>
>>> print(a[2])
f
>>> print(b[1])
2
>>> print(c[3])
g
这里的索引操作符,实际就是一种多态行为,对于字符串、元组、列表进行同种操作,但实际行为由对象本身决定。下面的例子利用继承定义了多个类,展示了多态行为:
class Animal(object):
def __init__(self, name=''):
self.name = name
def talk(self):
pass
class Cat(Animal):
def talk(self):
print("Meow!")
class Dog(Animal):
def talk(self):
print("Woof!")
animals = [Cat("Missy"), Dog("Rocky")]
for a in animals:
a.talk()
# >> Meow!
# >> Woof!
这里对a对象调用talk,实际执行时由对象的实际类型决定了哪种操作,这种动态运行的效果就是多态性,多态特性能很大程度上简化代码。
4 抽象类
Python在面向对象编程方面,没有提供定义接口的方法,但是支持抽象基类的。要定义抽象基类,需要使用python的abc库。下面给出一个python2.x版本的例子(来自Abstract Classes in Python):
from abc import ABCMeta, abstractmethod
class Animal(object):
__metaclass__ = ABCMeta
@abstractmethod
def say_something(self): pass # 抽象方法 非抽象子类需实现
class Cat(Animal):
def say_something(self):
return "Miauuu!"
a = Animal()
a.say_something()
如果试图实例化抽象基类,则会提示错误:
Traceback (most recent call last):
File "abstactDemo.py", line 13, in <module>
a = Animal()
TypeError: Can't instantiate abstract class Animal with abstract methods say_something
实例化实现了全部抽象方法的子类,则是允许的:
from abc import ABCMeta, abstractmethod
class Animal(object):
__metaclass__ = ABCMeta
@abstractmethod
def say_something(self):
return "I'm an animal!"
class Cat(Animal):
def say_something(self):
s = super(Cat, self).say_something()
return "%s - %s" % (s, "Miauuu")
a = Cat()
print(a.say_something())
# >> I'm an animal! - Miauuu
其他版本Python抽象基类实现,可以参考Is it possible to make abstract classes in python?。
参考资料
- Python class inherits object
- correct way to define class variables in Python
- What are “class methods” and “instance methods”, in Python?
- Object-oriented programming in Python
- Abstract Classes in Python
- Is it possible to make abstract classes in python?
- Improve Your Python: Python Classes and Object Oriented Programming
以上是关于数据结构与算法(Python)-Python快速入门篇3的主要内容,如果未能解决你的问题,请参考以下文章