字符串格式化
Python的字符串格式化有两种方式: 百分号方式、format方式
百分号的方式相对来说比较老，而format方式则是比较先进的方式，企图替换古老的方式，目前两者并存。[PEP-3101]
This PEP proposes a new system for built-in string formatting operations, intended as a replacement for the existing \'%\' string formatting operator.
1、百分号方式
%[(name)][flags][width].[precision]typecode
- (name) 可选，用于选择指定的key
- flags 可选，可供选择的值有:
- + 右对齐；正数前加正好，负数前加负号；
- - 左对齐；正数前无符号，负数前加负号；
- 空格 右对齐；正数前加空格，负数前加负号；
- 0 右对齐；正数前无符号，负数前加负号；用0填充空白处
- width 可选，占有宽度
- .precision 可选，小数点后保留的位数
- typecode 必选
- s，获取传入对象的__str__方法的返回值，并将其格式化到指定位置
- r，获取传入对象的__repr__方法的返回值，并将其格式化到指定位置
- c，整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置
- o，将整数转换成 八 进制表示，并将其格式化到指定位置
- x，将整数转换成十六进制表示，并将其格式化到指定位置
- d，将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置
- e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
- E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
- f， 将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
- F，同上
- g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
- G，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
- %，当字符串中存在格式化标志时，需要用 %%表示一个百分号
注：Python中百分号格式化是不存在自动将整数转换成二进制表示的方式
常用格式化：
|
1
2
3
4
5
6
7
8
9
10
11
|
tpl = "i am %s" % "alex"
tpl = "i am %s age %d" % ("alex", 18)
tpl = "i am %(name)s age %(age)d" % {"name": "alex", "age": 18}
tpl = "percent %.2f" % 99.97623
tpl = "i am %(pp).2f" % {"pp": 123.425556, }
tpl = "i am %.2f %%" % {"pp": 123.425556, }
|
2、Format方式
[[fill]align][sign][#][0][width][,][.precision][type]
- fill 【可选】空白处填充的字符
- align 【可选】对齐方式（需配合width使用）
- <，内容左对齐
- >，内容右对齐(默认)
- ＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。 即使：符号+填充物+数字
- ^，内容居中
- sign 【可选】有无符号数字
- +，正号加正，负号加负；
- -，正号不变，负号加负；
- 空格 ，正号空格，负号加负；
- # 【可选】对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示
- ， 【可选】为数字添加分隔符，如：1,000,000
- width 【可选】格式化位所占宽度
- .precision 【可选】小数位保留精度
- type 【可选】格式化类型
-
传入” 字符串类型 “的参数
- s，格式化字符串类型数据
- 空白，未指定类型，则默认是None，同s
-
传入“ 整数类型 ”的参数
- b，将10进制整数自动转换成2进制表示然后格式化
- c，将10进制整数自动转换为其对应的unicode字符
- d，十进制整数
- o，将10进制整数自动转换成8进制表示然后格式化；
- x，将10进制整数自动转换成16进制表示然后格式化（小写x）
- X，将10进制整数自动转换成16进制表示然后格式化（大写X）
-
传入“ 浮点型或小数类型 ”的参数
- e， 转换为科学计数法（小写e）表示，然后格式化；
- E， 转换为科学计数法（大写E）表示，然后格式化;
- f ， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
- F， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；
- g， 自动在e和f中切换
- G， 自动在E和F中切换
- %，显示百分比（默认显示小数点后6位）
-
传入” 字符串类型 “的参数
常用格式化：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
tpl = "i am {}, age {}, {}".format("seven", 18, \'alex\')
tpl = "i am {}, age {}, {}".format(*["seven", 18, \'alex\'])
tpl = "i am {0}, age {1}, really {0}".format("seven", 18)
tpl = "i am {0}, age {1}, really {0}".format(*["seven", 18])
tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18)
tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})
tpl = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
tpl = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)
tpl = "i am {:s}, age {:d}".format(*["seven", 18])
tpl = "i am {name:s}, age {age:d}".format(name="seven", age=18)
tpl = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)
|
更多格式化操作：https://docs.python.org/3/library/string.html
迭代器和生成器
1、迭代器
迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退，不过这也没什么，因为人们很少在迭代途中往后退。另外，迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件
特点：
- 访问者不需要关心迭代器内部的结构，仅需通过next()方法不断去取下一个内容
- 不能随机访问集合中的某个值 ，只能从头到尾依次访问
- 访问到一半时不能往回退
- 便于循环比较大的数据集合，节省内存
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
>>> a = iter([1,2,3,4,5])
>>> a<list_iterator object at 0x101402630>
>>> a.__next__()1>>> a.__next__()2>>> a.__next__()3>>> a.__next__()4>>> a.__next__()5>>> a.__next__()Traceback (most recent call last): File "<stdin>", line 1, in <module>
StopIteration |
2、生成器
一个函数调用时返回一个迭代器，那这个函数就叫做生成器（generator）；如果函数中包含yield语法，那这个函数就会变成生成器；
|
1
2
3
4
5
|
def func():
yield 1
yield 2
yield 3
yield 4
|
上述代码中：func是函数称为生成器，当执行此函数func()时会得到一个迭代器。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
>>> temp = func()
>>> temp.__next__()1>>> temp.__next__()2>>> temp.__next__()3>>> temp.__next__()4>>> temp.__next__()Traceback (most recent call last): File "<stdin>", line 1, in <module>
StopIteration |
########生成器 # def test(): # print(\'from run\') # yield 1 # print(\'from runhahah\') # yield 2 # # t = test() # next(t) # next(t) # t.__next__() #x = yield 10 # t.send(\'1234\') #生成器表达式 # age=10 # res = True if age>10 else False # # l=[\'a\' for i in range(10)] # g_l=(\'a\' for i in range(10)) # # # def test(): # for i in range(4): # yield i # # t = test() # # t1 = (i for i in t) # # print(list(t1)) # # # for i in t1: # # # print(i) # # t1 = (i for i in t) # t2 = (i for i in t1) # print(list(t1)) # print(list(t2))
迭代器和生成器
#=============================================================================== ########递归与迭代 #1迭代器协议是指：对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么就引起一个Stopiteration 异常，以终止迭代（只能往后走，不能往前退） #2.可迭代对象：实现了迭代器协议的对象（如何实现：对象内部定义一个__iter__()方法） #3.协议是一种约定 # x=\'hello\' # iter_test=x.__iter__() # print(iter_test) # print(iter_test.__next__()) # l = [1,2,3] # for i in l: #i_l= l.__iter__() i_l.__next() # print(i) #第一种方法 #打印l列表中的各个元素 # print(l[0]) # index=0 # while index < len(l): # print(l[index]) # index += 1 #第二种方法 # iter_l=l.__iter__() #遵循迭代器协议，生成可迭代对象 # print(iter_l.__next__()) # print(iter_l.__next__()) # for i in l: # print(i) s = {2,3,4} # for i in s: # print(i) # iter_s=s.__iter__() # print(iter_s) # print(iter_s.__next__()) # dic = {\'a\':1,\'b\':2} # iter_d = dic.__iter__() # print(iter_d.__next__()) # f = open(\'test1\',\'r+\') # #for i in f: # # iter_f=f.__iter__() # print(iter_f.__next__(),end=\'\') # print(iter_f.__next__(),end=\'\') # l = [\'dieE\',\'erzi\',\'sunzi\',\'chongsunzi\'] # iter_l=l.__iter__() # print(iter_l.__next__()) # print(iter_l.__next__()) # print(next(iter_l))##next---->iter_l.__next__() #yuanchengqi cnblogs ##########=============================== ###生成器 ###生成器可以理解为一种数据类型，实现了自动实现迭代协议，所以生成器就是可迭代对象 # def test(): # yield 1 # g=test() # print(g) # print(g.__next__()) # print(g.__next__()) #三元表达式 #name = \'alex\' # name = \'lin\' # res = \'sx\' if name == \'alex\' else \'shuaige\' # print(res) #列表解析 # egg_list = [] # for i in range(10): # egg_list.append(\'jidan%s\' %i) # print(egg_list) # l = [ \'jidan%s\' %i for i in range(10) ] # ll = [ \'jidan%s\' %i for i in range(10) if i <5 ] # l3 = [ \'jidan%s\' %i for i in range(10) else \'hahsh\' ] ######报错，不能有else # print(l) # print(ll) # print(l3) # laomuji = (\'jidan%s\' %i for i in range(10)) #生成器表达式 # print(laomuji) # print(laomuji.__next__()) # print(laomuji.__next__()) # print(next(laomuji)) # print(next(laomuji)) # print(next(laomuji)) # l = [1,3,34] #map(func,l) #print(sum(l)) #print(sum(i for i in range(10000)))
3、实例
a、利用生成器自定义range
|
1
2
3
4
5
6
7
8
|
def nrange(num):
temp = -1
while True:
temp = temp + 1
if temp >= num:
return
else:
yield temp
|
b、利用迭代器访问range
4、装饰器
###装饰器： 本质就是函数，功能为其他函数添加附加功能 原则： 1.不修改被修饰函数的源代码 2.不修改被修饰函数的调用方式 import time def cal(l): start_time = time.time() res = 0 for i in l: time.sleep(0.1) res+=i stop_time = time.time() print(\'函数的运行时间是%s\'%(stop_time-start_time)) return res print(cal(range(100))) 装饰器的知识储备 装饰器=高阶函数+函数嵌套+闭包 import time def timer(func): def wrapper(*args,**kwargs): start_time=time.time() res=func(*args,**kwargs) stop_time=time.time() print(\'函数的运行时间%s\'%(stop_time-start_time)) return res return wrapper @timer def cal(l): res = 0 for i in l: time.sleep(0.1) res+=i return res res = cal(range(20)) print(res) 高阶函数 1.函数接收参数是一个函数名 2。函数的返回值是一个函数名。3。满足上述任一个条件 import time def foo(): time.sleep(3) print(\'hello ,lin\') def test(func): print(func) start_time=time.time() func() stop_time=time.time() print(\'函数运行时间 %s\'%(stop_time-start_time)) test(foo) 第二种 def foo(): print(\'from the foo\') def test(func): return func #res = test(foo) #print(res) #res() foo = test(foo) foo() 第三种 不修改foo源代码 不修改foo的调用方式 import time def foo(): time.sleep(3) print(\'来自foo\') #多运行一次，不合格 # def timer(func): # start_time=time.time() # func() # stop_time=time.time() # print(\'函数运行时间 %s\'%(stop_time-start_time)) # return func # foo = timer(foo) # foo() def timer(func): start_time=time.time() func() stop_time=time.time() print(\'函数运行时间 %s\'%(stop_time-start_time)) return func foo = timer(foo) foo() 函数嵌套 def bar(): print(\'from bar\') def foo() print(\'from foo\') def test(): print(\'ste\') 闭包 def father(name): #print(\'from father %s\' %name) #name=\'linha_1\' def son(): #print(\'wode baba %s\' %name) def grandson(): #name=\'jiushiwoziji\' print(\'wodefa %s\'%name) grandson() son() father(\'lin\') 形成闭包的条件 1、必须要有一个内嵌函数 2、内嵌函数中要对自由变量的引用 3、外部函数必须返回内嵌函数 如果在一个函数的内部定义了另一个函数，外部的我们叫他外函数，内部的我们叫他内函数。 闭包： 在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用。这样就构成了一个闭包。 一般情况下，在我们认知当中，如果一个函数结束，函数的内部所有东西都会释放掉，还给内存，局部变量都会消失。但是闭包是一种特殊情况， 如果外函数在结束的时候发现有自己的临时变量将来会在内部函数中用到，就把这个临时变量绑定给了内部函数，然后自己再结束 装饰器的架子 import time def timer(func): #func= test def wrapper(): print(func) start_time = time.time() func() #就是在运行test() stop_time = time.time() print(\'yunxingshijian %s\' %(stop_time-start_time)) return wrapper @timer #test = timer(test) def test(): time.sleep(3) print(\'test函数运行完毕\') # res = timer(test) #返回的是wrapper的地址 # res() #执行是wrapper（） # test = timer(test) #返回的是wrapper的地址 # test() #执行是wrapper（） # @timer 就相当于test = timer(test) test() 加上返回值 import time def timer(func): #func= test def wrapper(): print(func) start_time = time.time() res = func() #就是在运行test() stop_time = time.time() print(\'yunxingshijian %s\' %(stop_time-start_time)) return res return wrapper @timer #test = timer(test) def test(): time.sleep(3) print(\'test函数运行完毕\') return \'这是test的返回值\' res = test() #就是在运行wrapper print(res) 加上参数 import time def timer(func): #func= test (\'linaf\',age=19) args=(\'linaf\') kwargs={\'age\':19} def wrapper(*args,**kwargs): print(func) start_time = time.time() res = func(*args,**kwargs) #就是在运行test() args=(\'linaf\') kwargs={\'age\':19} stop_time = time.time() print(\'yunxingshijian %s\' %(stop_time-start_time)) return res return wrapper @timer #test = timer(test) def test(name,age): time.sleep(3) print(\'test函数运行完毕,名字是%s,年龄是%d\'%(name,age)) return \'这是test的返回值\' @timer #test1=timer(test1) def test1(name,age,gender): time.sleep(1) print(\'test函数运行完毕,名字是%s,年龄是%d,性别是%s\'%(name,age,gender)) return \'这是test的返回值\' # res = test(\'linaf\',age=19) #就是在运行wrapper # # print(res) # # test1(\'alex\',18,\'male\') def test2(name,age,gender): print(name) print(age) print(gender) def test1(*args,**kwargs): test2(*args,**kwargs) test1(\'alex\',18,\'male\') test1(1,2,3,4,name=3) test1(*(1,2,3,4),**{\'name\':\'alsdf\'})
序列操作：
l = [10,2,3,3,4,6,7,8,1,3] # a,b,c=\'hel\' # a,b,c = [1,2,3] #a,*_,c = l # print(a) ####l列表的首字母 # print(c) #####l列表的尾字母 # a,*d,c=l # print(a) # print(d) # print(c) # a,b,*_,c,d = l # print(a) # print(b) # print(c) # print(d)
ustage1：
######模拟后台 # user_list [ # {\'name\':\'wuwu\',passwd:\'123\'} # ] # # current_dic = {\'username\':None,\'login\':False} # # def auth_func(func): # def wrapper(*args,**kwargs): # if user_dic[\'username\'] and user_dic[\'login\']: # res = func(*args, **kwargs) # return res # username=input(\'yhumi:\').strip() # passwd = input(\'mima:\').strip() # for user_dic in user_list: # # if username ==\'haha\' and passwd == \'123\': # # user_dic[\'username\'] = username # # user_dic[\'login\'] = True # # res = func(*args,**kwargs) # # return res # # else: # # print(\'yonghuming huo mima 错误\') # return wrapper # # # @auth_func # def index(): # print(\'欢迎来到京东\') # # @auth_func # def home(name): # print(\'欢迎回家%s\'%name) # @auth_func # def shopping_car(name): # print(\'购物车里有[%s ,%s,%s]\' %(name,\'naic\',\'mei\')) # # # index() # home(\'产品\') # shopping_car(\'产品\') #列表 # user_list = [ # {\'name\':\'wuwu\',\'passwd\':\'123\'}, # {\'name\':\'wu\',\'passwd\':\'123\'} # ] # # current_dic = {\'username\':None,\'login\':False} # def auth(auth_type=\'filedb\'): # def auth_func(func): # def wrapper(*args,**kwargs): # print(auth_type) # if auth_type == \'filedb\': # if current_dic[\'username\'] and current_dic[\'login\']: # res = func(*args, **kwargs) # return res # username=input(\'yhumi:\').strip() # passwd = input(\'mima:\').strip() # for user_dic in user_list: # if username == user_dic[\'name\'] and passwd == user_dic[\'passwd\']: # current_dic[\'username\'] = username # current_dic[\'passwd\'] = True # res = func(*args, **kwargs) # return res # else: # print(\'用户名密码错误\') # elif auth_type ==\'ldap\': # print(\'鬼才知道\') # # else: # print(\' 鬼才知道你的认证方式\') # # if username ==\'haha\' and passwd == \'123\': # # user_dic[\'username\'] = username # # user_dic[\'login\'] = True # # res = func(*args,**kwargs) # # return res # # else: # # print(\'yonghuming huo mima 错误\') # return wrapper # return auth_func # # @auth(auth_type=\'filedb\') #auth_func=auth(\'auth_type\'=\'filedb\')-->@auth_func 附加了一个auth_type-->index=auth_func(index) # def index(): # print(\'欢迎来到京东\') # # # @auth_func # # def home(name): # # print(\'欢迎回家%s\'%name) # # @auth_func # # def shopping_car(name): # # print(\'购物车里有[%s ,%s,%s]\' %(name,\'naic\',\'mei\')) # # print(\'before--->\',current_dic) # index() # print(\'before--->\',current_dic) # home(\'产品\') # shopping_car(\'产品\')
ustage2:
#############修改haproxy.conf配置文件 # import os # def fetch(data): # print(\'\033[1;43m这是查询功能\033 [0m\') # print(\'\033[1;43m cahxun \033 [0m %s\'%data) # backend_data=\'backend %s\' %data # with open(\'haproxy.conf\',\'r\') as read_f: # tag = False # for read_line in read_f: # if read_line.strip() == backend_data: # tag = True # continue # # if tag and read_line.startswith(\'backend\'): # #tag = False # break # if tag: # print(\'\033[1;45m%s\033[0m\'%read_line,end=\'\') # ret.append(read_line) # # return ret # # def add(): # pass # # def change(): # print(\'只是修改功能\') # pirnt(\'用户输入的数据是\',data) # backend = data[0][\'backend\'] #文件当中的一条记录 # backend_data = \'backend %s\' %backend # old_server_record= \'%sserver %s %s weight %s maxconn %s\n\'%(\'\'*8,data[0][\'record\'][\'server\'],data[0][\'record\'][\'server\'], # data[0][\'record\'][\'weight\'],data[0][\'record\'][\'maxconn\'] # ) # new_server_record = \'%sserver %s %s weight %s maxconn %s\n\' % ( # \'\' * 8, data[1][\'record\'][\'server\'], data[1][\'record\'][\'server\'], # data[1][\'record\'][\'weight\'], data[1][\'record\'][\'maxconn\'] # ) # print(\'用户想要修改的记录\',old_server_record) # res= fetch(backend) # print(\'来自change函数\',res) # if not res or old_server_record not in res: # return \'修改的记录不存在\' # else : # index= res.index(old_server_record) # res[index]=new_server_record # res.insert(0,\'%s\n\'%backend_data) # 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_data: # 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: # 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 delete(): # pass # # if __name__ == \'__main__\': # msg = \'\'\' # 1:查询 # 2：添加 # 3：修改 # 4:delete # 5:退出 # \'\'\' # msg_dic={ # \'1\':fetch, # \'2\':add, # \'3\':change, # \'4\':delete, # } # while True: # print(msg) # choice = input(\'请输入你的选项：\').strip() # if not choice :continue # if choice == \'5\': break # data = input(\'请输入你的数据:\').strip() # if choice != \'1\': # data = eval(data) # res = msg_dic[choice](data) # print(\'最终结果是\',res) ########################### # import os # # def file_handler(backend_data,res=None,type=\'fetch\'): # if type ==\'fetch\': # with open(\'haproxy.conf\', \'r\') as read_f: # tag = False # for read_line in read_f: # if read_line.strip() == backend_data: # tag = True # continue # # if tag and read_line.startswith(\'backend\'): # # tag = False # 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_data: # 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: # 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(data): # print(\'\033[1;43m这是查询功能\033 [0m\') # print(\'\033[1;43m cahxun \033 [0m %s\' % data) # backend_data = \'backend %s\' % data # return file_handler(backend_data) # # # def add(): # pass # # # def change(): # print(\'只是修改功能\') # pirnt(\'用户输入的数据是\', data) # backend = data[0][\'backend\'] # 文件当中的一条记录 # backend_data = \'backend %s\' % backend # old_server_record = \'%sserver %s %s weight %s maxconn %s\n\' % ( # \'\' * 8, data[0][\'record\'][\'server\'], data[0][\'record\'][\'server\'], # data[0][\'record\'][\'weight\'], data[0][\'record\'][\'maxconn\'] # ) # new_server_record = \'%sserver %s %s weight %s maxconn %s\n\' % ( # \'\' * 8, data[1][\'record\'][\'server\'], data[1][\'record\'][\'server\'], # data[1][\'record\'][\'weight\'], data[1][\'record\'][\'maxconn\'] # ) # print(\'用户想要修改的记录\', old_server_record) # res = fetch(backend) # print(\'来自change函数\', res) # if not res or old_server_record not in res: # return \'修改的记录不存在\' # else: # index = res.index(old_server_record) # res[index] = new_server_record # res.insert(0, \'%s\n\' % backend_data) # # file_handler(backend_data,res=res,type=\'change\') # # def delete(): # pass # # # if __name__ == \'__main__\': # msg = \'\'\' # 1:查询 # 2：添加 # 3：修改 # 4:delete # 5:退出 # \'\'\' # msg_dic = { # \'1\': fetch, # \'2\': add, # \'3\': change, # \'4\': delete, # } # while True: # print(msg) # choice = input(\'请输入你的选项：\').strip() # if not choice: continue # if choice == \'5\': break # data = input(\'请输入你的数据:\').strip() # if choice != \'1\': # data = eval(data) # res = msg_dic[choice](data) # print(\'最终结果是\', res)
|
1
|
... |