运维初学PythonDay08

生成器yield读取文件

def gen_file(fname):
    list01=[]
    with open(fname,mode="r") as f:#打开文件
        for line in f.readlines(): 遍历
            list01.append(line)#追加
            if len(list01)==10:#看长度
                yield list01#返回
                list01.clear()#清空
    if len(list01)!=0:
        yield list01
if __name__ == '__main__':
    gen=gen_file("/etc/passwd")
    for i in gen:
        print(i)

自定义模块

我们自定义的模块不与系统定义的模块名同名

自定义模块的导入 export PYTHONPATH=/xx/xxx/xx

import /xxx/xxx/xx

hashlib模块

.hexdigest()#

字符串.encode()

""字符串

b""字节串

一次性计算hashlib.md5(b"123456") print(a.hexdigest())以十六进制方式显示

分批计算大文件读取校验md5值

import hashlib
def get_md5(fname):
    m=hashlib.md5()
    with open(fname,mode="rb") as f1:
        while 1:
            data=f1.read(4*4096)
            if len(data)==0:
                break
            m.update(data)
    return m.hexdigest()
if __name__ == '__main__':
    print(get_md5("/etc/hosts"))

tarfile模块

打包

tar=tarfile.open("路径",mode="w:gz")

tar.add("XX/XX")#添加文件

tarfilr.close()

解包

tar=tarfile.open("路径",mode="r")

tar.extractall(path="/opt")

tarfilr.close()

with tarfile.open("/opt/xx.tar.gz",mode="w:gz") as f1:

f1.add("/etc/passwd")

面向过程

以事件为中心 把所有步骤分析出来 然后用函数把这些步骤实现，在一步一步的具体步骤中再按顺序调用函数。所有事情都是自己做 注重过程 不注重职责分工

面向对象

以对象为中心 描述某个对象的行为方法

类和对象 都是面向对象的编程

特征-----属性

行为------方法

类是模板 对象是根据类模板创建出来的 先有类 再有对象

类只有一个 对象可以有多个

类中定义了什么属性和方法 对象就有什么属性和方法 不会多也不会少

类三要素

类名 事物的名字 满足大驼峰

1. 每一个单词的首字母大写

1. 单词与单词之间没有下划线

属性 特征

方法 行为

方法：类中定义的函数

函数：类外部定义的函数

面向对象三大特性

1. 封装 根据 职责 将 属性 和 方法 封装 到一个抽象的 类 中

1. 继承 实现代码的重用，相同的代码不需要重复的编写

1. 多态 不同的对象调用相同的方法，产生不同的执行结果，增加代码的灵活度

语法结构

定义只包含方法的类

• 方法 的定义格式和之前学习过的 函数 的定义几乎一样

• 区别在于第一个参数必须是 self

class 类名: def 方法1(self, 参数列表): pass def 方法2(self, 参数列表): pass

class Print:
    def print_1(self):
        print(f"a.color:{self.color}")
if __name__ == '__main__':
    a=Print()#创建对象： 类名()
    a.color = "yellow"
    a.print_1()#对象.方法名
    b=Print()#创建对象： 类名()
    b.color = "red"
    b.print_1()

self哪个对象调用的方法就返回给哪个对象

但是 这是错的因为属性还在外面 不符合类的定义

正确的应该这样写

class Print:
    def __init__(self,color): #初始化
        self.color = color
    def print_1(self):
        print(f"a.color:{self.color}")
if __name__ == '__main__':
    a=Print("red")#创建对象： 类名(给init去传参)
    a.print_1()#对象.方法名

• 在日常开发中，不推荐在 类的外部 给对象增加属性

• 如果在运行时，没有找到属性，程序会报错

• 对象应该包含有哪些属性，应该 封装在类的内部

• 当使用 类名() 创建对象时，会 自动 执行以下操作：

1. 为对象在内存中 分配空间 —— 创建对象

1. 为对象的属性 设置初始值 —— 初始化方法(init)

• 这个 初始化方法 就是 __init__ 方法，__init__ 是对象的内置方法

• __init__ 方法是 专门 用来定义一个类 具有哪些属性的方法！

游戏人物角色类实现

class youxi:
    def __init__(self,name,wq):
        self.name=name
        self.wq=wq
        #self.dx=dx
    def gongji(self,dx):
        print(f"我是: {self.name} 用的武器是: {self.wq}准备攻击：{dx}")
a= youxi("李明翰","魔法棒子")
a.gongji("123")
b= youxi("李明","魔法")
b.gongji("456")

总结就是 类里把属性放在初始化函数里 动作方法放在一个函数里

用创建的对象去传形式参数到init里面对象.动作去调用 类中设置好的属性和方法

组合

将两个类组合 让一个类作为另一个类的属性

代码如下：

class youxi:
    def __init__(self,name,wq,gjl):
        self.name=name
        self.wq=wq
        self.gjl=gjl
        #self.dx=dx
    def gongji(self,dx):
        print(f"我是: {self.name} 用的武器是: {self.wq.wname}准备攻击：{dx}造成伤害为：{self.gjl.gjl}")
class wuqi:
    def __init__(self,wname,gjl):
        self.wname=wname
        self.gjl=gjl
if __name__ == '__main__':
    w1=wuqi("6666","9999")
    a= youxi("李明翰",w1,w1)
    a.gongji("123")

继承

class 类名 （父类名）：

class role:
    def __init__(self,name,nl):
        self.name=name
        self.nl=nl
    def show_me(self):
        print(f"名字:{self.name} 年龄:{self.nl}")
class zi(role):
    def gongji(self,who):
        print(f"我是{self.name}在与{who}XXXX")
class zizi(role):
    def gongji(self, who):
        print(f"我是{self.name}在与{who}XXXX")
if __name__ == '__main__':
    a=zi("yhl","22")
    a.show_me()
    a.gongji("司马")
    b=zizi("yyy","777")
    b.gongji("诸葛")

子类没有方法与属性用pass代替必须有东西：代表了层级因为

子类有东西先调用子类的

子类调用父类的init

父类名.__init__()

你需要知道

1 在OOP编程时，常用的magic魔法方法有哪些？

__init__初始化

__str__打印返回字符串

__call__用于创建可调用的实例

2 OOP编程，什么是组合，什么是派生？

组合就是让不同的类混合并加入到其他类中 增加代码的重用（一个类调用另一个类）

继承可以继承父类属性和方法

3 在OOP编程时，什么时候使用组合，什么时候使用派生？

• 当类之间有显著的不同，并且较小的类是较大的类所需要的组件时组合表现得很好

• 但当设计“相同的类但有一些不同的功能”时，使用派生