python基础篇_006_面向对象

面向对象

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），而接口只强调函数属性的相似性。

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

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

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

import abc

class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def talk(self):
        pass

class Person(Animal):
    def talk(self):
        print("person .. ")

class Dog(Animal):
    def talk(self):
        print("Dog .. ")

def talk(obj):
    obj.talk()

talk(Person())

封装：

隐藏对象的属性和实现细节，仅对外提供公共访问方式

【封装原则】

      1. 将不需要对外提供的内容都隐藏起来；

      2. 把属性都隐藏，提供公共方法对其访问。

私有变量和私有方法：使用双下划线

# 其实这仅仅这是一种变形操作
# 类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式：

class A:
    __N = 0  # 类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N

    def __init__(self):
        self.__X = 10  # 变形为self._A__X

    def __foo(self):  # 变形为_A__foo
        print('from A')

    def bar(self):
        self.__foo()  # 只有在类内部才可以通过__foo的形式访问到.

# A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形

这种自动变形的特点：

1.类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。

2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。

3.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

class A:
    __N = 0  # 类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N

    def __init__(self):
        self.__X = 10  # 变形为self._A__X

    def __foo(self):  # 变形为_A__foo
        print('from A')

    def bar(self):
        self.__foo()  # 只有在类内部才可以通过__foo的形式访问到.

# A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形
a = A()
# a.bar()

print(a._A__N)  # 知道类名，属性名 就可以访问
print(a._A__foo())

私有方法：在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的

5.property属性：

一个静态属性property本质就是实现了get，set，delete三种方法

class Goods:

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    @property
    def price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    @price.setter
    def price(self, value):
        self.original_price = value

    @price.deleter
    def price(self):
        del self.original_price

obj = Goods()
obj.price  # 获取商品价格
obj.price = 200  # 修改商品原价
print(obj.price)
del obj.price  # 删除商品原价

classmethod:

class Classmethod_Demo():
    role = 'dog'

    @classmethod
    def func(cls):
        print(cls.role)

Classmethod_Demo.func()

staticmethod:

class Staticmethod_Demo():
    role = 'dog'

    @staticmethod
    def func():
        print("当普通方法用")

Staticmethod_Demo.func()

6.isinstance和issubclass

class A(object):
    pass

a = A()

# isinstance(obj,cls)检查是否obj是否是类 cls 的对象
print(isinstance(a, object))
# issubclass(sub, super)检查sub类是否是 super 类的派生类
print(issubclass(A, (object)))

7.反射

通过字符串的形式操作对象相关的属性 -- 自省

hasattr  是否有该属性
getattr  获取属性
setattr  设置属性
delattr  删除属性

class Person():
    role = 'person'

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

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

p = Person("zhangsan")
print(hasattr(p, 'name'))

print(getattr(p, 'role'))

print(setattr(p, 'name', 'lisi'))
print(getattr(p, 'name'))

print(delattr(p, 'role'))
print(getattr(p, 'role'))  # AttributeError

__str__和__repr__

format_dict={
    'nat':'{obj.name}-{obj.addr}-{obj.type}',#学校名-学校地址-学校类型
    'tna':'{obj.type}:{obj.name}:{obj.addr}',#学校类型:学校名:学校地址
    'tan':'{obj.type}/{obj.addr}/{obj.name}',#学校类型/学校地址/学校名
}
class School:
    def __init__(self,name,addr,type):
        self.name=name
        self.addr=addr
        self.type=type

    def __repr__(self):
        return 'School(%s,%s)' %(self.name,self.addr)
    def __str__(self):
        return '(%s,%s)' %(self.name,self.addr)

    def __format__(self, format_spec):
        # if format_spec
        if not format_spec or format_spec not in format_dict:
            format_spec='nat'
        fmt=format_dict[format_spec]
        return fmt.format(obj=self)

s1=School('oldboy1','北京','私立')

print('from repr: ',repr(s1))
print('from str: ',str(s1))
print(s1)

'''
str函数或者print函数--->obj.__str__()
repr或者交互式解释器--->obj.__repr__()
如果__str__没有被定义,那么就会使用__repr__来代替输出
注意:这俩方法的返回值必须是字符串,否则抛出异常
'''
print(format(s1,'nat'))
print(format(s1,'tna'))
print(format(s1,'tan'))
print(format(s1,'asfdasdffd'))