类--python基础

已于 2022-06-22 11:59:48 修改
阅读量269 收藏 2
点赞数
分类专栏： python基础 文章标签： python 开发语言
于 2022-06-01 19:09:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chongbaikaishi/article/details/124994002
版权

1. 类

1.1 面向对象

面向过程的关注点：怎么做
面向对象的关注点：谁来做
面向对象编程（00P）是一种解决软件复用的设计和编程方法。这种方法把软件系统中相近相似的操作逻辑和操作应用数据、状态，以类的形式的描述出来，以对象实例的形式在软件系统中复用，以达到提高软件开发效率的作用。
类：类是具有一组相同或相似特征（属性）和行为的一系列对象的组合；是模板，模板中可以包含多个函数，函数里实现一些功能；类是负责创建对象的
对象：则是根据模板创建的实例，通过实例对象可以执行类中的函数。
类相当于制造汽车的图纸，用这个图纸制造的汽车相当于对象。
1） 使用面向过程编程：

# 问题情景；每位同学报告,并做自我介绍

stu_a = {
    'name': 'zhangsan',
    'age': 18,
    'gender': 'F',
    'hometown': 'henan'
}

stu_b = {
    'name': 'lisi',
    'age': 19,
    'gender': 'M',
    'hometown': 'hubei'
}

stu_c = {
    'name': 'wangwu',
    'age': 16,
    'gender': 'M',
    'hometown': 'qinghai'
}


def stu_info(stu):
    '''
每位学生自我介绍：
    '''
    for key, value in stu.items():
        print('我的', key, '是', value)


stu_info(stu_a)
stu_info(stu_b)
stu_info(stu_c)

'''
上述情景花费大量时间在学生信息定义上，自我介绍使用函数进行了封装简化， 
'''

2）使用面向对象编程

class Student:
    def __init__(self,name,age,birthplace):
        self.name = name
        self.age = age
        self.birthplace = birthplace
        print('我叫{},今年{}岁,家在{}'.format(self.name,self.age,self.birthplace))
stuA = Student('张三',20,'河南')
stuB = Student('李四',24,'湖北')

在这里插入图片描述
使用类能够实现代码的重复利用，提高开发效率

1.2 类的组成

类由3部分构成：
类的名称：类名
类的属性：一组数据，反应特征
类的方法：行为

在这里插入图片描述

2. 类

2.1 类名：

  1. 采用“大驼峰”命名方法:
    (1)每个单词首字母大写；
    (2)单词与单词之间没有下划线

2.2 创建简单类

通过class关键字，创建类

# 创建类
class Animal:
    pass


print(id(Animal))
print(type(Animal))

在这里插入图片描述
可以看到，虽然类内部我们还没定义具体的内容，但计算机已经给类开辟了内存空间。

接下来，我们在类的内部定义一个简单的实例方法

class Animal:
    def eat(self):
        print('吃东西才能活着')

先不要管self参数，后面会讲到，当你输入（）的时候pychrm会自动补充self参数。

2.3 类的实例化—实例（对象）

2.3.1 创建类的对象

根据类创建类的对象，使用：

变量名 = 类名（）

class Animal:
    def eat(self):
        print('吃东西才能活着')


am = Animal()
print(am)
nl = Animal()
print(nl)

在这里插入图片描述
这里创建了Animal的两个对象，可以看到，当我们输出创建的对象，python将会返回对象所属的类信息，以及在内存中的地址（十六进制表示），每个对象python都会分配单独的内存空间。

2.2.3 调用对象方法

调用对象的方法，只需要使用

对象名.方法名()

class Animal:
    def eat(self):
        print('吃东西才能活着')


am = Animal()
# print(am)
nl = Animal()
# print(nl)
am.eat()
nl.eat()

在这里插入图片描述
上面不同对象am、nl调用eat方法时，输出的是相同的内容，如果我们想要输出与对象am、nl相关的信息，就需要使用self参数。

2.2.4 self 参数

python中根据同一个类创建的对象都能够调用类中定义的方法，哪个对象调用方法，方法中的self参数就和那个对象名指向相同的内存地址。下面通过对代码打断点来看一下

在这里插入图片描述

