python 面向对象（二）

1 面向对象

1.1 类的构造方法

• __init__构造方法
  • 调用时间：在对象被实例化时被程序自动调用
  • 作用：用于对象创建时初始化
  • 书写格式：init前后分别是2个下划线
  • 程序不显示定义init方法，则程序默认调用一个无参数的init方法
  • 对象创建过程（无参）

• 设置对象属性（有参）

 

• 创建对象过程（有参）

 

1.2 类的方法权限

• 修改对象属性的方法
  • 方法1：对象变量名.属性 = 新值

问题：

可能修改的属性值不合法

在类的外部可以随意修改类的内部属性

• 方法2：对象变量名.内部修改属性方法
• 私有属性
  • 定义：__私有变量名
  • 只能在类内部使用，类外部不能访问，否则报错
• 私有方法
  • 只能在类内部调用，在类的外部无法调用
  • 定义私有方法在方法名前添加2个下划线：__私有方法()
  • 类内部调用私有方法要使用self.私有方法的方式调用

#私有方法的定义&&使用
class Comrade:
    # 私有方法
    def __send_message(self):
        print("消息已经向上级汇报")
    def answer_secret(self, secret):
        if secret == "芝麻开门":
            print("接头成功！")
            self.__send_message() # 调用私有方法
        else:
            print("接头失败！")
comrade = Comrade()
comrade.answer_secret("芝麻开门") 

1.3 继承

class Rectange:
    def __init__(self,length,width):
        self.length=length
        self.width=width
    def area(self):
        return self.length+self.width
    def permeter(self):
        return (self.length+self.width)*2
    @classmethod
    def fearure(cls):
        print('两边的长宽都相等')
    @staticmethod
    def static():
        print('静态方法的使用')
res = Rectange(5,4)
print(res.__dict__)
# print(Rectange(5,4).area()) #调用实例方法的面积
# print(Rectange(5,4).permeter()) #调用实例方法的周长
# Rectange.area(3,4) #类不能调用实例方法，会报错
Rectange(5,4).fearure() #实例方法调用类方法
Rectange.fearure() #类调用类方法
Rectange(5,4).static() #静态方法调用类
Rectange.static() #静态方法调用实例
#type类型查看某个方法是否是函数还是方法。
# print(type(res.fearure)) #fearure是类方法
# print(type(res.static))  #static是函数，静态方法
# #inspect模块,可以判断某个对象是否是某种类型。
# import inspect
# print(inspect.ismethod(res.fearure)) #True，判断是否是方法。
# print(inspect.ismethod(res.static)) #False
# print(inspect.isfunction(res.static)) #True，判断是否是函数。

#继承
#1.完成继承
class Square(Rectange):
    pass
squ =Square(6,6)
print(squ.permeter())
print(squ.area())

#2.部分继承
class Square_some(Rectange):
    def __init__(self,side):
        self.length =side
        self.width=side
squ1=Square_some(6)
print(squ1.area())
print(squ1.permeter())

#3.全部重写，相当于没有继承。
class requre(Rectange):
    def __init__(self,side):
        self.length=side
    def area(self):
        return self.length*4
    def permeter(self):
        return self.length*2
squ2=requre(7)
print(squ2.area())
print(squ2.permeter())

• 在程序中，继承描述的是类中类型与子类型之间的所属关系，例如猫和狗都属于动物
• 单继承如果在子类中没有定义init构造方法，则自动调用父类的init构造方法；如果子类中已定义init构造方法，则不会调用父类的构造方法
  • 子类继承一个父类，在定义子类时，小括号()中写父类的类名
  • 父类的非私有属性、方法，会被子类继承
  • 子类中方法的查找方式：先查找子类中对应的方法，如果找不到，再到父类中查找
  • 子类可以继承父类的非私有属性和方法，也可继承父类的父类的非私有属性和方法，以此类推
  • 在子类中调用父类的方法：ClassName.methodname(self)

• 重写父类方法

  • 子类对父类允许访问的方法的实现过程进行重新编写
  • 在子类中定义与父类同名的方法
  • 优点：子类可以根据需要，定义合适的方法实现逻辑

