首页 > 代码库 > 18-面向对象之基础

18-面向对象之基础

2024-10-07 08:29:39   214人阅读

目录：类和对象，多态与多态性，封装，绑定与非绑定方法，继承，反射
 
-------------------------------------------
面向过程：根据业务逻辑从上到下写垒代码
函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
面向对象：对函数进行分类和封装，让开发“更快更好更强...
 
面向过程编程
核心是过程，过程就是解决问题的步骤，即先做什么，在做什么，基于面向过程设计程序，好比流水线，是一种机械思维方法。
优点：复杂的问题简单化
缺点：可扩展性差，牵一发而动全身
应用场景： linux内核，httpd，git
 
面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）
核心是对象，要理解对象应该把自己当作上帝，一切事务都是对象，不存在的也可创建出来。
 
对象(obj)
对象是特征(变量)与技能(函数)的结合体
优点：可扩展性强
缺点：无法像面向过程一样准确的知道什么阶段发生什么事，会有什么结果
应用场景：与用户层交互多的，公司内部的软件，游戏，互联网软件
 
类(class)
类是一些列对象共有的特征与技能的集合体
 
在程序中使用，需要先定义类，再定义对象，即实例化出对象
 
-------------------------------------------
 
-------------------------------------------
创建类和对象
 
面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用
--类就是一个模板，模板里可以包含多个函数，函数里实现一些功能
--对象则是根据模板创建的实例，通过实例对象可以执行类中的函数
类的语法：
 
  1. class 类名:
  2.     """
  3.     注释
  4.     """
  5.     类体(可是任意代码)
示例：
  1. # 定义一个类
  2. class Chinese:
  3. country = ‘China‘ # 属性
  5. def __init__(self, name, age): # 初始化,实例化出来的对象默认拥有name,age等属性
  6. self.name = name # p1.name=name
  7. self.age = age # p1.age=age
  9. def talk(self): # 技能
  10. print(‘say Chinese‘)
  12. p1 = Chinese(‘rain‘, 18) # 实例化出一个对象p1
  13. print(p1.country) # 类的数据属性
  14. print(p1.__init__) # 类的函数属性
  15. print(p1.talk()) # 类的函数属性,加括号即可运行
  16. print(p1.name)
  17. print(p1.age)
PS：
1,class是关键字，表示类,注意后面冒号‘:‘
2,创建对象，类名称后加括号即可
3,类中的函数,默认第一个参数都为为self,代表实例化对象自己,self.name相当于p1.name
4,整个函数的功能称作类的方法
5,定义在类内部的变量，是所有对象共有的，id全一样
6,定义在类内部的函数，是绑定到所有对象的，是给对象来用，obj.func()会把obj本身当做第一个参数出入
7,绑定方法：绑定到谁的身上，就是给谁用的，谁来调用就会自动把自己当作第一个参数传入
 
类的特殊方法：
__dict__:查看类的属性字典或类的名称空间
 
  1. print(Chinese.__dict__)
  3. 运行结果：(一个字典)
  4. {‘talk‘: <function Chinese.talk at 0x0000000000B4E268>, ‘country‘: ‘China‘, ‘__doc__‘: None, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Chinese‘ objects>, ‘__init__‘: <function Chinese.__init__ at 0x0000000000B4E1E0>, ‘__module__‘: ‘__main__‘, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Chinese‘ objects>}
 
-------------------------------------------
 
 
-------------------------------------------
练习1:对象个数统计功能
每实例化一次，记一次数，最后统计一个类实例化了几个对象
  1. class Foo:
  2. count = 0 # 类的数据属性
  3. def __init__(self, name):
  4. Foo.count += 1
  5. self.name = name
  7. obj1 = Foo(‘rain‘)
  8. obj2 = Foo(‘tom‘)
  9. print(‘该类共实例化了 %s 个对象.‘ % Foo.count)
  11. 运行结果：
  12. 该类共实例化了 2 个对象.
 
 
