07-Python之面向对象编程（类的基本操作）

Posted 2022-05-11 cmn-note

# 1.实例化一个类：

- 基本格式：变量 = 类名() # 实列化一个对象

　　* 案例1

# 定义了一个Person类
class Person:   
    count = 1
    age = 18
    
# 实例化对象    
# 执行class时就会得到类对象，并将其赋值给变量名（Person)
p = Person()    # p是一个变量，指向了Person类产生的对象
print(Person)  # Person是一个类
print(p)       # p就成了Person类产生的对象 
"""
# 结果
<class ‘__main__.Person‘>
<__main__.Person object at 0x0000022294ED7F98>
"""

# 2.查看类的信息

- 2.1.可以通过默认内置变量来检查类和对象的所有成员
　　- 对象所有成员检查：obj.__dict__
　　- 类所有成员检查：class_name.__dict__
- 2.2.使用help()函数
- 2.3.使用dir()函数
- 2.4.使用type()查看实例的类型归属
- 2.5.使用内置方法isinstance(实例， ClassName)来测试一个对象是否为某各类的实例

　　* 案例2

# 定义了一个Person类
class Person:   
    name = "China"
    age = 18
    
# 实例化对象     
p = Person()    

# 1.查看成员
    # 1.1查看对象的成员
print(p.__dict__)        # 空字典
    # 1.2查看类的成员
print(Person.__dict__)

# 2.使用help()函数查看
print(help(p))     
# print(help(Person))  # 两个会是一样的结果，指向关系

# 3.使用dir()可以查看对象的属性和方法
print(dir(Person))   # print(dir(p))效果一样

# 4.查看归属
print(type(p), type(Person)) # <class ‘__main__.Person‘> <class ‘type‘>

# 5.判断关系
print(isinstance(p,Person))
    # 如果是该类的实例返回True,否则返回False
    # 注意要判断的p和类Person一定要存在，不然会报错。

# 3.对类的属性进行操作

- 3.0.属性和变量区别：
　　- 变量：根据不同的位置，有不同的访问权限
　　- 属性：只能通过变量名来引用。

- 3.1.访问对象成员
　　- 使用点操作符
　　- obj.成员属性名称
　　- obj.成员方法

- 3.2.增加属性
　　- 动态增加增加
　　　　变量.属性名 = 值
　　- 实例对象可以通过字典__dict__进行增加和修改
　　- 通过类的初始化方法（构造方法）
　　　　__init__ 方法

- 3.3.删除属性
　　- 一般情况下，属性存储在__dict__的字典当中
　　　　- 有些内置对象没有这个__dict__ 属性
　　- 一般对象可以直接修改__dict__属性
　　- 但类对象的__dict__为只读模式
　　　　- 默认无法修改
　　　　- 可以通过setarr方法修改

　　* 案例3

class Person:   
    age = 18
    
p = Person()    # 实例化对象  

# 1.进行访问  
    # 1.1通过类名进行访问
print(Person.age)  # 18
    # 1.2通过实例化对象进行访问   
print(p.age)       # 18            
"""-----------------------------------------------------------"""
# 2.增加操作
    # 注意：如果要增加的变量已存在，则修改
    # 2.1动态增加
        # 2.1.1直接通过类名进行属性增加
Person.name = ‘abc‘   
print("Person:", Person.__dict__)   
print("p:", p.__dict__)   # 空字典
        # 2.1.2通过实例进行增加
p.zeng = 100    # 只在p里面增加，不影响Person
print("Person:", Person.__dict__)
print("p:", p.__dict__)    # ‘zeng‘: 100
    # 2.2使用构造方法(属于方法的操作)
"""-----------------------------------------------------------"""
# 3.删除操作
    # 注意：
        # del p.age  #会报错，p内不存在age
        # 可以进行del p.zeng,因为前面增加了zeng属性
    # 3.1实例删除
del p.zeng
    # 3.2直接通过类
