python类的构造使用以及例子+python的魔法方法+迭代器

最新推荐文章于 2022-07-07 22:05:53 发布
最新推荐文章于 2022-07-07 22:05:53 发布
阅读量450 收藏 2
点赞数
分类专栏： python入门+数据分析（numpy等） 文章标签： 列表 python 类 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42198265/article/details/118879892
版权

python

学习的路径：戳一戳

本篇博客说明

最后的几个知识点，单纯看文档有点吃力，我再去康康视频，后续应该会有他们的详细补发博客，这个只是做个记录。

定义一个简单的类

基本语法：

class 函数名:
    函数体

对象名 = 函数名( )
对象名.(需要的数或者方法)

注意：

  • 由于下面这个代码，并没有对name，age，height进行修饰，由于python的值可以到处跑，所以说在下方改变name，也就是把name的值修改了，所以输出的就不是Bessie_Lee,而是Bessie

代码显示：

class hh:
    name = "Bessie_Lee"
    age = 18
    height = 161
    def major(self):
        print("I am a software engineering student")
    def time(self):
        print("I start to study at half past eight every morning!")

h = hh()
h.major()
h.time()
h.name = "Bessie"
print(h.name)

'''输出：
I am a software engineering student
I start to study at half past eight every morning!
Bessie
'''

使用私有方法（构造方法）__init__

  • 下面的类，就可以直接在创建对象名的时候传入对应参数
  • 注意：
  • 如果传入参数的时候，没有指定哪个传入哪个，就一定要按照类里面的参数顺序传入：
    • 对应例子：类里面：def __init__(self, age, name):，对应的调用h = hh(18, "Bessie_Lee")
  • 如果传入的参数指定哪个传入哪个，就不用管顺序
    • 对应例子：类里面：def __init__(self, age, name):，对应的调用h = hh(name = "Bessie_Lee", age = 18)【指定哪个是哪个的参数】
class hh:
    def __init__(self, age, name):
        self_age = age
        self_name = name
    def major(self):
        print("I am a software engineering student")
    def time(self):
        print("I start to study at half past eight every morning!")

h = hh(name = "Bessie_Lee", age = 18)
h.major()
h.time()
h.name = "Bessie"
print(h.name)

'''代码输出：
I am a software engineering student
I start to study at half past eight every morning!
Bessie
'''

pass语句+函数

  • pass - 啥作用都没有，就是可以给你留一个空格出来，保证代码不会报错
class MyList(list):
    pass

lis = MyList([12, 34, 45, 56])
lis.append(89)
lis.sort()
print(lis)
# [12, 34, 45, 56, 89]

调用父类的俩种方法

  • 父类名.__init__(self)
  • super().__init__()

对应代码：

import random
class Fish:
    def __init__(self):
        self.x = random.randint(0, 10)
        self.y = random.randint(0, 10)

    def move(self):
        self.x -= 1
        print("我的位置", self.x, self.y)


class Shark(Fish):  # 鲨鱼
    def __init__(self):
    #    Fish.__init__(self)
        super().__init__()
        self.hungry = True

    def eat(self):
        if self.hungry:
            print("吃货的梦想就是天天有得吃！")
            self.hungry = False
        else:
            print("太撑了，吃不下了！")
            self.hungry = True

a = Shark()
a.eat() #吃货的梦想就是天天有得吃！

同名属性和方法

class A:
    x = 10
    def x(self):
        print("same!")

p = A()
p.x() # same!
p.x = 199
print(p.x) # 199

绑定（我也不太会）

  • Python 对象的数据属性通常存储在名为.__ dict__的字典中，我们可以直接访问__dict__，或利用 Python 的内置函数vars()获取.__ dict__。

代码说明：

class CC:
    def setXY(self, x, y):
        self.x = x
        self.y = y

    def printXY(self):
        print(self.x, self.y)

