Python学习笔记（六）--面向对象编程

最新推荐文章于 2024-04-19 21:46:17 发布

suixinsuiyuan33

最新推荐文章于 2024-04-19 21:46:17 发布

阅读量519

点赞数

分类专栏： Python学习笔记

本文链接：https://blog.csdn.net/suixinsuiyuan33/article/details/61920603

版权

Python学习笔记专栏收录该内容

7 篇文章 0 订阅

订阅专栏

本文详细介绍了Python中的面向对象编程，包括类和实例的概念、访问限制、继承和多态，以及如何获取对象的信息。通过实例展示了类的创建、实例化、方法定义，以及如何隐藏内部属性。还探讨了Python中的继承特性，如多态性，并强调了动态语言的鸭子类型。最后，讨论了如何使用type()、isinstance()和dir()等函数来获取和检查对象的属性和类型信息。

摘要由CSDN通过智能技术生成

Python学习笔记（六）--面向对象编程

ObjectOriented Programming

OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。

面向过程的程序设计：把计算机程序视为一系列的命令集合，即一组函数的顺序执行。为了简化程序设计，面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度。

面向对象的程序设计：把计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。

在Python中，所有数据类型都可以视为对象，当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类（Class）的概念。

一、类和实例

牢记：

类是抽象的模板。

实例是根据类创建出来的一个个具体的“对象”。每个对象实例都拥有相同的方法，但各自的数据可能不同。

classStudent(object):

类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的，继承的概念我们后面再讲，通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。

创建实例是通过“类名+()”实现的

通过定义一个特殊的__init__方法，在创建实例的时候，我们认为必须绑定的属性强制填写进去：

def __init__(self, name, score):

self.name = name

self.score = score

注意：特殊方法“_ _init_ _”前后有两个下划线！！！

注意到__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。

有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去:

bart = Student('BartSimpson', 59)

和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数。除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数。

数据封装

可以直接在Student类的内部定义访问数据的函数，这样，就把“数据”给封装起来了。这些封装数据的函数是和Student类本身是关联起来的，我们称之为类的方法：

def print_score(self):

print('%s: %s' % (self.name, self.score))

除了第一个参数是self外，其他和普通函数一样。要调用一个方法，只需要在实例变量上直接调用，除了self不用传递，其他参数正常传入。

如何打印，都是在Student类的内部定义的，这些数据和逻辑被“封装”起来了，

1、调用很容易，但却不用知道内部实现的细节。

2、封装的另一个好处是可以给Student类增加新的方法，比如get_grade：

小结

类是创建实例的模板，而实例则是一个一个具体的对象，各个实例拥有的数据都互相独立，互不影响；

方法就是与实例绑定的函数，和普通函数不同，方法可以直接访问实例的数据；

通过在实例上调用方法，我们就直接操作了对象内部的数据，但无需知道方法内部的实现细节。

和静态语言不同，Python允许对实例变量绑定任何数据，也就是说，对于两个实例变量，虽然它们都是同一个类的不同实例，但拥有的变量名称都可能不同：

>>>bart = Student('Bart Simpson', 59)

>>>lisa = Student('Lisa Simpson', 87)

>>>bart.age = 8

>>>bart.age

>>>lisa.age

Traceback(most recent call last):

File "<stdin>", line 1, in <module>

AttributeError:'Student' object has no attribute 'age'

二、访问限制

如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线_ _，在Python中，实例的变量名如果以_ _开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问

class Student(object):

def __init__(self,name, score):

self.__name = name

self.__score = score

def print_score(self):

print('%s: %s' %(self.__name, self.__score))

无法从外部访问实例变量.__name和实例变量.__score

class Student(object):
    def __init__(self,name,score):
        self.__name = name
        self.__score = score
    def print_score(self):
        print('%s %s' % (self.__name,self.__score))
    def get_score(self):
        return self.__score
    def get__name(self):
        return self.__name

aaa= Student('aaa aa', 20)
aaa.print_score()
# print(aaa.name)   # private

print(aaa.get__name())

l 不能直接访问__name是因为Python解释器对外把_ _name变量改成了_Student__name，所以，仍然可以通过_Student__name来访问__name变量：

print(aaa._Student__name)

l 变量名类似_ _xxx_ _的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量；

l 以一个下划线开头的实例变量名，比如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”

aaa = Student('aaa aa', 20)

aaa._ _name = ‘bbb bb’

表面上看，外部代码“成功”地设置了__name变量，但实际上这个__name变量和class内部的__name变量不是一个变量！内部的__name变量已经被Python解释器自动改成了_Student__name，而外部代码给aaa新增了一个__name变量。

三、继承和多态

