python基础篇_006_面向对象

Posted 2021-10-27 yin-fei

面向对象

1.初识类：

# 定义一个函数，我们使用关键字 def 
"""
def 函数名(参数):
    ‘‘‘函数说明‘‘‘
    函数体
    return 返回值
"""


def func():
    print("func execute...")

# 定义一个类 使用关键字 class
"""
class 类名:
    ‘‘‘类说明‘‘‘
    类体
"""

class C:
    pass

class Person:
    role = ‘person‘  # 属性

    def walk(self):
        print("person is walking ... ")  # 动态属性

2.类属性引用和实例化

属性引用：类型.属性

class Person:
    role = ‘person‘

    def walk(self):
        print("person is walking...")


print(Person.role)  # 查看人的role属性
print(Person.walk)  # 引用人的走路方法，注意，这里不是在调用，引用的是函数地址

 

实例化：类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征

class Person:
    role = ‘person‘

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

    def walk(self):
        print("person is walking...")


# 类实例化-->对象    对象 = 类名(参数)

p1 = Person("zhangsan")  # Person("zhangsan") 调用__init__(self, name)方法，构造方法

# 查看对象的属性 调用对象的方法
print(p1.role)
p1.walk()

3.类命名空间与对象、实例的命名空间

创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性

而类有两种属性：静态属性和动态属性

静态属性就是直接在类中定义的变量        类的数据属性是共享给所有对象的
动态属性就是定义在类中的方法            类的动态属性是绑定到所有对象的

创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性

在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常

 

4.面向对象三大特性

继承：

新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类

python中类的继承分为：单继承和多继承

class ParentClass1:  # 定义父类
    pass


class ParentClass2:  # 定义父类
    pass


class SubClass1(ParentClass1):  # 单继承，基类是ParentClass1，派生类是SubClass
    pass


class SubClass2(ParentClass1, ParentClass2):  # python支持多继承，用逗号分隔开多个继承的类
    pass

先抽象在继承：

增强代码重用性

子类可以自己实现新的属性和方法，或者重新定义父类的，不会影响父类。

在python3中，子类执行父类的方法也可以直接用super方法.

抽象类与接口类

继承有两种用途：

一：继承基类的方法，并且做出自己的改变或者扩展（代码重用）  

二：声明某个子类兼容于某基类，定义一个接口类Interface，接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能

接口定义：

from abc import ABCMeta, abstractmethod


class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(self, money):
        pass


class Wechatpay(Payment):
    def pay(self, money):
        print("Wechatpay pay...")

    def fuqian(self, money):
        print(‘微信支付了%s元‘ % money)


p = Wechatpay()  
p.pay(100)

依赖倒置原则：
高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该应该依赖细节；细节应该依赖抽象。换言之，要针对接口编程，而不是针对实现编程

抽象类：
只能被继承，不能实例化

# 一切皆文件
import abc  # 利用abc模块实现抽象类


class All_file(metaclass=abc.ABCMeta):
    all_type = ‘file‘

    @abc.abstractmethod  # 定义抽象方法，无需实现功能
    def read(self):
        ‘子类必须定义读功能‘
        pass

    @abc.abstractmethod  # 定义抽象方法，无需实现功能
    def write(self):
        ‘子类必须定义写功能‘
        pass


# class Txt(All_file):
#     pass
#
# t1=Txt() #报错,子类没有定义抽象方法

class Txt(All_file):  # 子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print(‘文本数据的读取方法‘)

    def write(self):
        print(‘文本数据的读取方法‘)


class Sata(All_file):  # 子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print(‘硬盘数据的读取方法‘)

    def write(self):
        print(‘硬盘数据的读取方法‘)


class Process(All_file):  # 子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print(‘进程数据的读取方法‘)

    def write(self):
        print(‘进程数据的读取方法‘)


wenbenwenjian = Txt()

yingpanwenjian = Sata()

jinchengwenjian = Process()

# 这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()

print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)

抽象类与接口类：

抽象类的本质还是类，指的是一组类的相似性，包括数据属性（如all_type）和函数属性（如read、write），而接口只强调函数属性的相似性。

抽象类是一个介于类和接口直接的一个概念，同时具备类和接口的部分特性，可以用来实现归一化设计 

多继承接口，接口定义一种规范

多态：多态指的是一类事物有多种形态

 

封装：