dd = CC()
print(dd.__dict__) # {}
print(vars(dd)) # {}
print(CC.__dict__) # ①

dd.setXY(4, 5)
print(dd.__dict__) # {'x': 4, 'y': 5}
print(vars(CC)) # ①
print(CC.__dict__) # ①

# 称为：① ：{'__module__': '__main__', 'setXY': <function CC.setXY at 0x0000019FB236C4C0>, 'printXY': <function CC.printXY at 0x0000019FB236C550>, '__dict__': <attribute '__dict__' of 'CC' objects>, '__weakref__': <attribute '__weakref__' of 'CC' objects>, '__doc__': None}

魔法方法

  • 若__new__没有正确返回当前类cls的实例，那__init__是不会被调用的，即使是父类的实例也不行，将没有__init__被调用。

利用__new__实现单例模式

class Earth:
    __instance = None  # 定义一个类属性做判断

    def __new__(cls):
        if cls.__instance is None:
            cls.__instance = object.__new__(cls)
            return cls.__instance
        else:
            return cls.__instance


a = Earth()
print(id(a))  # 2945214668704
b = Earth()
print(id(b))  # 2945214668704

实例化

  • __new__方法主要是当你继承一些不可变的 class 时（比如int, str, tuple）， 提供给你一个自定义这些类的实例化过程的途径。
class CapStr(str):
    def __new__(cls, string):
        string = string.upper()
        return str.__new__(cls, string)


a = CapStr("i love lsgogroup")
print(a)  # I LOVE LSGOGROUP

加法减法（有点重要）

__add__(self, other)定义加法的行为：+
__sub__(self, other)定义减法的行为：-

代码：

class MyClass:

    def __init__(self, height, weight):
        self.height = height
        self.weight = weight

    # 两个对象的长相加，宽不变.返回一个新的类
    def __add__(self, others):
        return MyClass(self.height + others.height, self.weight + others.weight)

    # 两个对象的宽相减，长不变.返回一个新的类
    def __sub__(self, others):
        return MyClass(self.height - others.height, self.weight - others.weight)

    # 说一下自己的参数
    def intro(self):
        print("高为", self.height, " 重为", self.weight)


def main():
    a = MyClass(height=10, weight=5)
    a.intro()

    b = MyClass(height=20, weight=10)
    b.intro()

    c = b - a
    c.intro()

    d = a + b
    d.intro()


if __name__ == '__main__':
    main()

# 高为 10  重为 5
# 高为 20  重为 10
# 高为 10  重为 5
# 高为 30  重为 15

其他方法

  • __mul__(self, other)定义乘法的行为：*
  • __truediv__(self, other)定义真除法的行为：/
  • __floordiv__(self, other)定义整数除法的行为：//
  • __mod__(self, other) 定义取模算法的行为：%
  • __divmod__(self, other)定义当被 divmod() 调用时的行为
    divmod(a, b)把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。

反算术运算符（我不懂）

  • 反运算魔方方法，与算术运算符保持一一对应，不同之处就是反运算的魔法方法多了一个“r”。当文件左操作不支持相应的操作时被调用。
    在这里插入图片描述

  • 注意 self 在后面

class Nint(int):
    def __radd__(self, other):
        return int.__sub__(other, self) # 注意 self 在后面


a = Nint(5)
b = Nint(3)
print(a + b)  # 8
print(1 + b)  # -2

这个知识点好抽象。。。。。我想看网课，这个文字看的我有点麻
在这里插入图片描述

class C:
    def __getattribute__(self, item):
        print('__getattribute__')
        return super().__getattribute__(item)

    def __getattr__(self, item):
        print('__getattr__')

    def __setattr__(self, key, value):
        print('__setattr__')
        super().__setattr__(key, value)

    def __delattr__(self, item):
        print('__delattr__')
        super().__delattr__(item)


c = C()
c.x
# __getattribute__
# __getattr__

c.x = 1
# __setattr__