练习2：对象间的交互
定义2个英雄人物，可以互相攻击，血量减少
  1. class Garen:
  2. camp = ‘Demacia‘ # 定义通用属性：阵营
  3.  
  4. def __init__(self, nickname, life_value=600, agg = 100):
  5. self.nickname = nickname
  6. self.life_value = life_value
  7. self.agg = agg
  9. def attack(self, enemy): # 定义攻击方法，攻击敌人
  10. enemy.life_value -= self.agg
  12. class Riven:
  13. camp = ‘Noxus‘
  14.  
  15. def __init__(self, nickname, life_value=400, agg = 150):
  16. self.nickname = nickname
  17. self.life_value = life_value
  18. self.agg = agg
  20. def attack(self, enemy):
  21. enemy.life_value -= self.agg
  23. g = Garen(‘德码‘)
  24. r = Riven(‘瑞文‘)
  25. print(g.life_value) # 查看血量值
  26. print(r.life_value)
  28. g.attack(r) # 模拟攻击
  29. print(r.life_value) # 攻击后血量值
  30.  
  31. r.attack(g)
  32. print(g.life_value)
 
-------------------------------------------
 
-------------------------------------------
 
继承
1,什么是继承：
继承是一种创建新类的方式，新建的类可以继承一个多个父类，父类又可称为基类或超类，新建的类称为派生类或子类
 
格式：
 
  1. class ParentClass1:
  2.     pass
  3. class ParentClass2:
  4.     pass
  6. class SubClass1(ParentClass1):
  7.     """
  8.     继承父类1
  9.     """
  10.     pass
  12. class SubClass2(ParentClass1, ParentClass2):  # 调用时，会按照从左到右顺序查找
  13.     """
  14.     继承2个父类：父类1和父类2
  15.     """
  16.     pass
 
2,继承关系的寻找
先在对象自己里面找，没有再去对象的类中找，再没有去父类找
 
在Python3中可以使用
print(Foo.mro())
返回值是个列表：
列表元素固定，也就是继承查找的顺序
 
Python2中的类分为：新式类与经典类
  1. 新式类：
  2. class Foo(object):
  3.     pass
  5. 经典类：
  6. class Foo:
  7.     pass
  9. Python3中都为新式类
  10. class Foo:
  11.     pass
  12. print(Foo.__dict__())
 
 
 
 
例如：
关系图如下：
技术分享
F的父类是A,B,C;
A的父类是D;
B的父类是E;
定义如下类来测试：
  1. class E:
  2. def test(self):
  3. print(‘from E‘)
  4. pass
  5. class A(E):
  6. def test(self):
  7. print(‘from A‘)
  8. pass
  9. class D:
  10. def test(self):
  11. print(‘from D‘)
  12. pass
  13. class B(D):
  14. def test(self):
  15. print(‘from B‘)
  16. pass
  17. class C:
  18. def test(self):
  19. print(‘from C‘)
  20. pass
  21.  
  22. # 优先找F自己类中的test函数,F类中没有，找A-->D,D没有回来找B-->E,还没有找C
  23. class F(A, B, C):
  24. def test(self):
  25. print(‘from F‘)
  26. pass
  28. f = F()
  29. f.test()
如果是如下图形式：
技术分享
新式类查找顺序：广度优先
F-->D-->B-->E-->C-->A  (不回一找到底,找完分支后,最后找A)
经典类查找顺序：深度优先
F-->D-->B-->A-->E-->C
 
3,继承可以解决代码冗余问题，继承反映的是一种什么是什么的关系
 
例如：
 
 
  1. class People: # 定义父类
  2.     def __init__(self, name, age, sex):
  3.         self.name = name
  4.         self.age = age
  5.         self.sex = sex
  7. class Teacher(People): # 子类继承父类,且有自己的独特的属性salary
  8.     def __init__(self, name, age, sex, salary):
  9.     People.__init__(self, name, age, sex)
  10.     self.salary = salary 
  12. class Student(People): # 子类继承父类
  13.     pass
  16. t = Teacher(‘rain‘, 19, ‘male‘, 3000)
  17. print(t.salary)
  18. s = Student(‘a‘, 10, ‘male‘)
  19. print(s.name)
  20. print(s.age)
  21. print(s.sex)
  23. 运行结果:
  24. 3000
  25. a
  26. 10
  27. male
 
