码迷,mamicode.com
首页 > 编程语言 > 详细

Python3.5修炼手册13

时间:2017-09-17 19:01:54      阅读:173      评论:0      收藏:0      [点我收藏+]

标签:多态   封装   继承   多重继承   类的定义于使用   

面向对象编程

python是一门面向对象编程语言,对面向对象语言编程的过程叫做面向对象.

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

在python中,所有数据类型都被视为对象,也可以自定义对象.自定义对象数据类型就是面对对象中的类(Class)的概念.

面向对象术语简介:

类: 用来描述具有相同属性和方法的对象集合.类定义了集合中每个对象共有的属性和方法.对象式类的实例.

类变量(属性): 类变量在整个实例化的对象中是公用的.类变量定义在类中,且在方法之外.类变量通常不作为实例变量使用.类变量也称作属性.

数据成员: 类变量或实例变量用于处理类及其实例对象的相关数据.

方法重写: 如果从父继承的方法不能满足子类的需求,就可以对其内容进行改写,这个过程称为方法的覆盖(Override),也称为方法的重写.

实例变量: 定义在方法中的变量只能作用于当前实例的类.

多态(Polymorphism): 对不同类的对象使用同样的操作.

封装(Encapsulation): 对外部世界隐藏对象的工作细节.

继承(Inheritance): 即一个派生类(derived class)继承基类(base class)的字段和方法.继承允许把一个派生类的对象作为一个基类对象对待,以普通类为基础建立专门的类对象.

实例化(Instance): 创建一个类的实例,类的具体对象.

方法:类中定义的函数.

对象: 通过类定义的数据jiegou实例.对象包括两个数据成员(类变量和实例变量)和方法.

python中的类提供了面向对象编程的所有基本功能:类的继承机制允许多个基类、派生类可以覆盖基类中的任何方法、方法中可以调用基类中同名方法.

对象可以包含任意数量和类型的数据.


类的定义与使用

类的定义

类的语法格式如下:

      class ClassName(object):

   <statement-1>

.

.

.

       <statement-N>

由代码段和类的定义我们看到,python中定义类使用class关键字,class后面紧接着类名,类名通常是大写开头的字母;紧接着是(object),表示该类从哪个类继承下来的.通常,如果没有合适的继承类,就使用object类,这是所有类最终都会继承的类.类包含属性和方法(相当于函数中的语句和方法).

注意:在类中定义方法的形式和函数差不多,但是不称为函数,而称为方法.方法的调用需要绑定到特定对象上,而函数不需要.

类的使用

例如:

class MyClass(object):
    i = 123
    def f(self):
          return ‘helloworkd‘
user_class = MyClass()
print(‘调用类的属性:‘,user_class.i)
print(‘调用类的方法:‘,user_class.f())

C:\python\python.exe C:/python.py/lei.py

调用类的属性: 123

调用类的方法: helloworkd

由上例的调用方式可知,类的用比函数多了几个操作,调用类时需要执行如下操作:

user_class = MyClass()

这步叫做实例化,即创建一个类的实例.此处得到的use_class变量称为类的具体对象.

user_class.i用于调用类的属性,也就是所谓的类变量.

user_class.f()用于调用类的方法.

对于类中定义方法的要求:在类中定义方法时,第一个参数必须式self.除第一个参数外,类的方法和普通函数没什么区别,如可以使用默认参数、可变参数、和命名关键字参数等.

对于在类中调用方法的要求:要调用一个方法,在实例变量上直接调用即可.除了self不用传递,其他参数正常传入.

类对象支持两种操作,即属性引用和实例化.属性引用的标准语法如下:

obj.name

语法中obj.代表类对象,name代表属性.


深入类

类的构造方法

例如:

class MyClass(object):
    i = 123
    def __init__(self,name):
        self.name = name
    def f(self):
         return  ‘hello,‘+self.name
user_class = MyClass(‘duyuheng‘)
print(‘调用类的属性:‘,user_class.i)
print(‘调用类的方法:‘,user_class.f())

C:\python\python.exe C:/python.py/lei.py

调用类的属性: 123

调用类的方法: hello,duyuheng

