Python中类和对象的属性方法

Isleta ·

更新时间:2024-11-10

· 862 次阅读

1、类的格式

类：所有类名要求首字母大写，多个单词使用驼峰式命名，所有类都默认继承Object

class 类名[(父类)]:
    属性:特征
    方法:动作

注： python与其他语言不一样，可以动态的加载对象的属性和方法。

2、类属性 & 对象属性

类属性

#定义类和属性
class Student:
    # 类属性
    name = 'Jason'
    age = 20
object1 = Student() #使用类，创建对象
object1.age = 21 #对象属性
print(object1.name)
print(Student.name)

对象属性

class Phone:
    def __init__(self,brand,price,date): #初始的，初始化，类似构造函数
        '''
        动态的给self空间中添加了两个属性：brand，price
        '''
        self.brand = brand
        self.price = price
        self.date = date
object1 = Phone('huawei','4999','2019/9')
print(object1.brand)

类属性与对象属性的区别：
类属性可以直接通过类名访问。__init__方法中的self属性是对象所特有的,此时访问的是实例化对象的属性。对象属性是先找__init__中的，没找到才到类属性中找。

3、普通方法 & 类方法 & 静态方法

普通方法

格式：
def 方法名(self[,参数1，参数2])：
	  pass
#以下call就为普通方法	    
class Phone:
    brand = 'xiaomi'
    price = 2399
    type = '米8'
    #魔术方法之一：称作魔术方法 __名字__()
    def __init__(self,brand,price,date): #初始的，初始化，类似构造函数
        '''
        动态的给self空间中添加了两个属性：brand，price
        '''
        self.brand = brand
        self.price = price
    def call(self): #self类似于java中的this
        print('正在打电话...',self.note)

类方法
特点：
1、定义需要依赖装饰器classmethod
2、类方法中参数不是一个对象，而是类。
print(cls) # <class ‘_main_.Dog’>
3、类方法中只可以使用类属性
4、类方法中可否使用普通方法？不能
类方法作用： 因为只能访问类属性和类方法，所以可以在对象创建之前，完成一些动作(功能)。

class Dog:
    __age = 18 # __age类属性的私有，只能在类中访问!!!
    def __init__(self,nickname):
        self.nickname = nickname
    #这个方法必须依赖对象才能存在的
    def run(self):
        print('{}在院子里跑来跑去！'.format(self.nickname))
    def  eat(self):
        print('吃饭。。。')
        self.run() #类中方法的调用，需要通过self.方法名()
    #类方法，只要有类存在方法就存在
    @classmethod  #底层封装好的，不用深究。
    def test(cls):  #cls class
        print(cls)   #
        # print(cls.nickname)
d = Dog('大黄')
Dog.test() #直接上类

静态方法
特点： 使用类似于类方法
1.需要装饰器@staticmethod
2.静态方法是无需传递参数
3.也只能访问类的属性和方法，对象的是无法访问的
4.加载时机同类方法

class Dog:
    __age = 18 # __age类属性的私有，只能在类中访问!!!
    def __init__(self,nickname):
        self.nickname = nickname
    #这个方法必须依赖对象才能存在的
    def run(self):
        print('{}在院子里跑来跑去！'.format(self.nickname))
    def  eat(self):
        print('吃饭。。。')
        self.run() #类中方法的调用，需要通过self.方法名()
    #类方法，只要有类存在方法就存在
    @classmethod  #底层封装好的，不用深究。
    def test(cls):  #cls class
        print(cls)   #
        # print(cls.nickname)
    @staticmethod
    def test1():
        print('--静态方法--')
        print(Dog.__age)
d = Dog('大黄')
Dog.test1() #调用静态方法也直接上类

总结
类方法 与 静态方法
不同:
1.装饰器不同
2.类方法是有参数的，静态方法没有参数
相同:
1.只能访问类的属性和方法，对象的是无法访问的
2.都可以通过类名使用访问
3.都可以在创建对象之前使用，因为是不依赖对象