supper().父类的方法名：允许子类重用父类中的方法
例如:
  1. class Foo:
  2. def test(self):
  3. print(‘from foo.test...‘)
  5. class Bar(Foo): # 如果有多个父类，按照从左到右顺序查找,print(Bar.mro())可查看查看顺序
  6. def test(self):
  7. super().test() # Foo.test(self)
  8. # super(Bar, self).test()
  9. print(‘from Bar...‘)
  10.  
  11. b = Bar()
  12. b.test()
  14. 运行结果：
  15. from foo.test...
  16. from Bar...
 
组合
组合也可以解决代码冗余问题，组合反映的是什么有什么的关系
将不同的类组合起来相互调用
 
例如：
 
 
  1. class Date:
  2.     def __init__(self, year, mon, day):
  3.         self.year = year
  4.         self.mon = mon
  5.         self.day = day
  6.     def tell(self):
  7.         print(‘%s-%s-%s‘ % (self.year, self.mon, self.day))
  9. class People:
  10.     def __init__(self, name, age, sex):
  11.         self.name = name
  12.         self.age = age
  13.         self.sex = sex
  15. class Teacher(People):
  16.     def __init__(self, name, age, sex, salary, year, mon, day):
  17.     People.__init__(self, name, age, sex)
  18.     self.salary = salary
  19.     self.birth = Date(year, mon, day)
  21. class Student(People):
  22.     def __init__(self, name, age, sex, year, mon, day):
  23.         People.__init__(self, name, age, sex)
  24.         self.birth = Date(year, mon, day)
  27. t = Teacher(‘rain‘, 19, ‘male‘, 10000, 1990, 6,20)
  28. print(t.salary)
  29. t.birth.tell()
  31. s = Student(‘a‘, 11, ‘male‘, 2007, 12, 12)
  32. print(s.name)
  33. s.birth.tell()
  35. 运行结果:
  36. 1000
  37. 1990-6-20
  38. a
  39. 2007-12-12
 
组合应用场景：
学生类与学号类
学生类与学生学的课程类
教师类与教师教的课程类
 
多态和多态性
 
多态：同一种事物的多种形态,例如:
1,序列类型有多种形态:如字符串,列表,元组等
2,动物有多种形态:人,狗,猫
例如：动物有不同的形态：人, 狗, 猪, 猫,不管你是什么动物，只要知道动物都能发声，有talk方法即可,定义一个通用的接口func，来统一调方法即可。
 
  1. class Animal:
  2. def talk(self):
  3. print(‘发声...‘)
  6. class People(Animal):
  7. def talk(self):
  8. print(‘人在说话...‘)
  10. class Pig(Animal):
  11. def talk(self):
  12. print(‘猪在叫...‘)
  14. class Dog(Animal):
  15. def talk(self):
  16. print(‘狗在叫...‘)
  18. class Cat(Animal):
  19. def talk(self):
  20. print(‘猫在叫...‘)
  22. def func(obj):
  23. """
  24. 统一接口
  25. obj具有多态性，没有类型概念
  26. :param obj:
  27. :return:
  28. """
  29. obj.talk()
  31. peo1 = People()
  32. dog1 = Dog()
  33. pig1 = Pig()
  34. cat1 = Cat()
  35. # peo1.talk()
  36. # dog1.talk()
  37. # pig1.talk()
  38. func(peo1)
  39. func(dog1)
  40. func(pig1)
  41. func(cat1)
  43. 运行结果:
  44. 人在说话...
  45. 狗在叫...
  46. 猪在叫...
  47. 猫在叫...
 
封装
为啥要封装:
1,封装数据的主要原因是:保护隐私
2,封装方法的主要原因是:隔离复杂度
 
类中把某些属性和方法隐藏起来(或者说定义成私有的),仅在类的内部使用,外部无法访问,或者留下少量接口(函数)供外部访问.
在python中用双下划线的方式实现隐藏属性(即设置成私有的)
 