从上例输出结果可以看到,实例化MyClass类时调用了__init__()方法.

在python中,__init__()方法是一个特殊方法,在对象爱实例化时会被调用__init__()的意思式初始化,式initialization的简写.这个方法的书写方式是:先输入两个下划线,后接着init在接着两个下划线,这个方法也叫构造方法.

在定义类时,若不显示到定义一个__init__()方法,则程序默认调用一个无参的__init__()方法.

代码对比:

代码一:使用__init__()方法

class DefaultInit(object):
    def __init__(self):
        print(‘类实例化时执行我,我是__init__方法.‘)
    def show(self):
        print(‘我是类中定义的方法,需要通过实例化对象调用.‘)
test =DefaultInit()
print(‘类实例化结束.‘)
test.show()

C:\python\python.exe C:/python.py/lei.py

类实例化时执行我,我是__init__方法.

类实例化结束.

我是类中定义的方法,需要通过实例化对象调用.

代码二:不使用__init__方法

class DefaultInit(object):
    def show(self):
        print(‘我是类中定义的方法,需要通过实例化对象调用.‘)
test =DefaultInit()
print(‘类实例化结束.‘)
test.show()

C:\python\python.exe C:/python.py/lei.py

类实例化结束.

我是类中定义的方法,需要通过实例化对象调用.

从上面两段代码可以看出,当代码中定义了__init__()方法时,实例化类时会调用该方法;若没有定义__init__()方法,也不会报错,此时调用默认的__init__()方法.

在python中定义类时若没有定义构造方法(__init__()方法),则在类的实例化时系统调用默认的构造方法.另外,__init__()方法可以有参数,参数通过_=__init__()传递到类的实例化操作上.

__init__()方法是python中构造方法,那么是否可以在一个类中定义多个构造方法呢?

例一:只有一个不带参数的__init__()方法

class DefaultInit(object):
    def __init__(self):
        print(‘我是不带参数的__init__()方法.‘)
DefaultInit()
print(‘类实例化结束.‘)

C:\python\python.exe C:/python.py/lei.py

我是不带参数的__init__()方法.

类实例化结束.

只有一个__init__()方法时,实例化类时没有什么顾虑.

例二:第一个为不带参数的,第二个为带参数的__init__()方法

class DefaultInit(object):
    def __init__(self):
        print(‘我是不带参数的__init__()方法.‘)
    def __init__(self,param):
        print(‘我是带参数的__init__()方法,参数值为:‘,param)
DefaultInit(‘hello‘)
print(‘类实例化结束.‘)

C:\python\python.exe C:/python.py/lei.py

我是带参数的__init__()方法,参数值为: hello

类实例化结束.

由执行结果可以看到,调用的是一个带pram参数的构造方法.

注意:此例实例化类时只能调用带两个占位参数的构造方法,调用其他的方法都会报错.

例三:第一个为带参数的,第二个为不带参数的__init__()方法

class DefaultInit(object):
    def __init__(self, param):
        print(‘我是带参数的__init__()方法,参数值为:‘, param)
    def __init__(self):
        print(‘我是不带参数的__init__()方法.‘)
DefaultInit()
print(‘类实例化结束.‘)

C:\python\python.exe C:/python.py/lei.py

我是不带参数的__init__()方法.

类实例化结束.

由执行结果可以看到,调用的构造方法除了self外,没有其他参数.

注意:此例实例化类时只能调用一个带占位参数的构造方法,调用其他构造方法都会报错.

结论:一个类中可以定义多个构造方法,但是实例化类时只能实例化到最后的构造方法,即后面的构造方法会覆盖前面的构造方法,并且需要根据最后一个构造方法的形式进行实例化.建议一个类中只定义一个构造函数.\


类的访问权限

在类内部有属性和方法,外部代码可以通过直接调用实例变量的方法操作数据,这样就隐藏了内部的复杂逻辑.

例如:

