python类和对象

编程思想

• 面向过程：事物比较简单，可以用线性的思维去解决
• 面向对象：事物比较复杂，使用简单的线性思想无法解决
• 共同点：面向过程和面向对象都是解决实际问题的一种思维方式；二者相辅相成，并不是对立的；解决复杂问题，通过面向对象方式便于我们从宏观上把握事物之间复杂的关系，方便我们分析
• 整个系统：具体到微观操作，仍然使用面向过程方式来处理

类和对象

• 类：多个类似事物组成的群体的统称。能够帮助我们快速理解和判断事物的性质
• 数据类型：不同的数据类型属于不同的类；使用内置函数查看类型
• 对象：100，99，520都是int类之下包含的相似的不同个例，这个个例专业数语称为实例或对象

python中一切皆对象

类的创建

class Student:
        pass

类的组成

• 类属性
• 实例方法
• 静态方法
• 类方法

class Student:  # Student为类的名称（类名）由一个或多个单词组成，每个单词的首字母大写，其余小写
    pass


# python中的一切皆对象
print(id(Student))      # 2684548738128
print(type(Student))    # <class 'type'>
print(Student)      # <class '__main__.Student'>

class Student:  # Student为类的名称（类名）由一个或多个单词组成，每个单词的首字母大写，其余小写
    native_pace = '武汉'  # 直接写在类里的变量，称为类属性
    def __init__(self,name,age):
        self.name = name    # self.name 称为实体属性，进行了一个赋值的操作，将局部变量的name的值赋给实体属性
        self.age = age
    # 实例方法
    def eat(self):
        print('学生在吃饭...')

    # 静态方法（静态方法里面不能写self）
    @staticmethod
    def method():
        print('我使用了statticmethod进行修饰，所以我是静态方法')

    # 类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')


# 在类之外定义的称为函数，在类之内定义的称为方法
def drink():
    print('喝水')

类属性，类方法，静态方法

• 类属性：类中方法外的变量称为类属性，被该类的所有对象所共享
• 类方法：使用@classmethod修饰的方法，使用类名直接访问的方法
• 静态方法：使用@staticmethod修饰的主法，使用类名直接访问的方法

class Student:  # Student为类的名称（类名）由一个或多个单词组成，每个单词的首字母大写，其余小写
    native_pace = '武汉'  # 直接写在类里的变量，称为类属性

    def __init__(self, name, age):
        self.name = name  # self.name 称为实体属性，进行了一个赋值的操作，将局部变量的name的值赋给实体属性
        self.age = age

    # 实例方法
    def eat(self):
        print('学生在吃饭...')

    # 静态方法（静态方法里面不能写self）
    @staticmethod
    def method():
        print('我使用了statticmethod进行修饰，所以我是静态方法')

    # 类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')


# 类属性的使用方式
print(Student.native_pace)
stu1 = Student('张三', 20)
stu2 = Student('李四', 30)
print(stu1.native_pace)
print(stu2.native_pace)
Student.native_pace = '天津'
print(stu1.native_pace)
print(stu2.native_pace)
print('-------类方法的使用方式-------')
Student.cm()
print('-------静态方法的使用方法-------')
Student.method()

一个Student类可以创建N多个Student类的实例对象，每个实例对象的属性值不同

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

    def eat(self):
        print(self.name+'在吃饭')


stu1 = Student('张三', 20)
stu2 = Student('李四', 30)
print(id(stu1))     # 2049758793680
print(id(stu2))     # 2049758793488
print('-------为stu2动态绑定性别属性-------')
stu1.gender = '男'
print(stu1.name, stu1.age, stu1.gender)
print(stu2.name, stu2.age)
# print(stu2.gender)  # AttributeError: 'Student' object has no attribute 'gender'
print('-------')
stu1.eat()  # eat()定义在类当中的
stu2.eat()


def show():
    print('定义在类之外的，称函数')


stu1.show = show
stu1.show()     # 定义在类之外的，称函数
# stu2.show()   # 因为stu2并没有绑定show()方法

面向对象的三大特征

封装：提高程序的安全性

• 将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度
• 在python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前面使用两个“_”。

class Car:
    def __init__(self, brand):
        self.brand = brand

    def start(self):
        print('汽车已启动')


car = Car('宝马X5')
print(car.brand)
car.start()


