类与对象——从定义到使用，最系统性的学习

于 2024-08-07 14:22:26 发布
阅读量724 收藏 4
点赞数 13
分类专栏： Python 文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ruo_Rachel/article/details/140960466
版权

前言

我们可能会遇到这样一种情况：
一个软件需要建立一个用户管理系统，每一个新用户注册都要录入系统里，录入的个人信息可能有姓名、年龄、电话号码、特殊记录......，为了便于登记和统一管理，这个时候就可以用到“类”

正文

类的定义：

我们可以把类（class）理解成一个模块，把同一种东西放在一块
类的成员：类的对象（变量）（如我们上面举的例子中的新用户）、类的方法（函数）
可以传入参数（如姓名、年龄、电话号码、特殊记录......），使其成为某一对象的一个属性

先来看看基本结构：

首先录入的用户都有姓名、年龄、电话号码（可能只有部分人有特殊记录，所以这里不考虑），我们可以统一录入，相当于初始化设置

class User:
    def __init__(self, name, age, number):
        self.name = name
        self.age = age
        self.number = number

user_1 = User('Alice', 18, 18888888888)

观察一下结构：
1.类的命名使用“大驼峰命名法” (eg.UserName、UserAge),每个单词首字母大写
2.__init__是类的构造方法（前后各有两个下划线，后文出现的下划线都为两个），在创建对象时自动使用，所以可以用于初始化，注意传参位置要写上一个self
3.def内部要用self.*** = ***的形式，让传入的参数变成该对象的属性
如果只是传入，但内部不用self调用，则仅参与构造，不属于该对象的属性。
如果不传入，只是调用，可参与构造，且属于该对象的属性

class User:
    def __init__(self, name, age, number=10000000000):
        self.name = name
        self.age = age
        self.number = number

user_1 = User('Alice', 18)
print(user_1.number)

注意：
如果我们在传入时让某一变量有一个固定的初始值，如果不为它传入一个数，则默认为该初始值（如果既没有初始值，又不传入，会报错）

双下划线法（“魔术方法”或“特殊方法”）

有一种形象的理解方法，可以把它认为某种意义上的import，def之后就可以在下方代码实现一些操作

1.__del__ 

删除对象，下方可用 del 对象

class User:
    def __init__(self, name, age, number):
        self.name = name
        self.age = age
        self.number = number
    def __del__(self):
        print('del something')

user_1 = User('Alice', 18,18888888888)
del user_1

#下方为打印结果（以下示例同样）
del something

2.__str__ 

打印对象时，可以自定义打印出来的字符串，可以 print(对象)

class User:
    def __init__(self, name, age, number):
        self.name = name
        self.age = age
        self.number = number
    def __str__(self):
        return f'用户名称为{self.name}，年龄为{self.age}，电话为{self.number}'

user_1 = User('Alice', 18,18888888888)
print(user_1)

用户名称为Alice，年龄为18，电话为18888888888

3.针对索引的几种情况