可以看到，在第六行代码运行之后，产生了am对象，具体执行过程如下：
1）python会首先寻找内存中等号=右边的类Animal是否已经分配内存空间；
2）若类的内存空间存在，则利用类向内存中申请创建一块与类一样的空间；
3）回到类中查看是否定义了魔术方法__init__，
4）若没有定义魔术方法__init__，则直接将开辟的内存空间给变量名am；若有魔术方法__init__，则先进入魔术方法__init__内部执行里面的代码，然后再将开辟的内存空间给对象名变量。
接下类看对象am调用eat()方法的过程：
在这里插入图片描述

可以看到self指向的内存地址与am对象名指向的内存地址相同。

在这里插入图片描述

接下来，再看对象nl
在这里插入图片描述
在这里插入图片描述

每次运行代码，Animal类都会重新开辟新的内存空间给对象。同样可以看到，当创建对象nl后，nl调用eat方法时，其中的self指向的内存地址与nl相同
也就是说，哪个对象调用方法，方法中的self参数就和那个对象名指向同一个内存空间。
了解了self参数，跟调用方法的对象有关，那么想要不同的对象输出不同的内容，只需要self后面跟上不同的名字表示对象名，以及其他属性。要想在类中使用self.属性需要先定义self.属性。对不同的对象输出不同的属性，就需要在创建类时传入不同的实参，那也就需要在类中定义相应的形参。

2.2.5 自动调用初始化方法：init

前面说到在创建对象时，python会先找类中有没有__init__方法，再将开辟的内存赋给对象名变量。__init__方法时创建实例时自动执行的方法，我们可以在里面定义一些参数，用于指定对象相关属性

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

    def eat(self):
        print('吃东西才能活着')

由于__init__方法会创建实例时自动执行，因此创建实例时，我们也需要传入对象相应的实参

am = Animal('艾玛', 6)
am.eat()

nl = Animal('纽乐', 4)
nl.eat()

在这里插入图片描述

代码中的self.后面的属性名不一定要与形参的一致，习惯保持一致。
接下来，验证__init__中 的内容是不是不需要主动调用，在创建对象时就自动执行
在这里插入图片描述

可以看到__init__中的内容，确实创建完实例，不需要调用就会自动执行。

当创建对象时从外界传入了name、age参数，在定义实例方法时，就可以使用。

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

    def eat(self):
        print('%s说： 吃东西才能活着'% self.name)


am = Animal('艾玛', 6)
am.eat()

nl = Animal('纽乐', 4)
nl.eat()

在这里插入图片描述
同样的也可以在方法中，定义其他形参，例如：

在这里插入图片描述

**总结：**
1） 创建出来的对象叫做类的实例
2）创建对象的动作叫做实例化
3）对象的属性叫做实例属性
4）对象调用的方法叫做实例方法
5）__init__方法是python的内置方法，在创建实例时会自动执行，可以在函数里面接收参数，定义实例属性，
   实现不同对象不同属性。
6）通过对象名.属性名可以调用对象属性；同样的通过对象名.方法名可以调用对象方法
7）默认情况下print(对象名)，将输出对象创建的类与十六进制的对象内存地址

上面总结7）说到：默认情况下print(对象名)，将输出对象创建的类与十六进制的对象内存地址，但是我们还可以改变print(对象名)时的输出内容，通过__str__函数实现。

2.4 自定义输出信息：str

若在开发中，希望在使用print输出时不是看到对象所属的类与内存地址，可以使用__str__方法自定义输出内容，但是需要注意：__str__方法必须返回一个字符串（return函数）
先来看默认情况下，print(对象名)的输出结果：

