文章目录

• 二、Python面向对象
• • 1.类（Class）
  • • 1.1.定义类
    • 1.2.类属性
    • 1.3.实例属性
    • • 1.3.1.内部添加
      • 1.3.2.外部添加
    • 1.4.实例方法
    • 1.5.类方法
    • 1.6.静态方法
    • 1.7.__init__方法（初始化）
    • 1.8.Self(当前对象的引用)
    • 1.9.魔术方法
    • • 1.9.1.魔术方法介绍大全
  • 2.方法、继承、多态
  • • 2.1.析构方法`__del__ `
    • • 2.1.1.释放对象时调用
      • 2.1.2.手动清空对象
    • 2.2.继承
    • • 2.2.1.单继承
      • 2.2.2.多继承
      • 2.2.3.重写父类方法
      • 2.2.4.重写`__init__`方法
      • 2.2.4多态
    • 2.3类属性和实例属性区别
    • 2.4类方法和实例方法和静态方法
  • 3.封装与单例
  • • 3.1.封装
    • 3.2.单例模式
    • 3.3.异常处理
    • • 3.3.1.异常类型
      • 3.3.2.自定义异常类型
    • 3.4.动态添加属性和方法

二、Python面向对象

1.类（Class）

1.1.定义类

class Person :name = '小明'#类属性age = '20'#类属性def eat(self):print('吃饭')passpass

• 使用

xiaoming =  Person()

1.2.类属性

在类的内部，使用def关键字定义且有类似(self)的，使用权归实例所有

name = '小明'#类属性

1.3.实例属性

1.3.1.内部添加

在方法的内部，使用self引用的属性

    def __init__(self):self.friend = '小红'

1.3.2.外部添加

class People :def eat(self):print(self)passpassxiaoming = People()
xiaoming.name = '小明'
xiaoming.age = 20
print(xiaoming.name)

1.4.实例方法

在类的内部，使用def关键字定义且有类似(self)的，使用权归实例所有

def eat(self):print('吃饭')passpass

1.5.类方法

类对象所拥有的方法，用装饰器@classmethod来标
识其为类方法，对于类方法，第一个参数必须是类对象，
一般以cls作为第- -个参数，
类方法可以通过类对象，实例对象调用

类方法可以访问、修改类属性

	name = '小明'@classmethoddef findNameInfo(cls):return cls.namepass

1.6.静态方法

静态方法不需要传参例如（cls/self）
静态方法不可以访问类属性
通常用类直接访问静态方法，本身和类与实例无关

import time
class Test :def __init__(self,hour,min,second):self.hour = hourself.min = minself.second = second@staticmethoddef showTime():return time.strftime("%H:%M:%S" ,time.localtime())pass
passprint(Test(1,2,3).showTime())

1.7.__init__方法（初始化）

*类似于构造函数，对self的属性进行构造
自动执行的初始化方法,自带的内置函数

class People :def __init__(self,name,age):self.name = nameself.age = agepassdef showInfo(self):print(self.name+'年龄'+self.age)passpassxiaoming = People('小明',20)

1.8.Self(当前对象的引用)

实例化后，python解释器会把当前对象自动传递给self

1.9.魔术方法

• __str__
  打印时调用的方法

class People :def __init__(self,name,age):self.name = nameself.age = agepassdef __str__(self):return  '姓名：%s 年龄：%d'%(self.name,self.age)passpassxiaoming = People('小明',20)
print(xiaoming)

• __new__
  创建对象实例的方法，调用一次就会生成新的对象cls（class）cls自动提供
  真正创建实例的方法，经常单例模式使用，必须返回实例

class People :def __init__(self,name,age):self.name = nameself.age = ageprint('__init__')passdef __new__(cls, *args, **kwargs):print('__new__')return object.__new__(cls)passpassxiaoming = People('小明',20)

• 区别__new __和__init__

• __new __类的实例化方法必须要返回该实例否则对象就创建不成功
• __init__用来做数据属性的初始化工作也可以认为是实例的构造方法接受类的实例self并对其进行构造
• __new __至少有一个参数是cls代表要实例化的类，此参数在实例化时由python解释器自动提供
• __new __函数执行要是于__init__函数

1.9.1.魔术方法介绍大全

魔术方法介绍大全

2.方法、继承、多态

2.1.析构方法__del__

当一个对象被删除或者被销毁时，python解释器也会默认调用一个方法，这个方法为__del__ ()方
法，也称为析构方法

2.1.1.释放对象时调用

class People :def __init__(self,name,hp):self.name = nameself.hp = hppassdef __del__(self):print('销毁了')passpassxiaohong = People('xiaohong',100)

2.1.2.手动清空对象

del xiaohong

2.2.继承

2.2.1.单继承

class Animal :def eat(self):print('吃')passpassclass Dog(Animal) :def wwj(self):print('汪汪叫')passpass

2.2.2.多继承

class Animal :def eat(self):print('吃')passpassclass God:def fly(self):print('飞')passpassclass Wukong(Animal,God):def Dayaoguai(self):print('打妖怪')passpass

• 多继承，同名方法查找父类，如没有则向父类的父类查找（广度优先）
• __mro__方法解析顺序，用来了解继承顺序

2.2.3.重写父类方法

