‘‘‘ 驼峰命名法： 大驼峰：每个单词首字母大写 小驼峰：第二个单词首字母大写 ‘‘‘ # 定义一个汽车类 class Cart(): # 属性 color = ‘白色‘ brand = ‘奥迪‘ pailiang = 2.4 # 方法 def lahuo(self): print("小汽车能拉货") def doufeng(self): print("小汽车能兜风") def bamei(self): print(‘带妹子去嗨...‘) aodi = Cart() aodi.bamei()
‘‘‘ 什么是对象成员？ 一个对象通过类实例化之后，那么在类中定义的属性和方法，可以使用实例化的对象来操作 类中定义的属性也称为成员属性，类中定义的方法，也称为成员方法 ‘‘‘ # 定义一个汽车类 class Cart(): # 属性 color = ‘白色‘ brand = ‘奥迪‘ pailiang = 2.4 # 方法 def lahuo(self): print("小汽车能拉货") def doufeng(self): print("小汽车能兜风") def bamei(self): print(‘带妹子去嗨...‘) # 实例化对象 a = Cart() b = Cart() # 对象的成员操作 # 一，在类的外部，使用对象操作属性 # 访问成员属性，先找对象有没该属性，没有再去类中找 res = a.color print(res) # 修改属性值 # 注意:修改对象的属性值：实际上等于给对象创建了一个属于自己的color属性 a.color = ‘黑色‘ print(a.color) # 添加属性 a.name = ‘A6‘ # 该属性只属于该对象 print(a.name) # 删除属性(只在类中存在的不能删除，对象自己的属性可以删除) del a.name del a.color # del a.color # 二，在类的外部，操作对象的方法 # 访问对象的方法：实际上如果这个对象没有自己的方法，那么会访问这个对象所属类的方法 a.lahuo() # 修改对象的方法 def func(): print(‘这是一个新的方法‘) a.lahuo = func a.lahuo() # 添加新的方法 a.func2 = func a.func2() # 删除方法 del a.func2 del a.lahuo # del a.bamei 不可以删除对象类的方法，只能删除自己的方法 ‘‘‘ 总结： 一个类定义类成员属性和成员方法，那么通过这个类实例化的对象，也具备这些方法和属性吗？ 实际上，创建对象的时候，并不会把类中的属性和方法复制一份给对象，而是在对象中引用父类的方法 因此在访问对象的的属性和方法时，先找自己的，在找父类的。 一个对象由类创建后，是一个独立的对象，会引用父类中的属性和方法 如果在对象创建后，给对象的属性或方法，进行修改或添加，那么此时等于给这个对象创建了一个自己的属性和方法 所以在删除时，只能删除对象中添加或修改的属性和方法 ‘‘‘
‘‘‘ self只是一个形参，并不是关键字 self在方法中代表对象自己 self在方法中代表对象可以去操作成员，可以使用self在类的内部访问成员 对象能做的事情,self在类的内部都能做 不含self的方法只能用类来调用 ‘‘‘ class Person(): name = ‘名字‘ age = ‘年龄‘ sex = ‘性别‘ def sing(self): print(‘会唱....‘) def dance(self): print(‘会跳....‘) def rap(self): print(‘会rap....‘) def func(self,a,b,c): # 测试，在类的内部是否可以像外部一样，去访问和操作成员 self.name = a self.age = b self.sex = c print(self) zs = Person() print(zs.name) zs.func(‘yyj‘,24,‘男‘) print(zs.name,zs.age,zs.sex)
# 定义一个汽车类 class Cart(): # 属性 color = ‘白色‘ brand = ‘奥迪‘ pailiang = 2.4 # 方法 def lahuo(self): print("小汽车能拉货") def doufeng(self): print("小汽车能兜风") def bamei(self): print(‘带妹子去嗨...‘) # 在类的外部，可以直接通过类对成员进行操作 a = Cart() print(Cart.color) # 修改属性 # 修改以后，实例化的对象也会修改 Cart.color = ‘黑色‘ print(Cart.color) b = Cart() print(a.color) print(b.color)
‘‘‘ 魔术方法: 魔术方法也和普通方法一样都是类中定义的成员方法 魔术方法不需要手动去调用，会再某种情况下，自动触发(自动执行) 多数魔术方法 前后都有两个连续的下划线 魔术方法不是我们自己定义的，而是系统定义好的，我们来使用 __init__ 初始化方法 触发机制：通过类实例化对象自动触发的一个方法 作用： 可以在对象实例化后完成对象的初始化(属性赋值,方法的调用) 应用场景：文件的打开，资源的获取，干活前的准备工作 注意事项： ‘‘‘ class Person(): name = None age = None sex = None def __init__(self,n,a,s): self.name = n self.age = a self.sex = s self.say() def say(self): print("大家好，我是渣渣辉，是兄弟就来砍我") zzh = Person(‘渣渣辉‘,60,‘男‘)
‘‘‘ __del__ 析构方法 触发机制：当前类实例化的对象被销毁时，自动触发 作用： 可以在析构方法中完成一些特殊任务，比如在初始化方法中打开的文件可以关闭 应用场景： 注意事项：是对象被销毁时触发了这个方法，而不是这个方法销毁了对象 对象会在哪些情况下被销毁？ 1.当程序执行完毕，内存中的所有资源都会被销毁释放 2.使用del删除对象时 3.对象不再被引用时，会自动销毁（对象指向None或者实例化时没有被接受） ‘‘‘ ‘‘‘ 定义一个类，完成一个信息的记录 调用这个对象的时候，传递一个信息 这个对象会创建一个文件，开始写入，并在最后关闭这个文件 ‘‘‘ import time class writeLog(): # 文件路径 fileurl = ‘./‘ # 日志名称 filename = ‘2019-10-10.log‘ # 初始化 打开文件 def __init__(self): # 完成文件的打开 self.fileobj = open(self.fileurl+self.filename,‘a+‘,encoding=‘utf-8‘) # 写日志的方法 def log(self,s): print(f‘把日志：{s} 写入文件中‘) self.fileobj.write(f‘把日志：{s} 写入文件中‘) # 析构方法 def __del__(self): print(‘析构方法被触发了‘) # 在对象被销毁时，关闭在初始化方法中打开的文件对象 self.fileobj.close() l = writeLog() l.log(‘今天天气还不错哦...‘) print(‘......‘)
‘‘‘ 日志类 class Mylog 功能： 能够随时写入一个日志信息 分析： 日志文件在什么地方？ 默认当前目录 日志文件的名是什么？ 当前日期：2020-04-13.log 日志的格式是什么样的？ 2020-04-13 12:12:12 错误信息... 属性：成员属性的作用就是存储信息，供成员方法使用 日志文件的地址：fileurl 日志文件的名称：filename 打开的文件对象：fileobj 方法：具体完成一个功能的过程 __init__() ==> 初始化方法，完成对象的初始化，并打开文件 wlog() ==> 负责接收给日志的信息，并写入到日志文件中 __del__() ==> 析构方法，在对象被销毁时，关闭打开的文件 ‘‘‘ import time class Mylog(): # 文件路径 fileurl = ‘./‘ # 日志名称 filename = str(time.strftime(‘%Y-%m-%d‘)) + ‘.log‘ fileobj = None # 初始化 打开文件 def __init__(self): # 完成文件的打开 self.fileobj = open(self.fileurl + self.filename, ‘a+‘, encoding=‘utf-8‘) # 写日志的方法 def wlog(self, s): # 2020-04-13 12:12:12 错误信息... data = time.strftime(‘%Y-%m-%d %H:%M:%S‘) msg = data + ‘ ‘ + s # print(msg) self.fileobj.write(msg+‘\n‘) # 析构方法 def __del__(self): # print(‘析构方法被触发了‘) # 在对象被销毁时，关闭在初始化方法中打开的文件对象 self.fileobj.close() w = Mylog() # w.wlog(‘今天天气不错哦....‘) w.wlog(‘一个人在家学习...‘)
‘‘‘ 被特殊语法封装的成员，会有不同的访问权限 封装级别 公有的 public 不需要做任何处理 受保护的 protected 在成员前面加_ (约定俗成，而Python没有具体实现) 私有的 private 在成员前面加__ 差别： 公有的 public 受保护的 protected 私有的 private 在类的内部 OK OK OK 在类的外部 OK NO(Python可以) NO 可以使用特殊的语法获取到私有变量 ‘‘‘ class Person(): name = None _age = None __sanwei = None sex = None def __init__(self,n,a,s): self.name = n self._age = a self.__sanwei = s def say(self): print(self.__sanwei) print(‘聊聊人生和理想...‘) def _sing(self): print(‘高歌一曲...‘) def __kiss(self): print(‘打个kiss...‘) ym = Person(‘杨幂‘,25,‘60 50 60‘) print(ym.say()) # 可以使用特殊的语法获取到私有变量 # print(ym._Person__sanwei) # 查看对象的所有成员 print(ym.__dict__) # 获取当前对象自己的所有成员信息(不包括类中存在的成员信息) print(Person.__dict__) # 获取当前类的所有成员信息
‘‘‘ 1.当子类继承父类后，就可以去使用父类中的成员属性和方法(除了私有成员) 2.子类可以有自己独立的属性和方法，也可以没有 3.子类继承父类后，重新定义了父类中的方法，这种情况称为对父类方法的重写 4.在子类中可以去直接调用父类中定义的属性和方法使用super() 5.子类继承父类后，定义了父类中没有的方法，这种情况称为对父类的扩展 6.一个父类可以被多个子类继承 7.子类调用父类的方法时，如果该方法有参数要求，也需要传递参数 ‘‘‘ # 猫科动物 class maoke(): # 属性 maose = ‘猫纹‘ sex = ‘m‘ # 方法 def pao(self): print(‘走猫步‘) def pa(self): print(‘能上树‘) # 定义猫类 class mao(maoke): # 继承父类后，重新定义了父类中的方法 def pa(self): print(super().maose) super().pa() print(‘很快的就能上树...‘) # 通过猫类实例化对象 h = mao() # print(h) # 可以获取对象的属性 寻找过程：猫对象自己的属性==>猫类属性==>猫的父类属性 # print(h.maose) # 可以获取对象的方法 寻找过程：猫对象自己的方法==>猫类方法==>猫的父类方法 h.pa()
‘‘‘ 多继承语法 class 父亲(): pass class 母亲(): pass class 子类(父亲,母亲): pass 在多继承中调用方法时，先找自己有没有，再找第一个继承类，再找第二个继承类，依次下去。 ‘‘‘ class F(): def eat(self): print(‘大口喝酒，大口吃肉...‘) class M(): def eat(self): print(‘动作优雅，浅尝辄止‘) class C(F,M): def eat(self): super().eat() print(‘吃也哭，不吃也哭‘) c = C() c.eat()
‘‘‘ A B C D ‘‘‘ class H(): num = 555 def eat(self): print(‘顿顿挨饿...‘) class HuMan(): num = 444 def eat(self): print(self.num) print(‘顿顿都是小烧烤...‘) self.say() def say(self): print("我是HuMan中的say") class F(HuMan): num = 333 def eat(self): super().eat() print(super().num) print(‘大口喝酒，大口吃肉...‘) class M(HuMan): num = 222 def eat(self): super().eat() print(super().num) print(‘动作优雅，浅尝辄止‘) class C(F,M): num = 111 def eat(self): super().eat() print(super().num) print(‘吃也哭，不吃也哭‘) def say(self): print("我是C中的say") c = C() c.eat() print(c.num) ‘‘‘ 继承关系：C->F->M->HuMan 在调用父类方法时self始终表示对象自己 ‘‘‘ # mro() 获取MRO列表，就是类的继承关系 print(C.mro()) ‘‘‘ [<class ‘__main__.C‘>, <class ‘__main__.F‘>, <class ‘__main__.M‘>, <class ‘__main__.HuMan‘>, <class ‘object‘>] ‘‘‘ ‘‘‘ super() 使用super去调用父级方法时，实际上是在用super调用MRO列表中的上一级中的方法 使用super去访问父级属性时，实际上是在用super访问MRO列表中的上一级中的属性 super()本身调用父级方法时，传递的self对象，就是这个方法中self对象自己 ‘‘‘ res = C.__bases__ print(res)
‘‘‘ A B C D ‘‘‘ class H(): def eat(self): print(‘顿顿挨饿...‘) class HuMan(): def eat(self): print(‘顿顿都是小烧烤...‘) class F(HuMan): # def eat(self): # print(‘大口喝酒，大口吃肉...‘) pass class M(HuMan): def eat(self): print(‘动作优雅，浅尝辄止‘) class C(F,M): pass c = C() c.eat()
class A: pass class B(A): pass class C(A): pass class D(B,C): pass # 获取mro列表 print(D.mro()) # 检测一个类是不是另一个类的子类 res = issubclass(D,B) print(res) res = issubclass(D,C) print(res) res = issubclass(D,A) print(res) res = issubclass(B,C) print(res) res = issubclass(C,B) print(res)
# 对于同一个方法，由于调用的对象不同(或传入的对象不同，最终实现了不同的结果) # 定义电脑类 class Computer(): # 在电脑类中定义了一个sub的规范的接口方法 def usb(self,obj): obj.start() class Mouse(): def start(self): print(‘鼠标启动成功，可以双击单击嗨起来...‘) class KeyBord(): def start(self): print(‘键盘启动成功...‘) class Udisk(): def start(self): print(‘U盘启动了....‘) # 实例化对象 c = Computer() m = Mouse() k = KeyBord() u = Udisk() c.usb(m) c.usb(k) c.usb(u)
‘‘‘ 定义一个接口规范类，其他类都继承这个类，并实现(重写)父类中的方法 由于每个对象实现父类方法的方式或者过程都不相同，最后的结果是不一样的形态 ‘‘‘ # 定义 USB class USB(): ‘‘‘ 当前类说明： 这个类是一个接口规范类，需要子类继承并实现start方法 start方法不做任何具体的功能实现 ‘‘‘ # 在USB类中定义一个规范的接口方法，但是不实现任何功能 def start(self): pass # 定义鼠标类 class Mouse(USB): def start(self): print(‘鼠标启动成功，可以双击单击嗨起来...‘) # 定义键盘类 class KeyBord(USB): def start(self): print(‘键盘启动成功...‘) # 定义U盘类 class Udisk(USB): def start(self): print(‘U盘启动了....‘) # 实例化对象 m = Mouse() k = KeyBord() u = Udisk() m.start() k.start() u.start()
原文：https://www.cnblogs.com/yuyunjie/p/13127342.html