del c.x
# __delattr__

描述符

  • __get__(self, instance, owner)用于访问属性，它返回属性的值。
  • __set__(self, instance, value)将在属性分配操作中调用，不返回任何内容。
  • __del__(self, instance)控制删除操作，不返回任何内容

格式：

class MyDecriptor:
    def __get__(self, instance, owner):
        print('__get__', self, instance, owner)

    def __set__(self, instance, value):
        print('__set__', self, instance, value)

    def __delete__(self, instance):
        print('__delete__', self, instance)


class Test:
    x = MyDecriptor()


t = Test()
t.x
# __get__ <__main__.MyDecriptor object at 0x000000CEAAEB6B00> <__main__.Test object at 0x000000CEABDC0898> <class '__main__.Test'>

t.x = 'x-man'
# __set__ <__main__.MyDecriptor object at 0x00000023687C6B00> <__main__.Test object at 0x00000023696B0940> x-man

del t.x
# __delete__ <__main__.MyDecriptor object at 0x000000EC9B160A90> <__main__.Test object at 0x000000EC9B160B38>

编写一个不可改变的自定义列表，要求记录列表中每个元素被访问的次数

class CountList:
    def __init__(self, *args):
        self.values = [x for x in args]
        self.count = {}.fromkeys(range(len(self.values)), 0)

    def __len__(self):
        return len(self.values)

    def __getitem__(self, item):
        self.count[item] += 1
        return self.values[item]


c1 = CountList(1, 3, 5, 7, 9)
c2 = CountList(2, 4, 6, 8, 10)
print(c1[1])  # 3
print(c2[2])  # 6
print(c1[1] + c2[1])  # 7

print(c1.count)
# {0: 0, 1: 2, 2: 0, 3: 0, 4: 0}

print(c2.count)
# {0: 0, 1: 1, 2: 1, 3: 0, 4: 0}

迭代器

  • 迭代是 Python 最强大的功能之一，是访问集合元素的一种方式。
  • 迭代器是一个可以记住遍历的位置的对象。
  • 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。
  • 迭代器只能往前不会后退。
  • 字符串，列表或元组对象都可用于创建迭代器：
string = 'lsgogroup'
for c in iter(string):
    print(c, end = " ")
# l s g o g r o u p 

links = {'B': '百度', 'A': '阿里', 'T': '腾讯'}
for each in iter(links):
    print(each, end=" ")
    print('%s -> %s' % (each, links[each]))
'''
B B -> 百度
A A -> 阿里
T T -> 腾讯
'''

生成器

def libs(n):
    a = 0
    b = 1
    while True:
        a, b = b, a + b
        if a > n:
            return
        yield a


for each in libs(100):
    print(each, end=' ')