普通方法 与 两者区别
1.没有装饰器
2.普通方法永远是要依赖对象，因为每个普通方法都有一个self
3.只有创建了对象才可以调用普通方法，否则无法使用。

4、魔术方法（自动执行的方法）

可以参考：Python中的魔术方法详解

__init__:初始化对象，类似构造函数
触发时机：初始化对象时触发（不是实例化触发，但是和实例化在一个操作中）

__new__: 实例化的魔术方法
触发时机：在实例化时触发

__call__:对象调用方法
#触发时机：将对象当成函数使用的时候，会默认调用此函数中内存

__del__:解除对地址引用，类似析构函数
触发时机：del 标识符,解除对地址的引用，或者程序执行完（回收所有在本次执行过程中使用到的空间）。

__str__: 提供对象信息
触发时机：打印对象名自动触发去调用__str__里面的内容
注意：一定要在__str__方法中添加return，return后面内容就是打印对象看到内容

class Person:
    def __init__(self,name): #对象把地址给__init__
        print('__init__')
        self.name = name
    def __new__(cls, *args, **kwargs):  #先执行这个，申请内存，先开辟空间
        print('__new__')
        return  object.__new__(cls)  #抛出地址，给对象
    #__call__：把对象当成函数来调用,必须重写__call__方法
    def __call__(self,name):
        print('------>call',name)
    def __del__(self):  #一般不写哦，知道就行啦
        #删除地址引用的时候就会触发
        print('--------del----------')
    def __str__(self):
        return self.name

总结
__init__ 构造方法，创建空间之后调用的第一个方法。
__str__ 作用：返回人工添加对象信息。
了解：
__new__ 作用：开辟空间。
__del__ 作用：没有指针引用的时候会调用，99%都不需要重写类似析构函数。
__call__ 作用：想不想将对象当成函数用。

补充
怎么获取一个地址被引用了多少次？

import sys  #首先导入sys模块
print(sys.getrefcount('地址'))

5、实例

实例1：

class Phone:
    brand = 'xiaomi'
    price = 2399
    type = '米8'
    #魔术方法之一：称作魔术方法 __名字__()
    def __init__(self,brand,price,date): #初始的，初始化，类似构造函数
        '''
        动态的给self空间中添加了两个属性：brand，price
        '''
        self.brand = brand
        self.price = price
    def call(self): #self类似于java中的this
        print('正在打电话...',self.note)
object1 = Phone('voio','2999','2019')

找有没有一块空间是Phone 利用Phone类，向内存申请一块Phone一样的空间去Phone中找有没有__init__,如果没有则执行，将开辟内存给对象名object1 如果有__init__，则会进入init方法执行里面动作。再将内存地址赋值给对象object1

实例2：

class Cat:
    type = '猫'
    def __init__(self,nickname,age,color):
        #以下都是对象属性
        self.nickname = nickname
        self.age = age
        self.color = color
    # 动作，方法
    def eat(self,food):
        print('{}喜欢吃{}'.format(self.nickname,food))
    def catch_mouse(self,color,weight):
        print('{},抓了一只{}kg的，{}的大老鼠！'.format(self.nickname,weight,color))
    def sleep(self,hour):
        if hour <5:
            print('乖乖，继续睡叭！')
        else:
            print('赶快起床出去抓老鼠！')
#创建对象，对内存来说就是开辟一块空间
cat1 = Cat('花花',2,'灰色')
cat1.eat('fish')

6、大总结

方法：
    普通方法 ----》  重点
        def 方法名(self,[参数]):
            方法体
        对象.方法()
        方法之间的调用：
        class  A :
            def a(self):
                pass
            def b(self):
                #调用a方法
                self.a()
    类方法：
        @classmethod
        def 方法名(cls,[参数]):
            pass
        类名.方法名()
        对象.方法名()
    静态方法：
        @staticmethod
            def 方法名(cls,[参数]):
            pass
        类名.方法名()
        对象.方法名()
    魔术方法：
        自动执行方法

作者：随风飘飘天地任我逍遥

方法属性对象类和对象 Python

1024 个赞