Python 7 面向对象编程

 1.类

class Student:
    # 类属性：定义在类中，方法外的变量
    school = '一小'

    # 初始方法
    def __init__(self, xm, age):
        self.name = xm  # 实例属性
        self.age = age

    # 实例方法
    def show(self):
        print(f'我叫：{self.name}, 今年{self.age}岁了')

    # 静态方法
    @staticmethod
    def sm():
        print('静态方法不能调用实例属性和实例方法')

    # 类方法
    @classmethod
    def cm(cls):
        print('类属性，也不能调用实例属性和实例方法')

# 类属性， 直接用类名
print(Student.school)

# 创建类的对象
stu = Student('yy', 18)

# 实例属性，使用对象进行打点调用
print(stu.name, stu.age)
# 实例方法
stu.show()

# 类方法 @classmethod 进行修饰的方法，直接用类名打点调用
Student.cm()

# 静态方法 @staticmethod 进行修饰的方法，直接用类名打点调用
Student.sm()

实例

class Student:
    school = '一小'

    def __init__(self, xm, age):
        self.name = xm
        self.age = age

    def show(self):
        print(f'{self.name} {self.age}')

stu = Student('yy', 16)
stu2 = Student('ll', 17)
stu3 = Student('uu', 20)
stu4 = Student('kk',21)

print(type(stu))

Student.school = '教育'

lst = [stu, stu2, stu3, stu4]
for item in lst:
    item.show()

动态绑定

class Student:
    school = '一小'

    def __init__(self, xm, age):
        self.name = xm
        self.age = age

    def show(self):
        print(f'{self.name} {self.age}')

stu = Student('yy', 16)
stu2 = Student('ll', 17)

print(stu2.name)

# 动态绑定一个实例属性
stu.gender = '男'
print(stu.gender, stu.age)

# 动态绑定方法
def introduce():
    print('动态绑定')
    
stu2.fun = introduce  # 函数赋值

stu2.fun()

2. 面向对象

三大特征：封装，继承，多态

2.1 封装

权限控制

class Student():
    def __init__(self, name, age, gender):
        self._name = name  # 受保护，只能本类和子类访问
        self.__age = age  # 私有，只能类本身访问
        self.gender = gender

    def _fun1(self):
        print('子类及本身可以访问')

    def __fun2(self):
        print('只有定义的类可以访问')

    def show(self):
        self._fun1()  # 类本身访问受保护的方法
        self.__fun2()  # 类本身访问私有方法
        print(self._name)  # 受保护的实例属性
        print(self.__age)  # 私有的实例属性

stu = Student('yy', 19, 'man')
print(stu._name)
stu._fun1()
print('-'*40)

# 私有实例属性和方法的访问
print(stu._Student__age)
stu._Student__fun2()
# 不推荐

属性设置

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

    # 用@property，将方法当成属性使用
    @property
    def gender(self):
        return self.__gender

    # 将gender这个属性设置为可写属性
    @gender.setter
    def gender(self,value):
        if value != 'man' and value != 'woman':
            print('wrong, 默认设为man')
            self.__gender = 'man'
        else:
            self.__gender = value

stu = Student('uu', 'man')
print(stu.name, stu.gender)

stu.gender = 'else'
print(stu.name, stu.gender)

2.2 继承

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

# Student 继承 Person类
class Student(Person):
    def __init__(self, name, age, stuno):
        super().__init__(name, age)
        self.stuno = stuno

class Doctor(Person):
    def __init__(self, name, age, department):
        super().__init__(name, age)
        self.department = department

stu = Student('yy', 20, '1001')
stu.show()

doctor = Doctor('uu', 34, '外科')
doctor.show()

方法重写

子类直接show()

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

# Student 继承 Person类
class Student(Person):
    def __init__(self, name, age, stuno):
        super().__init__(name, age)
        self.stuno = stuno
    def show1(self):
        print(self.name, self.age, self.stuno)


class Doctor(Person):
    def __init__(self, name, age, department):
        super().__init__(name, age)
        self.department = department

stu = Student('yy', 20, '1001')
stu.show()
stu.show1()

doctor = Doctor('uu', 34, '外科')
doctor.show()

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

# Student 继承 Person类
class Student(Person):
    def __init__(self, name, age, stuno):
        super().__init__(name, age)
        self.stuno = stuno
    def show1(self):
        print(self.name, self.age, self.stuno)


class Doctor(Person):
    def __init__(self, name, age, department):
        super().__init__(name, age)
        self.department = department
    def show2(self):
        super().show()
        print(self.department)


stu = Student('yy', 20, '1001')
stu.show()
stu.show1()

print('-'*40)

doctor = Doctor('uu', 34, '外科')
doctor.show()
doctor.show2()

多继承

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

    def showA(self):
        print('A的方法')

class FatherB():
    def __init__(self, age):
        self.age = age

    def showB(self):
        print('B的方法')

class Son(FatherA, FatherB):
    def __init__(self, name, age, gender):
        FatherA.__init__(self, name)
        FatherB.__init__(self, age)
        self.gender = gender

son = Son('yy', 20, 'man')
son.showA()
son.showB()

2.3  多态

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

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

class Dog():
    def eat(self):
        print('狗啃骨头')

# 这三个类中都有一个同名方法， eat
# 编写函数
def fun(obj):
    obj.eat()
    # 通过变量obj调用eat

# 创建三个类的对象
per = Person()
cat = Cat()
dog = Dog()

# 调用fun函数
fun(per)
fun(cat)
fun(dog)
# 不关心对象的数据类型，只关心对象是否具有同名方法

3. object()

收尾双下划线定义

特殊方法

a = 10
b = 20
print(a.__add__(b))

4. 特殊属性

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

a = A()
b = B()
c = C('yy', 20)

# 属性字典
print(a.__dict__)
print(b.__dict__)
print(c.__dict__)

5. 类的浅拷贝深拷贝

copy.copy()

copy.deepcopy()