【Python】15.两大编程思想——面向过程与面向对象

1.两大编程思想

2.类与对象的创建

1.类：多个类似事物组成的群体的统称。能够帮助我们快速理解和判断事物的性质（不同数据类型属于不同的类）。

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

#Python中一切皆对象。Student是对象吗？内存有开空间吗？
print(id(Student))  #1142399412544
print(type(Student))    #<class 'type'>
print(Student)  #<class '__main__.Student'>

类的组成：类属性、实例方法、静态方法、类方法

class Student:
    native_space = '山东'   #直接写在类里的变量，称为类属性
    def __init__(self,name,age):
        self.name = name    #self.name称为实体属性，进行了一个赋值操作，将局部变量的name值赋给实体属性
        self.age = age

#在类之外定义的是函数，类之内定义的是方法

    #实例方法
    def eat():
        print('学生在吃饭...')
    #静态方法
    @staticmethod
    def method():
        print('使用了staticmethod进行修饰，所以是静态方法')
    #类方法
    @classmethod
    def cm(cls):
        print('使用了classmethod进行修饰，所以是类方法')

2.对象：类之下包含的相似的不同个例。
对象的创建又称为类的实例化
语法

实例名=类名（）

意义
有了实力就可以调用类中的内容
例子（接上）

#创建Student类的实例对象
stu1 = Student('张三',20)
stu1.eat()  #对象名.方法名（）
Student.eat(stu1)   #类名.方法名（类的对象）
#上两行代码功能相同
print(stu1.name)
print(stu1.age)

3.类对象与类属性；类方法与静态方法

4.动态绑定属性和方法

class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def eat(self):
        print(self.name+'在吃饭')

stu1=Student('张三',20)
stu2=Student('李四',31)
print('------为stu2动态绑定性别属性------')
stu2.gender='女'
print(stu1.name, stu1.age)
print(stu2.name,stu2.age,stu2.gender)

print('------为stu1动态绑定性别方法------')
def show():
    print('定义在类之外的，称函数')
stu1.show = show
stu1.show()

5.面向对象

面向对象三大特征

5.1封装

class Student:
    def __init__(self,name,age):
        self.name=name
        self.__age=age    #年龄不希望在类的外部使用，故加了两个__
    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)    #在类的外部可以通过_Student__age进行访问

5.2继承

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

class Person(object):#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_num):
        super().__init__(name,age)  #子类中通过super()方法调用父类的方法
        self.stu_num=stu_num


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

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

5.3方法重写

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

5.4object类

class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):  #重写str方法
        return '我的名字是{0}，今年{1}岁'.format(self.name,self.age)    #格式化字符串
stu = Student('张三',20)
print(dir(stu))
print(stu)  #默认调用__str__()方法
print(type(stu))

5.5多态

不知道一个变量所引用的对象到底是什么类型，仍可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态决定调用哪个对象中的方法，跟继承关系无关。

class Animal:
    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(Cat())  #Cat是一个类，并不是对象，加了括号才叫做对象
fun(Dog())
fun(Animal())
fun(Person())

5.6特殊方法和特殊属性

特殊属性

class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age
#创建C类的对象
x = C('Jack',20)#x是C类型的一个实例对象
print(x.__dict__)
#{'name': 'Jack', 'age': 20}，输出实例对象的属性字典
print(x.__class__)
#<class '__main__.C'>,输出对象所属的类
print(C.__bases__)
#(<class '__main__.A'>, <class '__main__.B'>)，C类的父类类型的元素
print(C.__base__)
#<class '__main__.A'>
print(C.__mro__)
#(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>),查看类的层次结构
print(A.__subclasses__())
#[<class '__main__.C'>],查看子类列表

特殊方法

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('Jack')
print(len(stu1))
stu2=Student('李四')
s=stu1+stu2
print(s)
#在Student类中编写__add__()特殊方法，实现了两个对象的加法

一段高深的代码

class Person(object):

    def __new__(cls,*args,**kwargs):
        print('__new__被调用执行了，cls的id值为{0}'.format(id(cls)))
        obj=super().__new__(cls)
        print('创建对象的id值为{0}'.format(id(obj)))
        return obj
    def __init__(self,name,age):
        print('__init__被调用执行了，self的id值为{0}'.format(id(self)))
        self.name=name
        self.age=age
#new在前创建对象，init在后对对象属性进行初始化

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

#创建Person类的实例对象
p1=Person('张三',20)
print('p1这个Person类的实例对象的id为{0}'.format(id(p1)))

5.7类的浅拷贝与深拷贝

变量的赋值操作：只形成两个变量，但实际上还是指向同一个对象

5.7.1浅拷贝

Python拷贝一般是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象，使用copy模块

5.7.2深拷贝

使用copy模块的deecopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同