当前位置： 首页 > article >正文

Python面向对象（15对象嵌套特殊成员）

article 2024/12/23 16:46:05

  Python基础语法文章导航：

  1. Python基础（01初识数据类型&变量）
  2. Python基础（02条件&循环语句）
  3. Python基础（03字符串格式化&运算符&进制&编码）
  4. Python基础（04 基础练习题）
  5. Python数据类型（day05整型&布尔类型&字符串类型）
  6. Python数据类型（06列表&元组）
  7. Python数据类型（07集合&字典&浮点型&None）
  8. Python文件操作01（自动化测试文件相关操作）

  9. Python函数入门（08函数定义&参数&返回值）

  10. Python文件操作02（自动化测试文件相关操作）

  11. Python函数（10生成器&内置函数&推导式）

  12. Python函数（11自定义模块&第三方模块&内置模块）

  13. Python函数（12时间处理&正则表达式）

  14. Python函数（13面向对象）

  15. Python面向对象（14成员&成员修饰符）

  16. Python函数（16进程和线程）

  17. Python基础语法（17多线程&线程锁&单例模式）

  18. Python基础语法（18多进程开发&进程建数据共享&进程锁&进程池）

目录

一.对象嵌套

二.特殊成员

1.__init__，初始化方法

2.__new__，构造方法

 3.__call__

4. __str__

5. __dict__

6.__getitem__、__setitem__、__delitem__

7.__enter__、__exit__

8.__add__

9.__iter__

一.对象嵌套

        在基于面向对象进行编程时，对象之间可以存在各种各样的关系，例如：组合、关联、依赖等，就是各种嵌套。以下是常见的嵌套的情景：

情景一：

class Student(object):
    """ 学生类 """
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def message(self):
        data = "我是一名学生，我叫:{},我今年{}岁".format(self.name, self.age)
        print(data)

s1 = Student("武沛齐", 19)
s2 = Student("Alex", 19)
s3 = Student("日天", 19)

class Classes(object):
    """ 班级类 """
    def __init__(self, title):
        self.title = title
        self.student_list = []

    def add_student(self, stu_object):
        self.student_list.append(stu_object)

    def add_students(self, stu_object_list):
        for stu in stu_object_list:
            self.add_student(stu)

    def show_members(self):
        for item in self.student_list:
            # print(item)
            item.message()

c1 = Classes("三年二班")
c1.add_student(s1)
c1.add_students([s2, s3])
print(c1.title)
print(c1.student_list)
# 三年二班
# [<__main__.Student object at 0x00000299D5FB7FD0>, <__main__.Student object at 0x00000299D5FB7DC0>, <__main__.Student object at 0x00000299D5FB7D60>]

 情景二：

class Student(object):
    """ 学生类 """
    def __init__(self, name, age, class_object):
        self.name = name
        self.age = age
        self.class_object = class_object

    def message(self):
        data = "我是一名{}班的学生，我叫:{},我今年{}岁".format(self.class_object.title, self.name, self.age)
        print(data)

class Classes(object):
    """ 班级类 """
    def __init__(self, title):
        self.title = title
c1 = Classes("Python全栈")
c2 = Classes("Linux云计算")

user_object_list = [
    Student("武沛齐", 19, c1),
    Student("Alex", 19, c1),
    Student("日天", 19, c2)
]

for obj in user_object_list:
    print(obj.name,obj.age, obj.class_object.title)
# 武沛齐 19 Python全栈
# Alex 19 Python全栈
# 日天 19 Linux云计算

 情景三：

class Student(object):
    """ 学生类 """
    def __init__(self, name, age, class_object):
        self.name = name
        self.age = age
        self.class_object = class_object

    def message(self):
        data = "我是一名{}班的学生，我叫:{},我今年{}岁".format(self.class_object.title, self.name, self.age)
        print(data)

class Classes(object):
    """ 班级类 """
    def __init__(self, title, school_object):
        self.title = title
        self.school_object = school_object

class School(object):
    """ 学校类 """
    def __init__(self, name):
        self.name = name

s1 = School("北京校区")
s2 = School("上海校区")

c1 = Classes("Python全栈", s1)
c2 = Classes("Linux云计算", s2)

user_object_list = [
    Student("武沛齐", 19, c1),
    Student("Alex", 19, c1),
    Student("日天", 19, c2)
]
for obj in user_object_list:
    print(obj.name, obj.class_object.title ,  obj.class_object.school_object.name)
