python中类与对象

python中一切皆对象

编程两大思想：

面向对象和面向过程都是解决问题的思路.，只是角度不同
面向过程强调:解决问题的每一个细节和步骤都亲历亲为
面向对象强调:使用特定对象解决特定的问题

注意:
面向对象是基于面向过程

类组成：

类属性

实例方法

静态方法

类方法

class Student:  # 类的名称首字母大写，不同的单词以下划线分隔，且都要大写  例如Student_Method
    native_place = '安徽'  # 类属性，只要是卸载类里面的变量广义上都叫类属性

    def __init__(self,name,age):  # 初始化函数，里面传的name，age等是局部变量，这个方法相当于将变量实例化
        self.name = name
        self.age = age  # self.age是实例属性，这是将局部变量赋值给实例属性

    def eat(self):  # 实例方法
        print('我正在吃饭')

    @staticmethod  #修饰器
    def sta_method():  # 静态方法，里面不需要传入self
        print('我是类方法')

    @classmethod
    def cla_method(cls):  # 类方法，里面默认传入cls
        print('我是静态方法')

创建类对象：

通俗的说就是类的实例化

stu1 = Student('张三',20) # 将类实例化
stu1.eat()  # 将类实例化之后可以引用类中的实例属性和实例方法
print(stu1.name)
print(stu1.age)

Student.eat(stu1)  # 或者通过这种方法调用，类名加方法传入一个对象

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

 

print(Student.native_place)
stu1 = Student('张三',20)
stu2 = Student('李章',12)
print(stu1.native_place)
print(stu2.native_place)
print('--------------')
Student.native_place = '南京'
print(stu1.native_place)
print(stu2.native_place)  # 注意类属性，是其实例对象所共有的，当修改其值，所有对象的类属性值都修改了，其本质是实例对象有个类指针指向它

# 调用类方法
# 在不多引入参数的时候
Student.cla_method()
stu1.cla_method()
print('--------------')
# 调用静态方法
Student.sta_method()
stu1.sta_method()

 动态绑定属性和方法

python一门动态类型的语言

# 动态绑定属性
# 例如类对象没有gender属性，我们通过给实例对象加这个属性就叫动态绑定属性
stu1 = Student('张三',20)
stu1.gender = '男'
print(stu1.gender)  # 其他实例对象没有这个属性

# 动态绑定方法
# 例如类对象没有me方法，我们可以为其添加这种实例方法，其他实例对象不具有


def me():
    print('新添加的方法')
stu1.me = me
stu1.me()

 面向对象三大特征：封装，继承，多态

封装：

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()
# 如果直接调用例如 stu.__age会报错
# 并不是不可以在类的外部使用
print(dir(stu))
print(stu._Student__age)

 继承：

class Person(object):  # 默认都是继承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,studyage):
        super().__init__(name,age)  # 继承父类的name，age属性 ，同时也会继承它的实例方法
        self.studyage = studyage


class Teacher(Person):
    def __init__(self,name,age,teachage):
        super().__init__(name,age)
        self.teachage = teachage
stu = Student('张三',30,10)
tea = Teacher('李四',35,15)
stu.info()
tea.info()

 同时python支持多继承

class A(object):
    pass


class B(object):
    pass


class C(A,B):
    pass

 方法重写:如果子类对继承父类的某个属性或方法不满意，可以在子类对其方法体进行重写

 

class Person(object):  # 默认都是继承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,studyage):
        super().__init__(name,age)  # 继承父类的name，age属性 ，同时也会继承它的实例方法
        self.studyage = studyage
    def info(self):
        super().info()
        print(self.studyage)


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

    def info(self):
        super().info()
        print(self.teachage)
stu = Student('张三',30,10)
tea = Teacher('李四',35,15)
stu.info()
tea.info()

动态语言崇尚多态’鸭子类型‘，不需要关心对象类型，只需要关心对象行为

特殊属性：

class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name = name
        self.age = age
class D(A):
    pass
x = C('张三',10)
print(x.__dict__)  # 实例对象的属性字典
print(C.__dict__)
print(C.__bases__)  # C类的父类的所有元素
print(C.__base__)  # 输出离的最近的一个继承的类
print(x.__class__)  # 输出对象所属的类
print(A.__subclasses__())  # 子类的列表
print(C.__mro__)  # 类的层次结构

特殊方法 ：

__len__() ,__add__(),__new__(),__init__()。

赋值。浅拷贝，深拷贝：

在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。

浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复制

深拷贝：外围和内部元素都进行了拷贝对象本身，而不是引用。也就是，把对象复制一遍，并且该对象中引用的其他对象我也复制。