# 1 1 2 3 5 8 13 21 34 55 89
Bessie_Lee_gogogo
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
python中的类与构造函数
qq_42111171的博客
03-03 1060
python中类的用法（继承、静态变量、类中函数自有变量、类中函数之间的调用） python中类的用法（继承、静态变量、类中函数自有变量、类中函数之间的调用 类中构造函数的作用 构造函数的作用 构造函数主要用来在创建对象时完成对对象属性的一些初始化等操作, 当创建 对象时, 对象会自动调用它的构造函数。实例化对象时是可以传入参数的，这些参数会自动传入__init__()方法中，可以通过重写这个方法来自定义对象的初始化操作。构造方法可以带有除self外的其它各种参数(关键字参数、默认参数、用元组收集参数、用
Python构造函数、成员函数，类变量、成员变量和局部变量
ct745363083的博客
08-07 2705
一直对这些概念比较混淆，今天理一下。 构造函数和成员函数 构造函数也被称为构造器，当创建对象的时候第一个被自动调用的函数，系统默认提供了一个无参的构造函数，语法如下： def __ init__(self,arg1,arg2,...): 函数体 构造函数和成员函数的区别 成员函数的函数名可以自定义，但是，构造函数的函数名是固定的__init__ 成员函数需要被手动调用，但是，构造函数在创建对象的过程中是自动被调用的 对于同一个对象而言，成员函数可以被调用多次，但是，构造函数只能被调用一次 参考文档：
Python 类的结构
钢铁男儿
12-19 1720
1、类的结构 1.1、术语 – 实例 1）、使用面向对象开发，第1步 是设计 类； 2）、使用 类名（） 创建对象，创建对象 的动作有两步： 第一步：在内存中尾对象 分配空间； 第二步：调用初始化方法 init 为 对象初始化； 3）、对象创建后，内存 中就有一个对象的 实实在在 的存在 — 实例； 因此，通常也会把： 1）、创建出来的 对象 叫做 类的 实例； 2）、创建对象的 动作 叫做 实例化； 3）、对象的属性 叫做 实例属性； 在程序运行时： 1）、对象各自拥有自己的 实例属性； 2）、调用对象
编程知识 | python应用实例
weixin_44067030的博客
04-30 620
3.相关应用实例 3.1文本进度条 改进： 单行动态刷新：用打印后的字符覆盖之前的字符。 不能换行：print()需要被控制。（print()默认输出后换行到下一行。） 要能回退：打印后光标退回到之前的位置\r。 IDLE运行结果： IDLE是编写程序的开发环境，不是程序运行的主要环境。一般程序使用双击或者控制台来运行，很少用IDLE来运行。IDLE由于是开发环境，为了保证参数运行效果，\r的功能被屏蔽掉了。可以使用Windows操作环境中的命令行类似的相关工具；或者在Linux环境下打开bshell
python字符串内建函数
菜鸟清风
04-22 398
在八进制数前面显示零(‘0’)，在十六进制前面显示’0x’或者’0X’(取决于用的是’x’还是’X’) 0 显示的数字前面填充’0’而不是默认的空格 % ‘%%’输出一个单一的’%’ (var) 映射变量(字典参数) m.n. m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) Python2.6 开始，新增了一种格式化字符串的函数 str.format()，...
python迭代器的使用方法实例
12-24
python中有很多的对象都是迭代器，例如：列表，元素，字符串，文件，映射，集合 如何使用迭代器？ 1. for 变量 in 可迭代对象 复制代码 代码如下: list1 = [1,2,3,4,5] for ele in list1: print ele, 结果为：1 2 ...
python 使用cycle构造无限循环迭代器
01-19
源码里我们可以看到它实现了__iter__和__next__的魔术方法，说明它既是可迭代对象也是一个迭代器，我们可以使用for循环和next()方法去操作它 我们先来看看以普通的方式去遍历一个列表 li = ['python', 'java', 'c',...
python迭代器使用笔记.doc
10-01
python迭代器使用笔记
python中实现迭代器（iterator）的方法示例
12-24
迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。 延迟计算或惰性求值 (Lazy evaluation) 迭代器不要求你事先准备好整个迭代过程中...
Python使用迭代器捕获Generator返回值的方法
09-21
主要介绍了Python使用迭代器捕获Generator返回值的方法,结合具体实例形式分析了Python迭代器获取生成器返回值的相关操作技巧,需要的朋友可以参考下
Python的专用方法
soul的技术杂记
07-26 477
原文引自：http://5ydycm.blog.51cto.com/115934/157548Python 类可以定义专用方法,专用方法是在特殊情况下或当使用特别语法时由 Python 替你调用的，而不是在代码中直接调用（象普通的方法那样）。.1    __init__类似于构造
python类的简单例子
qq_34474071的博客
03-08 867
# Java和C#来说只支持面向对象编程，而python比较灵活即支持面向对象编程也支持函数式编程 # 类就是一个模板，模板里可以包含多个函数，函数里实现一些功能 # 对象则是根据模板创建的实例，通过实例对象可以执行类中的函数 # 创建类 class Foo: # 类中定义的函数叫做 “方法” def Bar(self): print('Hi Bar') def Hello(self, name): print('i am %s' % name.
python创意实用案例-9个 Python 实用案例分享
q6q6q的专栏
10-28 1578
1. 整理字符串输入整理用户输入的问题在编程过程中极为常见。通常情况下，将字符转换为小写或大写就够了，有时你可以使用正则表达式模块「Regex」完成这项工作。但是如果问题很复杂，可能有更好的方法来解决：user_input="This string has some whitespaces... "character_map= {ord(' ') : ' ',ord(' ')...
python使用类的例子_使用类和实例
weixin_39933484的博客
02-03 370
## 使用类和实例你可以使用类来模拟现实世界中的很多情景。类编写好后，你的大部分时间都将花在使用根据类创建的实例上。你需要执行的一个重要任务是修改实例的属性。你可以直接修改实例的属性，也可以编写方法以特定的方式进行修改。## Car 类下面来编写一个表示汽车的类，它存储了有关汽车的信息，还有一个汇总这些信息的方法：```class Car():"""一次模拟汽车的简单尝试"""def __init...
python中类方法的应用实例一
qq_39132236的博客
12-10 290
项目背景：生物识别设备，单机版本使用测试其稳定性。实现功能：新增人员，每采集一次生物特征，调用虹膜摄像头一次，日志显示打开虹膜摄像头次数 + 1。使用两种方式来实现，一种使用类方法。另一种不使用类方法。 第一种：使用类方法实现 项目代码 from Foo.capability_json import getDriver from Foo.login import Login from Foo.pageSwitch import PageSwitch from util.baseView import Ba
python中类的应用实例
weixin_43331915的博客
10-29 733
import numpy as np class Generate(object): def __init__(self): self.group_images() self.lock = figure # 这里只是把self.lock指向了figure这个函数，没有运行这个函数 self.z = with_bracket() d...
python新手入门代码-介绍十个Python小案例，新手入门就在这里
q6q6q的专栏
10-28 5069
案例一：排列组合要求：将4个数字可能组成的所有互不相同且无重复数字的排列组合列出。注意：很多人学Python过程中会遇到各种烦恼问题，没有人帮答疑容易放弃。为此小编建了个Python全栈免费答疑.裙 ：七衣衣九起起巴而五（数字的谐音）转换下可以找到了，不懂的问题有老司机解决里面还有最新Python教程项目可拿,，一起相互监督共同进步！程项目可拿,，一起相互监督共同进步！分析：排列就好了代码：案例二...
python之类的构造方法
jiankang66的博客
07-07 6486
  Python 是一门易于学习、功能强大的编程语言。它提供了高效的高级数据结构，还能简单有效地面向对象编程。Python 优雅的语法和动态类型以及解释型语言的本质，使它成为多数平台上写脚本和快速开发应用的理想语言。下面我们来介绍一下python的类的构造方法。  构造方法的固定名称为__init__()，当创建类的对象时，系统会自动调用构造方法，从而实现对对象进行初始化的操作。   结果如下。   结果如下。   以上就是就是关于Python的类的构造方法相关知识，可以参考一下，觉得不错的话，欢迎点赞、
python函数示例_Python中带示例的构造函数
cumt30111的博客
07-24 376
python函数示例A Constructor is the special method (function) used to initialize the instance variables during object creation. 构造函数是用于在对象创建期间初始化实例变量的特殊方法(函数)。 Types of constructors in Python Python中的构...
python类方法使用例子
最新发布
11-29
以下是一个Python类方法的使用例子： ```python class MyClass: count = 0 def __init__(self): MyClass.count += 1 @classmethod def get_count(cls): return cls.count obj1 = MyClass() obj2 = MyClass...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Bessie_Lee_gogogo

你的鼓励是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值