sed 作业;掌握 函数式编程,文件处理,tag用法,程序解耦

sed作业 : 对文件实现查找,修改的功能

import os            ### 为了修改后面的文件名

def fetch(date):
    # print(‘\033[1;44m这是查询功能\033[0m‘)
    # print(‘\033[1;44m用户输入的数据是%s\033[0m‘%date)
    backend_date = ‘backend %s‘%date
    with open(‘haproxy.conf‘,‘r‘) as read_f:
        tag = False
        ret = []
        for read_line in read_f:
            if read_line.strip() == backend_date:
                tag = True
                continue
            if tag and read_line.startswith(‘backend‘):
                break
            if tag:
                print(‘\033[1;45m%s\033[0m‘%read_line,end=‘‘)
                ret.append(read_line)
    return ret

def add():
    pass

def change(date):
    ### 用户输入的date是[{‘backend‘:‘www.oldboy1.org‘,‘record‘:{‘server‘:‘2.2.2.5‘,‘weight‘:30,‘maxconn‘:4000}},{‘backend‘:‘www.oldboy1.org‘,‘record‘:{‘server‘:‘2.2.2.8‘,‘weight‘:30,‘maxconn‘:4000}}]
    # print(‘这是修改功能‘)
    # print(‘用户输入的数据是%s‘%date)
    backend = date[0][‘backend‘]     ### 文件中的一条记录 www.oldboy1.org
    backend_date = ‘backend %s‘ %backend
    ## ,‘record‘: ‘server 2.2.2.5 2.2.2.5 weight 30 maxconn 4000‘
    old_server_record = ‘%sserver %s %s weight %s maxconn %s\n‘ %(‘ ‘*8,date[0][‘record‘][‘server‘],
                                                                   date[0][‘record‘][‘server‘],
                                                                   date[0][‘record‘][‘weight‘],
                                                                   date[0][‘record‘][‘maxconn‘])
    print(‘用户想要修改的记录是:‘,old_server_record)
    new_server_record =  ‘%sserver %s %s weight %s maxconn %s\n‘ % (‘ ‘ * 8, date[1][‘record‘][‘server‘],
                                                                 date[1][‘record‘][‘server‘],
                                                                 date[1][‘record‘][‘weight‘],
                                                                 date[1][‘record‘][‘maxconn‘])
    print(‘用户要修改成的结果是:‘,new_server_record)
    res = fetch(backend)
    print(‘来自change函数--->‘,res)
    # if not res:
    #     print(‘你要修改的记录不存在‘)
    # if old_backend_record in res:
    #     print(‘你要修改的记录不存在‘)    ### 二个return 一样 可合并
    if not res or old_server_record not in res:
        return ‘你要修改的记录不存在‘
    else:
        index = res.index(old_server_record)   ### 根据值取索引
        res[index] = new_server_record    ###  把要改的那条  根据索引更改值
        # print(‘列表中的值已经修改‘)
    res.insert(0,‘%s\n‘%backend_date)  ### 把开头头加进去
    with open(‘haproxy.conf‘,‘r‘) as read_f,            open(‘haproxy.conf_new‘,‘w‘) as write_f:
        tag = False
        has_write = False
        for read_line in read_f:
            if read_line.strip() == backend_date:
                tag = True
                continue
            if tag and read_line.startswith(‘backend‘):
                tag = False
            if not tag:
                write_f.write(read_line)
            else:
                if not has_write:     ###  为防止遇到一个sever,就写一次 ,在写一个状态
                    for record in res:
                        write_f.write(record)
                    has_write = True
    os.rename(‘haproxy.conf‘,‘haproxy.conf.bak‘)
    os.rename(‘haproxy.conf_new‘,‘haproxy.conf‘)
    os.remove(‘haproxy.conf.bak‘)

def delate():
    pass

if __name__ == ‘__main__‘:
    msg = ‘‘‘
    1:查询
    2:修改
    3:添加
    4:删除
    5:退出
    ‘‘‘
    msg_dic = {
        ‘1‘:fetch,
        ‘2‘:change,
        ‘3‘:add,
        ‘4‘:delate
    }
    while True:
        print(msg)
        choice = input(‘请输入你的选项:‘).strip()
        if not choice:
            continue
        if choice == ‘5‘:
            break
        date = input(‘请输入你的数据:‘).strip()
        if choice != ‘1‘:
            date = eval(date)
        res = msg_dic[choice](date)
        print(res)

不使用程序解耦

import os            ### 为了修改后面的文件名
def fild_handler(backend_date,res = None,type = ‘fetch‘):
    if type == ‘fetch‘:
        with open(‘haproxy.conf‘, ‘r‘) as read_f:
            tag = False
            ret = []
            for read_line in read_f:
                if read_line.strip() == backend_date:
                    tag = True
                    continue
                if tag and read_line.startswith(‘backend‘):
                    break
                if tag:
                    print(‘\033[1;45m%s\033[0m‘ % read_line, end=‘‘)
                    ret.append(read_line)
        return ret
    elif type == ‘change‘:
        with open(‘haproxy.conf‘, ‘r‘) as read_f,                 open(‘haproxy.conf_new‘, ‘w‘) as write_f:
            tag = False
            has_write = False
            for read_line in read_f:
                if read_line.strip() == backend_date:
                    tag = True
                    continue
                if tag and read_line.startswith(‘backend‘):
                    tag = False
                if not tag:
                    write_f.write(read_line)
                else:
                    if not has_write:  ###  为防止遇到一个sever,就写一次 ,在写一个状态
                        for record in res:
                            write_f.write(record)
                        has_write = True
        os.rename(‘haproxy.conf‘, ‘haproxy.conf.bak‘)
        os.rename(‘haproxy.conf_new‘, ‘haproxy.conf‘)
        os.remove(‘haproxy.conf.bak‘)

def fetch(date):
    # print(‘\033[1;44m这是查询功能\033[0m‘)
    # print(‘\033[1;44m用户输入的数据是%s\033[0m‘%date)
    backend_date = ‘backend %s‘%date
    return fild_handler(backend_date)

def add():
    pass

def change(date):
    ### 用户输入的date是[{‘backend‘:‘www.oldboy1.org‘,‘record‘:{‘server‘:‘2.2.2.5‘,‘weight‘:30,‘maxconn‘:4000}},{‘backend‘:‘www.oldboy1.org‘,‘record‘:{‘server‘:‘2.2.2.8‘,‘weight‘:30,‘maxconn‘:4000}}]
    # print(‘这是修改功能‘)
    # print(‘用户输入的数据是%s‘%date)
    backend = date[0][‘backend‘]     ### 文件中的一条记录 www.oldboy1.org
    backend_date = ‘backend %s‘ %backend
    ## ,‘record‘: ‘server 2.2.2.5 2.2.2.5 weight 30 maxconn 4000‘
    old_server_record = ‘%sserver %s %s weight %s maxconn %s\n‘ %(‘ ‘*8,date[0][‘record‘][‘server‘],
                                                                   date[0][‘record‘][‘server‘],
                                                                   date[0][‘record‘][‘weight‘],
                                                                   date[0][‘record‘][‘maxconn‘])
    print(‘用户想要修改的记录是:‘,old_server_record)
    new_server_record =  ‘%sserver %s %s weight %s maxconn %s\n‘ % (‘ ‘ * 8, date[1][‘record‘][‘server‘],
                                                                 date[1][‘record‘][‘server‘],
                                                                 date[1][‘record‘][‘weight‘],
                                                                 date[1][‘record‘][‘maxconn‘])
    print(‘用户要修改成的结果是:‘,new_server_record)
    res = fetch(backend)
    print(‘来自change函数--->‘,res)
    # if not res:
    #     print(‘你要修改的记录不存在‘)
    # if old_backend_record in res:
    #     print(‘你要修改的记录不存在‘)    ### 二个return 一样 可合并
    if not res or old_server_record not in res:
        return ‘你要修改的记录不存在‘
    else:
        index = res.index(old_server_record)   ### 根据值取索引
        res[index] = new_server_record    ###  把要改的那条  根据索引更改值
        # print(‘列表中的值已经修改‘)
    res.insert(0,‘%s\n‘%backend_date)  ### 把开头头加进去
    fild_handler(backend_date,res = res,type = ‘change‘)

def delate():
    pass

if __name__ == ‘__main__‘:
    msg = ‘‘‘
    1:查询
    2:修改
    3:添加
    4:删除
    ‘‘‘
    msg_dic = {
        ‘1‘:fetch,
        ‘2‘:change,
        ‘3‘:add,
        ‘4‘:delate
    }
    while True:
        print(msg)
        choice = input(‘请输入你的选项:‘).strip()
        if not choice:
            continue
        if choice == ‘5‘:
            break
        date = input(‘请输入你的数据:‘).strip()
        if choice != ‘1‘:
            date = eval(date)
        res = msg_dic[choice](date)
        print(res)

使用程序解耦

掌握 函数式编程,文件处理,tag用法,程序解耦

原文地址:https://www.cnblogs.com/glh-ty/p/8481547.html

时间: 2024-08-30 14:28:38

sed 作业;掌握 函数式编程,文件处理,tag用法,程序解耦的相关文章

“完全”函数式编程

引子 有了面向对象编程,还需要函数式编程吗 ? 函数式编程,有什么妙处 ? 函数式的理念主要是: 函数式编程是将程序看成是一系列函数的组合.可以将函数作为变量进行赋值,作为函数参数传入,也可以作为返回值返回,函数无处不在. 不可变.函数式编程不会改变传入的对象,返回的也是新创建的对象. 确定性.相同的输入,经过函数式处理后,必然得到相同的输出. 这些理念导致的结果是:函数式编程,更容易达到程序行为可预测和推断的目标. 本文将带着"函数式编程的有色眼镜",重新审视日常的编程结构.重点是以

每天学习一点Scala01_函数式编程

Scala是什么? Scala是一种函数式编程语言.Scala是编程语言中的"凯迪拉克". 什么是函数式编程? 将函数作为程序的"一类"公民. 函数具有与变量和值同样的地位. 函数式编程允许像使用一个变量一样使用函数. 函数式编程允许将一个函数作为参数传递给另一个函数. 函数式编程允许另一个函数将一个函数作为返回值返回. 函数式编程允许在任何地方定义函数,包括在另一个函数内定义一个函数. 函数式编程允许使用一个匿名函数作为参数传递给另一个函数. 函数式编程中的函数是

Python学习笔记八:文件操作(续),文件编码与解码,函数,递归,函数式编程介绍,高阶函数

文件操作(续) 获得文件句柄位置,f.tell(),从0开始,按字符数计数 f.read(5),读取5个字符 返回文件句柄到某位置,f.seek(0) 文件在编辑过程中改变编码,f.detech() 获取文件编码,f.encoding() 获取文件在内存中的编号,f.fileno() 获取文件终端类型(tty.打印机等),f.isatty() 获取文件名,f.name() 判断文件句柄是否可移动(tty等不可移动),f.seekable() 判断文件是否可读,f.readable() 判断文件是

函数式编程(三元运算、文件操作)

一.三元运算 简介: 三元运算又称三目运算,是对简单的条件语句简写,如: #简单条件语句 if 1 < 2: var =1 else: var = 2 print(var) #改成三元运算 var_1 = 1 if 1 < 2 else 2 print(var_1) #输出 1 1 二.文件处理 文件操作分为读.写.修改. 读: #注意这个路径如果不写绝对路径就是与python程序处于同一路径,建议使用绝对路径 #这里一定要注意编码的问题,以什么编码写的要以什么编码打开,否则就是乱码了 #mo

第3课 Scala函数式编程彻底精通及Spark源码阅读笔记

本课内容: 1:scala中函数式编程彻底详解 2:Spark源码中的scala函数式编程 3:案例和作业 函数式编程开始: def fun1(name: String){ println(name) } //将函数名赋值给一个变量,那么这个变量就是一个函数了. val fun1_v = fun1_ 访问 fun1_v("Scala") 结果:Scala 匿名函数:参数名称用 => 指向函数体 val fun2=(content: String) => println(co

PYTHON修饰器的函数式编程

转自:http://coolshell.cn/articles/11265.html Python修饰器的函数式编程 Python的修饰器的英文名叫Decorator,当你看到这个英文名的时候,你可能会把其跟Design Pattern里的Decorator搞混了,其实这是完全不同的两个东西.虽然好像,他们要干的事都很相似--都是想要对一个已有的模块做一些"修饰工作",所谓修饰工作就是想给现有的模块加上一些小装饰(一些小功能,这些小功能可能好多模块都会用到),但又不让这个小装饰(小功能

python_way.day7 模块(configparser,xml,shutil,subprocess)、面向对象(上)(创建类,类的构成,函数式编程与面向对象编程的选择,类的继承)

python_way.day7 1.模块 configparser,xml,shutil,subprocess 2.面向对象(上) 创建类,类的构成,函数式编程与面向对象编程的选择,类的继承 1.模块 configparser 用于处理特定格式的文件,其本职上使用open来操作,只能是  [test1] 特定的格式 [test1] k1 = 123 k2 = True [test2] k1 = 123 k2 = v1 文件内容 1.获取 import configparser #打开文件找到文件

python 入门 - 函数式编程

函数式编程的一个特点就是,允许把函数本身作为参数传入另一个函数,还允许返回一个函数 http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001386819196283586a37629844456ca7e5a7faa9b94ee8000     函数 定义函数 def my_abs(x): if x >= 0: return x else: return -x result =my_

用C++进行函数式编程

近年来函数式编程(Functional Programming,FP)开始获得越来越多的关注,继面向对象编程之后,函数式编程或许会成为下一个编程的主流范式(Programming Paradigm).函数式编程具有代码简洁.开发速度快.更接近自然语言和易于并发编程等优点.目前越来越多的语言开始或增强对函数式编程的支持,如Python.Ruby.Javascript等. 在维基百科中对函数式编程的定义是:In computer science, functional programming is