python:模块加载、hashlib模块、tarfile模块、os.walk方法、面向对象的编程（组合、继承）

模块

• 文件是物理上组织代码的形式，模块就是逻辑上组织代码的形式。模块名是文件名去掉.py。

python导入模块时，将会从以下两个位置搜索模块：

• sys.path定义的路径
• PYTHONPATH环境变量定义的路径

>>> import sys
>>> sys.path
['', '/usr/local/lib/python36.zip', '/usr/local/lib/python3.6', '/usr/local/lib/python3.6/lib-dynload', '/usr/local/lib/python3.6/site-packages']

常用的导入方法

>>> import os
>>> from time import strftime

不常用的导入方法

>>> import random, datetime
>>> import pickle as p

导入和加载

• import是导入
• load是加载。加载就是将模块中的代码运行一遍
• 不管导入多少次，只会加载一次。

hashlib模块
计算哈希值的模块。

• hash哈希是单向加密的算法。

• 通过原始数据可以生成固定长度的乱码

• 原始数据相同，乱码也一定相同

• 原始数据有微小的不同，乱码也一定完全不同

• 不能通过乱码反推回原始数据

• 常用的算法有：md5、sha（均为单向加密算法）

• 经常用于：存储加密密码、文件完整性校验

>>> import hashlib
>>> m = hashlib.md5(b'123456')		#校验数据时要求是bash类型
>>> m.hexdigest()		#以十六进制（hex）数的形式返回md5值
'e10adc3949ba59abbe56e057f20f883e'

#如果需要计算的数据量非常大，可以分批量进行更新
>>> m1 = hashlib.md5()
>>> m1.update(b'12')
>>> m.hexdigest()
'e10adc3949ba59abbe56e057f20f883e'
>>> m1.update(b'34')
>>> m.hexdigest()
'e10adc3949ba59abbe56e057f20f883e'
>>> m1.update(b'56')
>>> m.hexdigest()
'e10adc3949ba59abbe56e057f20f883e'

案例：校验数据一致性

[root@room9pc01 day08]# vim check_md5.py
import hashlib
import sys

def check_md5(fname):
    m = hashlib.md5()

    with open(fname, 'rb') as fobj:
        while True:
            data =fobj.read(4096)
            if not data:
                break

            m.update(data)

    return m.hexdigest()

if __name__ == '__main__':
    print(check_md5(sys.argv[1]))
[root@room9pc01 day08]# python3 check_md5.py /etc/passwd
710e1b6731bb6d457c6bce0f9835830a

tarfile模块
实现归档压缩功能，支持gzip、bzip2、lzma格式的压缩。

>>> import tarfile
>>> tar = tarfile.open('/tmp/demo/myfile.tar.gz', 'w:gz')
>>> tar.add('/etc/security')
>>> tar.add('/etc/hosts')
>>> tar.close()
>>> tar = tarfile.open('/tmp/demo/myfile.tar.gz', 'r')
>>> tar.extractall('/tmp/demo')		#不指定解压目标目录，默认解压当前目录
>>> tar.close()
[root@room9pc01 day08]# ls /tmp/demo
etc  myfile.tar.gz
[root@room9pc01 day08]# cd /tmp/demo/etc/
[root@room9pc01 etc]# ls
hosts  security

os.walk方法

>>> os.walk('/tmp/demo/security')

>>> list(os.walk('/tmp/demo/security'))
[('/tmp/demo/security', ['console.apps', 'console.perms.d', 'limits.d', 'namespace.d'], ['access.conf', 'chroot.conf', 'console.handlers', 'console.perms', 'group.conf', 'limits.conf', 'namespace.conf', 'namespace.init', 'opasswd', 'pam_env.conf', 'sepermit.conf', 'time.conf', 'pwquality.conf']), ('/tmp/demo/security/console.apps', [], ['config-util', 'xserver', 'liveinst', 'setup']), ('/tmp/demo/security/console.perms.d', [], []), ('/tmp/demo/security/limits.d', [], ['20-nproc.conf']), ('/tmp/demo/security/namespace.d', [], [])]
>>> a = list(os.walk('/tmp/demo/security'))
>>> len(a)
5
>>> a[0]
('/tmp/demo/security', ['console.apps', 'console.perms.d', 'limits.d', 'namespace.d'], ['access.conf', 'chroot.conf', 'console.handlers', 'console.perms', 'group.conf', 'limits.conf', 'namespace.conf', 'namespace.init', 'opasswd', 'pam_env.conf', 'sepermit.conf', 'time.conf', 'pwquality.conf'])
>>> a[1]
('/tmp/demo/security/console.apps', [], ['config-util', 'xserver', 'liveinst', 'setup'])

