Python3入门笔记七之面向对象高级编程

简介: '限制实例的属性:__slots__ ,把一个方法变成属性调用:@property装饰器,多重继承&MixIn,定制类,枚举类:Enum,元类'限制实例的属性:__slots__限制实例的属性 比如只允许对Student实例添加name和age属性。 由于'score'没有被放到__slots__中,所以不能绑定score属性,试图绑定score将得到AttributeError的错误。注意:__slots__定义的属性仅对当前类实例起作用,对继承的子类是不起作用的


'限制实例的属性:__slots__ ,把一个方法变成属性调用:@property装饰器,多重继承&MixIn,定制类,枚举类:Enum,元类'


限制实例的属性:__slots__


限制实例的属性 比如只允许对Student实例添加name和age属性。 由于'score'没有被放到__slots__中,所以不能绑定score属性,试图绑定score将得到AttributeError的错误。注意:__slots__定义的属性仅对当前类实例起作用,对继承的子类是不起作用的


class Student(object):
    __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称
s = Student()
s.name='a'
s.age=11
s.score=99 # AttributeError: 'Student' object has no attribute 'score'
复制代码


子类实例允许定义的属性就是自身的__slots__加上父类的__slots__


把一个方法变成属性调用:@property装饰器


把一个getter方法变成属性,只需要加上@property就可以了,此时,@property本身又创建了另一个装饰器@score.setter,负责把一个setter方法变成属性赋值


class Student(object):
    @property
    def score(self):
        return self._score
    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value
s = Student()
s.score=11
s.score
复制代码


不写 @score.setter 的话就只能读这个属性


多重继承&MixIn


(⊙﹏⊙) 这个就和java的不同了,在java中只能单继承,多实现。 而在这个python中,直接在括号中添加对应的父类即可。


class Dog(Mammal, RunnableMixIn):
    pass
复制代码


上面这个例子在设计上也称为mixin


MixIn的目的就是给一个类增加多个功能,这样,在设计类的时候,我们优先考虑通过多重继承来组合多个MixIn的功能,而不是设计多层次的复杂的继承关系。


一般单继承的class名称不加后缀MixIn(如Mammal),这个多继承的点要加后缀MixIn如(RunnableMixIn),


Python自带了TCPServerUDPServer这两类网络服务,而要同时服务多个用户就必须使用多进程多线程模型,这两种模型由ForkingMixInThreadingMixIn提供。

多线程模式的UDP服务:


class MyUDPServer(UDPServer, ThreadingMixIn):
    pass
复制代码


定制类


python3官方文档定制类介绍


__str__(),__repr__()


这两个同Java的toString()方法,只不过这个__str__()返回用户看到的字符串,而__repr__()返回程序开发者看到的字符串,__repr__()是为调试服务的


class Student(object):
    def __init__(self, name):
        self.name = name
    def __str__(self): # 2
        return 'Student object (name=%s)' % self.name
    __repr__ = __str__ # 1
s=Student('ken')
s # 2
print(s) # 1 Student object (name=ken)
# 同时注释掉 # 1 的内容就可以看到效果
复制代码


__iter__


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


这个博主之前的文章中也也有记录到:《python3入门笔记三之高级特性---切片,迭代,列表生成式,生成器,迭代器


网络异常,图片无法展示
|



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


__getitem__


  1. 按照下标取出元素


class Fib(object):
    def __getitem__(self, n):
        a, b = 1, 1
        for x in range(n):
            a, b = b, a + b
        return a
f = Fib()
f[10] # 89
复制代码


  1. 切片


getitem()传入的参数可能是一个int,也可能是一个切片对象slice,所以要做判断:


class Fib(object):
    def __getitem__(self, n):
        if isinstance(n, int): # n是索引
            a, b = 1, 1
            for x in range(n):
                a, b = b, a + b
            return a
        if isinstance(n, slice): # n是切片
            start = n.start
            stop = n.stop
            step = n.step
            print('step:',step)
            if start is None:
                start = 0
            if step is None:
                step = 1
            a, b = 1, 1
            L = []
            for x in range(stop):
                if x >= start:
                    if(x%step==0):
                        L.append(a)
                a, b = b, a + b
            return L
f=Fib()
print(f[:10]) #  [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] 
print(f[:10:2]) # [1, 2, 5, 13, 34]
print(f[10]) # 89
复制代码


__call__


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

怎么判断一个变量是对象还是函数呢? 通过callable()函数,我们就可以判断一个对象是否是“可调用”对象。


