Python高级语法2：私有化、import、封装继承多态

一、私有化

• xx : 公有变量
• _x :单前置下划线，私有化属性或方法，from somemodule import * 禁止导入，类对象和子类可以访问
• __xx: 双前置下划线，避免与子类中的属性命名冲突，无法外部直接访问(名字重整所以访问不到)
• __xx__: 双前后下划线，用户名字空间的魔法对象或属性。例如： __init__,__不要自己发明这样的名字
• xx_: 单后置下划线，用于避免与 Python 关键字的冲突

通过 name mangling (名字重整(目的就是防子类以重写基类的方法或者属性)如：_Class__object)机制就可以访问 private了

class Person(object):

    def __init__(self,name,age,taste):

         self.name = name
         self._age = age
         self.__taste = taste

    def showperson(self):
        print(self.name)
        print(self._age)
        print(self.__taste)

    def dowork(self):
        self._work()

    def _work(self):
        print("my _work")

    def __away(self):
        print("my __away")


class Student(Person):

    def construction(self,name,age,taste):
        self.name = name
        self._age = age
        self.__taste = taste

    def showstudent(self):
        print(self._age)
        print(self.name)
        print(self.__taste)

    @staticmethod
    def testbug():
        _Bug.showbug()


class _Bug(object):

     @staticmethod
     def showbug():

        print("showbug")


s1 = Student('jack', 25, 'football')
s1.showperson()
print('*'*20)

# 无法访问__taste,导致报错
# s1.showstudent()
s1.construction('rose', 30, 'basketball')
s1.showperson()
print('*'*20)

s1.showstudent()
print('*'*20)

Student.testbug()

• 总结

  • 父类中属性名为 __名字 的，子类不继承，子类不能访问
  • 如果在子类中向 __名字 赋值，那么会在子类中定义的一个与父类相同名字的属性
  • _名 的变量、函数、类在使用 from xxx import * 时都不会被导入

二、import 导入模块

• 2.1、常见的导入方式

  from xxx import yyy
  import xxx
  from xxx import *
  import xxx,yyy
  from xxx import zzz,nnn
  import xxx as bbb
  

• 2.2、import xxx as bbb 给模块起别名

  • 给模块起别名的好处：(1)、可以简化模块名太长的问题；(2)、解决引用的模块有和模块名一样的变量名

  • 举个例子：如果你导入一个模块aa，模块里面有一个属性 name，你在当前的模块又定义了一个变量aa,那么你再调用模块aa的name赋值的时候就会报错

    import aa
    
    aa = 100
    aa.name = "Jack"
    

    运行结果：AttributeError: 'int' object has no attribute 'name'
    如果我们给aa模块起个别名bb,如：import aa as bb 就不会报错了

    import aa as bb
    
    aa = 100
    bb.name = "Jack"
    

• 2.3、import 搜索路径

  import sys
  
  print(sys.path)
  

  

  import 搜索路径

  • 路径搜索

    • 从上面列出的目录里依次查找要导入的模块文件
    • '' 表示当前路径
    • 列表中的路径的先后顺序代表了python解释器在搜索模块时的先后顺序

  • 程序执行时添加新的模块路径

    sys.path.append('/home/itcast/xxx')
    sys.path.insert(0, '/home/itcast/xxx')  # 可以确保先搜索这个路径
    

    

    程序执行时添加新的模块路径

• 2.4、重新导入模块
  模块被导入后，import module不能重新导入模块，重新导入需用reload，也就是当你在一个模块内导入了一个 import module,接不管i导入多少次 import module都不起作用，只有第一句导入有效

三、多个模块 import 导入注意点（也就是公共模块的问题）