例如:__x
类中所有双下划线开头的名称如__x,都会会自动转换为_类名__x的形式:
示例1:
  1. class Foo:
  2. __x = 1
  3. def test(self):
  4. print(‘from test...‘)
  6. print(Foo.__dict__) # {‘_Foo__x‘: 1}
  7. print(Foo._Foo__x) # 1
实例2:
  1. class People:
  2. """
  3. 变形仅在定义阶段完成，后续不再变形
  4. """
  5. def __init__(self, name, age, sex):
  6. self.__name = name # self._People__name = name
  7. self.__age = age # self._People__age = age
  8. self.__sex = sex # self._People__sex = sex
  10. def tell_info(self):
  11. print(‘人的名字是：%s, 人的性别是: %s, 人的年龄是: %s‘ % (self.__name, self.__sex, self.__age))
  14. p = People(‘rain‘, 18, ‘male‘)
  15. p.tell_info()
  17. 运行结果:
  18. 人的名字是：rain, 人的性别是: male, 人的年龄是: 18
示例3:
  1. class Parent:
  2. def foo(self):
  3. """
  4. # 那么我要让他调用父类中的bar呢
  5. 改成self.__bar()
  6. :return:
  7. """
  8. print(‘from parent foo...‘)
  9. self.bar() # self._Parent__bar
  11. def bar(self): # _Parent__bar
  12. """
  13. 改成def __bar(self):
  14. :return:
  15. """
  16. print(‘from parent bar...‘)
  18. class Sub(Parent):
  19. def bar(self): # _Sub__bar
  20. print(‘from sub bar...‘)
  22. a = Sub()
  23. a.foo() # 默认按照查找顺序，对象本身-->对象所属的类-->父类：from sub bar...
示例4:
  1. class People:
  2. def __init__(self, name, age):
  3. self.__name = name
  4. self.__age = age
  6. def tell_info(self):
  7. print(‘人的名字是：%s, 人的年龄是: %s‘ % (self.__name, self.__age))
  9. def set_info(self, x, y):
  10. """
  11. 我们为了限制输入的类型:
  12. 比如名字规定必须是字符串，年龄必须是整形，
  13. 就需要加一点逻辑判断：isinstance(a,b)
  14. :param x:
  15. :param y:
  16. :return:
  17. """
  18. if not isinstance(x, str):
  19. raise TypeError(‘名字必须是字符串...‘)
  20. if not isinstance(y, int):
  21. raise TypeError(‘年龄必须是整形...‘)
  23. self.__name = x
  24. self.__age = y
  26. p = People(‘alex‘, 1000)
  27. p.tell_info()
  29. p.set_info(‘alex‘, 2000) # 修改
  30. p.tell_info()
  32. p.set_info(1111, 3000) # TypeError: 名字必须是字符串...
  33. p.tell_info()
  35. p.set_info(‘alex‘, ‘3000‘) # TypeError: 年龄必须是整形...
  36. p.tell_info()
 
自动变形的特点：
1,类中定义的__x只能在内部使用,如self.__x,引用的就是变形的结果：self._self__x
2,这种变形起始正式针对外部的变形,在外部是无法通过__x这个名字访问到的
3,在子类定义的__x不会覆盖在父类定义的__x,因为子类中在定义的时候自动变形为了:_子类名__x,而父类中变形成了:_父类名__x,即双下划线开头的属性在继承给子类的时候,子类是无法覆盖的.
 
注意:对于这一层面的封装(隐藏),我们需要在类中定义一个函数(即接口函数),在它内部访问被隐藏的属性,然后外部就可以正常使用了.
 
也可以使用property(特性)来代替接口函数
 
property(特性)
内置函数,装饰器
一旦在函数属性前加上装饰器property，这个函数就会变成一个数据属性
 
基本语法：
  1. class Foo:
  2. @property
  3. def test(self):
  4. print(‘from Foo.test...‘)
    1. # test=property(test)
  6. f = Foo()
  7. #f.test() # 结果：from Foo.test...
  8. f.test # 结果：from Foo.test...
 