• 多继承

  • Object类是所有类的基类，在定义类的时候不需要显示的在括号中表明继承自object类
  • 多继承：一个子类可以继承多个父类
  • 多继承定义方式：在类名后的括号中添加需要继承的多个类名
  • 多继承中，如果多个类中有同名的方法，子类调用查找方法的顺序是按照小括号内继承父类从左到右的顺序查找，第一个匹配的方法名的父类方法将会被调用

• 多态

  • 一个抽象类有多个子类，不同的类表现出多种形态

1.4 类属性、类方法、静态方法、类的特殊成员方法

• 实例属性（对象属性）
  • 在构造方法之内里定义的属性
  • 属于具体的实例对象，不同实例对象之间的实例属性互不影响
• 类属性
  • 在构造方法之外但在类里定义的属性
  • 属于类对象（类名），多个实例对象之间共享同一个类属性
  • 获取类属性方法：类名.类属性
  • 通过实例对象不能够修改类属性，如果修改的属性在实例中不存在，则动态添加实例属性

#类对象
class Person:
    sum_num = 0

    def __init__(self, new_name):
        self.name = new_name
        Person.sum_num += 1

p1 = Person("zhangsan")
print(p1.sum_num, Person.sum_num)
p2 = Person("lisi")
print(p1.sum_num, p2.sum_num, Person.sum_num)

#结果显示如下：
1 1
2 2 2 

• 类方法
  • 所属于类对象，使用@classmethod修饰的方法，主要用于操作类属性，不能操作实例属性
  • 定义类方法的第一个参数通常以”cls”参数作为类对象被传入
  • 调用方式：类名.类方法  或者  实例对象.类方法（不推荐）

# 类方法
@classmethod
def add_sum_num(cls):
    cls.sum_num += 1
    print(cls.sum_num) 

• 静态方法

  • 使用@staticmethod修饰的方法，不需要传递任何默认参数。不能操作实例属性

  • 调用方式：类名.静态方法  或者  实例对象.静态方法

@staticmethod
def static_test():
    print("-------静态方法-------")
    Person.sum_num += 1
    print(Person.sum_num) 

• 类的特殊成员方法

　　　　__doc__:表示类的描述信息

　　　　__module__:表示当前操作的对象在哪个模块

　　　　__class__:表示当前操作的对象的类时什么

　　　　__init__:构造方法，通过类创建对象时，自动触发执行 

　　　　__del__:析构方法，当对象在内存中被释放时，自动触发执行

　　　　__call__:对象后面加括号，触发执行

　　　　__dict__:查看类或对象中的所有成员

　　　　__str__:如果一个类中定义了__str__方法，那么在打印对象时，默认输出该方法的返回值

　　　　__new__\__metaclass__:__metaclass__表示该类由谁来实例化创建

class Dog(object):
    """这个类是描述狗这个对象的"""
    def func(self):
        pass
print(Dog.__doc__)

from aa import C
obj =C()
print(obj.__module__) #输出aa,即：输出模块
print(obj.__class__) #输出aa.C，即：输出类

class Foo:
    def __init__(self):
        #构造方法，通过类创建自动触发执行
        print("__init__")
    def __call__(self,*args,**kwargs):
        #对象后面加括号，自动触发执行
        print("__call__")

obj1 = Foo() #对象=类名(),执行__init__
obj1()  #对象()或者类()(),执行__call__

class Province:
    country ='china'
    def __init__(self,name,count):
        self.name = name
        self.count = count

    def func(self):
        print("func")
print(Province.__dict__) #获取类的成员，不包括实例属性
obj2=Province("chongqing",1000)
print(obj2.__dict__)#获取对象obj2的成员，不包括类属性

class Foo:
    def __str__(self):
        return 'wendy'
obj3 = Foo()
print(obj3)

#结果显示如下
这个类是描述狗这个对象的
aa
<class 'aa.C'>
__init__
__call__
{'__module__': '__main__', 'country': 'china', '__init__': <function Province.__init__ at 0x000001AC81A9C5E8>, 'func': <function Province.func at 0x000001AC81A9C8B8>, '__dict__': <attribute '__dict__' of 'Province' objects>, '__weakref__': <attribute '__weakref__' of 'Province' objects>, '__doc__': None}
{'name': 'chongqing', 'count': 1000}
wendy

类的特殊成员方法