'''
class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self, food):
        print('%s说：我爱吃 %s' % (self.name, food))


am = Animal('艾玛', 6)
am.eat('苹果')

nl = Animal('纽乐', 4)
nl.eat('火龙果')

#默认情况下，print(对象名)的输出结果
print(am)
print(nl)

在这里插入图片描述
下面使用__str__函数修改默认输出内容：

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

    def __str__(self):
        return '这是Animal的实例对象: [%s]' % (self.name)

    def eat(self, food):
        print('%s说：我爱吃 %s' % (self.name, food))


am = Animal('艾玛', 6)
am.eat('苹果')

nl = Animal('纽乐', 4)
nl.eat('火龙果')

#默认情况下，print(对象名)的输出结果
# print(am)
# print(nl)

# 使用__str__函数自定义后，print(对象名)的输出结果
print(am)
print(nl)

在这里插入图片描述

总结：
1） 每一个对象都有自己独立的内存空间，保存各自不同的属性：每个实例属性保存在每个对象的内存空间；
2）同一个类创建的多个对象的方法，在内存中只有一份，在调用方法时，把对象的引用传递到方法内部：即
实例方法保存在类的内存空间；
3）程序运行时，类在内存中只有一份，使用一个类可以创建出多个对象；
4）使用__str__方法可以自定义print(对象名)时的展示内容，且__str__方法必须使用
return函数返回一个字符串。

除了封装的实例属性和方法，类对象还可以拥有自己的属性和方法

2.5 类的属性和方法

2.5.1 类的属性

1）记录与类相关的特征
2）定义在类中，且在函数体外
3）类属性可以在所有实例化的对象中公用
4）使用赋值语句 属性名 = 属性值 定义类属性

class Animal:
    # 定义类属性
    legs = 4
    eyes = '眼神犀利'
    
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return '这是Animal的实例对象: [%s]' % (self.name)

    def eat(self, food):
        print('%s说：我爱吃 %s' % (self.name, food))


am = Animal('艾玛', 6)
am.eat('苹果')

nl = Animal('纽乐', 4)
nl.eat('火龙果')

#默认情况下，print(对象名)的输出结果
# print(am)
# print(nl)

# 使用__str__函数自定义后，print(对象名)的输出结果
print(am)
print(nl)

访问类属性，通过类名.属性名的方式

在这里插入图片描述
虽然也可以通过 实例名.属性名 的方式访问类属性。因为，我们前面提到，每个对象取值不同的实例属性是存放在对象内存中的，而类属性是存放在类内存中的。在python中属性的获取存在：向上查找机制

通过实例名.属性名： 属性的获取首先在对象内部查找，如能找到，则直接返回属性值，若对象内部没有找到，
则向上到类中查找属性，找到就返回结果，找不到就报错。

在这里插入图片描述
但建议类属性使用类名.属性名的方式访问

2.5.2 类方法

定义类方法
1）需要使用修饰器：@classmethod，告诉解释器这是一个类方法
2）类方法的第一个参数应为cls，类似于实例方法的第一个参数为self

class Animal:
    # 定义类属性
    legs = 4
    eyes = '眼神犀利'
    num = 0

    @classmethod
    def sub_count(cls):
        print('Animal类创建了%d个对象' % Animal.num)

    def __init__(self, name, age):   # 该方法没此创建对象就会自动执行，因此可以在此计算
        self.name = name
        self.age = age
        Animal.num += 1

    def __str__(self):
        return '这是Animal的实例对象: [%s]' % self.name

    def eat(self, food):
        print('%s说：我爱吃 %s' % (self.name, food))


am = Animal('艾玛', 6)
nl = Animal('纽乐', 4)

print(Animal.num)

在这里插入图片描述

2.6 静态方法

在开发时，如果类中封装的方法：
1）既不需要访问实例属性或者调用实例方法
2）也不需要访问类属性或者类方法
这时该方法中的内容不会随实例或者类的创建与不同发生改变，可封装为静态方法
静态方法需要：
1）使用修饰器：@staticmethod 标识，让解释器知道这是一个静态方法
2）可以通过 类名.方法名 调用静态方法

class Animal:
    # 定义类属性
    legs = 4
    eyes = '眼神犀利'
    num = 0

    @classmethod
    def sub_count(cls):
        print('Animal类创建了%d个对象' % Animal.num)

    def __init__(self, name, age):   # 该方法没此创建对象就会自动执行，因此可以在此计算
        self.name = name
        self.age = age
        Animal.num += 1

    @staticmethod
    def help_mes():
        print('类的具体学习请参考课本XXX页')

    def __str__(self):
        return '这是Animal的实例对象: [%s]' % self.name

    def eat(self, food):
        print('%s说：我爱吃 %s' % (self.name, food))


Animal.help_mes()

在这里插入图片描述

总结：
1） 方法内部需访问实例属性————实例方法
实例方法内部也可以通过类名访问类属性
2）方法内部只需要访问类属性————类方法
3）方法内部既不需要访问类属性也不需要访问实例属性————静态方法

2.7 私有属性和私有方法

在实际开发中，对象的某些属性和方法，只希望在类内部进行访问，而不希望在外部被访问到。这时，就可以采用私有属性和私有方法，以隐藏相关内容，避免他人修改。
1）私有属性：对象不希望公开的属性
2）私有方法：类不希望公开的方法
3）通过属性名或方法名前面加两个下划线__的方式定义
4）私有属性和私有方法仅能在类的内部访问和调用
5）私有的好处：
（1）隐藏属性，不被外界随意修改
（2）也可以通过函数setXXX 修改
（3）可以筛选赋值的内容(if语句)
（4）如果想要在外界获取属性，可以定义getXXX方法

首先，对于我们已经写好的下面这段代码：

class Animal:
    # 定义类属性
    legs = 4
    eyes = '眼神犀利'
    num = 0

    @classmethod
    def sub_count(cls):
        print('Animal类创建了%d个对象' % Animal.num)

    def __init__(self, name, age):   # 该方法没此创建对象就会自动执行，因此可以在此计算
        self.name = name
        self.age = age
        Animal.num += 1

    @staticmethod
    def help_mes():
        print('类的具体学习请参考课本XXX页')

    def __str__(self):
        return '这是Animal的实例对象: [%s]' % self.name

    def eat(self, food):
        print('%s说：我爱吃 %s' % (self.name, food))

    def drink(self, water):
        print('%s喜欢喝： %s' % (self.name, water))


am = Animal('艾玛', 6)
nl = Animal('纽乐', 4)

是可以通过实例名.属性名 = 属性值的方式新增或者修改属性

am = Animal('艾玛', 6)
# 修改属性值
print('修改前：', am.age)
am.age = 99
print('修改后：', am.age)
# 当属性不存在时，可以新增属性
am.school = 'cwdx'
print(am.school)

在这里插入图片描述

在实际开发项目时，如果不希望在外界可以修改属性值，就可以采用私有属性方式，比如不希望外界随便修改年纪值

class Animal:
    # 定义类属性
    legs = 4
    eyes = '眼神犀利'
    num = 0

    @classmethod
    def sub_count(cls):
        print('Animal类创建了%d个对象' % Animal.num)

    def __init__(self, name, age):   # 该方法没此创建对象就会自动执行，因此可以在此计算
        self.name = name
        self.__age = age
        Animal.num += 1

    @staticmethod
    def help_mes():
        print('类的具体学习请参考课本XXX页')

    def __str__(self):
        return '这是Animal的实例对象: [%s]' % self.name

    def eat(self, food):
        print('%s说：我爱吃 %s' % (self.name, food))

    def drink(self, water):
        print('%s喜欢喝： %s' % (self.name, water))


am = Animal('艾玛', 6)
# 访问私有属性值
print('私有后：', am.__age)

在这里插入图片描述
私有化后将会提示没有__age属性，不能在外界访问。
如果想实现外界访问可以采用

1) 实例名._类名__属性名

在这里插入图片描述
但是这种方式并不推荐使用。

2）通过在类内部定义实例方法，在类的内部方法是可以访问私有属性的。

class Animal:
    # 定义类属性
    legs = 4
    eyes = '眼神犀利'
    num = 0

    @classmethod
    def sub_count(cls):
        print('Animal类创建了%d个对象' % Animal.num)

    def __init__(self, name, age):   # 该方法没此创建对象就会自动执行，因此可以在此计算
        self.name = name
        self.__age = age
        Animal.num += 1

    @staticmethod
    def help_mes():
        print('类的具体学习请参考课本XXX页')

    def __str__(self):
        return '这是Animal的实例对象: [%s]' % self.name

    def eat(self, food):
        print('%s说：我爱吃 %s' % (self.name, food))

    def drink(self, water):
        print('%s喜欢喝： %s' % (self.name, water))

    def getage(self):
        print(self.__age)


am = Animal('艾玛', 6)
am.getage()

在这里插入图片描述

同时要想在外界修改年纪，也可以通过调用函数的形式：

class Animal:
    # 定义类属性
    legs = 4
    eyes = '眼神犀利'
    num = 0

    @classmethod
    def sub_count(cls):
        print('Animal类创建了%d个对象' % Animal.num)

    def __init__(self, name, age):   # 该方法没此创建对象就会自动执行，因此可以在此计算
        self.name = name
        self.__age = age
        Animal.num += 1

    @staticmethod
    def help_mes():
        print('类的具体学习请参考课本XXX页')

    def __str__(self):
        return '这是Animal的实例对象: [%s]' % self.name

    def eat(self, food):
        print('%s说：我爱吃 %s' % (self.name, food))

    def drink(self, water):
        print('%s喜欢喝： %s' % (self.name, water))

    def getage(self):
        print(self.__age)

    def setage(self, age):
        if 0 < age <= 120:
            self.__age = age
        else:
            print('年龄不符合要求')


am = Animal('艾玛', 6)
# 外界修改前：
am.getage()
# 外界修改后：
am.setage(100)
am.getage()

在这里插入图片描述

这样我们不仅能够实现外界修改，而且可以对外界修改输入的内容进行限制。

总结：
1）私有属性和私有方法可以阻止在外部随意修改属性
2）私有属性的定义方式是在属性名前加双下划线__
3）私有属性可以在类内部被访问，因此
（1）可以通过非私有方法访问私有属性，再在外界调用方法，从而输出私有属性，如：代码中的__age，可以通过getage方法获得，
也因此说python的私有属性和方法是伪私有。
（2）获取属性的方法就是正常定义的方法，只是为了见名知意，一采用：getXXX(XXX为要获取的私有属性名)
（3）与（2）同理，设置在外界修改私有属性的函数，使用setXXX(XXX为要获取的私有属性名),在函数内部还可以对
外界输入的属性进行限制与校验，这也是外界直接通过
                           实例名.属性名 = 属性值 
修改不具备的优势

3. 封装

封装是面向对象的核心思想，将对象的属性和行为封装起来，隐藏实现细节。

class Human:
    def __init__(self,name,weight):
        self.name=name
        self.weight=weight
    def __str__(self):
        return (self.name+'  原本  '+str(self.weight)+'kg  的体重变化情况:')
    def run(self,times):
        self.weight = self.weight-0.5*times
        print(times,'次跑步后的体重为：', self.weight)
    def eat(self,times):
        self.weight = self.weight+0.5*times
        print(times,'次吃饭后的体重为：', self.weight)
xm = Human('xiaoming',50)
print(xm)
xm.run(2)
xm.eat(1)
xm.run(1)

在这里插入图片描述

class Item:
    def __init__(self, name, area):
        self.name = name
        self.area = area

    def __str__(self):
        return (self.name + '， 占地面积是:  ' + str(self.area) + ' 平方米')


bed = Item('席梦思', 4)

chest = Item('衣柜', 2)

table = Item('餐桌', 150)


class House:
    def __init__(self,house_type,area):
        self.house_type = house_type
        self.area = area
        self.free_area = area
        self.item_list = []
    def __str__(self):
        # python能够自动将一对括号内部的代码连接在一起
        return ('户型：%s；  总面积：%.2f' %(self.house_type,self.area))
    def add_item(self,item):
        if item.area>self.free_area:
            print(' %s  太大了，放不下'%(item.name))
        else:
            self.item_list.append(item.name)
            self.free_area = self.free_area-item.area
            print('家里面有：%s，剩余面积为：%.2f 平方米' % (self.item_list,self.free_area))

my_home = House('两室一厅',70)
print(my_home)

my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)

在这里插入图片描述
在python中如果不知道给对象设置什么属性值，可以设置将属性值设置为None

4. 继承

继承是实现代码的重用，相同的代码不需要重复编写
子类拥有父类的所有属性和方法

# 继承
# 定义动物类：有吃、喝、跑、睡
class Animal:
    def eat(self):
        print('吃...')
    def drink(self):
        print('喝...')
    def run(self):
        print('跑...')
    def sleep(self):
        print('睡...')

# 再定义1个动物类中的狗类，除了拥有吃、喝、跑、睡、还有吠
class Dog:
    def eat(self):
        print('吃...')
    def drink(self):
        print('喝...')
    def run(self):
        print('跑...')
    def sleep(self):
        print('睡...')
    def bark(self):
        print('汪...')

使用继承就不需要在狗类中重新编写或赋值与动物类中相同的方法；且在父类方法中改变的属性和方法能够同步到子类中。

# 继承
# 定义动物类：有吃、喝、跑、睡
class Animal:
    def eat(self):
        print('吃...')
    def drink(self):
        print('喝...')
    def run(self):
        print('跑...')
    def sleep(self):
        print('睡...')

# 再定义1个动物类中的狗类，除了拥有吃、喝、跑、睡、还有吠
class Dog(Animal):
    def bark(self):
        print('汪...')
wangcai = Dog()
wangcai.drink()

在这里插入图片描述
修改动物类（Animal）中的方法drink，可以看到子类的Dog()对象，在调用drink方法时也同步发生了变化
在这里插入图片描述

4.1 继承的传递性

C类从B类继承，B类又从A类继承，那么C类就具有B类和A类的所有属性和方法

class Animal:
    def eat(self):
        print('吃...')
    def drink(self):
        print('喝喝喝喝喝')
    def run(self):
        print('跑...')
    def sleep(self):
        print('睡...')

# 再定义1个动物类中的狗类，除了拥有吃、喝、跑、睡、还有吠
class Dog(Animal):
    def bark(self):
        print('汪...')

class KeJi(Dog):
    def jump(self):
        print('蹦...')

wangcai = KeJi()
wangcai.drink()
wangcai.bark()
wangcai.jump()

在这里插入图片描述

4.2 重写父类方法

4.2.1 覆盖父类的方法

在开发中，父类的方法实现和子类的方法实现不同，可以使用覆盖的方式，在子类中重新编写父类的方法实现
具体实现方式：在子类中定义一个和父类同名的方法并且实现
重写之后，子类的对象只会调用子类中重写的方法，而不再调用同名的父类封装方法
如：柯基类的叫声与狗类不一样，可以通过柯基类中重新定义bark方法实现
在这里插入图片描述

4.2.2 对父类方法扩展

如果父类中封装的方法只是子类方法的一部分，可以使用扩展的方式在子类中重写父类的方法
实现方式：
使用super().父类方法,来调用父类方法
然后再编写子类特有的方法
比如：KeJi类中bark方法，除了会Dog类中的叫法，还会其他叫法，就可以使用super().父类方法实现父类方法的继承，同时再加上KeJi类的独特叫法
在这里插入图片描述

4.3 多继承

子类可以有多个父类，并且具有所有父类的属性和方法

class 子类名（父类名1,,父类名2,...）
     pass

class A:
    def test(self):
        print('这是父类A')
class B:
    def demo(self):
        print('这是父类B')
class D(A,B):
    pass
d = D()
d.demo()
d.test()

在这里插入图片描述
如果不同的父类存在同名的方法或属性，应尽量避免使用多继承。
python中不同父类存在同名的方法或属性时，子类的继承顺序，可以通过类的内置属性__MRO__（method resolution order）方法查看
在这里插入图片描述
按照__MRO__输出结果从左至右的顺序查找，如果找到方法就直接执行，不再搜索；没找到，继续向后一个类中搜索，直至最后一个，仍没有则报错
在这里插入图片描述

5. 多态

多态是不同的子类独享调用相同的父类方法，会产生不同的执行结果
（1） 多态可以增加代码的灵活度
（2） 以继承和重写父类方法为前提
（3） 是调用方法的技巧，不会影响类的内部设计

class Dog:
    def __init__(self,name):
        self.name = name
    def game(self):
        print(self.name,'正在玩耍...')
class KeJi(Dog):
    def game(self):
        print(self.name,'花式玩耍中...')
class Human:
    def __init__(self,name):
        self.name = name
    def play_with(self,so):
        print(self.name,'正和',so.name,'玩耍')
        so.game()

wangcai1  = Dog('旺财')
xiaomei = Human('小美')
xiaomei.play_with(wangcai1)

wangcai2 = KeJi('短腿旺财')
xiaomei.play_with(wangcai2)

在这里插入图片描述
可以看到在play_with方法中，传入不同类的对象，导致不同的执行效果
（1）在python中每一个对象都有自己独立的内存空间，保存各自不同的属性
（2）多个对象的方法，在内存中只有1份，保存在类所在的内存空间，在调用方法时，需要把对象的引用传递到方法内部
（3） 类对象在内存中只有1份，使用一个类可以创建出多个对象

参考资料： 黑马程序员Python教程

牵牛花主人
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python 类
qq_37958020的博客
07-31 507
文章目录面向过程面向对象面向对象编程类的定义和使用类的定义数据封装对象之间的交互类命名空间与对象、实例的空间类的三大特性私有属性鸭子类型 面向过程 所谓过程就是我们解决问题的步骤，一步步按照流程走，有先后之分。 整个设计就好比流水线，思维上比较机械化。 优缺点： 优点： 复杂的问题流程化，将问题分解简化。 缺点： 拓展性不好。 面向对象 核心是对象。 对象是一个数据以及相关行...
python类的方法的装饰
qq_36719861的博客
08-24 475
当类的方法不需要访问实例时，根据具体场景选择使用@staticmethod或者是@classmethod进行装饰。Python中一般的类方法要接收一个self参数表示此类的实例，但是有些方法不需要访问实例，这分为两种情况： 1.方法不需要访问任何成员，或者只需要显式访问这个类自己的成员，这样的方法不需要额外的参数，应当用@staticmethod装饰。在Python3.X版本中，允许直接定义不含self参数的方法，并且允许不通过实例调用。但是一旦通过实例调用这个方法，就会因为参数不匹配而出错。加上@sta
面向对象编程（00P）
ansn1_0的博客
02-19 301
·以类的方式编程，以面向对象（封装）的方式写数据；
Python中的类属性，类方法与实例属性，实例方法
weixin_41557802的博客
11-18 1034
class Person(object): num=10000 def __init__(self,name): self.name=name @classmethod def getNum(cls): return cls.num def getName(self): return self.name p=P...
python中类属性与实例属性的区别
web开发与Python
10-15 343
python的类属性与实例属性，初学者很容易搞混，在这里，平哥给大家举个例子就能很好的理解了。 我们以人为例，正常的人类都是两条胳膊两条腿。先定义一个人类： class Person: :::::::::legs = 2 #类属性 :::::::::def init(self, name): :::::::::::::::self.name = name 实例属性self.name 注意一下注释里...
基础-python基础知识源码
04-21
本资源包“基础-python基础知识源码”显然旨在帮助初学者深入理解Python的核心概念和实践技能。 Python的基础教学通常涵盖以下几个关键领域： 1. **语法基础**：Python的语法非常直观，例如缩进替代其他语言的花...
化工应用数学-02.1-python编程基础-python基础语法-讲义1
08-03
2. **面向对象**：Python是面向对象的语言，支持类和对象的概念，可以进行复杂的数据结构操作。 3. **强大的标准库**：Python的标准库涵盖广泛，包含HTML/XML解析、字符串处理、正则表达式、单元测试、网络访问和...
ComTrade-CODE-Python-Basic：Python基础课程
03-04
"ComTrade-CODE-Python-Basic" 是一个针对初学者的Python基础课程，旨在帮助学习者掌握Python编程的基础知识和技能。 课程内容可能涵盖以下几个方面： 1. **Python安装与环境配置**：首先，学习者需要了解如何在...
wp-api-python：WooCommerce API的Python包装器
02-05
**wp-api-python：WooCommerce API的Python包装器** `wp-api-python` 是一个Python库，专门设计用于简化与WooCommerce的API交互。WooCommerce是基于WordPress的开源电子商务平台，它允许开发者通过RESTful API接口...
ant-learn-python-100P:蚂蚁学Python，入门编程100例
04-04
《蚂蚁学Python，入门编程100例》是针对初学者设计的一套全面的Python教程，旨在通过100个实例帮助新手快速掌握Python编程基础。这个资源包名为"ant-learn-python-100P-main"，包含了丰富的学习材料，帮助你从零开始...
python内置类属性name_Python 类与对象编程详解三（类属性、实例属性）
weixin_27219587的博客
01-29 318
Python 类与对象编程详解三(类属性、实例属性),属性,方法,实例,操作,类属Python 类与对象编程详解三(类属性、实例属性)易采站长站，站长之家为您整理了Python 类与对象编程详解三(类属性、实例属性)的相关内容。上一篇：Python 类与对象编程详解二(成员保护和访问限制)目录类属性属性的定义操作类属性的三种方法属性存在的意义操作类属性的方法使用@property装饰器操作类属性通...
Python——类和实例
时光·漫步的博客
08-22 8381
一. 类的定义 在Python中，定义类是通过class关键字。 语法格式如下： class ClassName(object):         &lt;statement-1&gt;         .         &lt;statement-N&gt; class后面紧接着是类名，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的，通常，如果没...
Java内部类_01
Oceanst的博客
02-17 218
1.内部类的初步介绍 1.1 内部类的定义 当我们将一个类A放置于另一个类B的内部定义时，那么我们称A为内部类（或嵌套类），称B为外部类（或宿主类）。 1.2 内部类的主要作用 ①　内部类提供了更好的封装效果，可以将内部类隐藏在外部类之内，在内部类中完成封装效果； ②　内部类成员可以直接访问外部类的私有数据，可以作为外部类的成员，一个类中的成员可以相互访问； ③　匿名内部类可以用于创建仅需要使用一...
Python作业九
Aa12364567的博客
03-26 2210
str()方法中返回值类型是 类里面方法中self参数是指 以下关于类与对象说法正确的是 1.定义一个动物类 2.使用__init__方法，在创建某个动物时，为其添加name,age,color,food等属性，如‘猫’，3，‘黑色’，‘鱼’ 3.为动物类定义一个run方法，调用run方法打印相关信息，比如‘猫在奔跑’ 4.为动物类定义一个get_age方法，调用get_age方法打印相关信息，比如‘猫今年3岁了’ 5.为动物类定义一个eat方法，调用eat方法打印相关信息，比如‘猫正在吃鱼’ 6.通
【机器学习】基于python的简易动物识别算法（知识工程）
heroybc的博客
11-06 4354
#十个特征，4类动物 animal = ['鸡','鸭','鱼','狗'] dict_feature = {'1':'有羽毛','2':'不会飞','3':'会下蛋', '4':'吃肉','5':'有犬齿','6':'有爪', '7':'有鱼鳞','8':'会游泳','9':'有鳃', '10':'跑得快'} dog_fe...
Python爬虫与MongoDB的完美结合
最新发布
weixin_52392194的博客
08-03 389
我们掌握了在Windows和Linux系统下安装MongoDB，设计适合爬虫存储数据的写入规范，并通过实际爬虫示例展示了如何将爬取到的数据存储到MongoDB中。此外，还进行了MongoDB性能优化，提高了数据存储和查询的效率。
Selenium与WebDriver：Errno 8 Exec格式错误的多种解决方案
ip16yun的博客
07-30 397
在使用Selenium和WebDriver进行网页自动化时，可能会遇到各种错误。其中一个常见问题是执行格式错误（Errno 8 Exec format error）。这个错误通常在运行ChromeDriver时出现，错误提示涉及路径中的某个文件。本文将概述这个问题的背景，并提供多种解决方案，包括如何使用代理IP技术进行数据抓取。
python字符串数据容器练习（replace,split,count）
2301_79600015的博客
07-31 481
Python字符串是由一系列字符组成的数据类型。在Python中，字符串是不可变的，这意味着一旦创建了一个字符串，就不能修改它的内容。以下是关于Python字符串的一些重要知识点：1. 字符串的基本操作：拼接字符串：使用`+`运算符。重复字符串：使用`*`运算符。索引和切片：使用`[]`和`:`操作符访问字符串中的子串。长度：使用`len()`函数获取字符串长度。转换大小写：使用`upper()`和`lower()`方法。分割和连接：使用`split()`和`join()`方法。
Python面试题：如何使用WebSocket实现实时Web应用
bigorsmallorlarge的专栏
07-30 578
通过上述步骤，你可以使用 Django Channels 和 WebSocket 创建一个简单的实时 Web 应用。Django Channels 提供了强大的功能，使得在 Django 中实现实时功能变得更加容易。你可以在此基础上扩展，添加更多功能和复杂的逻辑。
WOA-DELM python
06-07
WOA-DELM算法在ELM算法的基础上增加了一个权重因子，使得模型可以更好地适应不同类别之间的差异性。在分类任务中，WOA-DELM算法通常表现出色，并且相对于其他深度学习算法，它的训练速度也非常快。 Python是一种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值