# 武沛齐 Python全栈 北京校区
# Alex Python全栈 北京校区
# 日天 Linux云计算 上海校区

二.特殊成员

        在Python的类中存在一些特殊的方法，这些方法都是“ __方法__ ”格式，这种方法在内部均有特殊的含义，接下来我们来讲一些常见的特殊成员：

1.__init__，初始化方法

class Foo(object):
    def __init__(self, name):
        self.name = name

obj = Foo("武沛齐")

2.__new__，构造方法

class Foo(object):
    def __init__(self, name):
        print("第二步：初始化对象，在空对象中创建数据")
        self.name = name

    def __new__(cls, *args, **kwargs):
        print("第一步：先创建空对象并返回")
        return object.__new__(cls)


obj = Foo("武沛齐")

 3.__call__

class Foo(object):
    def __call__(self, *args, **kwargs):
        print("执行call方法")

obj = Foo()
obj()

4. __str__

class Foo(object):
    def __str__(self):
        return "哈哈哈哈"

obj = Foo()
data = str(obj)
print(data)

5. __dict__

class Foo(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age


obj = Foo("武沛齐",19)
print(obj.__dict__)

6.__getitem__、__setitem__、__delitem__

class Foo(object):
    def __getitem__(self, item):
        pass

    def __setitem__(self, key, value):
        pass

    def __delitem__(self, key):
        pass


obj = Foo("武沛齐", 19)
obj["x1"]
obj['x2'] = 123
del obj['x3']

7.__enter__、__exit__

class Foo(object):

    def __enter__(self):
        print("进入了")
        return 666

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("出去了")


obj = Foo()
with obj as data:
    print(data)

数据连接，每次对远程的数据进行操作时候都必须经历。
1.连接 = 连接数据库
2.操作数据库
3.关闭连接

class SqlHelper(object):

    def __enter__(self):
        self.连接 = 连接数据库
        return 连接
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.连接.关闭
      
with SqlHelper() as 连接:
    连接.操作..
       
with SqlHelper() as 连接:
    连接.操作...

上下文管理的语法。

8.__add__

class Foo(object):
    def __init__(self, name):
        self.name = name

    def __add__(self, other):
        return "{}-{}".format(self.name, other.name)


v1 = Foo("alex")
v2 = Foo("sb")

# 对象+值，内部会去执行 对象.__add__方法，并将+后面的值当做参数传递过去。
v3 = v1 + v2
print(v3)

9.__iter__

# 迭代器类型的定义：
    1.当类中定义了 __iter__ 和 __next__ 两个方法。
    2.__iter__ 方法需要返回对象本身，即：self
    3. __next__ 方法，返回下一个数据，如果没有数据了，则需要抛出一个StopIteration的异常。
	官方文档：https://docs.python.org/3/library/stdtypes.html#iterator-types
        
# 创建 迭代器类型 ：
	class IT(object):
        def __init__(self):
            self.counter = 0

        def __iter__(self):
            return self

        def __next__(self):
            self.counter += 1
            if self.counter == 3:
                raise StopIteration()
            return self.counter

# 根据类实例化创建一个迭代器对象：
    obj1 = IT()
    
    # v1 = obj1.__next__()
    # v2 = obj1.__next__()
    # v3 = obj1.__next__() # 抛出异常
    
    v1 = next(obj1) # obj1.__next__()
    print(v1)

    v2 = next(obj1)
    print(v2)

    v3 = next(obj1)
    print(v3)


    obj2 = IT()
    for item in obj2:  # 首先会执行迭代器对象的__iter__方法并获取返回值，一直去反复的执行 next(对象) 
        print(item)
        
迭代器对象支持通过next取值，如果取值结束则自动抛出StopIteration。
for循环内部在循环时，先执行__iter__方法，获取一个迭代器对象，然后不断执行的next取值（有异常StopIteration则终止循环）。

 

# 创建生成器函数
    def func():
        yield 1
        yield 2
    
# 创建生成器对象（内部是根据生成器类generator创建的对象），生成器类的内部也声明了：__iter__、__next__ 方法。
    obj1 = func()
    
    v1 = next(obj1)
    print(v1)

    v2 = next(obj1)
    print(v2)

    v3 = next(obj1)
    print(v3)


    obj2 = func()
    for item in obj2:
        print(item)

如果按照迭代器的规定来看，其实生成器类也是一种特殊的迭代器类（生成器也是一个中特殊的迭代器）。
# 如果一个类中有__iter__方法且返回一个迭代器对象 ；则我们称以这个类创建的对象为可迭代对象。

class Foo(object):
    
    def __iter__(self):
        return 迭代器对象(生成器对象)
    
obj = Foo() # obj是 可迭代对象。

# 可迭代对象是可以使用for来进行循环，在循环的内部其实是先执行 __iter__ 方法，获取其迭代器对象，然后再在内部执行这个迭代器对象的next功能，逐步取值。
for item in obj:
    pass
class IT(object):
    def __init__(self):
        self.counter = 0

    def __iter__(self):
        return self

    def __next__(self):
        self.counter += 1
        if self.counter == 3:
            raise StopIteration()
        return self.counter


class Foo(object):
    def __iter__(self):
        return IT()


obj = Foo() # 可迭代对象


for item in obj: # 循环可迭代对象时，内部先执行obj.__iter__并获取迭代器对象；不断地执行迭代器对象的next方法。
    print(item)
# 基于可迭代对象&迭代器实现：自定义range
class IterRange(object):
    def __init__(self, num):
        self.num = num
        self.counter = -1

    def __iter__(self):
        return self

    def __next__(self):
        self.counter += 1
        if self.counter == self.num:
            raise StopIteration()
        return self.counter


class Xrange(object):
    def __init__(self, max_num):
        self.max_num = max_num

    def __iter__(self):
        return IterRange(self.max_num)


obj = Xrange(100)

for item in obj:
    print(item)
class Foo(object):
    def __iter__(self):
        yield 1
        yield 2


obj = Foo()
for item in obj:
    print(item)
# 基于可迭代对象&生成器 实现：自定义range

class Xrange(object):
    def __init__(self, max_num):
        self.max_num = max_num

    def __iter__(self):
        counter = 0
        while counter < self.max_num:
            yield counter
            counter += 1


obj = Xrange(100)
for item in obj:
    print(item)

常见的数据类型：

v1 = list([11,22,33,44])

v1是一个可迭代对象，因为在列表中声明了一个 __iter__ 方法并且返回一个迭代器对象。
from collections.abc import Iterator, Iterable

v1 = [11, 22, 33]
print( isinstance(v1, Iterator) )  # false，判断是否是迭代器；判断依据是__iter__ 和 __next__。
v2 = v1.__iter__()
print( isinstance(v2, Iterator) )  # True

v1 = [11, 22, 33]
print( isinstance(v1, Iterable) )  # True，判断依据是是否有 __iter__且返回迭代器对象。

v2 = v1.__iter__()
print( isinstance(v2, Iterable) )  # True，判断依据是是否有 __iter__且返回迭代器对象。


http://www.kler.cn/a/290975.html

相关文章：

  • WPF 使用LibVLCSharp.WPF实现视频播放、停止、暂停功能
  • Tomcat部署war包项目解决404问题
  • python如何保存.npy
  • Godot RPG 游戏开发指南
  • MyBatis入门的详细应用实例
  • electron-vite【实战系列教程】
  • 云原生 | 在 Kubernetes 中使用 Cilium 替代 Calico 网络插件实践指南!
  • 大零售时代：开源 AI 智能名片、2+1 链动与 O2O 商城小程序引领融合新趋势
  • Ajax 2024/3/31
  • 零售自动化新趋势：AI 智能名片与 S2B2C 商城系统助力零售业变革
  • git常用之已存在的目录转换为一个 GIT 项目并托管到github仓库
  • 每天五分钟深度学习：广播机制（以python语言为例）
  • 【大数据】生活中三大数据的概念及其关系
  • 新品上市丨科学级新款制冷相机sM4040A/sM4040B
  • 【ShuQiHere】深入理解递归：从基础概念到实际应用
  • ffmpeg音视频开发从入门到精通——ffmpeg日志及目录操作
  • Java开发笔记--通用消息组件设计(移动短信、华为短信、163邮件)
  • chapter03 流程语句 知识点Note
  • JS基础-ClassList -移动端插件的引入-touch事件-sessionStorage 和 localStorage
  • STM32—I2C的基本时序，MU6050的ID读取
  • 云计算和传统IT相比，有哪些优势？
  • map和set的区别和底层实现是什么？map取值的 find，[]，at方法的区别
  • GitLab 是什么？GitLab使用常见问题解答
  • 论文浅尝 | TaxoLLaMA: 用基于WordNet的模型来解决多个词汇语义任务（ACL2024）
  • 微信小程序npm扩展能力探究
  • Linux性能监控神器：深入nmon详解与使用