class Animal :def eat(self):print('吃')passpassclass Dog(Animal) :def eat(self):print('大口吃')passpass

2.2.4.重写__init__方法

class People :def __init__(self,name,hp):self.name = nameself.hp = hpprint('调用People__init__')passpassclass Man(People):def __init__(self,name,hp):People.__init__(self,name,hp)#调用父类方法1#super().__init__(name,hp)#调用父类方法2,可在父类逐个查找print('调用Man__init__')passpassman = Man('xxx',100)

2.2.4多态

继承并扩展父类代码，不需要修改父类代码

class Animal :def eat(self):print('吃')passpassclass Dog(Animal) :def eat(self):print('大口吃')passpassclass Cat(Animal) :def eat(self):print('小口吃')passpassdef commonInvoke(obj) :obj.eat()listObj = [Animal(),Cat(),Dog()]for item in listObj :commonInvoke(item)

2.3类属性和实例属性区别

实例对象不可以修改类属性，类属性所有权归类所有

2.4类方法和实例方法和静态方法

1.类方法的第一个参数是类对象cls，通过cls引用的类对象的属性和方法
2.实例方法的第一个参数是实例对象self,通过self引用的可能是类属性、也有可能是实例属
性(这个需要具防分析)，不过在存在相同名称的类属性和实例属性的情况下，实例属性优先
级更高。
3.静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类对象来引
用。

3.封装与单例

3.1.封装

• 属性私有化，无法外部访问，不能被继承，只能内部类使用

class Person :__age = 20 #类属性私有化def __init__(self):self.__name = '小明'#实例属性私有化passpass

• 方法私有化，无法外部访问，不能被继承，只能内部类使用

class Person :def __run(self): #实例方法私有化print('跑')passpass

• 下划线类型

• property（属性函数）

• 类属性的方式实现

class Person :def __init__(self):self.__name = '小明'passdef get_name(self):return self.__namedef set_name(self,name):if name < 0:print('no')else :self.__name = namepassname = property(get_name, set_name)
pass
person = Person()
print(person.name)#访问类属性name

• 装饰器方式实现

class Person :def __init__(self):self.__name = '小明'pass@property #添加装饰器 添加属性标志def name(self):return self.__name@name.setter #提供一个setter方法def name(self,name):if name == '小明':print('no')else :self.__name = namepass
pass
person = Person()
person.name = '小红'
print(person.name)#访问类属性name

• __new__实例化方法

class Person :def __init__(self):self.__name = '小明'passdef __new__(cls, *args, **kwargs):return super().__new__(cls, *args, **kwargs)passpass

3.2.单例模式

不能使用自身new方法，会产生深度递归

class Person :__instance = Nonedef __new__(cls, *args, **kwargs):if not hasattr(cls,'_instance') :cls.__instance = super().__new__(cls, *args, **kwargs)return cls.__instancepasspass

3.3.异常处理

try#可能出现错误的代码块
except:#出错之后执行的代码块
else:#没有出错的代码块
finally:#不管出没出错都会执行的代码块

根据错误类型来捕获的（NameError 、IndexError …）
自上而下依次判断

try :print(b)li = [1,2,3,4]print(li[100])
except NameError as msg:print('出错')print(msg)
except IndexError as msg:print('出错')print(msg)
except Exception as msg:#所有异常print('出错')print(msg)

3.3.1.异常类型

当前函数没找到，则向上层一层层传递查找

3.3.2.自定义异常类型

class LenException(Exception):def __init__(self,leng):self.len = lengpassdef __str__(self):return '长度超了'passdef name_Test():try :name = '1111111111'if len(name)>5:raise LenException(len(name))else:print(name)passpassexcept LenException as msg:print(msg)
passname_Test()

3.4.动态添加属性和方法

• 动态添加属性

class Student :def __init__(self,name):self.name = namepassdef __str__(self):return '姓名:%s' %(self.name)
student = Student('小明')
student.age = 20 # 动态添加实例属性
Student.age = 20 # 动态添加类属性
print(student)
print(student.age)

• 动态添加实例方法

import types #添加方法的库def runA(self):print(self.name)passclass Student :def __init__(self):self.name = '小明'passpass
stu = Student()
stu.run = types.MethodType(runA , stu)#动态添加实例方法
stu.run()#调用

• 动态添加类方法

@classmethod
def runA(self):print(self.name)passclass Student :name = '小明'pass
Student.run = runA#动态添加实例方法
Student.run()#调用

• 动态添加静态方法

@staticmethod
def runA():print('55555')passclass Student :name = '小明'pass
Student.run = runA#动态添加实例方法
Student.run()#调用

• __slots__属性
  来限制该class能添加的属性。
  子类不会继承，只有在当前类中有效。
  子类声明__slots__属性才会继承
• 限制添加的属性

class Student(object) :__slots__ = ('name','age') # 限制添加的属性，避免存储多余的数据def __str__(self):return '{},{}' .format(self.name,self.age)passpassstu = Student()
stu.name = '1'
stu.age = 20
stu.high = 20 # 添加不了报错了
print(stu)
print(stu.__dict__)#所有可以用的属性都在这里，占空间大
print(stu.__slots__ )#存储限制添加的属性，避免存储多余的数据

• __call__属性

class Student(object) :def __call__(self, *args, **kwargs):print('1111')passstu = Student()
stu()

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！