class Student(object):
    def __init__(self, name):
        self.name = name
    def __call__(self):
        print('My name is %s.' % self.name)
s = Student('Michael')
if callable(s):
    s() # My name is Michael.
复制代码


动态返回一个属性:__getattr__


这个在上篇笔记中有写到《python入门笔记六之面向对象编程

网络异常,图片无法展示
|


class Student(object):
    def __getattr__(self, attr):
        if attr=='age':
            return lambda: 25
        elif attr =='name':
            return 'Amy'
s = Student()
print(s.age()) # 25 注意这里返回的是一个lambda表达式,需要调用该方法才能拿到值
print(s.name) # Amy 
复制代码


链式调用的例子 :


class Chain(object):
    def __init__(self, path=''):
        self._path = path
    def __getattr__(self, path):
        return Chain('%s/%s' % (self._path, path))
    def __call__(self, path):
        return Chain('%s/%s' % (self._path, path))
    def __str__(self):
        return self._path
    __repr__ = __str__
print(Chain().status.user.timeline.list) # /status/user/timeline/list
# 注意这里的chain返回的是chain对象,所以这个users('michael')就可以很好地理解了。
print(Chain().users('michael').repos) # /users/michael/repos
复制代码


使用枚举类:Enum


枚举类型定义一个class类型,然后,每个常量都是class的一个唯一实例


from enum import Enum
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))
for name, member in Month.__members__.items():
    print(name, '=>', member, ',', member.value)
# value属性则是自动赋给成员的int常量,默认从1开始计数。
# Jan => Month.Jan , 1
# Feb => Month.Feb , 2
# Mar => Month.Mar , 3
# .
# .
# .
# Dec => Month.Dec , 12
复制代码


获取枚举常量的两种方式:


  1. 根据成员名称


  1. 根据value值


from enum import Enum, unique
@unique # @unique装饰器可以帮助我们检查保证没有重复值。
class Weekday(Enum):
    Sun = 0 # Sun的value被设定为0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6
print(Weekday.Mon,'=',Weekday.Mon.value) # Weekday.Mon = 1
print(Weekday['Mon'],'=',Weekday.Mon.value)  # Weekday.Mon = 1
print(Weekday(1),'=',Weekday.Mon.value)  # Weekday.Mon = 1
for name, member in Weekday.__members__.items():
    print(name, '=>', member)
复制代码


小测试: 把gender属性改造为枚举类型,避免使用字符串


class Gender(Enum):
    Male = 0
    Female = 1
