Python(10)---面向对象初步，类和对象

一、类的组成

• 类名
• 属性：特性，变量
• 方法：行为，函数

二、类的定义

# 本例演示类的定义

# python中定义类使用关键字class
# object是所有类的基类（最初始的类）
# 语法格式：class 类名(object):
#              类中的代码

# 类定义方式一
class Dog(object):
    pass


# 类定义方式二
class Dog1():
    pass


# 类定义方式三
class Dog2:
    pass


'''
新式类：直接或间接继承Object的类
在Python3中，所有类默认继承Object类，即Python3中所有的类都是新式类
经典类（旧式类）：已经过时，不推荐使用
'''

三、创建对象，调用方法

# 本例演示创建对象

# 在代码中，对象是由类创建的
class Dog(object):
    # 类中定义方法
    def play(self):
        print("play method!")
    pass

# 创建一个对象：变量 = 类名()
dog1 = Dog()
# 2468913811408
print(id(dog1))
# 再创建一个对象
dog2 = Dog()
# 2468913811360
print(id(dog2))
# 对象调用方法
# play method!
dog1.play()
# play method!
dog2.play()

四、类外添加和获取属性

# 类外部获取和添加属性

# 定义类
class Dog(object):
    def eat(self):
        print("eat method execute!")


# 创建对象
dog = Dog()
# 调用方法
dog.eat()
# 给对象添加属性：对象.属性名 = 值
dog.name = 'zhangsan'
dog.age = 1
# 打印对象的属性值
# zhangsan
print(dog.name)
# 1
print(dog.age)
# 修改属性值，若属性值不存在就添加，属性值存在就修改
dog.age = 2
# 2
print(dog.age)

五、类内部操作属性

# 类内部操作属性

# 定义类
class Dog(object):
    # self作为类中方法的第一个形参，在通过对象调用方法的时候，不需要手动传递实参值
    # python解释器自动将调用该方法的对象传递给self
    # 因此self代表的就是当前对象
    # self是形参名，可以写成其它的形参名，但一般不修改这个名字，默认叫self
    def printSelf(self):
        print(id(self))
    def pringName(self):
        print(self.name)


# 定义对象
dog1 = Dog()
# 2639926337488
print(id(dog1))
# 2639926337488
dog1.printSelf()
dog1.name = 'zhangsan'
# zhangsan
dog1.pringName()

六、__init__方法

# __init__方法
# __init__方法类似Java和C++中的构造函数
# 在创建对象时会调用init方法
class Dog(object):
    def __init__(self,name='lisi'):
        print("__init__ method execute!")
        # 定义属性并赋值
        self.name = name


# 定义对象
# __init__ method execute!
Dog()
# __init__ method execute!
dog = Dog()
# lisi
print(dog.name)
dog1 = Dog('zhangsan')
# zhangsan
print(dog1.name)

七、__str__方法

没有定义__str__函数的情况

# __str__方法
'''
__str__方法的调用时机：
    1.print(对象)时，会自动调用__str__方法，打印的输出结果时__str__方法的返回值
    2.str(对象)：将对象转换为字符串类型时，会自动调用__str()__方法
注意：
    __str__方法必须返回一个字符串，且只有self一个参数
'''
class Dog(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age


dog = Dog('zhangsan',12)
# 没有str函数，默认打印地址
# <__main__.Dog object at 0x000001A30FAC1FD0>
print(dog)
# <__main__.Dog object at 0x000001A30FAC1FD0>
print(str(dog))

定义了__str__函数的情况

class Dog(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    # 定义str方法，返回字符串类型
    def __str__(self):
        return f"dog's name = {self.name}, dog's age = {self.age}"


dog = Dog('zhangsan',12)
# dog's name = zhangsan, dog's age = 12
print(dog)
# dog's name = zhangsan, dog's age = 12
print(str(dog))

八、__del__方法

# __del__方法：析构函数
'''
调用时机：
    对象在内存中被销毁删除的时候（引用计数为0）自动调用__del__方法
    (1)程序运行结束时，该程序中所有创建的对象和变量都会被删除撤销
    (2)使用 del 变量，将这个对象的引用计数变为0时，会自动调用__del__方法
引用计数：
    1.引用计数是python内存管理的一种机制，是指一块内存有多少个变量在引用
    2.有几个引用变量在引用，引用变量就是几
    3.当一个变量引用一块内存的时候，引用计数+1
    4.当删除一个变量，或者这个变量不再引用这块内存的时候，引用计数-1
    5.当内存的引用计数变为0时，这块内存被删除，内存中的数据被销毁
    例：
        list = [1,2] 引用计数+1
        list1 = list 引用计数+1
        del list 引用计数-1
        del list1 引用计数-1
'''
class Dog(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    # 定义str方法，返回字符串类型
    def __str__(self):
        return f"dog's name = {self.name}, dog's age = {self.age}"
    def __del__(self):
        print("del method execute!")


dog = Dog('zhangsan',4)

# 使用引用计数的方式
dog1 = Dog('lisi',3)
dog2 = dog1
print('第一次删除之前')
del dog1
print('第一次删除之后')
print('第二次删除之前')
# 此时引用计数为0，会执行__del__方法
# del method execute!
del dog2
print('第二次删除之后')

# 程序结束，自动销毁dog对象
# del method execute!

九、__repr__方法

# __repr__方法

class Dog(object):
    def __init__(self,name):
        self.name = name
    def __str__(self):
        return f"name = {self.name}"
    def __repr__(self):
        return f"name = {self.name}"

list1 = [Dog('zhangsan'),Dog('李四')]
# 若为定义__repr__方法，则打印对应的地址
# [<__main__.Dog object at 0x0000023C5C651FD0>, <__main__.Dog object at 0x0000023C5C651F10>]
# 定义了__repr方法，打印对应的地址
# [name = zhangsan, name = 李四]
print(list1)