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

2018-12-13 本文已影响3人 IIronMan

一、私有化

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']

提示：

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

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

猜你喜欢

热点阅读