zoukankan      html  css  js  c++  java
  • Python(27)--文件相关处理的应用(增、删、改、查)

    文件名为message,文件内容如下:

    global
    log 127.0.0.1 local2
    daemon
    maxconn 256
    log 127.0.0.1 local2 info
    defaults
    log global
    mode http
    timeout connect 5000ms
    timeout client 50000ms
    timeout server 50000ms
    option dontlognull
    
    listen stats :8888
    stats enable
    stats uri /admin
    stats auth admin:1234
    
    frontend oldboy.org
    bind 0.0.0.0:80
    option httplog
    option httpclose
    option forwardfor
    log global
    acl www hdr_reg(host) -i www.oldboy.org
    use_backend www.oldboy.org if www
    
    backend www.oldboy1.org
    server 101.1000.7.9 101.1000.7.9 weight 20 maxconn 30
    server 2.2.2.7 2.2.2.7 weight 30 maxconn 4000
    server 10.10.10.1 10.10.10.1 weight 22 maxconn 2000
    server 2.2.2.4 2.2.2.4 weight 20 maxconn 3000
    
    backend www.oldboy2.org
    server 3.3.3.3 3.3.3.3 weight 20 maxconn 3000
    backend www.oldboy20.org
    server 10.10.0.10 10.10.0.10 weight 9999 maxconn 33333333333

    要求:对message文件中的backend内容进行查询、修改、添加和删除操作


    (其中修改操作为:server 2.2.2.4 2.2.2.4 weight 20 maxconn 3000修改为server 2.2.2.5 2.2.2.5 weight 30 maxconn 4000

    [{'backend':'www.oldboy1.org','record':{'server':'2.2.2.4','weight':20,'maxconn':3000}},{'backend':'www.oldboy1.org','record':{'server':'2.2.2.5','weight':30,'maxconn':4000}}]

    程序及其分析如下:

     1 import os
     2 def inquire(data):                                    #对文件信息进行查询函数
     3     print('欢迎使用查询功能')
     4     backend_data ='backend %s'%data                 #对输入的data进行拼接,使得www.oldboy1.org==>backend www.oldboy1.org   
     5     with open ('message', 'r', encoding='utf-8') as open_file:    #打开文件
     6         tag = False                                     #设置一个状态,通过状态来标志一种操作 
     7         res = []
     8         for target in open_file:                        #对文件内容进行遍历 
     9             if backend_data == target.strip():  #判断:输入的data是否与文件内容相匹配(文件每一行内容后默认有一个换行符。通过strip函数去掉)
    10                 tag = True                       #一旦找到匹配信息,tag状态发生改变,查询到信息,执行后续打印操作      
    11                 continue
    12             if tag and target.startswith('backend'):   #在tag状态发生改变并且再一次遇到新的backend信息内容时,标志着所查询内容结束
    13                 break
    14             if tag:
    15                 print(target,end='')
    16                 res.append(target)
    17     return res
    18 def modify(data):                                           #对文件信息进行修改函数
    19     print('欢迎使用修改功能')
    20     print('您要修改的记录为%s修改结果为%s'%(data[0],data[1]))
    21     backend = data[0]['backend']
    22     backend_data ='backend %s'%backend
    23     old_record_data = '%sserver %s weight %s maxconn %s
    '%(' '*8,data[0]['record']['server'],        #修改前server数据处理,将字典拼接成字符串
    24                                                            data[0]['record']['weight'],
    25                                                            data[0]['record']['maxconn'])
    26     new_record_data = '%sserver %s weight %s maxconn %s
     ' % (' ' * 8, data[1]['record']['server'],   #修改后server数据处理,将字典拼接成字符串
    27                                                              data[1]['record']['weight'],
    28                                                              data[1]['record']['maxconn'])
    29     res = inquire(backend)   #修改前进行查询,判断修改的记录是否存在                                       
    30     if not res or old_record_data not in res:  #修改记录不存在(backend信息不存在或者backend信息存在但server信息不存在)
    31         print('您修改的记录不存在')
    32     else:                             #以下是通过索引对查询出的列表内容进行修改
    33         index = res.index(old_record_data)
    34         res[index] = new_record_data
    35         res.insert(0, '%s
    ' % backend_data)
    36     with open('message', 'r') as read_file,    #以下是对文件内容进行修改(以读的方式打开message文件,并创建一个新文件messag_new)
    37             open('message_new', 'w') as write_file:
    38         tag = False
    39         had_write = False
    40         for read_line in read_file:                 #对文件进行遍历
    41             if read_line.strip() == backend_data:
    42                 tag = True
    43                 continue
    44             if tag and read_line.startswith('backend'):
    45                 tag = False
    46             if not tag:                        #如果没有遇到修改信息,原文件直接写入新文件
    47                 write_file.write(read_line)
    48             else:                       #如果遇到修改信息,将刚才修改过的列表内容遍历写入新文件
    49                 if not had_write:
    50                     for target in res:
    51                         write_file.write(target)
    52                     had_write = True
    53     os.rename('message','message_old')            #通过对文件重新命名的方式,用修改过的文件覆盖未修改的文件
    54     os.rename('message_new','message')
    55     os.remove('message_old')
    56     return
    57 def add(data):
    58     print('欢迎使用添加功能')
    59     print('您要添加的数据是%s'%data)
    60 def delete(data):
    61     print('欢迎使用删除功能')
    62     print('您要删除的数据是%s'%data)
    63 if __name__ == '__main__':                  #python程序的入口
    64     retrieve_information = '''               
    65     1:查询
    66     2:修改
    67     3:添加
    68     4:删除
    69     5:退出
    70     '''                                      #设置检索信息
    71     retrieve_information_dic = {
    72         '1':inquire,
    73         '2':modify,
    74         '3':add,
    75         '4':delete,
    76     }
    77     while True:                             #用户循环输入操作
    78         print(retrieve_information)
    79         choice = input('请输入您想要执行操作的序号==>').strip()
    80         if not choice:continue                  
    81         if choice == '5':break
    82         data = input('请输入信息==>').strip()
    83         if choice != '1':                    #输入信息为字符串,如果是查询操作,不需要对信息进行处理
    84             data = eval(data)
    85         res = retrieve_information_dic[choice](data)         #调用想要的函数,并将返回值赋给res
    86         print(res)

    我们在写程序的时候,要注意吧一个功能封装为一个函数。

    一是有利于程序的可读性

    二是有利于程序可移植性

    我们在上述程序中发现,在对文件进行查询和修改操作过程中,存在大量文件操作,

    我们把其中文件操作的程序单独拿出来,定义一个文件处理的函数

    其实这就是文件的解耦

    数据之间的耦合带来的最大问题就是可读性很差,一堆程序,不知道要表达什么意思

    修改后的程序如下:

     1 import os
     2 def file_handler(backend_data, res = None ,type = 'inquire'):    #新增加了文件处理函数
     3     if type == 'inquire':
     4         with open('message', 'r', encoding='utf-8') as open_file:
     5             tag = False
     6             res = []
     7             for target in open_file:
     8                 if backend_data == target.strip():
     9                     tag = True
    10                     continue
    11                 if tag and target.startswith('backend'):
    12                     break
    13                 if tag:
    14                     print(target, end='')
    15                     res.append(target)
    16         return res
    17     elif type == 'modify':
    18         with open('message', 'r') as read_file, 
    19                 open('message_new', 'w') as write_file:
    20             tag = False
    21             had_write = False
    22             for read_line in read_file:
    23                 if read_line.strip() == backend_data:
    24                     tag = True
    25                     continue
    26                 if tag and read_line.startswith('backend'):
    27                     tag = False
    28                 if not tag:
    29                     write_file.write(read_line)
    30                 else:
    31                     if not had_write:
    32                         for target in res:
    33                             write_file.write(target)
    34                         had_write = True
    35         os.rename('message', 'message_old')
    36         os.rename('message_new', 'message')
    37         os.remove('message_old')
    38 def inquire(data):
    39     print('欢迎使用查询功能')
    40     backend_data ='backend %s'%data
    41     return file_handler(backend_data)       #直接调用文件处理函数即可
    42 def modify(data):
    43     print('欢迎使用修改功能')
    44     print('您要修改的记录为%s修改结果为%s'%(data[0],data[1]))
    45     backend = data[0]['backend']
    46     backend_data ='backend %s'%backend
    47     old_record_data = '%sserver %s weight %s maxconn %s
    '%(' '*8,data[0]['record']['server'],
    48                                                            data[0]['record']['weight'],
    49                                                            data[0]['record']['maxconn'])
    50     new_record_data = '%sserver %s weight %s maxconn %s
     ' % (' ' * 8, data[1]['record']['server'],
    51                                                              data[1]['record']['weight'],
    52                                                              data[1]['record']['maxconn'])
    53     res = inquire(backend)
    54     if not res or old_record_data not in res:
    55         print('您修改的记录不存在')
    56     else:
    57         index = res.index(old_record_data)
    58         res[index] = new_record_data
    59         res.insert(0, '%s
    ' % backend_data)
    60     file_handler(backend_data,res = res,type = 'modify')
    61 def add(data):
    62     print('欢迎使用添加功能')
    63     print('您要添加的数据是%s'%data)
    64 def delete(data):
    65     print('欢迎使用删除功能')
    66     print('您要删除的数据是%s'%data)
    67 if __name__ == '__main__':
    68     retrieve_information = '''
    69     1:查询
    70     2:修改
    71     3:添加
    72     4:删除
    73     5:退出
    74     '''
    75     retrieve_information_dic = {
    76         '1':inquire,
    77         '2':modify,
    78         '3':add,
    79         '4':delete,
    80     }
    81     while True:
    82         print(retrieve_information)
    83         choice = input('请输入您想要执行操作的序号==>').strip()
    84         if not choice:continue
    85         if choice == '5':break
    86         data = input('请输入信息==>').strip()
    87         if choice != '1':
    88             data = eval(data)
    89         res = retrieve_information_dic[choice](data)
    90         print(res)

    虽然程序长短没什么变化,可是可读性变好了许多

  • 相关阅读:
    散列算法
    【转】认证 (authentication) 和授权 (authorization) 的区别
    Filter和interceptor比较
    【转】深入理解Spring的两大特征(IOC和AOP)
    [转]web.xml中servlet ,filter ,listener ,interceptor的作用与区别
    线程同步
    Java容器
    进程间交互的几种方式
    JSP和Servlet的区别
    IPC介绍
  • 原文地址:https://www.cnblogs.com/guoruxin/p/10114547.html
Copyright © 2011-2022 走看看