class Student(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def __str__(self):
          return 'Student object name={},gender={}'.format(self.name,self.gender)
    __repr__=__str__
bart = Student('Bart', Gender.Male)
print(bart) #  Student object name=Bart,gender=Gender.Male
bart # Student object name=Bart,gender=Gender.Male
复制代码


使用元类


type()


这个也在上篇博文讲到,现在要补充下它的其他知识点


  1. type()函数可以查看一个类型或变量的类型


  1. type()函数既可以返回一个对象的类型,又可以创建出新的类型


网络异常,图片无法展示
|


print(type(str)) # <class 'type'>  str是class,所以类型是type
print(type('123')) # <class 'str'> '123'是实例。所以类型是str
def fn(self, name='world'): # 先定义函数    
    print('Hello, %s.' % name)
复制代码


通过type()函数创建出Hello类,而无需通过class Hello(object)...的定义:


要创建一个class对象,type()函数依次传入3个参数:


  1. class的名称;


  1. 继承的父类集合,注意Python支持多重继承,如果只有一个父类,别忘了tuple的单元素写法


  1. class的方法名称与函数绑定,这里我们把函数fn绑定到方法名hello上。


如图(通过这些ide可以帮助我们更快认识这个函数):


网络异常,图片无法展示
|


def fn(self, name='world'):
    return name
Hello=type('Hello',(object,),dict(hello=fn)) # 创建出Hello类
h=Hello() # 注意这里才去创建Instance实例
print(h.hello('1'))
print(type(Hello)) # <class 'type'>
print(type(h)) # <class '__main__.Hello'>
复制代码


metaclass


除了使用type()动态创建类以外,要控制类的创建行为,还可以使用 metaclassmetaclass是Python面向对象里最难理解,也是最难使用的魔术代码 (已劝退😆 哈哈哈)


大概理解就是它可以定义创建类时候的行为。


# metaclass是类的模板,所以必须从`type`类型派生:
class ListMetaclass(type):
    def __new__(cls, name, bases, attrs):
        attrs['add'] = lambda self, value: self.append(value)
        return type.__new__(cls, name, bases, attrs)
class MyList(list, metaclass=ListMetaclass):
    pass
L = MyList()
L.add(1)
L # 1
复制代码


一般写代码的时候用不上,使用metaclass的典型例子是ORM框架(😱老底都揭露出来了)另外再写写这个例子😄



目录
相关文章
|
1天前
|
缓存 算法 数据处理
Python入门:9.递归函数和高阶函数
在 Python 编程中,函数是核心组成部分之一。递归函数和高阶函数是 Python 中两个非常重要的特性。递归函数帮助我们以更直观的方式处理重复性问题,而高阶函数通过函数作为参数或返回值,为代码增添了极大的灵活性和优雅性。无论是实现复杂的算法还是处理数据流,这些工具都在开发者的工具箱中扮演着重要角色。本文将从概念入手,逐步带你掌握递归函数、匿名函数(lambda)以及高阶函数的核心要领和应用技巧。
Python入门:9.递归函数和高阶函数
|
1天前
|
开发者 Python
Python入门:8.Python中的函数
### 引言 在编写程序时,函数是一种强大的工具。它们可以将代码逻辑模块化,减少重复代码的编写,并提高程序的可读性和可维护性。无论是初学者还是资深开发者,深入理解函数的使用和设计都是编写高质量代码的基础。本文将从基础概念开始,逐步讲解 Python 中的函数及其高级特性。
Python入门:8.Python中的函数
|
1天前
|
存储 SQL 索引
Python入门:7.Pythond的内置容器
Python 提供了强大的内置容器(container)类型,用于存储和操作数据。容器是 Python 数据结构的核心部分,理解它们对于写出高效、可读的代码至关重要。在这篇博客中,我们将详细介绍 Python 的五种主要内置容器:字符串(str)、列表(list)、元组(tuple)、字典(dict)和集合(set)。
Python入门:7.Pythond的内置容器
|
1天前
|
存储 索引 Python
Python入门:6.深入解析Python中的序列
在 Python 中,**序列**是一种有序的数据结构,广泛应用于数据存储、操作和处理。序列的一个显著特点是支持通过**索引**访问数据。常见的序列类型包括字符串(`str`)、列表(`list`)和元组(`tuple`)。这些序列各有特点,既可以存储简单的字符,也可以存储复杂的对象。 为了帮助初学者掌握 Python 中的序列操作,本文将围绕**字符串**、**列表**和**元组**这三种序列类型,详细介绍其定义、常用方法和具体示例。
Python入门:6.深入解析Python中的序列
|
1天前
|
知识图谱 Python
Python入门:4.Python中的运算符
Python是一间强大而且便捷的编程语言,支持多种类型的运算符。在Python中,运算符被分为算术运算符、赋值运算符、复合赋值运算符、比较运算符和逻辑运算符等。本文将从基础到进阶进行分析,并通过一个综合案例展示其实际应用。
|
1天前
|
程序员 UED Python
Python入门:3.Python的输入和输出格式化
在 Python 编程中,输入与输出是程序与用户交互的核心部分。而输出格式化更是对程序表达能力的极大增强,可以让结果以清晰、美观且易读的方式呈现给用户。本文将深入探讨 Python 的输入与输出操作,特别是如何使用格式化方法来提升代码质量和可读性。
Python入门:3.Python的输入和输出格式化
|
1天前
|
存储 Linux iOS开发
Python入门:2.注释与变量的全面解析
在学习Python编程的过程中,注释和变量是必须掌握的两个基础概念。注释帮助我们理解代码的意图,而变量则是用于存储和操作数据的核心工具。熟练掌握这两者,不仅能提高代码的可读性和维护性,还能为后续学习复杂编程概念打下坚实的基础。
Python入门:2.注释与变量的全面解析
|
6月前
|
存储 Python
Python笔记8 函数
本文是作者的Python复习笔记第八篇,全面介绍了Python中的函数定义与使用,包括函数的参数传递(位置参数、关键字参数、默认参数、列表参数、任意数量参数和关键字参数)、函数的返回值以及如何创建和调用函数库(模块),并提供了丰富的示例代码。
37 0
|
6月前
|
Python
【python笔记】使用zip函数迭代多个可迭代对象
【python笔记】使用zip函数迭代多个可迭代对象
|
9月前
|
Python
Python基础 笔记(九) 函数及进阶
Python基础 笔记(九) 函数及进阶
58 6

热门文章

最新文章

推荐镜像

更多