Python_Day2_列表、字典、文件

一、列表、元组操作
 names = ['zhang', 'wang', 'li', 'gu', 'guan']  
 ○取第1个值names[0]   取第二到第三个names[1:3](取左不取右）----切片  取到最后一个names[1:]    取最后一个names[-1]（两种排序方式，从左至右（0开始），从右至左（-1开始）倒数第二个取到最后一个names[-2:]  从第一个开始取到第二个names[0:2]或names[:2]
 ○插入  names.append('xu')----插入到最后一个    names.insert(1, 'qin')---插入到wang前面
 ○修改  names[2] = 'xie' ----替换新的值
 ○删除  names.remove('gu')；del names[4]；names.pop()---删掉最后一个；names.pop(1)---效果同del names[1]
 ○查询  names.index('li')---返回位置    print(names[names.index('li')])---返回li--先查寻再取用
  可以有重复值
 ○其他操作：统计   print(names.count('wang'))；names.clear()---清空列表；names.reverse()---翻转；names.sort()---排序，默认按ASSCI码升序排序，特殊符号--数字--大写字母--小写字母；names.extend()---扩展，放在末尾，以列表形式增加names.extend(names2)---names2依然存在；删除变量  del names2；
 names3 = names.copy()---输出的names3与names完全相同。修改names时，若修改元素，则names3不变，names[2] = "项“；若修改的元素是列表（列表里面的元素可以是列表），则names3随之改变，原：names = [...,["a","B"],...]，names[3][0] = "A'，此时输出的names3变[...,["A", "B",...]---------称之为浅copy，只是前一个列表的引用
 copy独立模块：完全复制，copy.deepcopy()，形成完全独立的两个列表，占用两份独立空间； copy.copy()----依旧是浅copy，
  import copy
  person = ['name', '['a', 100]
  浅copy的实现方式： p1 = copy.copy(person)；p2 = person[:]；p3 = list(person) 列表循环：for i in names:

    print(i)-----输出列表中所有元素
 print(names[0:-1:2])或print(names[::2])----隔一个输出一个元素值
 

1 import copy
 2 names = ["Sun", "Li", "Ji", [1, 3, 5], "Fan"]
 3 
 4 print(names[::3])
 5 for i in names:
 6     print(i)
 7 name2 = copy.copy(names)    # 浅copy
 8 print(names, name2)
 9 name2[2] = "吉"
10 name2[3][1] = 4
11 print(names, name2)
12 names.append("Lei")     # 在列表末尾插入
13 names.insert(1, "Zhang")    # 在列表位置1处插入
14 names[2] = "Xie"    # 替换
15 names.remove("Sun")     # 删除
16 names.insert(0, "Sun")
17 del names[0]    # 删除
18 names[0] = "Sun"
19 names.pop(0)    # 删除
20 print(names)
21 print(names.index("Ji"))
22 print(names[names.index("Ji")])
23 print(names[1], names[2])
24 print(names[0:2])   # 切片
25 print(names[3])     # 切片
26 print(names[-1])    # 切片
27 print(names[-3:])   # 切片
28 names2 = ['1', '2', '3']
29 names.extend(names2)    # 扩展（合并）列表
30 print(names)
31 names.reverse()     # 翻转列表
32 print(names)
33 '''names.sort()    # 表内数据类型不同时不能排序
34 print(names)'''
35 names.clear()   # 清空列表
36 print(names)
list operate

 1 ['Sun', [1, 3, 5]]
 2 Sun
 3 Li
 4 Ji
 5 [1, 3, 5]
 6 Fan
 7 ['Sun', 'Li', 'Ji', [1, 3, 5], 'Fan'] ['Sun', 'Li', 'Ji', [1, 3, 5], 'Fan']
 8 ['Sun', 'Li', 'Ji', [1, 4, 5], 'Fan'] ['Sun', 'Li', '吉', [1, 4, 5], 'Fan']
 9 ['Xie', 'Ji', [1, 4, 5], 'Fan', 'Lei']
10 1
11 Ji
12 Ji [1, 4, 5]
13 ['Xie', 'Ji']
14 Fan
15 Lei
16 [[1, 4, 5], 'Fan', 'Lei']
17 ['Xie', 'Ji', [1, 4, 5], 'Fan', 'Lei', '1', '2', '3']
18 ['3', '2', '1', 'Lei', 'Fan', [1, 4, 5], 'Ji', 'Xie']
19 []

 

 元组：元组其实跟列表差不多，也是存一组数，只不是它一旦创建，便不能再修改，所以又叫只读列表
 它只有2个方法，一个是count,一个是index。

 product_list.index(item),给每个item从0开始编号
 for index,item in enumerate(product_list)----返回两个值，index是从0开始的编号
 enumerate()---取出列表的下标
 len(product_list)----判断列表的长度，返回一个数值
 \033[31;1m%s\033[0m----把%s代表的字体变成红色，32--绿色
 列表可以嵌套任何数据类型

二、字符串操作str
 a = 'alex'
 a[1]
 >>>'e'----可以像列表那样取值，但不可以赋值
 对字符串的修改不是基于原来的，而是产生新的。

1 name = "My name \tis {name}, and I'm {age} years-old."
 2 
 3 print(name.capitalize())    # 首字母大写,其余小写
 4 print(name.count("s"))      # 字符串中某字符出现的次数，可指定开始结束位置
 5 print(name.casefold())      # 将所有大写字母转换为小写，类似lower()方法
 6 print(name.center(50, "-"))     # 打印50个字符，不够的用-补齐，且将name放于中间
 7 print(name.endswith("C"))   # 判断字符串是否以指定后缀结尾，是True否False，可指定开始结束位置
 8 print(name.startswith("M"))     # 判断字符串是否以指定前缀开始，是True否False，可指定开始结束位置
 9 print(name.expandtabs(tabsize=0))    # 将字符串中的\t转换为指定数量的空格
10 print(name.find("name"))    # 索引字符(串)的开始位置-可用于字符串切片
11 print(name.format(name='SJC', age=18))      # 格式化
12 print(name.format_map({'name': 'SJC', 'age': 18}))  # 可传字典格式
13 print(name.isalnum())       # 检测字符串是否由字母和数字组成
14 print(name.isalpha())       # 检测字符串是否只由字母组成
15 print(name.isdecimal())     # 检查字符串是否只包含十进制字符
16 print(name.isdigit())       # 检测字符串是否只由数字组成
17 print('Name'.isidentifier())  # 判断是否是一个合法的标识符(变量名)
18 print(name.islower())       # 检测字符串是否由小写字母组成
19 print(name.isnumeric())     # 检测字符串是否只由数字组成。这种方法是只针对unicode对象。
20 print(name.istitle())       # 检测字符串是否是标题格式
21 print(name.isupper())       # 检测字符串是否由大写字母组成
22 print(','.join(['1', '2', '3']))      # 将序列(字符串、列表等)中的元素以指定的字符连接生成一个新的字符串 str.join(sequence)
23 print(name.ljust(50, "*"))  # 打印50个字符，不够的用*补齐，将name放于前方
24 print(name.rjust(50, "@"))  # 打印50个字符，不够的用*补齐，将name放于后方
25 print(name.lower())         # 大写换小写
26 print(name.upper())         # 小写换大写
27 print("\nSJC\n".lstrip())   # 从左侧去除空格或回车
28 print("\nSJC\n".rstrip())   # 从右侧去除空格或回测
29 print("\nSJC\n".strip())    # 去除两侧空格或回车
30 p = str.maketrans("SJC", "123")
31 # 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标
32 # 两个字符串的长度必须相同，为一一对应的关系
33 print("SJC".translate(p))   # 用p的映射关系转换字符SJC后输出
34 print("baidu.com".partition("."))  # 据指定的分隔符将字符串进行分割
35 # 如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串
36 print('python is funny'.replace('n', '*', 1))   # 替换且可指定最大替换次数
37 print(name.rfind('a'))     # 从左向右查找，找到最右侧的a并返回其位置
38 print(name.rsplit())
39 print("1+2+3+4".split("+"))     # 将字符串按照要求分割为列表（默认为空字符，可指定其他字符），可指定分割次数
40 print(name.swapcase())      # 大小写互化
41 print(name.title())         # 化成标题格式
42 print(name.zfill(50))       # 从左侧用0填充字符串至指定长度

String Operate

1 My name     is {name}, and i'm {age} years-old.
 2 2
 3 my name     is {name}, and i'm {age} years-old.
 4 ---My name     is {name}, and I'm {age} years-old.---
 5 False
 6 True
 7 My name is {name}, and I'm {age} years-old.
 8 3
 9 My name     is SJC, and I'm 18 years-old.
10 My name     is SJC, and I'm 18 years-old.
11 False
12 False
13 False
14 False
15 True
16 False
17 False
18 False
19 False
20 1,2,3
21 My name     is {name}, and I'm {age} years-old.******
22 @@@@@@My name     is {name}, and I'm {age} years-old.
23 my name     is {name}, and i'm {age} years-old.
24 MY NAME     IS {NAME}, AND I'M {AGE} YEARS-OLD.
25 SJC
26 
27 
28 SJC
29 SJC
30 123
31 ('baidu', '.', 'com')
32 pytho* is funny
33 36
34 ['My', 'name', 'is', '{name},', 'and', "I'm", '{age}', 'years-old.']
35 ['1', '2', '3', '4']
36 mY NAME     IS {NAME}, AND i'M {AGE} YEARS-OLD.
37 My Name     Is {Name}, And I'M {Age} Years-Old.
38 000000My name     is {name}, and I'm {age} years-old.
39 
40 Process finished with exit code 0

Output

 

三、字典操作
 1.字典操作
  字典是一种key-value的数据类型。
   语法：info = {'stu1101':"TengLan Wu",
   'stu1102':"LongZe Luola",
   'stu1103':"XiaoZe Maliya",
   }
  字典的特性：1）dict是无序的；2）key必须是唯一的，所以会自动去掉重复的。
  增删改查
  多级字典嵌套及操作
  key尽量用英文，不要用中文
  catalog.setdefault(key:value)现在字典中查找，若有，则返回取到的值；若没有，则添加，再返回。
  info.update(b)---将字典b和字典info合并到info，若存在交叉（key相同），则覆盖原有的。
  info.items()---把字典转成列表
  dict.fromkeys()----初始化一个新的字典，给初始值
   c = dict.fromkeys([6,7,8],[1,{'name':'alex'},432])
   print(c)
   c[7][1]['name'] = 'Jack Chen'#此时会修改所有的键值
   print(c)
   输出结果：{6: [1, {'name': 'alex'}, 432], 7: [1, {'name': 'alex'}, 432], 8: [1, {'name': 'alex'}, 432]}
   {6: [1, {'name': 'Jack Chen'}, 432], 7: [1, {'name': 'Jack Chen'}, 432], 8: [1, {'name': 'Jack Chen'}, 432]}
  循环字典
   for i in info:
   print(i,info[i])   for k,v in info.items():   print(k,v)

   ---二者输出结果相同，但第一种更高效，数据量大时
  pass---占位符，什么也不做
  

# Author: April
age_of_oldboy = 56

for i in range(3):#i从0开始执行，默认步长为1
    guess_age = int(input("guess age:"))
    if guess_age == age_of_oldboy:
        print("yes, you get it. ")
        break
    elif guess_age > age_of_oldboy:
        print("think smaller...")
    else:
        print("think bigger!")
else:
    print('you have tried too many times...')

#key-value数据类型

'''c = dict.fromkeys([6,7,8],[1,{'name':'alex'},432])
print(c)
c[7][1]['name'] = 'Jack Chen'
print(c)

catalog = {
    '欧美':{'w':['多','大','一般'],
          'y':['多','大','高'],
          'z':['高','真']
          },
    '日韩':{'a':['多','大'],
          'b':['多','大','高'],
          'c':['高','真','一般']
          },
}
catalog['日韩']['a'][1] = '或'
catalog.setdefault('日韩',{'r':[1,2,3]})
print(catalog)
'''

info = {
    'stu1101': "Teng",
    'stu1102': "Long",
    'stu1103': "Xiao",
}
for i in info:
    print(i,info[i])

for k,v in info.items():
    print(k,v)


'''#info['stu1104']
print(info.get('stu1104'))#安全获取键值
print('stu1103' in info)


print(info)
#print(info['stu1101'])
#info['stu1101'] = '藤'
info['stu1104'] = '藤'
#del
#del info['stu1101']
#info.pop('stu1102')
info.popitem()
print(info)
'''

 

四、集合操作
 集合是一个无序的，不重复的数据组合，作用：
  去重---把一个列表变成集合，就自动去重了
  关系测试---测试两组数据之间的交集、差集、并集等关系。

list_1 = [1,4,5,7,3,6,7,9]
list_1 = set(list_1)#转换为集合
print(list_1, type(list_1))

list_2 = set([2,6,0,66,22,8])
print(list_1,list_2)

#交集
print(list_1.intersection(list_2))

#并集
print(list_1.union(list_2))

#差集
print(list_1.difference(list_2)) 

 

1 info = {
2     'stu1101': "SJC",
3     'stu1102': "WRR",
4     'stu1103': "WK"
5 }

1 info = {
 2     'stu1101': "SJC",
 3     'stu1102': "WRR",
 4     'stu1103': "WK"
 5 }
 6 print(info)
 7 print(info['stu1101'])      # 如果key不存在会报错
 8 info['stu1101'] = "ZYH"     # key存在则改其value不存在则新增
 9 print(info)
10 print("stu1104" in info)    # key存在返回True否则返回False
11 print(info.get('stu1104'))      # 如果key不存在会返回None
12 print(info.values())        # 输出所有value
13 print(info.keys())          # 输出所有key
14 print(info.items())         # 字典转列表输出
15 
16 info2 = {
17     'stu1105': "LY",
18     'stu1106': "SJC"
19 }
20 info.update(info2)          # 字典合并有交叉则覆盖
21 print(info)
22 info.setdefault("stu1104", "ZJL")   # key存在则返回其现有值不存在则创建新值及其value
23 print(info)

Operate_ex

1 {'stu1101': 'SJC', 'stu1102': 'WRR', 'stu1103': 'WK'}
 2 SJC
 3 {'stu1101': 'ZYH', 'stu1102': 'WRR', 'stu1103': 'WK'}
 4 False
 5 None
 6 dict_values(['ZYH', 'WRR', 'WK'])
 7 dict_keys(['stu1101', 'stu1102', 'stu1103'])
 8 dict_items([('stu1101', 'ZYH'), ('stu1102', 'WRR'), ('stu1103', 'WK')])
 9 {'stu1101': 'ZYH', 'stu1102': 'WRR', 'stu1103': 'WK', 'stu1105': 'LY', 'stu1106': 'SJC'}
10 {'stu1101': 'ZYH', 'stu1102': 'WRR', 'stu1103': 'WK', 'stu1105': 'LY', 'stu1106': 'SJC', 'stu1104': 'ZJL'}

Output

1 world_map = {
 2     "China": {
 3         "Hebei": ["Northeast", "flat area"],
 4         "Yunnan": ["Southwest", "hilly land"]
 5     },
 6     "Japan": {
 7         "Tokyo": ["Capital", "qqq"],
 8         "Osaka": ["South", "ppp"]
 9     },
10     "America": {
11         "New York": ["Famous of interest", "Statue of Liberty"],
12         "Washington": ["Capital", "White House"]
13     }
14 }
15 world_map["China"]["Hebei"][1] = "Nice"
16 print(world_map)

Multi_level_dic

1 for i in info:      # 循环字典，高效，推荐
2     print(i)    # 只打印key
3     print(i, info[i])   # 打印key及其value
4 
5 for k, v in info.items():   # 先将字典转为列表，数据量大时耗时长，不推荐
6     print(k, v)     # 打印key及其value

dic_circulation

购物车程序改进

product_list = [
    ('Iphone', 5800),
    ('Mac Pro', 9800),
    ('Bike', 800),
    ('Watch', 10600),
    ('Coffee', 31),
    ('Alex Python', 120),
]
shopping_list = []
salary = input('Input your salary:')
if salary.isdigit():#判断是否是字符串。若是，则返回真（1）
    salary = int(salary)
    while True:
        for index,item in enumerate(product_list):#此时返回两个值
#            print(product_list.index(item),item)
            print(index,item)
        user_choice = input('选择需要购买的商品>>>:')
        if user_choice.isdigit():
            user_choice = int(user_choice)
            if user_choice < len(product_list) and user_choice >= 0:
                p_item = product_list[user_choice]
                if p_item[1] <= salary:#买得起
                    shopping_list.append(p_item)
                    salary -= p_item[1]
                    print('Added %s into shopping cart, your current balance is \033[31;1m%s\033[0m'%(p_item,salary))
                else:
                    print("\033[41;1m你的余额只剩[%s]了，不能继续购买。\033[0m")
            else:
                print('product code [%s] is not exist!'% user_choice)

        elif user_choice == 'q':
            print('------shopping list------')
            for p in shopping_list:
                print(p)
            print('Your current balance:', salary)
            exit()
        else:
            print('invalid option')

 

五、文件操作
 对文件操作流程
  1.打开文件，得到文件句柄并赋值给一个变量；
  2.通过句柄对文件进行操作；
  3.关闭文件。
 windows默认为GBK，打开文件时，加上encoding='utf-8'----转换编码
 f = open('yesterday', encoding = 'utf-8')#文件句柄，以后可以直接操作f.read()
 文件读完一遍后，光标从第一行走到末尾，紧接着再读时，无可读内容
  r--只读；w--只写；a---追加（在末尾）；r+---读写（在原文件末尾写）；w+---写读（创建新文件，再写）；a+---追加读；rb，wb，ab---二进制文件（网络传输只能用二进制）
   f = open('yesterday2.txt', 'rb')
   f.write('hello binary\n'.encode())---.encode()转成二进制编码
 with open('log','r') as f:
  ......       ------自动关闭文件，不需要f.close()
 with open('log1') as obj1, open('log2') as obj2:
 . ......        ------支持同时对多个文件的上下文进行管理  
python代码中一行至多写84 个字符 多出的话另起一行

'''#data = open('yesterday.txt', encoding='utf-8').read()
f = open('yesterday2.txt', 'a', encoding='utf-8') # 文件句柄
#a = append---追加
#data = f.read()
#print(data)
f.write('\nwhen i was young i listen to the radio\n')
#f.write('天安门上太阳升')
data = f.read()
print('--read',data)

f.close()
'''

#f = open('yesterday.txt', 'r', encoding='utf-8') # 文件句柄

#单行读
#print(f.readline())
#print(f.readline())
#print(f.readline())

#循环读多行
#for i in range(5):
#    print(f.readline())

#print(f.readlines())#----得到列表
#low loop
'''
for index,line in enumerate(f.readlines()):
    if index == 9:
        print('---------')
        continue
    print(line.strip())

# high loop
count = 0
for line in f:
    if count == 9:
        print('-------------')
        count += 1
        continue
    print(line)#----逐行打印
    count += 1
'''
'''
f = open('yesterday.txt', 'r', encoding='utf-8') # 文件句柄
print(f.tell())#打印句柄指针所在的位置,按字符个数
print(f.readline())
print(f.readline())
print(f.readline())
print(f.tell())#打印句柄指针所在的位置，按字符个数
f.seek(10)#回到指定位置
print(f.tell())

print(f.encoding)#打印文件编码

print(f.fileno())#调用的操作系统的借口

#print(f.flush())#强制刷新到硬盘上，不必等缓冲区满
print(dir(f.buffer))

f = open('yesterday.txt', 'w', encoding='utf-8')
f.write('hello 1\n')
f.write('hello 2\n')
f.write('hello 3\n')

f = open('yesterday.txt', 'a', encoding='utf-8')
f.seek(10)
f.truncate(20)
'''
'''
#f = open('yesterday2.txt', 'r+', encoding='utf-8')
#f = open('yesterday2.txt', 'w+', encoding='utf-8')
f.write('-------------------------1\n')
f.write('-------------------------2\n')
f.write('-------------------------3\n')
f.write('-------------------------4\n')
print(f.tell())
f.seek(10)
print(f.tell())
print(f.readline())
f.write('should be at the beginning of the second line')#只能追加在后面，不能从指针指定的位置开始写
f.close()
'''

f = open('yesterday2.txt','wb')#文件句柄  二进制文件
f.write('hello binary\n'.encode())
f.close()

import sys
f = open('yesterday2.txt','r',encoding='utf-8')
f_new = open('yesterday2.bak','w',encoding='utf-8')

'''
for line in f:
    if '肆意的快乐等我享受' in line:
        line = line.replace('肆意的快乐等我享受','肆意的快乐等Alex享受')
    ''''''
      f_new.write(line)
    else:
        f_new.write(line)''''''
    f_new.write(line)
f.close()
f_new.close()
'''

find_str = sys.argv[1]
replace_str = sys.argv[2]

for line in f:
    if find_str in line:
        line = line.replace(find_str,replace_str)
    f_new.write(line)
f.close()
f_new.close()

 

六、字符编码与转码
 详细文章：
 http://www.cnblogs.com/yuanchenqi/articles/5956943.html
 http://www.diveintopython3.net/strings.html
 Ascii不能存中文
 编码：encode；解码： decode
 python默认是unicode编码
 #-*- coding:gbk -*-            把程序声明成按GBK模式编码
 需知:
  1.在python2默认编码是ASCII, python3里默认是unicode
  2.unicode 分为 utf-32(占4个字节),utf-16(占两个字节)，utf-8(占1-4个字节)， so utf-16就是现在最常用的unicode版本， 不过在文件里存的还是utf-8，因为utf8省空间
  3.在py3中encode,在转码的同时还会把string 变成bytes类型，decode在解码的同时还会把bytes变回string
 注：所有字符间的解码、编码都要经过unicode

import sys

s = '你好'
s_gbk = s.encode('gbk')
print(s_gbk)#GBK编码
print(s.encode())#UTF-8编码，默认是UTF-8编码
gbk_to_utf8 = s_gbk.decode('gbk').encode('utf-8')#先将gbk解码为uicode，再将unicode编码为utf-8
print('utf8',gbk_to_utf8)

#-*- encoding:gbk -*-
#声明文件编码
import sys
print(sys.getdefaultencoding())

s = '你好'#s的编码仍为unicode

print(s)
print(s.encode('gbk'))#显示gbk编码格式
print(s.encode('utf-8'))
print(s.encode('utf-8').decode('utf-8').encode('gb2312').decode('gb2312'))#gb2312同gbk格式相同，因为gbk向下兼容

 练习

 

#实现简单的shell sed替换功能
find_str = '我有太多歌曲永远不会被唱起'
replace_str = 'YOUTAIDUODEGEQUYONGYUANBUHUIBEICHANGQI'
with open('yesterday_new.txt','r',encoding = 'utf-8') as f,\
    open('yesterday_new.bak','w',encoding = 'utf-8') as f_new:
    for line in f:#f为一个迭代器，按行迭代
        if find_str in line:
            line = line.replace(find_str,replace_str)#字符串替换replace函数
        f_new.write(line)

 

# 修改haproxy配置文件
# 查询：输入网址获取当前backend下的所有记录
# 增加：输入字典增加一条记录
# 删除：输入字典删除该记录

import sys
def info():
    '提取当前配置文件中所有backend网址信息'
    backend = []
    with open('haproxy.txt','r') as f:
        for line in f:
            if line.startswith('backend'):#判断字符串是不是以backend开头，endswith，结尾
                line = line.strip()
                backend.append(line.partition(' ')[2])#partition()具体是来根据括号内的分隔符将一个字符串分割，而且仅仅是切一刀，生成的结果是一个元组。
    return backend

def search(website):
    '输入网址查找具体信息'
    info_backend = []
    if website in info():
        with open('haproxy.txt','r') as f:
            for line in f:
                if line.strip() == 'backend' + ' ' + website:
                    f1 = f.readline()
                    while f1.startswith('    server'):
                        info_backend.append(f1.strip())
                        f1 = f.readline()
            print(f'\033[31m{website}条目信息：\033[0m')
            for i,items in enumerate(info_backend):
                print(i+1,items.strip())
    else:
        print(f'{website}条目不存在')
    return info_backend

def delete(del_dic):
    '删除条目'
    del_dic = eval(del_dic)
    website = del_dic['backend']
    if website in info:
        with open('haproxy.txt','r') as f:
            with open('haproxy_new.txt','w=') as f1:
                for line in f:
                    if line.strip() == 'backend'+'  '+del_dic['backend']:
                        line = f.readline()
                        while line.startswith('    server'):
                            line = f.readline()
                            continue
                    else:
                        f1.write(line)
        print(f'{website}条目删除成功')
        with open('haproxy.txt','w') as f:
            with open('haproxy_new.txt','r') as f1:
                for line in f1:
                    f.write(line)
    else:
        print(f'{website}条目不存在')
    return

print("\033[31m欢迎进入haproxy配置系统\033[0m".center(50, ' '))
while True:
    print('-'.center(50, '-'))
    print("当前backend网址信息如下：")
    for j, backend in enumerate(info()):
        print(j+1, backend)
    print('-'.center(50, '-'))
    print("1.信息查询", '\n', "2.增加条目", '\n', "3.删除条目", sep='')
    choice1 = input("输入序号进入配置界面（输入q退出系统）：")
    if choice1.isdigit():
        choice1 = int(choice1)
        if choice1 in range(1, 4):
            if choice1 == 1:
                while True:
                    choice2 = input("请输入网址进行查询(例：www.baidu.com)（b返回q退出）：")
                    if choice2 == 'b':
                        break
                    elif choice2 == 'q':
                        print("系统退出")
                        sys.exit()
                    else:
                        search(choice2)
            elif choice1 == 2:
                while True:
                    choice3 = input("请输入条目字典（b返回q退出）：")
                    if choice3 == 'b':
                        break
                    elif choice3 == 'q':
                        print("系统退出")
                        sys.exit()
                    else:
                        add(choice3)
            elif choice1 == 3:
                while True:
                    choice4 = input("请输入添加条目字典（b返回q退出）:")
                    if choice4 == 'b':
                        break
                    elif choice4 == 'q':
                        print("系统退出")
                        sys.exit()
                    else:
                        delete(choice4)
        else:
            print("无此选项，请正确输入！")
    elif choice1 == 'q':
        print("系统退出")
        sys.exit()
    else:
        print("格式错误，请重新输入！")
        continue