在OOP程序设计中，当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Baseclass、Superclass）。

class Animal(object):
    def run(self):
        print('Animal is running')

class Dog(Animal):
    def run(self):
        print('Dog is running')

dog = Dog()

cat = Cat()

1、继承_好处：

1) 子类获得了父类的全部功能。

2) 当子类和父类都存在相同的方法时，我们说，子类的覆盖了父类的，在代码运行的时候，总是会调用子类的方法。这样，我们就获得了继承的另一个好处：多态。

2、多态

判断一个变量是否是某个类型可以用isinstance()判断

a = list()

>>> isinstance(a,list)

True

>>>Isinstance(dog,Animal)

True

在继承关系中，如果一个实例的数据类型是某个子类，那它的数据类型也可以被看做是父类。Dog可以看成Animal，但Animal不可以看成Dog。

def run_twice(animal): # 这个函数接受一个Animal类型的变量

animal.run()

当我们传入Cat的实例时，run_twice()就打印出：

>>> run_twice(Cat())

Cat isrunning...

新增一个Animal的子类，不必对run_twice()做任何修改，实际上，任何依赖Animal作为参数的函数或者方法都可以不加修改地正常运行，原因就在于多态。

传入的任意类型，只要是Animal类或者子类，就会自动调用实际类型的run()方法，这就是多态的意思

“开闭”原则：

对扩展开放：允许新增Animal子类；

对修改封闭：不需要修改依赖Animal类型的run_twice()等函数

3、静态语言 vs动态语言

1) 对于静态语言（例如Java）来说，如果需要传入Animal类型，则传入的对象必须是Animal类型或者它的子类，否则，将无法调用run()方法。

2) 对于Python这样的动态语言来说，则不一定需要传入Animal类型。我们只需要保证传入的对象有一个run()方法就可以了：

class Timer(object):

def run(self):

print('Start...')

这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子

Python的“file-like object“就是一种鸭子类型。对真正的文件对象，它有一个read()方法，返回其内容。但是，许多对象，只要有read()方法，都被视为“file-like object“。许多函数接收的参数就是“file-like object“，你不一定要传入真正的文件对象，完全可以传入任何实现了read()方法的对象。

小结

1) 继承可以把父类的所有功能都直接拿过来，这样就不必从零做起，子类只需要新增自己特有的方法，也可以把父类不适合的方法覆盖重写。

2) 动态语言的鸭子类型特点决定了继承不像静态语言那样是必须的。

四、获取对象的信息

1、 Type()

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

>>> type(123)

<class 'int'>

2) 如果一个变量指向函数或者类，也可以用type()判断：

>>> type(abs)

<class 'builtin_function_or_method'>

3) type()函数返回对应的Class类型

4) 判断一个对象是否是函数,可以使用types模块中定义的常量：

>>> import types

>>> def fn():

... pass

>>> type(fn)==types.FunctionType

True

>>> type(abs)==types.BuiltinFunctionType

True

2、使用isinstance()

isinstance()就可以告诉我们，一个对象是否是某种类型

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

前面的例子_继承关系是：

object -> Animal -> Dog -> Husky

>>> a = Animal()

>>> d = Dog()

>>> h = Husky()

>>> isinstance(d, Dog) and isinstance(d, Animal)

True

>>> isinstance(d, Husky)

False

2) 能用type()判断的基本类型也可以用isinstance()判断：

>>> isinstance('a', str)

True

>>> isinstance(123, int)

True

>>> isinstance(b'a', bytes)

True

3) 并且还可以判断一个变量是否是某些类型中的一种，比如下面的代码就可以判断是否是list或者tuple：

>>> isinstance([1, 2, 3], (list,tuple))

True

>>> isinstance((1, 2, 3), (list,tuple))

True

3、使用dir()

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

>>>print(dir('ABC'))

['__add__','__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__','__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__','__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__','__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__','__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__','__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode','endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum','isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric','isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower','lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust','rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip','swapcase', 'title', 'translate', 'upper', 'zfill']

类似__xxx_ _的属性和方法在Python中都是有特殊用途的，比如__len__方法返回长度。在Python中，如果你调用len()函数试图获取一个对象的长度，实际上，在len()函数内部，它自动去调用该对象的__len__()方法，所以，下面的代码是等价的：

>>> len('ABC')

>>> 'ABC'.__len__()

剩下的都是普通属性或方法。

2) 配合getattr()、setattr()以及hasattr()，我们可以直接操作一个对象的状态:

>>> class MyObject(object):

... def __init__(self):

... self.x = 9

... def power(self):

... return self.x * self.x

>>> obj = MyObject()

>>> hasattr(obj, 'x') # 有属性'x'吗？