实际应用：
示例1：
计算成人BMI值
过轻：低于18.5
正常：18.5-23.9
过重：24-27
肥胖：28-32
非常肥胖：高于32
体质指数(BMI) = 体重(kg) / (身高(m) ^ 2)
  1. class People:
  2. def __init__(self, name, weight, height):
  3. self.name = name
  4. self.weight = weight
  5. self.height = height
  6. @property
  7. def bmi(self):
  8. return self.weight / (self.height ** 2)
  10. p = People(‘rain‘, 75, 1.80)
  11. # print(p.bmi())
  12. print(p.bmi)
  14. 运行结果：
  15. 23.148148148148145
示例2：
计算圆的周长和面积
  1. import math
  2. class Circle:
  3. def __init__(self, radius): # 圆的半径radius
  4. self.radius = radius
  6. @property
  7. def area(self): # 计算圆的面积
  8. return math.pi * self.radius ** 2
  10. @property
  11. def perimeter(self): # 计算圆的周长
  12. return 2 * math.pi * self.radius
  14. c = Circle(10)
  15. print(c.radius)
  16. print(c.area)
  17. print(c.perimeter)
  19. 运行结果：
  20. 10
  21. 314.1592653589793
  22. 62.83185307179586
[注意：加了装饰器property,arear和perimeter不能被赋值]
 
示例3:
  1. class People:
  2. def __init__(self, name, permission=False):
  3. self.__name = name # 可转换为:self._People__name = name
  4. self.permission = permission # 用于判断,是否允许删除
  6. @property # 可转换为:name = property(name)
  7. def name(self):
  8. return self.__name # 可转换为:self._People__name
  10. @name.setter # name = name.setter(name)
  11. def name(self, value):
  12. if not isinstance(value, str): # 判断value是否是字符串
  13. raise TypeError(‘输入的内容必须是字符串.‘)
  14. self.__name = value # self._People__name = value
  16. @name.deleter
  17. def name(self):
  18. if not self.permission:
  19. raise TypeError(‘禁止删除.‘)
  20. del self.__name
  21. print(‘已删除名字‘)
  24. p = People(‘rain‘)
  25. print(p.name())
  26. print(p.name)
  27. p.name = ‘rain656‘
  28. print(p.name)
  29. p.name = 123123
  30. print(p.name)
  31. p.permission = True
  32. del p.name
  33. print(p.name)
 
绑定方法与非绑定方法：
 
绑定方法：绑定给谁，谁来调用就自动将它本身当作第一个参数传入
-绑定到类的方法：用classmethod装饰器装饰的方法
    对象也可以条用，但仍将类当作第一个参数传入
-绑定到对象的方法：没有被任何装饰器装饰的方法
 
非绑定方法：用staticmethod装饰器装饰的方法
-不与类或对象绑定，类和对象都可以调用，但是没有自动传值那么一说，就是一个普通工具而已
 
staticmethod示例：
statimethod不与类或对象绑定，谁都可以调用，没有自动传值效果，python为我们内置了函数staticmethod来把类中的函数定义成静态方法
  1. import hashlib
  2. import time
  3. class MySQL:
  4. def __init__(self,host,port):
  5. self.id=self.create_id()
  6. self.host=host
  7. self.port=port
  8. @staticmethod
  9. def create_id(): #就是一个普通工具
  10. m=hashlib.md5(str(time.clock()).encode(‘utf-8‘))
  11. return m.hexdigest()
  14. print(MySQL.create_id)
  15. conn=MySQL(‘127.0.0.1‘,3306)
  16. print(conn.create_id)
  18. 运行结果：
  19. <function MySQL.create_id at 0x0000000000D6E378>
  20. <function MySQL.create_id at 0x0000000000D6E378>
 
classmethod示例：
classmehtod是给类用的，即绑定到类，类在使用时会将类本身当做参数传给类方法的第一个参数（即便是对象来调用也会将类当作第一个参数传入），python为我们内置了函数classmethod来把类中的函数定义成类方法
 