class Student:
    def __init__(self, name, age):
        self.name = name
        self.__age = age  # 年龄不希望在类的外部被使用，所以加了两个

    def get_age(self):
        return self.__age

    # def set_age(self):
    #     if 0<=age<=120:
    #         self.__age = age
    #     else:
    #         self.__age = 18

    def show(self):
        print(self.name, self.__age)


stu = Student('张三', 20)
stu.show()
# 在类的外部使用name和age
print(stu.name)
# print(stu.__age)
# print(dir(stu))
print(stu._Student__age)

继承：提高代码的复用性

• 如果一个类没有继承任何类，则默认继承object
• python支持多继承
• 定义子类时，必须在其构造函数中调用父类的构造函数

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

    def info(self):
        print(self.name, self.age)


class Student(Person):
    def __init__(self, name, age, stu_no):
        super().__init__(name, age)
        self.stu_no = stu_no


class Teacher(Person):
    def __init__(self, name, age, teachofyear):
        super().__init__(name, age)
        self.teachofyear = teachofyear


stu = Student('张三', 20, '1001')
teacher = Teacher('李四', 34, 10)

stu.info()  # 调用父类方法
teacher.info()  # 调用父类方法


# python的多继承
class A(object):
	pass

class B(object):
	pass

class C(A,B):	# C 继承 A和B
	pass

方法重写

• 如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其（方法体）进行重新编写
• 子类重写后的方法中可以通过 super().xxx() 调用父类中被重写的方法

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

    def info(self):
        print(self.name, self.age)


class Student(Person):
    def __init__(self, name, age, stu_no):
        super().__init__(name, age)
        self.stu_no = stu_no

    def info(self):
        super().info()
        print(stu.stu_no)


class Teacher(Person):
    def __init__(self, name, age, teachofyear):
        super().__init__(name, age)
        self.teachofyear = teachofyear

    def info(self):
        super().info()
        print(teacher.teachofyear)


stu = Student('张三', 20, '1001')
teacher = Teacher('李四', 34, 10)

stu.info()  # 调用父类方法
teacher.info()  # 调用父类方法

object类

• object类是所有类的父类，因此所有类都有object类的属性和方法
• 内置函数dir()可以查看指定对象所有属性
• object有一个_str_()方法，用于返回一个对应“对象的描述”，对应于内置函数str()经常用于print()方法，帮我们查看对象的信息，所以我们经常会对_str_()进行重写

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

    def __str__(self):
        return '我的名字是{0},今年{1}岁'.format(self.name, self.age)


stu = Student('张三', 20)
print(dir(stu))
print(stu)	# 改变对象输出方式

多态：提高代码的可扩展性和可维护性

简单来说，多态就是“具有多种形态”，它指的是：即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态决定调用哪个对象中的方法

静态语言和动态语言关于多态的区别

静态语言实现多态的三个必要条件：

• 继承
• 方法重写
• 父类引用指向子类对象

动态语言的多态崇尚“鸭子类型”当看到一只鸟走起来像鸭子，游泳起来像鸭子，收起来也像鸭子，那么这只鸟就可以被称为鸭子。在鸭子类型中，不需要关心对象是什么类型，到底是不是鸭子，只关心对象的行为

class Animal(object):
    def eat(self):
        print('动物要吃东西')


class Dog(Animal):
    def eat(self):
        print('狗吃肉')


class Cat(Animal):
    def eat(self):
        print('猫吃鱼')


class Person():
    def eat(self):
        print('人吃五谷杂粮')


def fun(obj):
    obj.eat()


fun(Animal())	# 动物要吃东西
fun(Dog())		# 狗吃肉
fun(Cat())		# 猫吃鱼
print('----------------------------')
fun(Person())	# 人吃五谷杂粮

特殊方法和特殊属性

特殊属性：

• dict：获得类对象或实例对象绑定的所有属性和方法的字典

特殊方法：

• len()：通过重写__len__()方法，让内置函数len()的参数可以是自定义类型
• add()：通过重写__add__()方法，可使用自定义对象具有“+”功能
• new()：用于创建对象
• init()：对创建的对象进行初始化

# print(dir(object))
class A:
    pass


class B:
    pass


class C(A, B):
    def __init__(self, name):
        self.name = name


class D(A):
    pass


# 创建C类对象
x = C('Jack')  # x是C类型的一个实例对象
print(x.__dict__)  # {'name': 'Jack'} 实例对象的属性字典
print(C.__dict__)
print('------------------------------')
print(C.__class__)  # <class 'type'> 输出对象所属的类
print(C.__bases__)  # C类的父类类型的元素（多继承）
print(C.__base__)  # 类的基类
print(C.__mro__)  # 类的层次结构
print(A.__subclasses__())   # 子类的列表