os.walk()方法返回的数据由多个元组构成。每个元组又有三项，这三项分别是：路径字符串、该路径下的目录列表、该路径下的文件列表。

>>> list(os.walk('/tmp/demo/security'))
[
    ('父目录', ['父目录下的子目录列表'], ['父目录下的文件列表']),
    ('子目录1', ['子目录1下的孙目录列表'], ['子目录下的文件列表']),
    ('子目录2', ['子目录2下的孙目录列表'], ['子目录下的文件列表']),
]

>>> for path, folders, files in os.walk('/tmp/demo/etc'):
...   for file in files:
...     os.path.join(path, file)
... 
'/tmp/demo/etc/hosts'
'/tmp/demo/etc/security/namespace.conf'
'/tmp/demo/etc/security/sepermit.conf'
'/tmp/demo/etc/security/group.conf'
'/tmp/demo/etc/security/limits.conf'
'/tmp/demo/etc/security/time.conf'
'/tmp/demo/etc/security/access.conf'
'/tmp/demo/etc/security/pwquality.conf'
'/tmp/demo/etc/security/console.handlers'
'/tmp/demo/etc/security/opasswd'
'/tmp/demo/etc/security/chroot.conf'
'/tmp/demo/etc/security/console.perms'
'/tmp/demo/etc/security/pam_env.conf'
'/tmp/demo/etc/security/namespace.init'
'/tmp/demo/etc/security/console.apps/setup'
'/tmp/demo/etc/security/console.apps/xserver'
'/tmp/demo/etc/security/console.apps/config-util'
'/tmp/demo/etc/security/console.apps/liveinst'
'/tmp/demo/etc/security/limits.d/20-nproc.conf'

OOP：面向对象的编程
基本概念
• 类(Class):用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方
法。对象是类的实例。
• 实例化:创建一个类的实例,类的具体对象。
• 方法:类中定义的函数。
• 对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。

创建类
• 使用 class 语句来创建一个新类,class 之后为类的
名称并以冒号结尾
• 类名建议使用驼峰形式

class	BearToy:
        pass

创建实例
• 类是蓝图,实例是根据蓝图创建出来的具体对象
如果使用以前所学知识，可以定义字典保存人物属性，创建函数定义人物的行为：

tidy = BearToy()

• OOP的思想，是将现实世界的物体抽象成一个类class，这个类中有属性和行为，将数据和行为融合到一起。相当于创建了一个蓝图，然后再根据蓝图创建出具体的实例。
• __init___方法一般用于为实例对象绑定属性。当创建实例的时候，__init__方法自动调用，实例（lvbu）会作为第一个参数(self)传递。self不是关键字，java用this，但是都不是必须的名字，可以随意更换。一旦创建了实例，实例就会自动拥有类中定义的属性和方法（函数）。

>>> class GameCharacter:
...   def __init__(self, name, weapon):
...      self.name = name
...      self.weapon = weapon
...   def speak(self, word):
...      print('我是%s， %s' % (self.name, word))
... 
>>> lvbu = GameCharacter('吕布', '方天画戟')
>>> lvbu.name
'吕布'
>>> lvbu.weapon
'方天画戟'
>>> lvbu.speak('人在塔在')
我是吕布, 人在塔在
>>> guanyu = GameCharacter('关羽', '青龙偃月刀')
>>> guanyu.name
'关羽'
>>> guanyu.weapon
'青龙偃月刀'
>>> guanyu.speak('呵呵')
我是关羽, 呵呵
##############################################################
[root@room9pc01 day08]# vim game.py
class GameCharacter:
    def __init__(self, name, weapon):
        self.name = name
        self.weapon = weapon

    def speak(self, word):
        print('我是%s, %s' % (self.name, word))

    def walk(self):
        print('我有%s， 我能走' % self.weapon)

if __name__ == '__main__':
    lvbu =GameCharacter('吕布','方天画戟')
    print(lvbu.name)
    print(lvbu.weapon)
    lvbu.speak('人在塔在')
    lvbu.walk()
    guanyu = GameCharacter('关羽', '青龙偃月刀')
    print(guanyu.name)
    print(guanyu.weapon)
    guanyu.speak('呵呵')
[root@room9pc01 day08]# python3 game.py
吕布
方天画戟
我是吕布, 人在塔在
我有方天画戟， 我能走
关羽
青龙偃月刀
我是关羽, 呵呵

什么是组合
• 类被定义后,目标就是要把它当成一个模块来使用，并把这些对象嵌入到你的代码中去
• 组合就是让不同的类混合并加入到其它类中来增加功能和代码重用性
• 可以在一个大点的类中创建其它类的实例，实现一些其它属性和方法来增强对原来的类对象