del Person.age
print("Person:", Person.__dict__)    # 缺少了age属性
print("p:", p.__dict__)   # 空字典

# 4.类的属性的存储问题

- 4.1一般情况下，属性存储在__dict__的字典当中。
　　- 实例对象一般可以直接修改__dict__属性
　　- 类对象的__dict__为只读
- 4.2实例对象和类对象是存储在不同一块空间。
- 4.3访问时：
　　- 通过类对象：直接在类对象中查找
　　- 通过实例对象：优先在实例对象内部查找，没有找到需要的，就到指向的类对象中查找。
- 4.4修改时的区别：
　　- 通过实例对象进行增加、删除或者修改属性的值，都是在实例对象内部进行，对类对象没有影响
　　- 通过类对象进行增加、删除属性时:
　　　　- 对实例化对象内部没有的属性产生影响。
　　　　- 对实例化对象内部已拥有相同的属性不产生影响。

　　* 案例4.1

# 1.一般情况下，属性存储在__dict__的字典当中
class Person():
    age = 18
    
p = Person()
print(p.__dict__)  # 空字典
print(p.age)# 18 
            # 虽然是空字典但是能访问Person的属性，指向的关系
"""-----------------------------------------------------------"""    
# 1.1可以通过字典__dict__修改实例对象的属性
p.__dict__ = "count":2,"sex":"男"
"""-----------------------------------------------------------"""
# 1.2类对象的__dict__为只读
#Person.__dict__ = "count":3,"age":15
#Person.__dict__ = "sex":"男"  #会报错，
"""-----------------------------------------------------------"""
print(Person.__dict__)   
print(p.__dict__)   # ‘count‘: 2, ‘sex‘: ‘男‘

　　* 案例4.2

# 2.实例对象和类对象是存储在不同一块空间。
class Person():
    age = 19
    pass
"""-----------------------------------------------------------"""
# 2.1内存上开辟了新空间，两者的地址不一样
p = Person()  
print(id(p), id(Person))
"""-----------------------------------------------------------"""
# 2.2修改和新增类的地址都不变
p.age = 18  
Person.name = "aaaa"
print(id(p), id(Person))
"""-----------------------------------------------------------"""
# 2.3属性修改后的地址变化和列表的修改变化一样
p.pets = ["car","dog"]
print(p.pets,id(p.pets)) 

p.pets = ["car", "dog", "fish"]  # 直接修改   
print(p.pets,id(p.pets))
p.pets.append("iiiii")    # 进行追加操作
print(p.pets,id(p.pets))
"""-----------------------------------------------------------"""
print(p.__dict__)  #‘age‘: 18, ‘pets‘: [‘car‘, ‘dog‘, ‘fish‘, ‘iiiii‘]
print(Person.__dict__)  # Person 中z属性没发生改变

　　* 案例4.3

# 3.访问时：
class Person():
    age = 19
    pass
p = Person()  
p.age = 18
print(p.age)    # 18  # 优先访问自己的内部属性
print(Person.age) # 19 # Person.age没有被修改，
                    # 通过类访问，直接指向类对象的age

　　* 案例4.4

# 4.修改时：
class Person():
    age = 18
    pass
p = Person()  
# 4.1未修改前类对象和实例对象指向同一个属性。
print("Person:",Person.age, id(Person.age))
print("p     :", p.age, id(p.age))
print("---"*10)

# 4.2通过实例对象进行修改，没有对类对象产生影响
p.age = 28
print("Person:",Person.age, id(Person.age))
print("p     :", p.age, id(p.age))   
print("---"*10)

# 4.3通过类对象进行修改
Person.age = 38
    # 4.3.1实例对象p内部有age属性，无法造成影响
print("Person:",Person.age, id(Person.age))
print("p     :", p.age, id(p.age)) 
print("---"*10)

    # 4.3.2实例对象p内部没有age属性，无法造成影响