特殊方法：

a = 20
b = 100
c = a + b   # 两个整数类型的对象的相加操作
d = a.__add__(b)
print(c)
print(d)


class Student:
    def __init__(self, name):
        self.name = name

    def __add__(self, other):
        return self.name + other.name

    def __len__(self):
        return len(self.name)


stu1 = Student('张三')
stu2 = Student('李四')

s = stu1 + stu2     # 实现两个对象的加法运算（因为在Student类中 编写__add__()特殊的方法）
print(s)
s = stu1.__add__(stu2)  # 如果没有Student类里面的__add__()构造方法，则会报错
print(s)
print('------------------------')
lst = [11, 22, 33, 44]
print(len(lst))
print(lst.__len__())
print(len(stu1))

---

当我们用类来实例化对象时，系统就会自动调用__new__创建对象，这个创建的对象就是self，然后才会执行__init__，去构造实例的属性；准确点说是__new__创建对象（实力本身），然后传递给init上self这个形参上，才会执行init来构造实例对象的基础属性；可如果你重写了方法__new__，但把super().new__(cls)省略了，那么后同init形参self就没有值，init就不会执行

class Person:

    def __new__(cls, *args, **kwargs):
        print('__new__被调用执行了，cls的id值为{0}'.format(id(cls)))  # 6992
        obj = super().__new__(cls)
        print('创建的对象的id为：{0}'.format(id(obj)))  # 2688
        return obj

    def __init__(self, name, age):
        print('__init__被调用了，self的id值为：{0}'.format(id(self)))    # 2688
        self.name = name
        self.age = age


print('object这个类对象的id为：{0}'.format(id(object)))     # 5616
print('Person这个类对象的id为：{0}'.format(id(Person)))     # 6992

# 创建Person类的实例对象
p1 = Person('张三', 20)   # 先执行等号右边的代码,将Person传给cls
print('p1这个Person类的实例对象的id：{0}'.format(id(p1)))     # 2688

"""
object这个类对象的id为：140732853935616
Person这个类对象的id为：2586884266992
__new__被调用执行了，cls的id值为2586884266992
创建的对象的id为：2586891132688
__init__被调用了，self的id值为：2586891132688
p1这个Person类的实例对象的id：2586891132688

"""

类的浅拷贝和深拷贝

变量的赋值操作

• 只是形成两个变量，实际上还是指向同一个对象
• 其实就是对象的引用（别名）

浅拷贝

• python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象
• 拷贝父对象，不会拷贝对象的内部的子对象

深拷贝

• 使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同
• copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象

常使用的浅拷贝类型有：
(1)完全切片操作[:]
(2)利用工厂函数list(),dict()等
(3)使用copy模块的copy函数

class CPU:
    pass


class Disk:
    pass


class Computer:
    def __init__(self, cpu, disk):
        self.cpu = cpu
        self.disk = disk


# 变量的赋值
cpu1 = CPU()
cpu2 = cpu1
print(cpu1)  # <__main__.CPU object at 0x000001FE13030FD0>
print(cpu2)  # <__main__.CPU object at 0x000001FE13030FD0>

# 类的浅拷贝
disk = Disk()  # 创建一个硬盘类的对象
computer = Computer(cpu1, disk)  # 创建一个计算机类的对象

# 浅拷贝
import copy

computer2 = copy.copy(computer)
print(computer, computer.cpu, computer.disk)    # <__main__.Computer object at 0x0000024A7E010F70> <__main__.CPU object at 0x0000024A7E010FD0> <__main__.Disk object at 0x0000024A7E010FA0>
print(computer2, computer2.cpu, computer2.disk)     # <__main__.Computer object at 0x0000024A7E010D90> <__main__.CPU object at 0x0000024A7E010FD
print('-----------------------------')

# 深拷贝
computer3 = copy.deepcopy(computer)
print(computer, computer.cpu, computer.disk)    # <__main__.Computer object at 0x000001D83B011F70> <__main__.CPU object at 0x000001D83B011FD0> <__main__.Disk object at 0x000001D83B011FA0>
print(computer3, computer3.cpu, computer3.disk)     # <__main__.Computer object at 0x000001D83B011730> <__main__.CPU object at 0x000001D83B011400> <__main__.Disk object at 0x000001D83B02CD60>

浅拷贝

深拷贝