[root@room9pc01 day08]# vim game2.py
class Weapon:
    def __init__(self, wname, strength, type):
        self.name = wname
        self.strength = strength
        self.type = type

class GameCharacter:
    def __init__(self, name, weapon):
        self.name = name
        self.weapon = weapon

    def speak(self, word):
        print('我是%s, %s' % (self.name, word))

if __name__ == '__main__':
    ji =Weapon('方天画戟', 100, '物理攻击')
    lvbu = GameCharacter('吕布', ji)    #ji是Weapon类的实例，作为GameCharacte类的组件，实现将Weapon（武器）类实例绑定到Gamecharacter（游戏角色）类实例
    print(lvbu.weapon.name)
    print(lvbu.weapon.type)
    print(lvbu.weapon.strength)
    guanyu = GameCharacter('关羽','大刀')
    guanyu.speak('呵呵')
[root@room9pc01 day08]# python3 game2.py 
方天画戟
物理攻击
100
我是关羽, 呵呵

继承

• 当两个类有很多相似之处，只有一部分不同，使用继承。
• 子类可以有多个父类。当多个类有同名方法的时候，查找的顺序是自下向上，自左向右。

[root@room9pc01 day08]# vim game3.py
class GameCharacter:
    def __init__(self, name, weapon):
        self.name = name
        self.weapon = weapon

    def speak(self, word):
        print('我是%s, %s' % (self.name, word))

class Warrior(GameCharacter):  # 括号中指定父类(基类)
    def attack(self):
        print('近身肉搏')

class Mage(GameCharacter):
    def attack(self):
        print('远程攻击')

if __name__ == '__main__':
    gl = Warrior('盖伦', '大刀')
    tm = Mage('提莫', '蘑菇')
    gl.speak('人在塔在')
    gl.attack()
    tm.speak('我去前面用脸探探路')
    tm.attack()
[root@room9pc01 day08]# python3 game3.py
我是盖伦, 人在塔在
近身肉搏
我是提莫, 我去前面用脸探探路
##########################################################################
[root@room9pc01 day08]# vim myclass.py
class A:
    def foo(self):
        print('a foo')

class B:
    def bar(self):
        print('b bar')

class C(B, A):
    pass
  
if __name__ == '__main__':
    c1 = C()
    c1.foo()
    c1.bar()
[root@room9pc01 day08]# python3 myclass.py
a foo
b bar
###################################################################
[root@room9pc01 day08]# vim myclass.py
class A:
    def foo(self):
        print('a foo')

    def fn1(self):
        print('a fn')

class B:
    def bar(self):
        print('b bar')

    def fn1(self):
        print('b fn')

class C(B, A):
    pass
    def fn1(self):
        print('c fn')

if __name__ == '__main__':
    c1 = C()
    c1.foo()
    c1.bar()
    c1.fn1()
[root@room9pc01 day08]# python3 myclass.py
a foo
b bar
c fn
####################################################################
[root@room9pc01 day08]# vim myclass.py
class A:
    def foo(self):
        print('a foo')

    def fn1(self):
        print('a fn')

class B:
    def bar(self):
        print('b bar')

    def fn1(self):
        print('b fn')

class C(B, A):		#自左向右（自下向上：B—>A）调用父类
    pass
    # def fn1(self):
    #    print('c fn')

if __name__ == '__main__':
    c1 = C()
    c1.foo()
    c1.bar()
    c1.fn1()
[root@room9pc01 day08]# python3 myclass.py
a foo
b bar
b fn
######################################################################
[root@room9pc01 day08]# vim myclass.py
class A:
    def foo(self):
        print('a foo')

    def fn1(self):
        print('a fn')

class B:
    def bar(self):
        print('b bar')

    def fn1(self):
        print('b fn')

class C(A, B):		#自左向右（自上向下：A—>B）调用父类
    pass
    # def fn1(self):
    #    print('c fn')

if __name__ == '__main__':
    c1 = C()
    c1.foo()
    c1.bar()
    c1.fn1()
[root@room9pc01 day08]# python3 myclass.py
a foo
b bar
a fn

正则表达式

#将ip地址对应mac地址用：隔开方式表示
192.168.1.1   00G5C6123456
192.168.1.2   00A5G2127854 


192.168.1.1   00:G5:C6:12:34:56
192.168.1.2   00:A5:G2:12:78:54                                                                         
~                                                                                
~                                                                                
~                                                                                
:%s/\(..\)\(..\)\(..\)\(..\)\(..\)\(..\)$/\1:\2:\3:\4:\5:\6/

/t[a-z]m 匹配t（a-z任意单个字符）m
/t[^0-9]m 匹配t（取反，不是0-9）m
/t\Sm 匹配t（中间一个字符不是空白字符）m
/t\sm 匹配t（中间一个字符是空白字符）m