settings.py文件内容：
  1. HOST=‘127.0.0.1‘
  2. PORT=3306
  3. DB_PATH=r‘C:\Users\Administrator\PycharmProjects\test\面向对象编程\test1\db‘
 
  1. import settings
  2. import hashlib
  3. import time
  4. class MySQL:
  5. def __init__(self, host, port):
  6. self.host = host
  7. self.port = port
  9. @classmethod
  10. def from_conf(cls):
  11. print(cls)
  12. return cls(settings.HOST, settings.PORT)
  14. print(MySQL.from_conf)
  15. conn=MySQL.from_conf()
  17. print(conn.host, conn.port)
  18. conn.from_conf() #对象也可以调用，但是默认传的第一个参数仍然是类
  20. 运行结果：
  21. <bound method MySQL.from_conf of <class ‘__main__.MySQL‘>>
  22. <class ‘__main__.MySQL‘>
  23. 127.0.0.1 3306
  24. <class ‘__main__.MySQL‘>
 
比较staticmethod和classmethod的区别
示例1：
  1. import settings
  2. class MySQL:
  3. def __init__(self, host, port):
  4. self.host = host
  5. self.port = port
  7. @staticmethod
  8. def from_conf():
  9. return MySQL(settings.HOST,settings.PORT)
  11. @classmethod
  12. def from_conf(cls):
  13. return cls(settings.HOST,settings.PORT)
  15. def __str__(self):
  16. return ‘就不告诉你...‘
  18. class Mariadb(MySQL):
  19. def __str__(self):
  20. return ‘host:%s, port: %s‘ %(self.host,self.port)
  22. m=Mariadb.from_conf()
  23. print(m)
  25. 运行结果：
  26. # @classmethod存在时运行结果：host:127.0.0.1, port: 3306
  27. # @classmethod不存在时运行结果：就不告诉你...
 
示例2：
定义MySQL类
1.对象有id、host、port三个属性
2.定义工具create_id，在实例化时为每个对象随机生成id，保证id唯一
3.提供两种实例化方式，方式一：用户传入host和port 方式二：从配置文件中读取host和port进行实例化
4.为对象定制方法，save和get，save能自动将对象序列化到文件中，文件名为id号，文件路径为配置文件中DB_PATH;get方法用来从文件中反序列化出对象
  1. import settings
  2. import hashlib
  3. import time
  4. import random
  5. import pickle
  6. import os
  8. class MySQL:
  9. def __init__(self,host,port):
  10. self.id=self.create_id()
  11. self.host=host
  12. self.port=port
  14. def save(self):
  15. file_path=r‘%s%s%s‘ %(settings.DB_PATH,os.sep,self.id)
  16. pickle.dump(self,open(file_path,‘wb‘))
  18. def get(self):
  19. file_path=r‘%s%s%s‘ %(settings.DB_PATH,os.sep,self.id)
  20. return pickle.load(open(file_path,‘rb‘))
  22. @staticmethod
  23. def create_id():
  24. m=hashlib.md5(str(time.clock()).encode(‘utf-8‘))
  25. return m.hexdigest()
  27. @classmethod
  28. def from_conf(cls):
  29. print(cls)
  30. return cls(settings.HOST,settings.PORT)
  32. print(MySQL.from_conf) #<bound method MySQL.from_conf of <class ‘__main__.MySQL‘>>
  33. conn=MySQL.from_conf()
  34. print(conn.id)
  36. print(conn.create_id())
  37. print(MySQL.create_id())
  39. conn.save()
  40. obj=conn.get()
  41. print(obj.id)
  43. 运行结果：
  44. <bound method MySQL.from_conf of <class ‘__main__.MySQL‘>>
  45. <class ‘__main__.MySQL‘>
  46. 36d644ee6ae993da6a1e9530bbd7edfe
  47. 387747d3e0c9034e68cb459b89322364
  48. 578a0ec95b1d051128dcdfba3f673754
  49. 36d644ee6ae993da6a1e9530bbd7edfe
 