• 3.1、我们定义4个模块：main、Test1、Test2、Common

  • Common 模块里面定义一个变量 HANDLE，初始值 FALSE

    HANDLE = FALSE
    

  • Test1 模块

    from Common import HANDLE
    
    
    def change1():
    
          HANDLE = True
    
          if HANDLE:
                print("在 Test 里面修改HANDLE为：True")
          else:
                print("在 Test 里面没有修改HANDLE的值")
          print("*"*20)
    

  • Test2 模块

    from Common import HANDLE
    
    
    def change2():
    
         print(HANDLE)
    
         if HANDLE:
    
              print("在Test2里面 HANDLE 变为 True")
         else:
               print("在Test2里面 HANDLE 变为 False")
    
         print("*" * 20)
    

  • main 模块

    import Common
    import Test1
    import Test2
    
    
    if __name__ == "__main__":
    
          if Common.HANDLE:
    
             print("HANDLE在Common里面最初的值为 True")
          else:
             print("HANDLE在Common里面最初的值为 False")
    
          print("*"*20)
     
          Test1.change1()
          Test2.change2()
    
          if Common.HANDLE:
               print("HANDLE为 True")
          else:
               print("HANDLE为 False")
    

    main模块的打印结果：

    HANDLE在Common里面最初的值为 False
    ********************
    在 Test 里面修改HANDLE为：True
    ********************
    False
    在Test2里面 HANDLE 变为 False
    ********************
    HANDLE为 False
    

    • 分析：在 Test1 里面把 HANDLE 修改为 True 后，为什么在 Test2 里面 HANDLE 的值不是 True，还有就是 Common里面也没有变为 True;

    • 原因：在其他模块 使用 from Common import HANDLE,仅仅是 HANDLE 指向了 Common 里面 HANDLE 的 值,在其他模块不会在对 HANDLE 赋值的时候，仅仅是 HANDLE的引用指向发生了变化，并没有修改 Common 里面 HANDLE 的 值，说简单了：在其他模块导入from Common import HANDLE，仅仅是定义了 一个 HANDLE 变量；如果你在 Common 里面定义一个列表 list(),在其他模块导入列表的时候，在使用上是 使用列表的一些方法 对列表进行增加与减少，那么在其他模块 列表是会发生变化的

    • 解决办法：在其他模块 import Common导入就不会有问题了，再使用 HANDLE 就是 Common. HANDLE,指向的是 Common 这个模块

    • 效果：在Test1与Test2 使用import Common导入， Common. HANDLE 调用

      HANDLE在Common里面最初的值为 False
      ********************
      在 Test 里面修改HANDLE为：True
      ********************
      True
      在Test2里面 HANDLE 变为 True
      ********************
      HANDLE为 True
      

四、再议 封装、继承、多态

• 4.1、为啥要封装？
  

  

  1
  
  
  

  2
  • 好处

  • 1、在使用面向过程编程时，当需要对数据处理时，需要考虑用哪个模板中哪个函数来进行操作，但是当用面向对象编程时，因为已经将数据存储到了这个独立的空间中，这个独立的空间（即对象）中通过一个特殊的变量（__class__）能够获取到类（模板），而且这个类中的方法是有一定数量的，与此类无关的将不会出现在本类中，因此需要对数据处理时，可以很快速的定位到需要的方法是谁 这样更方便
  • 2、全局变量是只能有1份的，多很多个函数需要多个备份时，往往需要利用其它的变量来进行储存；而通过封装 会将用来存储数据的这个变量 变为了对象中的一个“全局”变量，只要对象不一样那么这个变量就可以再有1份，所以这样更方便
  • 3、代码划分更清晰

• 4.2、为啥要继承
  

  

  要继承的原因
  • 说明:

  1、能够提升代码的重用率，即开发一个类，可以在多个子功能中直接使用
  2、继承能够有效的进行代码的管理，当某个类有问题只要修改这个类就行，而其继承这个类的子类往往不需要就修改

• 4.3、怎样理解多态

  class MiniOS(object):
        """MiniOS 操作系统类 """
        def __init__(self, name):
             self.name = name
             self.apps = []  # 安装的应用程序名称列表
  
        def __str__(self):
             return "%s 安装的软件列表为 %s" % (self.name, str(self.apps))
  
        def install_app(self, app):
               # 判断是否已经安装了软件
               if app.name in self.apps:
                    print("已经安装了 %s，无需再次安装" % app.name)
               else:
                    app.install()
                    self.apps.append(app.name)
  
  
  class App(object):
        def __init__(self, name, version, desc):
              self.name = name
              self.version = version
              self.desc = desc
  
        def __str__(self):
              return "%s 的当前版本是 %s - %s" % (self.name, self.version, self.desc)
  
        def install(self):
              print("将 %s [%s] 的执行程序复制到程序目录..." % (self.name, self.version))
  
  class PyCharm(App):
        pass
  
  class Chrome(App):
        def install(self):
             print("正在解压缩安装程序...")
             super().install()
  
  
  linux = MiniOS("Linux")
  print(linux)
  
  pycharm = PyCharm("PyCharm", "1.0", "python 开发的 IDE 环境")
  chrome = Chrome("Chrome", "2.0", "谷歌浏览器")
  
  linux.install_app(pycharm)
  linux.install_app(chrome)
  linux.install_app(chrome)
  
  print(linux)
  

  运行结果

  Linux 安装的软件列表为 []
  将 PyCharm [1.0] 的执行程序复制到程序目录...
  正在解压缩安装程序...
  将 Chrome [2.0] 的执行程序复制到程序目录...
  已经安装了 Chrome，无需再次安装
  Linux 安装的软件列表为 ['PyCharm', 'Chrome']
  

  提示：
  

  

  多态的理解
  
  在理解多态的时候，相比前两者有点困难，我们可以简单的理解为，我们继承父类之后就拥有了父类的方法，如果父类的方法不能满足的时候，我们可以重写父类的方法，那么父类的方法就不会走了；如果你还想用父类的方法，那么久需要在重写父类的方法下面调用父类的方法，具体是先调用父类的方法，还是后调用父类的方法，那要看我们的处理了
  多态的基础理解