del p.age   # 删除p中的age
print("p     :", p.age, id(p.age))   # 此时访问p.age则指向Person.age
Person.age = 48    # 通过类对象修改age
print("Person:",Person.age, id(Person.age))
print("p     :", p.age, id(p.age)) 

# 5.对类的方法进行操作

- 5.1方法的存储：方法存储在类里面,不管是哪一种类型的方法，都是存储在类当中，没有在实例当中

　　* 案例5.1

class Person():
    
    # 1.实例方法：默认第一个参数需要接受到一个实例
    def eat(self):    # 必须要有参数，默认是self
        print("这是一个实例方法",self)
    
    # 2.类方法：默认第一个参数需要接受到一个实例
    @classmethod
    def leifangfa(cls):
        print("这是一个类方法",cls)

    # 33.静态方法：第一个参数啥也不默认接受
    @staticmethod
    def jingtaifangfa():
        print("这是一个静态方法")
        
p = Person()
# 查看参数
print(p)
p.eat()   # self和p的地址一样
Person.leifangfa()   # <__main__.Person object at 0x0000022294ECFE48>
Person.jingtaifangfa()  # <class ‘__main__.Person‘>
# 查看方法存储
print(p.__dict__)   # 空字典
print(Person.__dict__)  

-  5.2实例方法调用方式：本质就是找到函数本身调用
　　- 标准调用（推荐使用）：使用实例调用
　　- 类调用: 使用类名进行调用，没有意义
　　- 间接调用

　　* 案例5.2

class Person:
    def eat(self,food):
        print("我在吃饭",self, food)
        
# 1.标准调用
p = Person()
print(p) # p就时self，系统自动传入
print(p.eat("rich"))  # 这是实例化 可以只写一个参数，self是默认参数，可以不用写
                        # 标准调用，实例化调用 不用写第一个参数self        
    
# 2.类调用   
print(Person.eat)   # Person.eat 是一个函数
print(Person.eat(555,"FISH"))# 必须要有两个参数，不然会报错
                                # self = 555, food = FISH
# 3.间接调用
func = Person.eat  # Person.eat 是一个函数,func指向Person.eat
print(func(123,"DDD"))     # self = 123, food = DDD

- 5.3类方法

　　* 案例5.3

class Person():
    @classmethod    # 通过这个装饰器
    def leifangfa(cls, a):
        print("这是一个类方法",cls, a)

# 1.类调用
print(Person.leifangfa(123))

# 2.间接调用
func = Person.leifangfa
print(func(456))

# 3.实例化，标准调用
p = Person()
print(p.leifangfa(789))

- 5.4静态方法

　　* 案例5.4

class Person():
    @staticmethod
    def leifangfa(self):    # 参数没有默认接受
        print("这是一个静态方法",self)

# 1.类调用
print(Person.leifangfa(1))

# 2.间接调用
func = Person.leifangfa
print(func(2))

# 3.实例化，标准调用
p = Person()
print(p.leifangfa(3))

- 5.4不同方法的调用

　　* 案例5.5

class Person():
    age = 18  # 能通过实例和类访问
    def shilifangfa(self):   
        print(self)
        print(self.age)
        print(self.num)
        
    @classmethod
    def leifangfa(cls):
        print(cls)
        print(cls.age)
       #  print(Person.num)  无法访问

    @staticmethod
    def jingtaifangfa():
        print("jingtai")
p = Person()
p.num = 10  # 只能通过实例访问，无法通过类访问: Person.num
# 调用类属性
print(Person.age)  # 18
print(p.age)  # 18
# 调用实例属性
print(p.num) # 19
print(‘--‘*20)
print(p.shilifangfa())
print(‘--‘*20)
print(p.leifangfa())
print(‘--‘*20)
print(p.jingtaifangfa())
"""
# 结果
18
18
10
----------------------------------------
<__main__.Person object at 0x000001AA7705B668>
18
10
None
----------------------------------------
<class ‘__main__.Person‘>
18
None
----------------------------------------
jingtai
None
"""