Python学习笔记 day2 基础2

1.列表、元组操作

列表

定义列表 和 访问列表

names = ["小东", "小西", "小南", "小北"]
print(names[0])
print(names[-1])  # 倒着取，取最后一个

结果：
小东
小北

切片:取多个元素

print(names[1:3])  # 左闭右开，起始位置包括，尾部位置不包括。 取下标1至3之间的数字，包括1，不包括3

结果：['小西', '小南']

# 取前三个
print(names[0:3])
print(names[:3]
结果：['小东', '小西', '小南']

# 切片是从左往右数的
print(names[-3:-1])  # 左闭右开
结果：['小西', '小南']

print(names[1:-1])  # 取下标1至-1的值，不包括-1
结果：['小西', '小南']

# 如果想取到最后一个呢？
print(names[-3:])
结果：['小西', '小南', '小北']

print(names[1:])
结果：['小西', '小南', '小北']

# 分隔
步长切片
print(names[0::2]) #后面的2是代表，每隔一个元素，就取一个
结果：['小东', '小南']

等同于 print(names[::2])  print(names[0:-1:2])

追加

names.append("小中")
print(names)
结果：['小东', '小西', '小南', '小北', '小中']

插入

# 定位前插入，插在小西前面
names.insert(1, "小A")
print(names)
结果：['小东', '小A', '小西', '小南', '小北', '小中']

修改

names[2] = "小B"
print(names)
结果：['小东', '小A', '小B', '小南', '小北', '小中']

删除

remove
names.remove("小B")
print(names)
结果：['小东', '小A', '小南', '小北', '小中']

pop  # 默认删除列表最后一个值，在括号加数值效果等同于 del
names.pop()
print(names)
结果：['小东', '小A', '小南', '小北']

del 可删除单个元素 也可以删除整个列表
del names[1]
print(names)
结果：['小东', '小南', '小北']

扩展

扩展： 列表扩展
names = ["小东","小南","小北"]
b = [1,2,3]
names.extend(b)
print(names)
结果：['小东', '小南', '小北', 1, 2, 3]

拷贝
了解

浅copy  
names = ["小东", "小南", "小北", 1, 2, 3]
name_copy = names.copy()
print(name_copy)
结果：['小东', '小南', '小北', 1, 2, 3]

浅copy 只拷贝一层
列表是单独的内存地址，如果列表中有列表
copy复制的是内存地址
names = ["小东", "小西", ["复制1","复制2"], "小北"]
name_copy = names.copy()
print(names)
print(name_copy)
print('\n')
names[1] = "复制"
names[2][0] = "Bin"  # 因为同一块列表的内存地址 ，因此没有完全独立，只copy了第一层 小西。
print(names)
print(name_copy)
print('\n')
del name_copy[2][0]  # 删除第二个的时候第一个也跟着删除了。占用的内存地址是一样的
print(names)
print(name_copy)

结果：
['小东', '小西', ['复制1', '复制2'], '小北']
['小东', '小西', ['复制1', '复制2'], '小北']
['小东', '复制', ['Bin', '复制2'], '小北']
['小东', '小西', ['Bin', '复制2'], '小北']

['小东', '复制', ['复制2'], '小北']
['小东', '小西', ['复制2'], '小北']

浅copy 之 方法 2、3
name_copy2 = names[:]
name_copy3 = list(names)

浅copy场景：用于 两个人 用同一个存款的情况，当其中一个人用了存款的钱，则都会变。但名字两个人是独立的。


深copy
独立的克隆一个列表，占两个内存空间
import copy
names = ["小东", "小西", ["复制1","复制2"], "小北"]
name_copy = copy.deepcopy(names)
print(names)
print(name_copy)
print('\n')
names[1] = "复制"
names[2][0] = "Bin"  # 独立的克隆一个列表，占两个内存空间
print(names)
print(name_copy)
结果：
['小东', '小西', ['复制1', '复制2'], '小北']
['小东', '小西', ['复制1', '复制2'], '小北']

['小东', '复制', ['Bin', '复制2'], '小北']
['小东', '小西', ['复制1', '复制2'], '小北']

统计

names = ["小东", "小南", "小南"]
print(names.count("小南"))
结果：2

排序&翻转

排序：特殊符号>数字>大写>大小，按照ASCII码对照来的
names = ["5小东", "3小南", "8小北"]
names.sort()
print(names)
结果：['3小南', '5小东', '8小北']


names = ["小东", "小南", "小北"]
names.reverse()
print(names)
结果：['小北', '小南', '小东']

获取下标

names = ["小东", "小南", "小北"]
print(names.index("小南"))
结果：1

print(names[names.index("小南")])
结果：小南

元组

元组只有2个方法，一个是count,一个是index，只能查 不能改，可以理解为只读列表
场景：希望值是不能被改变的

names = ("小东", "小南", "小北")

程序：购物车程序

需求:
1.启动程序后，让用户输入工资，然后打印商品列表
2. 允许用户根据商品编号购买商品
3. 用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒
4.可随时退出，退出时，打印已购买商品和余额

# 购物车实例
product_list = [
    ('OPPO ACE',3100),
    ('HUAWEI P40',4399),
    ('Xiaomi K30',4000),
    ('Milk',45),
    ('Coca Cola',10)
]
shopping_list = []

salary = input("Input your salary:")
if salary.isdigit():
    salary = int(salary)
    while True:
        """
        for item in product_list:
            print(product_list.index(item),item)
        """
        for index,item in enumerate(product_list):
            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" % salary)
            else:
                print("product code [%s] is not exitst!" % user_choice)
        elif user_choice == 'q':
            print('-----shipping list------')
            for p in shopping_list:
                print(p)
            print("Your current valance:", salary)
            exit()
        else:
            print("Invalid Options")
else:
    print("你输入的不是数字")


优化：
1.用户和商家
用户
商品信息存在文件里
已购商品，余额记录

商家
可以添加商品，修改商品价格

 

2.字符串操作

特性：不可修改

# 首字母大写
name = "xiAoBin"
print(name.capitalize())  

# 大写全部变小写
print(name.casefold())    
print(name.lower())

# 小写全部变大写
print(name.upper()) 

# 大写变小写，小写变大写
print(name.swapcase())

# 统计i 出现次数
print(name.count("i"))    

# 打印50个字符，如果不够就用符号 - 补上
print(name.center(50, "-"))  

结果：
Xiaobin
xiaobin
xiaobin
XIAOBIN
XIaObIN
2
---------------------xiAoBin----------------------

# 长50，如果不够的话用*符号补上
name = "xiAoBin"
print(name.ljust(50,'*'))
print(name.rjust(50,'*'))
结果：
xiAoBin*******************************************
*******************************************xiAoBin

# title 每个字符的首字母变大写
name = "bin bin"
print(name.title())  # capitalize() 的话就是 Bin bin
结果：Bin Bin   

# 判断字符串以什么结尾 endwith
print(name.endswith("in"))
结果：True

# 转换指定tab
name = "xi \tAoBin"
print(name.expandtabs(tabsize=30))
结果：xi                            AoBin

# 查找B,找到返回其索引， 找不到返回-1
name = "xiAoBin"
print(name.find("B"))
结果：4
# 返回其索引，从左往右数，找对应最右边的索引,找不到返回-1
print(name.rfind('1'))   # 结果：5
# 返回其索引，找不到就报错 
print(name.index('C'))

# 字符串 切片
print(name[name.find("B"):])
结果：Bin

# format
name = "my name is {name} and i am {year} old"
print(name.format(name='Bin',year=22))
# print(name.format_map({'name':'Bin','year':12}))

结果：my name is Bin and i am 22 old

# 判断是否为整数
'6'.isdigit()

# 纯英文
print('abA'.isalpha())
# 包含阿拉伯数字，不能有特殊字符
print('ab23'.isalnum())
# 判断是部署一个合法的标识符
print('a1A'.isidentifier())
等等。。。。。。

# 列表 转化为 字符串  join
print('+'.join(['1','2','3']))
结果：1+2+3

# 去字符串 空格和回车
print('\nBin'.strip())  # 去掉空格和回车  去掉左边就lstrip，右边就rstrip
结果：Bin

# 把字符串转成对应后面的值，前后参数要一致
p = str.maketrans("abcdef",'123456')   
print("binbin".translate(p))
结果：2in2in

# 替换 replace
print('he bin bin'.replace('b','B'))
print('he bin bin'.replace('b','B',1)) # 替换一个
结果：
he Bin Bin
he Bin bin

# 分割字符串，默认按空格分割 split()
print('1+2 3+4 5+6 '.split())
结果：['1+2', '3+4', '5+6']

print('1+2+3+4'.split('+'))
结果：['1', '2', '3', '4']

 

3.字典操作

字典一种key - value 的数据类型
字典的特性：

dict是无序的
key必须是唯一的,因此天生去重

info = {
    'stu1':"小东",
    'stu2':"小彬",
    'stu3':"小西"
}
print(info)
结果：{'stu1': '小东', 'stu2': '小彬', 'stu3': '小西'}

print(info["stu2"])
结果：小彬

增加

info["stu4"] ="大V"
print(info)
结果：{'stu1': '小东', 'stu2': '小B', 'stu3': '小西', 'stu4': '大V'}

修改

info["stu2"] ="小B"
print(info)
结果：{'stu1': '小东', 'stu2': '小B', 'stu3': '小西'}

删除

# del
del info["stu1"]  
# info.pop("stu1")
print(info)
结果：{'stu2': '小B', 'stu3': '小西', 'stu4': '大V'}
# info.popitem() 随机删除

查找

info = {
    'stu1':"小东",
    'stu2':"小彬",
    'stu3':"小西"
}
print(info.get('stu2')) # get 有就返回指定键的值，无就返回None
结果：小彬
# info["stu2"] 也行，但这种key不存在会报错

# 判断是否在字典
print('stu2' in info)
结果：True

多级字典嵌套及操作

tv_catalog = {
    "动漫":{
        "yx": ["怡萱动漫"],
        "bili": ["哔哩哔哩"],
    },
    "韩剧":{
        "韩剧网":["梨泰院class，","请回答1988"]
    },
    "大陆":{
        "爱奇艺":["海贼王"]
    }
}

tv_catalog["大陆"]["爱奇艺"][0] += ",连载多年"
print(tv_catalog["大陆"]["爱奇艺"])
print(tv_catalog["韩剧"]["韩剧网"])

结果：
['海贼王,连载多年']
['梨泰院class，', '请回答1988']

其他姿势

info = {
    'stu1':"小东",
    'stu2':"小彬",
    'stu3':"小西"
}

#values
print(info.values())
结果：dict_values(['小东', '小彬', '小西'])

#keys
print(info.keys())
结果：dict_keys(['stu1', 'stu2', 'stu3'])

#setdefault
print(info.setdefault("stu2","AA"))
print(info.setdefault("stu4","AA"))
print(info)
结果：
小彬
AA
{'stu1': '小东', 'stu2': '小彬', 'stu3': '小西', 'stu4': 'AA'}
# 如果键不存在于字典中，将会添加键并将值设为默认值
# 返回值：如果字典中包含有给定键，则返回该键对应的值，否则返回为该键设置的值。

#update 合并，如果有交叉的key就覆盖，无交叉的key就新增
b = {
    'stu1':'小文',
    1:10,
    2:20
}
info.update(b)
print(info)
结果：{'stu1': '小文', 'stu2': '小彬', 'stu3': '小西', 1: 10, 2: 20}

#item 把一个字典转成了列表
print(info.items())
结果：dict_items([('stu1', '小文'), ('stu2', '小彬'), ('stu3', '小西'), (1, 10), (2, 20)])

#通过一个列表生成默认dict，少用。  
# 类似列表的copy，在嵌套多层字典下，一改全改，把一份列表的数据都放在同一个内存空间。
一层情况下
c = dict.fromkeys([1,2,3],'testd')
print(c)
结果：{1: 'testd', 2: 'testd', 3: 'testd'}

二层情况下
c = dict.fromkeys([1,2,3],[1,{"name":"小东"},444])
print(c)
c[1][1]['name']='小西'
print(c)
结果：
{1: [1, {'name': '小东'}, 444], 2: [1, {'name': '小东'}, 444], 3: [1, {'name': '小东'}, 444]}
{1: [1, {'name': '小西'}, 444], 2: [1, {'name': '小西'}, 444], 3: [1, {'name': '小西'}, 444]}

循环dict

#方法1
for key in info:  #直接索引取
    print(key,info[key])

#方法2
for k,v in info.items(): #会先把dict转成list,数据里大时莫用
    print(k,v)

程序练习

要求:
1.打印省、市、县三级菜单
2.可返回上一级
3.可随时退出程序

data = {
    '广东':{
        "广州":{
            "海珠区":["海珠富力城","珠江新城"],
            "越秀区":["越秀人民公园","纪念堂"]
            },
        "惠州":{
            "惠城区":["红花湖","西湖"],
            "惠东县":["巽寮湾","双月湾"]
            }
    },
    '广西':{
        "南宁":{
            "青秀区":["广西民族博物馆"],
            "江南区":["杨美古镇","太阳岛"]
        }
    }
}

flag = False

while not flag:
    for i in data:  # 打印第一层
        print("\t", i)
    choice = input("选择进入1：")
    if choice in data:
        while not flag:
            for i2 in data[choice]:  # 打印第二层
                print("\t", i2)
            choice2 = input("选择进入2：")
            if choice2 in data[choice]:
                while not flag:
                    for i3 in data[choice][choice2]:  # 打印第三层
                        print("\t", i3)
                    choice3 = input("选择进入3：")
                    if choice3 in data[choice][choice2]:
                        for i4 in data[choice][choice2][choice3]:
                            print("\t", i4)
                        choice4 = input("按b返回，q退出：")
                        if choice4 == "b":
                            pass
                        elif choice4 == 'q':
                            flag = True
                    if choice3 == "b":
                        break
                    elif choice3 == 'q':
                        flag = True
            if choice2 == "b":
                break
            elif choice2 == 'q':
                flag = True

4.集合操作

集合是一个无序的，不重复的数据组合，它的主要作用如下：

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据之前的交集、差集、并集等关系

list_1 = [1,2,4,5,2,3,5,6]
list_1 = set(list_1)
print(list_1,type(list_1))

list_2 = set([0,2,6,4,5,8,22])

#交集
print(list_1.intersection(list_2))
# print(list_1.isdisjoint(list_2))  # list_1.isdisjoint(list_2) 如果没交集为True
#并集
print(list_1.union(list_2))
#差集
print(list_1.difference(list_2))  # 在列表1有，但在列表2没有
print(list_2.difference(list_1))  # 在列表2有，但在列表1没有
#对称差集，我有你没，你有我没， 等同于上面两个差集结果的并集
print(list_1.symmetric_difference(list_2))
#子集
list_3 = set([2,4,6])
print(list_3.issubset(list_1))  # 判断list3是否为list1的子集
print(list_1.issuperset(list_3))  # 判断list1是否为list3的父集

#交集
print(list_1 & list_2)
#并集
print(list_2 | list_1)
#差集
print(list_1 - list_2) # in list_1 but not int list_2
#对称差集
print(list_1 ^ list_2)

结果：
{1, 2, 3, 4, 5, 6} <class 'set'>
{2, 4, 5, 6}
False
{0, 1, 2, 3, 4, 5, 6, 8, 22}
{1, 3}
{0, 8, 22}
{0, 1, 3, 8, 22}
True
True


# list是无序的
list_1.add(9999)
print(list_1)
list_1.update([888,777,666])
print(list_1)
结果：
{1, 2, 3, 4, 5, 6, 9999}
{1, 2, 3, 4, 5, 6, 777, 9999, 888, 666}

#删除一项
list_1.remove(9999)
# list_1.pop() 随机

#集合的长度
len(list_1)

#测试x是否为s的成员
x in s

#测试x是否不是s的成员
x not in s  

#测试是否 s 中的每一个元素都在 t 中  
s.issubset(t)  
s <= t  

#测试是否 t 中的每一个元素都在 s 中 
s.issuperset(t)  
s >= t  

#返回一个新的 set 包含 s 和 t 中的每一个元素
s.union(t)  
s | t  
  
#返回一个新的 set 包含 s 和 t 中的公共元素  
s.intersection(t)  
s & t  

#返回一个新的 set 包含 s 中有但是 t 中没有的元素  
s.difference(t)  
s - t  

#返回一个新的 set 包含 s 和 t 中不重复的元素  
s.symmetric_difference(t)  
s ^ t  

#返回 set “s”的一个浅复制
s.copy()  
  

 

5.文件操作

对文件操作流程
1.打开文件，得到文件句柄并赋值给一个变量
2.通过句柄对文件进行操作
3.关闭文件

现有文件如下

It keeps me awake
这一切让我彻夜难眠
The look on your face
你脸上的那表情
The moment you heard the news
你听到新闻的那一瞬间
You're screaming inside
你的内心在嘶吼
And frozen in time
时间一霎那凝结
You did all that you could do
你已经做了所有
The game was rigged, the ref got tricked
而游戏被操纵 裁判被愚弄
Only the young can run (Can run)
唯有这一代人可以逃出生天
So run
那么就奔跑吧
And run and run
继续狂奔 不要再停下

基本操作
第一种：

# 打开文件
f = open('Taylor.txt','r+')  # 打开文件
first_line = f.readline()
print('first line:', first_line)  # 读一行
print('我是分隔线'.center(50, '-'))
data = f.read()  # 读取剩下的所有内容,文件大时不要用
print(data)  # 打印文件
f.write("\nTaylor Swifts")
print(data)  # 打印文件

f.close()  # 关闭文件

第二种：

f = open('Taylor.txt','r+')  # 打开文件

first_line = f.readline()
print('first line:', first_line)  # 读一行
print('我是分隔线'.center(50, '-'))
# 高效率，一行一行读。
count = 0
for line in f:
    if count == 9:
        print('----------我是插入的----------')
        count += 1
        continue
    print(line.strip())
    count += 1
f.close()  # 关闭文件

第三种：修改

文件修改
改了之后写到新文件
循环一行一行读，每一行判断，就把这句话插入，然后写到新文件
f = open('Taylor.txt','r')  # 打开文件
f_new = open("Taylor-backup.txt","w")

for line in f:
    if "这一切让我彻夜难眠" in line:
        line = line.replace("这一切让我彻夜难眠","这一切让果子哥彻夜难眠")
    f_new.write(line)
f.close()
f_new.close()

其他

#文件指针
print(f.tell())  打印位置

#位置偏移
f.seek(0)  
file.seek()方法标准格式是：seek(offset,whence=0)
offset：开始的偏移量，也就是代表需要移动偏移的字节数
whence：给offset参数一个定义知，表示要从哪个位置开始偏移；0代表从文件开头开始算起，1代表从当前道位置开始算起，2代表从文件末尾算起。默认为0 
f.seek(-3, 2)  # 移动到文件倒数第三个字节
如果操作成功，则返回新的文件位置，如果操作失败，则函数返回 -1。


read([size])方法从文件当前位置起读取size个字节，若无参数size，则表示读取至文件结束为止，它范围为字符串对象
readline()方法每次读出一行内容，所以，读取时占用内存小，比较适合大文件，该方法返回一个字符串对象。
readlines()方法读取整个文件所有行，保存在一个列表(list)变量中，每行作为一个元素，但读取大文件会比较占内存

f.encoding()  文件的编码
f.flush()  刷新
额外对flush进行一种扩展
import sys,time
for i in range(20):
    sys.stdout.write("#")
    sys.stdout.flush()
    time.sleep(0.1)
因为刷新缓冲，结果是逐渐出现# ，如果没有就会等缓冲区满了才一次性打出。


f.truncate()方法用于从文件的首行首字节开始截断，截断文件为 size 个字节，无 size 表示从当前位置截断；截断之后 V 后面的所有字节被删除
 

打开文件的模式有：

r，只读模式（默认）。
w，只写模式。【不可读；不存在则创建；存在则删除内容；】
a，追加模式。【可读； 不存在则创建；存在则只追加内容；】

“+” 表示可以同时读写某个文件

r+，可读写文件。【可读；可写；可追加】
w+，写读
a+，同a 追加读

"U"表示在读取时，可以将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用）

rU
r+U

"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）

rb    网络传输
wb
ab

with语句
为了避免打开文件后忘记关闭，可以通过管理上下文，即：

with open('log','r') as f:

打开多个文件的方法
with open("Taylor.txt","r") as f,\
    open("Taylor-backup.txt","r") as f2:

程序练习　
和上面的第三种 类似　
程序1：实现简单的shell sed替换功能
程序2：修改haproxy配置文件

程序1: 实现简单的shell sed替换功能

文件修改
改了之后写到新文件
循环一行一行读，每一行判断，就把这句话插入，然后写到新文件
import sys
f = open('Taylor.txt','r+')  # 打开文件
f_new = open("Taylor-backup.txt","w")
find_str=sys.argv[1]
replace_str=sys.argv[2]
for line in f:
    line = line.replace(find_str,replace_str)
    print(line)
    f_new.write(line)
f.close()
f_new.close()  

在终端中运行   F:\python3学习>python day2.py T *   
这里T代表被替换参数，*代表替换参数。  

程序2:修改haproxy配置文件
需求：

功能实现：
1、输入相关网址，可查询相关记录信息；
2、按照字典样式输入网址及记录信息，可在haproxy文件中增加；
3、输入相关网址，可删除相关记录信息；
4、按照字典样式输入网址及记录信息，可在haproxy文件中更新。

思路：
1.search
2.add
3.update
4.delete

1、查
    输入：www.oldboy.org
    获取当前backend下的所有记录

2、新建  
    输入： 通过字典规范了，
        arg = {
            'bakend': 'www.oldboy.org',
            'record':{
                'server': '100.1.7.9',
                'weight': 20,
                'maxconn': 30
            }
        }

3、删除
    输入：
        arg = {
            'bakend': 'www.oldboy.org',
            'record':{
                'server': '100.1.7.9',
                'weight': 20,
                'maxconn': 30
            }
        }

需求

原配置文件

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.oldboy.org
        server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000

原配置文件

eval
a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]"
b = eval(a)
print(b)
结果：[[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]

完整程序：
def show_red(show_str):
    print("\033[3;31m{}\33[0m".format(show_str))

def if_continue():
    """ 询问是否继续 """
    if_cont = input("Do you want to continue ? [y/n]")
    if if_cont == 'y':
        pass
    else:
        exit()

def show_result(show_str):
    """ 显示特定的颜色 """
    print("\033[34;1m{}\033[0m".format(show_str).center(50, '-'))

def search():
    """ 搜索信息 """
    website = input("please enter the url you want to query: ")
    if website in file_content.keys():   # dict.keys() 以列表返回一个字典所有键
        show_result("查询信息")
        show_red(file_content[website])
    else:
        show_red("sorry，the information you want to inquire could not be founded!")

def add():
    # {'backend': 'www.baidu.org','record':{'server': '100.1.7.9','weight': 20,'maxconn': 30}}
    add_str = input('请输入要添加的记录:\n')
    add_dict = eval(add_str)   # 字符串转字典
    print(add_dict)
    with open("haproxy.txt", "a+") as f:
        f.write("\nbackend {} \n\t\tserver {} weight {} maxconn {}".format(add_dict['backend'],
                                                                           add_dict['record']['server'],
                                                                           add_dict['record']['weight'],
                                                                           add_dict['record']['maxconn']))
def delete():
    show_result("可删除的网页")
    for name in file_content.keys():
        print(name)
    user_order = input("请输入你想删除的url:\n")
    if user_order in file_content.keys():
        with open("haproxy.txt", "a+", encoding='utf-8') as Handle_file:
            Handle_file.seek(0)
            lines = Handle_file.readlines()
            index = lines.index("backend {}\n".format(user_order))
            del lines[index]
            del lines[index]
            Handle_file.seek(0)
            Handle_file.writelines(lines)
        show_red("删除网页成功")
    else:
        show_red("该网页不存在")

while True:
    file_content = {}
    f = open('haproxy.txt',"r+")
    for line in f:
        if "backend" in line and "use_backend" not in line:
            # 默认 以空格为分隔符，包含 \n，拆分将会形成一个字符串的数组并返回
            # [1]取出数组中第二个元素的值,www.oldboy.org
            # www.oldboy.org作为key 放在字典中，＃换行后的server作为value＃　这里不是很懂，记住把
            file_content[line.split()[1]] = f.readline().strip()
            print(file_content)
    user_choice = input("1.search\n2.add\n3.delete\n4.quit\n:")
    if user_choice == "4":
        show_red("软件已退出")
        exit()
    elif user_choice == "1":
        search()
        if_continue()
    elif user_choice == "2":
        add()
        if_continue()
    elif user_choice == "3":
        delete()
        if_continue()
    else:
        show_red("请重新输入")
        if_continue()
    f.close()

 

6.字符编码与转码

Python编码终极版：https://www.cnblogs.com/yuanchenqi/articles/5956943.html .

1.在python2默认编码是ASCII, python3里默认是unicode

2.unicode 分为 utf-32(占4个字节),utf-16(占两个字节)，utf-8(占1-4个字节)， utf-16就是现在最常用的unicode版本， 不过在文件里存的还是utf-8，因为utf8省空间

3.在py3中encode,在转码的同时还会把string 变成bytes类型，decode在解码的同时还会把bytes变回string
Python 3：默认就是Unicode

文件头：与文件编码一致
#-*- coding:gbk -*-

下图仅适用于Python 2：
Python编码终极版：https://www.cnblogs.com/yuanchenqi/articles/5956943.html .