示例3：
  1. import time
  2. class Date:
  3. def __init__(self,year,month,day):
  4. self.year=year
  5. self.month=month
  6. self.day=day
  8. @staticmethod
  9. def now():
  10. t=time.localtime()
  11. return Date(t.tm_year,t.tm_mon,t.tm_mday)
  13. @staticmethod
  14. def tomorrow():
  15. t=time.localtime(time.time()+86400)
  16. return Date(t.tm_year,t.tm_mon,t.tm_mday)
  18. a=Date(‘1987‘,11,21)
  19. b=Date.now()
  20. c=Date.tomorrow()
  22. print(a.year,a.month,a.day)
  23. print(b.year,b.month,b.day)
  24. print(c.year,c.month,c.day)
  26. 运行结果：
  27. 1987 11 21
  28. 2017 6 13
  29. 2017 6 14
 
示例4：
  1. import time
  2. class Date:
  3. def __init__(self,year,month,day):
  4. self.year=year
  5. self.month=month
  6. self.day=day
  7. @staticmethod
  8. def now():
  9. t=time.localtime()
  10. return Date(t.tm_year,t.tm_mon,t.tm_mday)
  12. class EuroDate(Date):
  13. def __str__(self):
  14. return ‘year:%s month:%s day:%s‘ %(self.year,self.month,self.day)
  16. e=EuroDate.now()
  17. print(e) #我们的意图是想触发EuroDate.__str__,但是结果为
  18. ‘‘‘
  19. 输出结果:
  20. <__main__.Date object at 0x1013f9d68>
  21. ‘‘‘
  22. #因为e就是用Date类产生的,所以根本不会触发EuroDate.__str__,解决方法就是用classmethod
  24. import time
  25. class Date:
  26. def __init__(self,year,month,day):
  27. self.year=year
  28. self.month=month
  29. self.day=day
  30. # @staticmethod
  31. # def now():
  32. # t=time.localtime()
  33. # return Date(t.tm_year,t.tm_mon,t.tm_mday)
  35. @classmethod #改成类方法
  36. def now(cls):
  37. t=time.localtime()
  38. return cls(t.tm_year,t.tm_mon,t.tm_mday) #哪个类来调用,即用哪个类cls来实例化
  40. class EuroDate(Date):
  41. def __str__(self):
  42. return ‘year:%s month:%s day:%s‘ %(self.year,self.month,self.day)
  44. e=EuroDate.now()
  45. print(e) #我们的意图是想触发EuroDate.__str__,此时e就是由EuroDate产生的,所以会如我们所愿
  48. 运行结果：
  49. <__main__.Date object at 0x0000000000AA0908>
  50. year:2017 month:6 day:13
__init__:类实例初始化函数
__str__:类实例字符串化函数
 
 
反射
反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）
python面向对象中的反射：通过字符串的形式操作对象相关的属性；
python中的一切事物都是对象（都可以使用反射）
例如：
  1. class Chinese:
  2. country = ‘China‘
  3. def __init__(self,name,age):
  4. self.name=name
  5. self.age=age
  7. p=Chinese(‘jack‘, 19)
  8. print(Chinese.country) # 可转换为Chinese.__dict__[‘country]
  9. print(p.name) # 可转换为p.__dict__[‘name‘]
转换的部分就是一种本质上的反射
 
下列方法可以实现自省的函数：
hasattr(obj,name)：判断obj是否有name属性,name需为字符串类型
 
getattr(obj,name,default=None)：获取对象obj的name属性,default表示设置默认返回值
 
setattr(x,y,v)：设置对象x的属性y，值为v，y必须为字符串类型
 
delattr(x,y)：删除类x的属性y，y需为字符串形式
 