class Student(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score
    def info(self):
        print(‘学生:%s; 分数:%s ‘%(self.name,self.score))
stu = Student(‘duyuheng‘,95)
print(‘修改前分数:‘,stu.score)
stu.info()
stu.score=0
print(‘修改后分数:‘,stu.score)
stu.info()

C:\python\python.exe C:/python.py/lei.py

修改前分数: 95

学生:duyuheng; 分数:95 

修改后分数: 0

学生:duyuheng; 分数:0 

由输出结果可以看出,在类中定义非构造方法可以调用类中的构造方法实现变量的属性,调用的方式为self.实例变量属性名,如上例中的self.name和self.score.可以在类的外部修改类的内部数属性.

要是让内部属性不被外部访问,可以在属性名前面加两个下划线__.在python中,实例的变量名如果以__开头,就会变成私有变量(private),只有内部可以访问,外部不能访问.

例如:

class Student(object):
    def __init__(self,name,score):
        self.__name = name
        self.__score = score
    def info(self):
        print(‘学生:%s; 分数:%s ‘%(self.__name,self.__score))
stu = Student(‘duyuheng‘,95)
print(‘修改前分数:‘,stu.__score)
stu.info()
stu.score=0
print(‘修改后分数:‘,__stu.score)
stu.info()

C:\python\python.exe C:/python.py/lei.py

Traceback (most recent call last):

  File "C:/python.py/lei.py", line 14, in <module>

    print(‘修改前分数:‘,stu.__score)

AttributeError: ‘Student‘ object has no attribute ‘__score‘

从输出结果可以看出,已经无法从外部访问实例变量的属性_score了,作用就是确保外部代码不能随意修改对象内部的状态,通过访问限制的保护,代码更加安全.

在python中,可以为类增加get_attrs方法,获取类中的私有变量,

例如:

class Student(object):
    def __init__(self,name,score):
        self.__name = name
        self.__score = score
    def info(self):
        print(‘学生:%s; 分数:%s ‘%(self.__name,self.__score))
    def get_score(self):
        return  self.__score
stu = Student(‘duyuheng‘,95)
print(‘修改前分数:‘,stu.get_score())
stu.info()
print(‘修改后分数:‘,stu.get_score())
stu.info()

C:\python\python.exe C:/python.py/lei.py

修改前分数: 95

学生:duyuheng; 分数:95 

修改后分数: 95

学生:duyuheng; 分数:95 

由执行结果可以看到,通过get_score方法已经可以正确得到类内部的属性值.

在python中,可可以为类增加set_attrs方法,修改类中的私有变量.

例如:

class Student(object):
    def __init__(self,name,score):
        self.__name = name
        self.__score = score
    def info(self):
        print(‘学生:%s; 分数:%s ‘%(self.__name,self.__score))
    def get_score(self):
        return  self.__score
    def set_score(self,score):
        self.__score=score
stu = Student(‘duyuheng‘,95)
print(‘修改前分数:‘,stu.get_score())
stu.info()
stu.set_score(0)
print(‘修改后分数:‘,stu.get_score())
stu.info()

C:\python\python.exe C:/python.py/lei.py

修改前分数: 95

学生:duyuheng; 分数:95 

修改后分数: 0

学生:duyuheng; 分数:0 

由执行结果看到,通过set_score方法正确更改了私有变量score的值.

在python中,通过自定义私有变量可对应的set方法可以做参数检查,避免传入无效的参数.

例如:

class Student(object):
    def __init__(self,name,score):
        self.__name=name
        self.__score=score
    def info(self):
        print(‘学生:%s; 分数:%s ‘%(self.__name,self.__score))
    def  get_score(self):
        return self.__score
    def set_score(self,score):
        if 0<=score<=100:
            self.__score=score
        else:
             print(‘请输入0到100的数字.‘)
stu =Student(‘duyuheng‘,95)
print(‘修改前的分数‘,stu.get_score())
stu.info()
stu.set_score(-10)
print(‘修改后的分数‘,stu.get_score())
stu.info()

C:\python\python.exe C:/python.py/lei.py

修改前的分数 95

学生:duyuheng; 分数:95 

请输入0到100的数字.

修改后的分数 95

学生:duyuheng; 分数:95 

上例输出结果可以看到,调用set_score方法时,如果传入的参数不满足条件,就按照不满足条件的程序逻辑执行.

类的私有方法也是由两个下划线开头,声明该方法为私有方法,且不能在类外使用.

私有方法的调用方式如下:

self.__private_methods

私有方法的使用:

例如:

class PrivatePublicMethod(object):
    def __init__(self):
        pass
    def __foo(self):
        print(‘这是私有方法‘)
    def foo(self):
        print(‘这是公共方法‘)
        print(‘公共方法中调用私有方法‘)
        self.__foo()
        print(‘公共方法调用私有方法结束‘)
pri_pub = PrivatePublicMethod()
print(‘开始调用公共方法:‘)
pri_pub.foo()
print(‘开始调用私有方法:‘)
pri_pub.__foo()

C:\python\python.exe C:/python.py/lei.py

Traceback (most recent call last):

  File "C:/python.py/lei.py", line 21, in <module>

    pri_pub.__foo()

AttributeError: ‘PrivatePublicMethod‘ object has no attribute ‘__foo‘

开始调用公共方法:

这是公共方法

公共方法中调用私有方法

这是私有方法

公共方法调用私有方法结束

开始调用私有方法:

由输出结果可以看出,私有方法和私有变量类似,不能通过外部调用.


继承

面对对象编程带来的好处之一是代码重用,实现重用的方法之一是通过继承机制.继承完全可以理解成类之间类型和子类型的关系.

在面向对象程序设计中,当我们定义一个class时,可以从某个现有的class继承,定义的新class称为子类(Subclass),而被继承的class称为基类,父类或超类(Base class、Super class).

继承定义如下:

clss DerivedClassName(BaseClassName):

<statement-1>

.

.

<statement-N>

需要注意:继承语法class子类名(基类名)时,//基类名写在括号里,基本类是在定义类时,在元组中指明的.

在python中,继承有以下特点:

(1)在继承中,类级泵的构造方法(__init__()方法)不会被自动调用,需要在子类的构造方法中专门调用.

(2)在调用基类的方法时需要加上基类的类名前缀,并带上self参数变量.区别于在类中调用普通函数时不需要带self参数.

(3)在python中,首先查找对应类型的方法,如果在子类中找不到对应的方法,才到基类中逐个查找

例如:

class Animal(object):
    def run(self):
        print(‘Animal is runing...‘)
#上面定义了一个名为Animal的类,类中定义了一个run()方法直接输出(默认调用__init__()方法)
class Dog(Animal):
        pass
class Cat(Animal):
        pass
#上面代码对于Dog和Cat来说Animal就是它的父类;对于Animal来说Dog和Cat来说Animal就是它的子类.
dog = Dog()
dog.run()
cat = Cat()
cat.run()

C:\python\python.exe C:/python.py/lei.py

Animal is runing...

Animal is runing...

由输出结果看到,子类中没有定义任何方法,但是都执行了run()方法.

继承的优点;

继承最大的好处时子类获得了父类全部非私有的功能.

子类也可以拥有自己的方法.

例如:

class Animal(object):
    def run(self):
        print(‘Animal is runing...‘)
class Dog(Animal):
        def eat(self):
            print(‘Eating...‘)
dog = Dog()
dog.run()
dog.eat()

C:\python\python.exe C:/python.py/lei.py

Animal is runing...

Eating...

由上例可以看出,唉Dog中增加了eat方法,从输出结果可以看书既执行了父类的方法,又执行了自己定义的方法.

若不想让子类继承父类中的私有方法,也不能调用父类的私有方法.父类定义如下.

例如:

class Animal(object):
    def run(self):
        print(‘Animal is runing...‘)
    def __run(self):
        print(‘I am private method.‘)
class Dog(Animal):
        pass
dog=Dog()
dog.__run()

C:\python\python.exe C:/python.py/lei.py

Traceback (most recent call last):

  File "C:/python.py/lei.py", line 15, in <module>

    dog.__run()

AttributeError: ‘Dog‘ object has no attribute ‘__run‘

由执行结果可以看到,子类不能调用父类的私有方法,子类虽然继承了父类,但是调用父类的私有方法相当于从外部调用类中的方法,因而调用不成功.

对于类中扩展的非私有方法,子类可以拿来即用,如在父类Animal中增加一个jump方法:

class Animal(object):
    def run(self):
        print(‘Animal is runing...‘)
    def jump(self):
        print(‘Animal is jumpping...‘)
    def __run(self):
        print(‘I am a private method.‘)
class Dog(Animal):
        pass
class Cat(Animal):
    pass
dog = Dog()
dog.run()
dog.jump()
cat =Cat()
cat.run()
cat.jump()

C:\python\python.exe C:/python.py/lei.py

Animal is runing...

Animal is jumpping...

Animal is runing...

Animal is jumpping...

由上例结果可以看出,子例可以立即获取父类增加的非私有方法.


多态

多台来自于希腊语,意思时有多种形式.多态意味着即使不知道变量所引用的对象类型是什么,也能对对象进行操作,多态会根据对象(或类)的不同而表现出不同的行为.

例如:

class Animal(object):
    def run(self):
        print(‘Animal is runing...‘)
class Dog(Animal):
    def run(self):
        print(‘Dog is running...‘)
class Cat(Animal):
    def run(self):
        print(‘Cat in runing...‘)
dog = Dog()
print(‘实例化Dog类‘)
dog.run()
cat = Cat()
print(‘实例化Cat类‘)
cat.run()

C:\python\python.exe C:/python.py/lei.py

实例化Dog类

Dog is running...

实例化Cat类

Cat in runing...

在上例中我们在Animal类中定义了run方法,Dog和Cat类分别继承Animal类,并且分别定义了自己的run方法,最后Dog和Cat调用的是自己定义的run方法.

当我们定义类时实际上就定义了一中数据类型.定意义数据类型和python自带的数据类型(如str、list、dict)没什么两样.

例如:

class Animal(object):
    def run(self):
        print(‘Animal is runing...‘)
class Dog(Animal):
    def run(self):
        print(‘Dog is running...‘)
class Cat(Animal):
    def run(self):
        print(‘Cat in runing...‘)
a=list()
b=Animal()
c=Dog()
print(‘a是否为list类型:‘,isinstance(a,list))
print(‘b是否为Animal类型:‘,isinstance(b,Animal))
print(‘c是否为Animal类型:‘,isinstance(c,Dog))

C:\python\python.exe C:/python.py/lei.py

a是否为list类型: True

b是否为Animal类型: True

c是否为Animal类型: True

输出结果可以看出:a,b,c确实分别为list,Animal,Dog三种类型

在执行下列语句:

print(‘c是否为Dog类型:‘,isinstance(c,Dog))
print(‘c是否为Animal类型:‘,isinstance(c,Dog))

C:\python\python.exe C:/python.py/lei.py

c是否为Dog类型: True

c是否为Animal类型: True

由执行结果可以看出,c既是Dog类型又是Animal类型,应为Dog是从Animal继承下来的,当我们创建Dog实例时,我们认为c的数据类型是Dog,但是c同时也是Animal,Dog本来就是Animal的一种.

在继承关系中,如果一个实例的数据类型是某个子类,那么他的数据类型也可以看作时父类.但是反过来就不行了:

在执行下列语句:

print(‘b是否为Dog类型:‘,isinstance(b,Dog))

C:\python\python.exe C:/python.py/lei.py

b是否为Dog类型: False

我们在看一个实例.编写一个函数,这个函数接受一个Animal类型的变量,定义并执行如下函数,执行时传入Animal的实例:

class Animal(object):
    def run(self):
        print(‘Animal is runing...‘)
class Dog(Animal):
    def run(self):
        print(‘Dog is running...‘)
class Cat(Animal):
    def run(self):
        print(‘Cat in runing...‘)
def run_two_times(animal):
    animal.run()
    animal.run()
run_two_times(Animal())

C:\python\python.exe C:/python.py/lei.py

Animal is runing...

Animal is runing...

若执行函数时传入Dog的实例,如下:

run_two_times(Dog())

C:\python\python.exe C:/python.py/lei.py

Dog is running...

Dog is running...

若执行函数时传入Cat的实例,如下:

run_two_times(Cat())

C:\python\python.exe C:/python.py/lei.py

Cat in runing...

Cat in runing...

如果在定义一个Bird类型,也继承Animal类,定义如下:

class Bird(Animal):
    def run(self):
        print(‘Bird is flying the sky ...‘)
run_two_times(Bird())

C:\python\python.exe C:/python.py/lei.py

Bird is flying the sky ...

Bird is flying the sky 

由执行结果可以看出,新增的Animal子类不必对run_two_times()方法做任何修改.实际上,任何依赖Animal作为参数的函数或方法都可以不加修改地正常运行,原因就在于多态.

多态的好处是:我们需要传入子类时,只需要接受父类型就可以了,因为子类都是父类型,按照父类型操作即可.由于父类型有run()方法,因此传入类型只要是父类或者是继承父类,都会自动调用实际类型的run()方法.

多态的意思:对于一个变量,我们只需要知道它是父类型,无需确切的知道它的子类型,就可以放心调用run()方法,.具体调用的run()方法作用于父类或者子类,由运行时该对象的确切类型决定.

多态真正的威力在于:调用方只管调用,不管细节.当我们新增一种Animal的子类时,只要确保run()方法编写正确即可,不用管原来的代码是如何调用的.这就是"开闭"原则:对于扩展开放,允许新增Animal子类;对于封闭,不需要修改依赖Animal类型的run_two_times()等函数.

很多函数和运算符都是多态的,只要使用多态函数和运算符,多态就会消除.唯一能毁掉多态的是使用函数显示地检查类型,如type、isinstance函数等.如果有可能,就尽量避免使用这些毁掉多态的方式,重要的是如何让对象按照我们希望的方式工作,无论它是否是正确类型或类.


封装

封装是全局作用域中其他区域隐藏多余信息的原则.听起来像多态,使用对象而不用知道其他内部的细节.

封装并不等同于多态.多态可以让用户不知道类(或对象类型)的对象进行方法调用,而封装可以不用关心对象是如何构建的,直接使用即可.

例如:

class Student(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score
std = Student(‘duyuheng‘,90)
def info(std):
    print(‘学生:%s; 分数:%s;‘%(std.name,std.score))
info(std)

C:\python\python.exe C:/python.py/lei.py

学生:duyuheng; 分数:90;

上例是通过函数调用并得到结果.

可以直接在Studnet类内部定义访问数据的函数,这样就把"数据"封装起来了.这些封装数据的函数数据和Student类本身是相关联的,我称之为方法.

要定义一个方法,除了第一参数时self外,其他参数和普通函数一样.要调用一个方法,在实例变量上直接调用即可.除了self不用传递,其他参数正常传入.

class Student0(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score
stu = Student0(‘xuwei‘,99)
def info(self):
    print(‘学生:%s  分数:%s‘%(self.name,self.score))
info(stu)

C:\python\python.exe C:/python.py/lei.py

学生:xuwei  分数:99

由上例我们从外部看出Studnt类,只需要知道创建实例需要给出的name和score,如何输出是在Student类的内部定义的,这些数据和逻辑被"封装"起来,调用很容易,但却不知道内部实现的细节.

封装的另一个好处时可以给student类增加新方法,比如访问权限中的get_score()方法和set_score()方法,使用这些方法时,无需知道内部的实现细节,直接调用即可.


多重继承

多重继承的定义如下:

class DerivedclassName(Base1,Base2,Base3)

<statement-1>

.

.

<statement-N>

多重继承就是使有多个基类(父类或超类).

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

例如:

class  A(object):
    def __init__(self,a):
        print(‘init A...‘)
        self.a = a
class B(A):
    def __init__(self,a):
        super(B,self).__init__(a)
        print(‘init B...‘)
class C(A):
    def __init__(self,a):
        super(C,self).__init__(a)
        print(‘init C...‘)
class D(B,C):
    def __init__(self,a):
        super(D,self).__init__(a)
        print(‘init D...‘)
d =D(‘d‘)

C:\python\python.exe C:/python.py/lei.py

init A...

init C...

init B...

init D...

由上列可以看出,D同时继承自B和C,也就是D拥有了A、B、C的全部功能.多重继承通过super()调用__init__()方法时,A虽然被继承了两次但是__init__()只调用一次.

多重继承的目的时从两种继承树中分别选择并继承出子类,以便组合功能使用.

多重继承一个子类可以继承多个父类,同时获得多个父类所有非私有功能


获取对象信息

python提供了3种获取对象类型的方法.

第1种使用type()函数

将一个变量实现哦昂函数或类

print(type(abs))#函数

C:\python\python.exe C:/python.py/lei.py

<class ‘builtin_function_or_method‘>

class  A(object):#类
    def __init__(self,a):
      pass
print(type( A(object)))

C:\python\python.exe C:/python.py/lei.py

<class ‘__main__.A‘>

由上面两例子可以看出,返回值对应的Class类型.

如果要在if语句中判断并比较两个变量的type类型是否同,如下:

print(type(123)==type(456))
print(type(123)==int)
print(type(‘abc‘)==type(‘123‘))
print(type(‘abc‘)==str)
print(type(‘abc‘)==type(123))

C:\python\python.exe C:/python.py/lei.py

True

True

True

True

False

由上例可以看出,判断基本数据类型可以直接写int、str.

可以使用tyoes模块中定义的常量.

例如:

import  types
def func():
    pass
print(type(abs)==types.BuiltinFunctionType)
print(type(lambda x:x)==types.LambdaType)
print(type((x for x in range(10)))==types.GeneratorType)

C:\python\python.exe C:/python.py/lei.py

True

True

True

由上例可以看出,函数的判断方式需要借助types模块的帮助.


第二种使用isinstance()函数

要明确class的继承关系,使用type()很不方便,通过判断class的数据类型确定class的继承关系要方便的多,这个时候要使用isinstance()函数.

例如:

class Animal(object):
    def run(self):
        pass
class Dog(Animal):
    def run(self):
        pass
animal = Animal()
dog =Dog()
print(isinstance(dog,Dog))
print(isinstance(dog,Animal))
C:\python\python.exe C:/python.py/lei.py
True
True

由上例可以得知:尽管dog式Dog类型,不过由于Dog是从Animal继承下来的,因此dog也是Animal类型.isinstance()判断的是一个对象是否为该类型的本身,或者是否为该类型继承的类型.

不过animal不是Dog类型

print(isinstance(animal,Dog))

C:\python\python.exe C:/python.py/lei.py

False

需要知道的是:能用type()判断的基本类型也可以用isinstance()判断.

isinstance()可以判断一个变量是否为某些类型中的一种,判断变量是否为list或tuple的方式.
print(isinstance([1,2,3],(list,tuple)))
print(isinstance((1,2,3),(list,tuple)))

C:\python\python.exe C:/python.py/lei.py

True

True

第三种使用dir()

如果要获得一个对象的所有属性和方法,就可以使用dir()函数.dir()函数返回一个字符串的list.

例如:

print(dir(‘abc‘))

C:\python\python.exe C:/python.py/lei.py

[‘__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‘]


类的专有方法

python类可以定义专有方法.专门方法是在特殊情况下或使用特别语法时由python调用的,而不像普通方法一样在代码中直接调用.

看到型如__xxx__的变量或函数名就要注意,这在python中是有特殊用途的.

这种特殊类型的函数定制类的方法由有以下几种.

第一种__str__ 用法如下:

class Studnet(object):
    def __init__(self,name):
        self.name= name
    def __str__(self):
        return ‘学生名称:%s‘%self.name
print(Studnet(‘duyuheng‘))

C:\python\python.exe C:/python.py/lei.py

学生名称:duyuheng

这样的输出不但好看而且,还是我们想要的

在看一下直接显示变量的内容:

class Studnet(object):
    def __init__(self,name):
        self.name= name
s=Studnet(‘duyuheng‘)
print(s)

C:\python\python.exe C:/python.py/lei.py

<__main__.Studnet object at 0x00000000010CB4E0>

上例输出结果为一堆字符串,这是因为直接显示变量调用的不是__str__(),而是__repr__(),两者的区别在于__str__()返回用户看到的字符串,而__repr__()返回程序开发者看到的字符.也就是说,__repr__()是说,__repr__()是为调试服务的.

解决这个办法是在定义一个__repr__().通常,__str__()和__repr__()代码是一样的,所以有一个简单的写法如下:

class Student(object):
    def __init__(self,name):
        self.name = name
    def __str__(self):
        return ‘学生名称:%s‘ % self.name
    __repr__=__str__
s = Student(‘duyuheng‘)
print(s)

C:\python\python.exe C:/python.py/lei.py

学生名称:duyuheng

上例已经得到满意的结果

第二种__iter__

如果想将一个类用于for...in循环,类似list或tuple一样,就必须实现一个__iter__()方法.该方法返回一个迭代对象,python的for循环会不断调用该迭代对象的__next__()方法,获得循环的下一个值,直到遇到StopIteration错误时退出循环.

以裴波那契(黄金分数列)为例,写一个可以作用于for循环的Fib类:

class Fib(object):
    def __init__(self):
        #初始化两个计数器a、b
        self.a,self.b = 0,1
    def __iter__(self):
        #实例本身就是就是迭代对象,故返回自己
        return self
    def __next__(self):
        #计算下一个值
        self.a,self.b=self.b,self.a+self.b
        #退出循环条件
        if self.a > 100:
            raise StopAsyncIteration();
        #返回下一个值
        return self.a
for n in Fib():
    print(n)

C:\python\python.exe C:/python.py/lei.py

1

1

2

3

5

8

13

21

34

55

89


第三种__getitem__

要像list一样按照下标取出元素,需要实现__getitem__()方法.

例如:

class Fib(object):
    def __getitem__(self, n):
        a,b =1,1
        for x in range(n):
            a,b =b,a+b
        return  a
fib = Fib()
print(fib[3])
print(fib[10])

C:\python\python.exe C:/python.py/lei.py

3

89

由执行结果看到,可以成功获取对应数列的值了.


第四种__getattr__

正常情况下,调用类的方法或属性时,如果类的方法或属性不存在就会报错,python提供了一种机制,就是写一个__getattr__()方法,动态返回一个属性.

class Student(object):
    def __init__(self):
        self.name =‘duyuheng‘
    def __getattr__(self, attr):
        if attr==‘score‘:
            return  95
stu = Student()
print(stu.name)
print(stu.score)

C:\python\python.exe C:/python.py/lei.py

duyuheng

95

注意:只有在没有找到属性的情况下才会调用__getattr__,已有的属性(如name),不会在__getatter__中查找,此外,如果所有调用都会返回None(如stu.abc),就是定义的__getattr__默认返回None.

第五种__call__

一个对象实例可以有自己的属性和方法,调用实例的方法时使用instance.method()调用.

任何类,只需要定义一个__call__()方法,就可以直接对实例进行调用.

例如:

class  Student(object):
    def __init__(self,name):
        self.name = name
    def __call__(self):
        print(‘名称:%s‘%self.name)
stu=Student(‘duyuheng‘)
stu()

C:\python\python.exe C:/python.py/lei.py

名称:duyuheng

由上例输出结果可以看到,直接对实例进行调用并得到结果.

__call__()还可以定义参数.对实例进行直接调用就像对一个函数调用一样,完全可以把对象看成函数,把函数看成对象,因为这两者本身就有根本区别.

如果把对象看成函数,函数本身就可以在运行期间动态创建出来,因为类的实例都是运行期间创建出来的,就模糊了对象和函数的界限.

很时候判断一个对象是否能被调用,可以使用Callable()函数,比如函数上例定义的带有__call__()的类实例.

print(callable((Student(‘duyuheng‘))))
print(callable(max))
print(callable([1,2,3]))
print(callable(None))
print(callable(‘a‘))

C:\python\python.exe C:/python.py/lei.py

名称:duyuheng

True

True

False

False

False

由操作结果可以看到,通过callable()函数可以判断一个对象是否为"可调用"对象


本文出自 “duyuheng” 博客,谢绝转载!

Python3.5修炼手册13

标签:多态   封装   继承   多重继承   类的定义于使用   

原文地址:http://duyuheng.blog.51cto.com/12879147/1966068

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!