__len__
__getitem__、__setitem__、__delitem__
分别可以 len(对象），对象[索引] = *，del 对象[索引]

class MyContent:
    def __init__(self, content):
        self.content = content
        
    def __len__(self):
        return len(self.content)
    
    def __getitem__(self, key):
        return self.content[key]
    
    def __setitem__(self, key, content):
        self.content[key] = content
    
    def __delitem__(self, key):
        del self.content[key]


my_content = MyContent([1, 2, 3, 4]) # 创建一个对象

print(len(my_content))        # 调用 __len__

my_content[1] = 10            # 调用 __set__
print(my_content.content)

del my_content[1]             # 调用 __del__
print(my_content.content)

4
[1, 10, 3, 4]
[1, 3, 4] 

4.用于for循环

__iter__、__next__

可以 for i in 对象:        且 print(i)

class MyContent:
    def __init__(self, content):
        self.content = content
        self.index = 0
        
    def __iter__(self):
        self.index = 0
        return self
    
    def __next__(self):
        if self.index < len(self.content):
            result = self.content[self.index]
            self.index += 1
            return result
        else:
            raise StopIteration


my_content = MyContent([1, 2, 3, 4])  # 创建一个对象
for item in my_content:  # 调用 __iter__ 和 __next__
    print(item)

1
2
3
4 

 其中，对于最后两行：in my_content调用了__iter__，for item调用了__next__

5.加减乘除

__add__、__sub__、__mul__、__truediv__

可以用 +、-、*、/ 

class Calculate:
    def __init__(self, x):
        self.x = x

    def __add__(self, other):
        return Calculate(self.x + other.x)

    def __sub__(self, other):
        return Calculate(self.x - other.x)

    def __mul__(self, other):
        return Calculate(self.x * other.x)

    def __truediv__(self, other):
        return Calculate(self.x / other.x)
    
    
v1 = Calculate(1)
v2 = Calculate(2)
v_add = v1 + v2  # 调用 __add__
v_sub = v1 - v2  # 调用 __sub__
v_mul = v1 * v2  # 调用 __mul__
v_truediv = v1 / v2  # 调用 __truediv__
print(v_add.x)
print(v_sub.x)
print(v_mul.x)
print(v_truediv.x)

3
-1
2
0.5

再看一个比较复杂的__add__：

class Calculate:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Calculate(self.x + other.x, self.y + other.y)


v1 = Calculate(1, 2)
v2 = Calculate(3, 4)
v3 = v1 + v2
print(v3.x, v3.y)

 4 6

6.比较大小

__eq__、__lt__、__gt__

 可以用 ==、<=、>=

class Calculate:
    def __init__(self, x):
        self.x = x

    def __eq__(self, other):
        return self.x == other.x
    
    def __lt__(self, other):
        return self.x <= other.x
    
    def __gt__(self, other):
        return self.x >= other.x
    
    
v1 = Calculate(1)
v2 = Calculate(2)
print(v1.x == v2.x)
print(v1.x <= v2.x)
print(v1.x >= v2.x)

False
True
False

 类的封装

那么除了上述的几种类的方法（官方的），我们也可以自己定义一个方法：
1.定义一个公共方法，eg.all_fuc，类似一个普通函数
2.定义一个私有方法，eg.__fuc，即class的外部不能访问，子类（后文会讲）也不能访问，以__***的形式命名

举个例子：

class User:
    def __init__(self, name, age, number):
        self.name = name
        self.age = age
        self.number = number
    
    def all_fuc(self):
        print('all_fuc被运行了')
    
    def __fuc(self):
        print('__fuc被运行了')


user_1 = User('Alice', 18, 18888888888)
user_1.all_fuc()
user_1.__fuc()

#user_1.all_fuc()能正常运行，user_1.__fuc()就报错了

all_fuc被运行了

AttributeError: 'User' object has no attribute '__fuc'

 但是我们的私有方法，仍可以在class内部被调用：

class User:
    def __init__(self, name, age, number):
        self.name = name
        self.age = age
        self.number = number
    
    def __fuc(self):
        print('__fuc被运行了')
        
    def test_fuc(self):
        print('test_fuc被运行了,准备调用__fuc')
        self.__fuc()


user_1 = User('Alice', 18, 18888888888)
user_1.test_fuc()

test_fuc被运行了,准备调用__fuc
__fuc被运行了

类的继承与多继承

1.单继承 

继承的意思是，它的子类可以使用父类所有的公开成员（包括对象和方法）

class User:
    def __init__(self, name, age, number):
        self.name = name
        self.age = age
        self.number = number
    
    def __fuc(self):
        print('__fuc被运行了')
            
    def test_fuc(self):
        print('test_fuc被运行了,准备调用__fuc')
        self.__fuc()

class SpecialUser(User):
    def __init__(self, name, age, number, tip):
        super().__init__(name, age, number)
        self.tip = tip


user_1 = User('Alice', 18, 18888888888)
user_2 = SpecialUser('Tom', 17, 16666666666, 'VIP用户')
print(user_2.age)
user_2.test_fuc()

17
test_fuc被运行了,准备调用__fuc
__fuc被运行了

分析一下：SpecialUser继承了User的属性，都有name, age, number，且自己还有一个别人没有的tip。我们用super().__init__(***)的形式，避免了重复初始化操作。age和test_fuc都是User的成员，user_2属于SpeicalUser类，但是可以调用User的成员

注意：
1.子类可以在父类的基础上定义自己的专属的成员（eg.tip）
2.如果子类的专属成员和父类的名字相同，则对于子类来说，以子类写的为准

2.多继承

class User:
    def __init__(self, name, age, number):
        self.name = name
        self.age = age
        self.number = number

class Tip:
    def __init__(self, tip):
        self.tip = tip

class SpecialUser(User, Tip):
    def __init__(self, name, age, number, tip):
        super().__init__(name, age, number)
        Tip.__init__(self, tip)


user_1 = User('Alice', 18, 18888888888)
user_2 = SpecialUser('Tom', 17, 16666666666, 'VIP用户')
print(user_2.age)
print(user_2.tip)

17
VIP用户

分析一下：SpecialUser继承了User和Tip，括号里前者是主父类，后者是其他的父类，super().__init__默认初始化第一个父类，后者要用 (后面的类的名称).__init__初始化，在这里，属于SpecialUser的user_2，可以调用它的两个父类的成员

看到这里，你已学习完毕：

恭喜你掌握了“类”！

ruo_Rachel
关注
  • 13
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值