方法示例：
  1. class BlackMedium:
  2. feature=‘Ugly‘
  3. def __init__(self,name,addr):
  4. self.name=name
  5. self.addr=addr
  6. def sell_house(self):
  7. print(‘%s 黑中介卖房子啦,傻逼才买呢,但是谁能证明自己不傻逼.‘ % self.name)
  9. def rent_house(self):
  10. print(‘%s 黑中介租房子啦,傻逼才租呢.‘ % self.name)
  12. # 检测是否含有某个属性
  13. b1 = BlackMedium(‘万成‘,‘回龙观‘)
  14. print(hasattr(b1,‘name‘)) # 判断对象b1是否有‘name‘这个属性，判断的属性必须是字符串形式
  15. print(hasattr(b1,‘sell_house‘))
  17. # 获取某个属性
  18. n = getattr(b1,‘name‘)
  19. print(n)
  20. func=getattr(b1,‘rent_house‘)
  21. func()
  22. # getattr(b1,‘aaaaa‘) # 提示报错
  23. print(getattr(b1,‘aaaaa‘,‘不存在...‘)) # 提示‘不存在‘
  25. # 设置某个属性
  26. setattr(b1,‘sb‘,True) # 设置对象b1的属性‘sb‘，值为True
  27. setattr(b1,‘show_name‘,lambda self:self.name+‘sb‘) # 设置b1属性‘show_name‘
  28. print(b1.__dict__) # 查看对象b1的属性字典
  29. print(b1.show_name(b1))
  31. # 删除属性
  32. delattr(b1,‘addr‘)
  33. delattr(b1,‘show_name‘)
  34. # delattr(b1,‘show_name111‘) # 不存在则报错
  35. print(b1.__dict__)
 
类也是对象，同对象一样支持反射的四个方法
  1. class Foo(object):
  3. staticField = "old boy"
  5. def __init__(self):
  6. self.name = ‘wupeiqi‘
  8. def func(self):
  9. return ‘func‘
  11. @staticmethod
  12. def bar():
  13. return ‘bar‘
  15. print getattr(Foo, ‘staticField‘)
  16. print getattr(Foo, ‘func‘)
  17. print getattr(Foo, ‘bar‘)
 
模块也是对象，也适用四个方法
  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  4. import sys
  7. def s1():
  8. print ‘s1‘
  11. def s2():
  12. print ‘s2‘
  15. this_module = sys.modules[__name__]
  17. hasattr(this_module, ‘s1‘)
  18. getattr(this_module, ‘s2‘)
导入其他模块，利用反射查找该模块是否存在某个方法
模块文件：module_test.py
  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  4. def test():
  5. print(‘from the test‘)
导入module.py模块，利用反射查找该模块是否存在
  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  4. """
  5. 程序目录：
  6. module_test.py
  7. index.py
  9. 当前文件：
  10. index.py
  11. """
  13. import module_test as obj
  15. #obj.test()
  17. print(hasattr(obj,‘test‘))
  19. getattr(obj,‘test‘)()
 
为什么用反射之反射的好处
 
好处一：实现可插拔机制
有俩程序员，一个lili，一个是egon，lili在写程序的时候需要用到egon所写的类，但是egon去跟女朋友度蜜月去了，还没有完成他写的类，lili想到了反射，使用了反射机制lili可以继续完成自己的代码，等egon度蜜月回来后再继续完成类的定义并且去实现lili想要的功能。
总之反射的好处就是，可以事先定义好接口，接口只有在被完成后才会真正执行，这实现了即插即用，这其实是一种‘后期绑定’，什么意思？即你可以事先把主要的逻辑写好（只定义接口），然后后期再去实现接口的功能
 
示例1：
1:ftpclient.py文件
  1. class FtpClient:
  2. ‘ftp客户端,但是还么有实现具体的功能‘
  3. def __init__(self,addr):
  4. print(‘正在连接服务器[%s]‘ %addr)
  5. self.addr=addr
2:test.py文件
  1. import ftpclient
  2. f1=ftpclient.FtpClient(‘192.168.1.1‘)
  3. if hasattr(f1,‘get‘):
  4. func_get=getattr(f1,‘get‘)
  5. func_get()
  6.  
  7. print(‘处理其他的逻辑代码‘)
示例2：
  1. class FtpCLient:
  2. def __init__(self,host):
  3. self.host=host
  4. print(‘connecting...‘)
  6. def run(self):
  7. while True:
  8. inp=input(‘>>: ‘).strip()
  9. inp_l=inp.split()
  10. if hasattr(self,inp_l[0]):
  11. func=getattr(self,inp_l[0])
  12. func(inp_l)
  14. def get(self,arg):
  15. print(‘download file‘,arg[1])
  17. f=FtpCLient(‘192.168.1.2‘)
  18. f.run()
 
好处二：动态导入模块（基于反射当前模块成员）
 

18-面向对象之基础


联系
我们