Python面向对象2-类对象增删改查、方法

类对象

万物皆对象，类也是一个对象
增删改查

增
方式一：Money.count = 1

#1.定义一个类
class Money:
    pass

#给类加属性
Money.count = 1
print(Money.count)
print(Money.__dict__)  #输出对象Money的所有属性
#输出：{'__module__': '__main__', '__dict__': <attribute '__dict__' of 'Money' objects>, '__weakref__': <attribute '__weakref__' of 'Money' objects>, '__doc__': None, 'count': 1}
#除了新加的count属性，还有作为类自带的属性

方式二：在定义类的时候就添加上属性

#方式2：
class Money:
    age = 18
    count = 1
    num = 666

print(Money.age)
print(Money.count)

查：

class Money:
    age = 18
    count = 1
    num = 666

one = Money()
print(one.__class__)  #返回类名
print(one.age)  #对象可以访问类的属性

查找中，对象是先查找自己的属性，没有才会去到对应类，查找类的属性

改：

class Money:
    age = 18
    count = 1
    num = 666

Money.age = 22  
print(Money.age)  #输出22，直接重命令值就修改了

注意：对象的赋值语句是无法修改到类上的
one.age = 18 不会让Money的age属性变成18

删

class Money:
    age = 18
    count = 1
    num = 666

one = Money()
print(one.age) #正常打印，输出18
del one.age  #语句报错，因为one本身没有age属性

’查‘ 可以对象本身没有时，课访问类的属性
‘增’与‘改’，‘删’ 都无法通过对象到达到类。

类属性的内存存储问题

class Money:
	pass

one = Money()
one.age = 18
one.height = 100
print(one.__dict__) #输出对象one的所有属性信息

通过给dict 赋值一个字典，直接赋值属性
对象的属性，也就是在dict字典里的值
但是，类的dict无法赋值修改

class Money:
    pass
one = Money()
one.__dict__ = {'name':'sz','age':18}
print(one.name)
#输出：sz

Money.__dict__ = {'name':'sz','age':18}
#会报错，类的dict无法赋值修改

类属性被各个对象共享

通过类限制对象的属性 slots

class Person:
    __slots__ = ['age']
    pass

p = Person()
p.age = 1  #正常赋值
p.name =12  #报错，不能定义此属性

方法

描述一个目标的行为动作，比如描述一个人怎么吃饭
和函数非常类似。都封装了一系列行为动作，与函数类似，与函数的区别在于：调用方式不同

#函数
def eat():
    print(1)
    print(2)
    print(3)
eat()

#方法
class Person:
    def eat2(self):   #代表一个方法：实例方法
        print(1)
        print(2)
        print(3) #方法内部的实现

p = Person()
p.eat2()  #调用方法必须要一个P，即对象

类对象 —> 对象（又称实例） ，这是一个实例化的过程
方法的划分：

1. 实例方法：默认第一个参数需要接收一个实例
2. 类方法：默认第一个参数需要接收一个类
3. 静态方法：第一个参数啥也不默认接收

class Person:
    def eat2(self):   #代表一个方法：实例方法
        print('这是一个实例方法',self)
        print(2)
        print(3) #方法内部的实现

    @classmethod
    def leifangfa(cls):  #类方法,括号里的是自动补全的
        print('这是一个类方法',cls)

    @staticmethod
    def jintaifangfa():
        print('这是一个静态方法')


p = Person()
print(p)  #<__main__.Person object at 0x000002528E0CAF10>
p.eat2()  #调用方法必须要一个P，即对象
#这是一个实例方法 <__main__.Person object at 0x0000024EDDE7AF10>

Person.leifangfa()
#这是一个类方法 <class '__main__.Person'>

Person.jintaifangfa()
#这是一个静态方法

划分依据：方法的第一个参数必须要接受的数据类型
不管是哪个方法，都是存储在类当中，没有在实例当作的

class Person:
    def eat2(self):   #代表一个方法：实例方法
        print('这是一个实例方法',self)
        print(2)
        print(3) #方法内部的实现

    @classmethod
    def leifangfa(cls):  #类方法,括号里的是自动补全的
        print('这是一个类方法',cls)

    @staticmethod
    def jintaifangfa():
        print('这是一个静态方法')
p = Person()

print(p.__dict__)  #输出：{}
print(Person.__dict__) #输出：

语法
不同类型的方法的规则
不同类型方法的调用
根据不同的问题设计不同的方法来解决

实例方法

class Person:
	def 函数名(self):
		pass