一、类
类：把一类事物的相同的特征和相同的动作整合到一起
二、对象
对象：特征与动作的结合由这个类产生的，具体的存在
三、面向对象设计
面向对象只是一个思想 基于函数
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 5 def dog(name, gender, category): # 有狗这个类的思想 6 def init(name, gender, category): 7 dog1 = { 8 "name": name, 9 "gender": gender, 10 "category": category, 11 "jiao": jiao, 12 "chi_shi": chi_shi 13 } 14 return dog1 15 16 def jiao(dog): 17 print('一条狗【%s】正在汪汪汪的叫唤' % name) 18 19 def chi_shi(dog): 20 print('一条狗【%s】正在吃屎' % name) 21 22 return init(name, gender, category) 23 24 25 d1 = dog("eric", "雄性", "藏獒") # 有对象思想 26 print(d1) 27 d1["jiao"](d1) 28 d1["chi_shi"](d1)
面向对象只是一个思想 基于类
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 5 class Dog: 6 def __init__(self, name, gender, category): 7 self.name = name 8 self.gender = gender 9 self.category = category 10 11 def jiao(self): 12 print('一条狗【%s】正在汪汪汪的叫唤' % self.name) 13 14 def chi_shi(self): 15 print('一条狗【%s】正在吃屎' % self.name) 16 17 18 d1 = Dog('eric', '雄性', '藏獒') 19 print(dir(Dog)) 20 print(d1.__dict__) 21 d2 = Dog('alex', '雄性', '京巴') 22 d1.jiao() 23 d2.jiao()
四、类相关（类的数据属性和函数属性）
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 5 class Chinese(object): 6 """中国人类""" 7 # 数据属性 8 governb = "NB" 9 10 # 函数属性 11 12 def sui_di_tu_tan(self): 13 print("随地吐痰") 14 15 def cha_dui(self): 16 print("插队") 17 18 19 print(Chinese.governb) 20 Chinese.sui_di_tu_tan("eric") 21 Chinese.cha_dui("yuanhao") 22 print(dir(Chinese)) # 查看这个类系统及全部的属性 23 print(Chinese.__dict__) # 查看类属性字典 24 Chinese.__dict__['sui_di_tu_tan']("eric") 25 print(Chinese.__module__) 26 print(Chinese.__bases__) 27 """ 28 #python为类内置的特殊属性 29 类名.__name__# 类的名字(字符串) 30 类名.__doc__# 类的文档字符串 31 类名.__base__# 类的第一个父类 32 类名.__bases__# 类所有父类构成的元组 33 类名.__dict__# 类的字典属性 34 类名.__module__# 类定义所在的模块 35 类名.__class__# 实例对应的类 36 37 """
五、对象相关以及类增删改查
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 5 class Chinese: 6 """这是一个中国人的类""" 7 country = "china" 8 9 def __init__(self, name, age, gender): 10 """ 11 函数默认返回的是None 12 自动为self封装数据返回字典形式 13 {'name': 'eric', 'age': 18, 'gender': '女'} 14 :param name: 15 :param age: 16 :param gender: 17 """ 18 self.name = name 19 self.age = age 20 self.gender = gender 21 22 def sui_di_tu_tan(self): 23 print("[%s]吐痰" % self.name) 24 25 def cha_dui(self): 26 print("[%s]插队" % self.name) 27 28 def eat_food(self, food): 29 print("[%s]正在吃【%s】" % (self.name, food)) 30 31 32 p1 = Chinese("eric", 18, "男") # 实例化就是执行初始化函数__init__方法 self就是实例化的这个对象即p1 33 print(dir(p1)) 34 print(p1.__dict__) 35 print(p1.__dict__['gender']) 36 print(p1.gender) 37 print(p1.country) 38 Chinese.sui_di_tu_tan(p1) 39 # p1.sui_di_tu_tan()=Chinese.sui_di_tu_tan(p1) 实例一定能访问类的函数属性 实例其实没有函数属性它是调用的类的函数属性 40 p1.sui_di_tu_tan() 41 p1.cha_dui() 42 p1.eat_food("屎") 43 44 # 类属性增删改查(数据属性函数属性都是相同道理) 45 # 查看 46 print(Chinese.country) 47 48 # 修改 49 Chinese.country = "Shanghai" 50 print(Chinese.country) 51 52 # 增加 53 Chinese.sichuan = "Chengdu" 54 print(Chinese.sichuan) 55 56 57 # 删除 58 del(Chinese.sichuan) 59 print(Chinese.__dict__) 60 61 # 增加函数属性 62 63 64 def play_ball(self, ball): 65 print("%s正在打%s球" % (self.name, ball)) 66 67 68 Chinese.play = play_ball 69 p1.play('篮') 70 print(dir(Chinese)) # 列表形式 71 print(Chinese.__dict__) # 字典形式
六、实例相关增删改查
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 china = "中国" 5 6 7 class People: 8 9 def __init__(self, name): 10 self.name = name 11 print('------>', china) 12 13 def play_ball(self, ball): 14 print("%s正在打%s" %(self.name, ball)) 15 16 17 p1 = People("eric") # 这里要打印中国哈 print('------>', china)跟类没任何关系 只有通过字典People.china p1.china调用才报错 18 print(p1.__dict__) 19 # 实例的增删改查 20 21 # 查看 22 print(p1.name) 23 print(p1.play_ball) # <bound method People.play_ball of <__main__.People object at 0x000001F04B708198>> \ 24 # 从这里看出来其实 实例本身没有函数属性，它是调用的类的函数属性 25 26 # 增加 27 p1.age = 18 28 print(p1.__dict__) 29 30 31 def test(self): 32 print("我是实例的函数属性", self) 33 34 35 p1.test_ball = test 36 print(p1.__dict__) 37 p1.test_ball(p1) # 这里必须加上p1参数 \ 38 # 因为类只有实例的时候才传入self参数，不传入就会报错 但是没什么卵用 基本没这么玩啊 39 40 # 修改 41 p1.age = 19 42 print(p1.__dict__) 43 44 # 删除 45 del p1.age 46 print(p1.__dict__)
七、静态属性、类方法、静态方法
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 5 class Room: 6 tag = 1 7 8 def __init__(self, owner, name, length, width, height): 9 self.owner = owner 10 self.name = name 11 self.length = length 12 self.width = width 13 self.height = height 14 15 @property # 静态属性 外部不能分辨出调用的是函数属性或数据属性 16 def cal_area(self): 17 return self.length * self.width 18 19 @classmethod # 类调用自己的方法 类能访问类的数据属性和类的函数属性 20 def tell_info(cls, x): 21 print(cls) 22 print("--->", cls.tag, x) 23 24 @staticmethod # 静态方法 是类的工具包 类和实例都可以调用 25 def wash_body(): 26 print('正在洗澡澡') 27 28 # def test(x, y): 29 # print(x, y) 不加@staticmethod实例不能调用啊,没有self,这么定义毫无意义，就是一个一般的函数 30 31 32 # 静态属性 33 r1 = Room("eric", '厕所', 5, 6, 8) 34 Room.wash_body() 35 r1.wash_body() 36 37 # 类方法 38 print(Room.tag) 39 Room.tell_info(10) 40 41 # 静态属性 42 r1 = Room("eric", '厕所', 5, 6, 8) 43 r2 = Room("藏獒", '厕所', 4, 5, 8) 44 print(r1.cal_area) 45 print(r2.cal_area) 46 # 看起来都是调用的数据属性 其实上边是调用的类的函数属性 下面才是调用的数据属性 47 print(r1.name) 48 print(r2.owner)
八、继承以及继承顺序
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 import abc 4 5 # 继承：继承一些祖先留下来的东西 接口继承尤其重要 6 # 派生：就是衍生出新的东西 7 # 类之间有相同的功能提取出来作为基类 8 9 10 class All_file(metaclass=abc.ABCMeta): 11 12 @abc.abstractmethod 13 def read(self): 14 pass 15 16 @abc.abstractmethod 17 def write(self): 18 pass 19 20 21 class Disk(All_file): 22 23 def read(self): 24 print('disk read') 25 26 def write(self): 27 print('disk write') 28 29 30 class Cdrom(All_file): 31 def read(self): 32 print('cdrom read') 33 34 def write(self): 35 print('cdrom write') 36 37 38 d1 = Disk() 39 d1.read() 40 41 42 # 深度优先：最左边优先 就是一条线走通找不到，回来再找别的路线 43 # 广度优先：最左边优先 就是一条路一直走（不包括最上面的一层），走到最后一层又回来找别的
九、子类调用父类的方法
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 5 class Vehicle: 6 def __init__(self, name, speed, load, power): 7 self.name = name 8 self.speed = speed 9 self.load = load 10 self.power = power 11 12 def run(self): 13 print('开动啦.......') 14 15 16 class Subway(Vehicle): 17 """ 18 super() -> same as super(__class__, <first argument>) 19 super(type) -> unbound super object 20 super(type, obj) -> bound super object; requires isinstance(obj, type) 21 super(type, type2) -> bound super object; requires issubclass(type2, type) 22 """ 23 def __init__(self, name, speed, load, power, line): 24 # Vehicle.__init__(self, name, speed, load, power) 25 # super(Subway, self).__init__(name, speed, load, power) 26 super().__init__(name, speed, load, power) 27 self.line = line 28 29 def run(self): 30 # Vehicle.run(self) 31 super().run() 32 print('%s %s号线,开动啦........'%(self.name, self.line)) 33 34 35 line1 = Subway('成都地铁', '350m/s', 100000000000, '电', 1) 36 print(dir(Subway)) 37 print(line1.__class__) # <class '__main__.Subway'> 38 line1.run()
十、多态
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 5 # 工厂就是面向对象中的类 6 7 # 工厂函数 8 str1 = str('sss') 9 print(str1) 10 l = list('abc') # list类加括号实例化 11 print(l) 12 13 print(len(l)) # 本质上就是调用print(l.__len__()) Python本身就是多态 14 15 16 # 多态：就是多个对象调用父类的相同的方法但结果不一样 强调的是执行相同的功能的时候 多态就是继承的一种表现形式 17 18 19 class H2O: 20 def __init__(self, name, t): 21 self.name = name 22 self.t = t 23 24 def turn_ice(self): 25 if self.t < 0: 26 print('【%s】温度太低结成冰' % self.name) 27 elif self.t > 0 and self.t < 100: 28 print('【%s】液化变成水了' % self.name) 29 elif self.t > 100: 30 print('【%s】气化变成水蒸汽了' % self.name) 31 32 33 class Water(H2O): 34 pass 35 36 37 class Ice(H2O): 38 pass 39 40 41 class Steam(H2O): 42 pass 43 44 45 w1 = Water('水', 25) 46 i1 = Ice('冰', -10) 47 s = Steam('蒸汽', 120) 48 w1.turn_ice() 49 i1.turn_ice() 50 s.turn_ice()