本章内容：
- 列表 & 元组操作
- 字符串操作
- 字典操作
- 集合操作
- 文件操作
- 字符编码与转码
Python 语言从未如此性感！
列表
Python中最基本的数据结构
Python有6个序列的内置类型.但最常见的是列表和元组
序列中的每个元素都分配一个数字标记它的”位置“或 ”索引”.第一个索引是0,第二个索引是1依此类推。
序列的基本操作
序列都可以进行的操作包括索引、切片、加、乘、检查成员。
序列是可以修改的，所以增加了一些元素赋值、元素删除、分片赋值的方法。
此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表简介
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
1 #Author:Junce Liu 2 Names = ["杭州","Junce","广州","苏州","通州",520]
使用下标索引来访问列表中，同样也可以使用方括号的形式截取字符。
如下所示：
1 Names = ["杭州","苏州","广州","苏州","通州","扬州"] 2 print(Names) 3 print(Names[0],Names[3]) # 指定打印（访问）列表中的元素。 4 print(Names[2:4]) # 切片，指定打印（访问）列表中的元素范围。 5 print(Names[-1]) # 切片，取反...最后一个元素 6 创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。 7 顾首不顾尾原则：在设定打印取值范围时，print(Names[2:4])的取值范围是索引2-4.输出却只打印了2 3[广州,苏州]，最后一个会默认忽略
列表截取
Python的列表截取与字符串操作类型，如下所示：
Name = ['Junce', 'Suce', 'soso']
操作：
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| Name[2] | 'Suce', | 读取列表中第三个元素 |
| Name[-2] | 'Junce' | 读取列表中倒数第二个元素 |
| Name[1:] | ['Junce', 'Suce', ] | 从第二个元素开始截取列表 |
列表作符
列表对 + 和 * 的操作符与字符串相似, + 号用于组合列表 * 号用于重复列表。
如下所示：
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| len([1, 2, 3]) | 3 | 长度 |
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
| ['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重复 |
| 3 in [1, 2, 3] | True | 元素是否存在于列表中 |
| for x in [1, 2, 3]: print x, | 1 2 3 | 迭代 |
方法
包含以下用法
| 序号 | 方法 |
|---|---|
| 1 增 | 在列表末尾添加新的对象 |
| 2 插 | 将对象插入列表 |
| 3 改 | 指定索引更改某个元素 |
| 4 删 | 删除列表中某个值的第一个匹配项 |
| 5 | 删除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| 6 统计 | 统计某个元素在列表中出现的次数 |
| 7 清空 | list.clear() |
| 8 反向 | 反向列表中元素 |
| 9 排序 | 对原列表进行排序 |
| 10 序列追加 | 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| 11 浅copy | 复制列表 |
1 #Author:Junce Liu 2 name = "junce is junce" 3 print(name.capitalize()) 4 print(name.count("e")) # 统计数量 5 print(name.center(50,"-")) # 字符串美化，50个"-"平均分布在name变量左右两侧并打印。 6 print(name.encode()) # 转换成二进制 7 print(name.endswith("ce")) # 判断是否以""中的字符串结尾。 8 print(name.expandtabs()) # 9 print(name.find("e")) # 10 print("e".isidentifier()) # 判断是不是合法的标识符号
字典
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key-value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 。
格式如下所示：
1 # Author:Junce Liu 2 City = {'01':"上海",'02':"北京",'03':"深圳"} 3 print(City) 4 print(City['01']) # 打印01键值 5 6 输出结果如下： 7 {'02': '北京', '01': '上海', '03': '深圳'} 8 上海
字典特性
键必须是唯一的
默认首字母排序，乱序
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
字典修改
字典已有键值修改.不存在键值对添加，键是唯一的不可更改。
1 City["01"]="杭州" # 更改键01的值为"杭州" 2 print(City) 3 City["05"]="武汉" # 添加键05值为"武汉" 4 5 输出结果如下： 6 {'01': '杭州', '03': '深圳', '02': '北京'} 7 {'05': '武汉', '01': '杭州', '03': '深圳', '02': '北京'}
字典删除
能删单一的元素也能清空字典
1 print(City) 2 del City['03'] # 删除键值03，Python全局del可删除字典. 3 print(City) 4 City.pop('05') # 删除键值05 5 print(City) 6 7 输出结果如下： 8 {'05': '武汉', '01': '杭州', '03': '深圳', '02': '北京'} 9 {'05': '武汉', '01': '杭州', '02': '北京'} 10 {'01': '杭州', '02': '北京'}
字典查询
标准查询，不存在键值显示None（没有）脚本执行不报错。
1 City = {'01':"上海",'02':"北京",'03':"深圳"} 2 print(City) 3 print(City.get('02')) # 打印02键值 4 print(City.get('04')) # 打印字典没有的键值元素 5 print('03' in City) # 查询键值03是否存在 6 print('06' in City) # 查询键值06是否存在 7 8 输出结果如下： 9 {'01': '上海', '03': '深圳', '02': '北京'} 10 北京 11 None 12 True 13 False
字典嵌套
多层嵌套，突然多三级菜单有了概念。
1 # Author:Junce Liu 2 City = { 3 "上海":{"上海":["徐汇","陆家嘴","浦东"]}, 4 "浙江":{"杭州":["滨江","西湖","江干",]}, 5 "广东":{"广州":["黄埔","天河","越秀"]} 6 } 7 print(City["上海"]) 8 print(City["浙江"]) 9 print(City["广东"]) 10 11 输出结果如下： 12 13 {'上海': ['徐汇', '陆家嘴', '浦东']} 14 {'杭州': ['滨江', '西湖', '江干']} 15 {'广州': ['黄埔', '天河', '越秀']}
方法
解锁更多姿势
姿势 01
1 # Author:Junce Liu 2 City = {'01':"上海",'02':"北京",'03':"深圳"} 3 print(City) 4 print(City.values()) # 仅打印字典值 5 print(City.keys()) # 仅打印字典键 6 7 输出结果如下： 8 {'01': '上海', '02': '北京', '03': '深圳'} 9 dict_values(['上海', '北京', '深圳']) 10 dict_keys(['01', '02', '03'])
姿势 02
1 #Author:Junce Liu 2 City = { 3 '上海':{"上海":["徐汇","陆家嘴","浦东"]}, 4 '浙江':{"杭州":["滨江","西湖","江干"]}, 5 '广东':{"广州":["黄埔","天河","越秀"]}, 6 } 7 8 b = { '上海':{"迪士尼":["徐汇","陆家嘴","浦东"]}, 9 1:5, 10 2:8 11 } 12 print(City) 13 City.update(b) # 将字典b添加到City，默认重复的键覆盖..none的添加 14 print(City) 15 16 输出结果如下： 17 18 {'浙江': {'杭州': ['滨江', '西湖', '江干']}, '上海': {'上海': ['徐汇', '陆家嘴', '浦东']}, '广东': {'广州': ['黄埔', '天河', '越秀']}} 19 {'浙江': {'杭州': ['滨江', '西湖', '江干']}, '上海': {'迪士尼': ['徐汇', '陆家嘴', '浦东']}, '广东': {'广州': ['黄埔', '天河', '越秀']}, 2: 8, 1: 5}
姿势 03
1 #Author:Junce Liu 2 City = { 3 '上海':{"上海":["徐汇","陆家嘴","浦东"]}, 4 '浙江':{"杭州":["滨江","西湖","江干"]}, 5 '广东':{"广州":["黄埔","天河","越秀"]}, 6 } 7 print(City) 8 print(City.items()) # 将字典转化成列表，列表中是元组。 9 10 输出结果如下： 11 {'浙江': {'杭州': ['滨江', '西湖', '江干']}, '上海': {'上海': ['徐汇', '陆家嘴', '浦东']}, '广东': {'广州': ['黄埔', '天河', '越秀']}} 12 dict_items([('浙江', {'杭州': ['滨江', '西湖', '江干']}), ('上海', {'上海': ['徐汇', '陆家嘴', '浦东']}), ('广东', {'广州': ['黄埔', '天河', '越秀']})])
姿势 04
1 #Author:Junce Liu 2 City = { 3 '上海':{"上海":["徐汇","陆家嘴","浦东"]}, 4 '浙江':{"杭州":["滨江","西湖","江干"]}, 5 '广东':{"广州":["黄埔","天河","越秀"]}, 6 } 7 print(City) 8 c = dict.fromkeys([1,2,3],[5,{"name":"junce"},111]) # 初始化一个字典，键存在。 9 print(c) 10 c[3][1]['name'] = "Junce liu" # 更改格式化字典 11 print(c) 12 13 输出结果如下： 14 {'上海': {'上海': ['徐汇', '陆家嘴', '浦东']}, '浙江': {'杭州': ['滨江', '西湖', '江干']}, '广东': {'广州': ['黄埔', '天河', '越秀']}} 15 {1: [5, {'name': 'junce'}, 111], 2: [5, {'name': 'junce'}, 111], 3: [5, {'name': 'junce'}, 111]} 16 {1: [5, {'name': 'Junce liu'}, 111], 2: [5, {'name': 'Junce liu'}, 111], 3: [5, {'name': 'Junce liu'}, 111]}
姿势 05
1 #Author:Junce Liu 2 City = { 3 '上海':{"上海":["徐汇","陆家嘴","浦东"]}, 4 '浙江':{"杭州":["滨江","西湖","江干"]}, 5 '广东':{"广州":["黄埔","天河","越秀"]}, 6 } 7 for i in City: 8 print(i,City[i]) 9 10 输出结果如下： 11 浙江 {'杭州': ['滨江', '西湖', '江干']} 12 广东 {'广州': ['黄埔', '天河', '越秀']} 13 上海 {'上海': ['徐汇', '陆家嘴', '浦东']}
集合
集合是一个无序的，不重复的数据组合，它的主要作用如下：
- 去重：集合创建，就自动重了。
- 关系测试：数据之前的交集、差集、并集等关系。
常用操作：
1 1 #Author:Junce Liu 2 2 3 3 # 集合创建 4 4 list = [1,5,1,3,4,9,5] 5 5 list_1 = set(list) # 集合列表 6 6 print (list_1,type(list_1)) # 打印并显示数据类型 7 7 8 8 输出效果如下： 9 9 {1, 3, 4, 5, 9} <class 'set'> # 显示打印去重，数据类型集合 10 10 11 11 # 交集,取出双方重复的值。 12 12 print(list_1.intersection(list_2)) 13 13 14 14 输出结果如下： 15 15 {1, 3, 4, 5, 9} {1, 2, 4, 5, 6, 9} 16 16 {1, 4, 5, 9} 17 17 18 18 # 并集，去重合并双方都没有的 19 19 print(list_1.union(list_2)) 20 20 输出结果如下： 21 21 {1, 2, 3, 4, 5, 6, 9} 22 22 23 23 # 差集，单方有一方没有的。 in list_1 but not in list_2 24 24 print(list_1.difference(list_2)) 25 25 26 26 输出结果如下： 27 27 {3} 28 28 29 29 # 父集，子集。 30 30 list_3 = set([1,3,7]) 31 31 print(list_1.issubset(list_2)) 32 32 print(list_1.issuperset(list_2)) 33 33 print(list_1.issubset(list_3)) 34 34 print(list_3.issuperset(list_1)) 35 35 36 36 输出结果如下： 37 37 False 38 38 False 39 39 True 40 40 True 41 41 42 42 # 对称差集,互相都没有的放一起。 43 43 print(list_1.symmetric_difference(list_2)) 44 44 45 45 输出显示如下： 46 46 {2, 3, 6}
增删改查
1 # 增 删 改 查 2 list_1.add(899) # 添加一项 3 print(list_1) 4 list_1.update([777,888,999]) # 添加多项 5 print(list_1) 6 print(list_1.pop()) # 任意删除 7 8 print(list_1.remove(999)) # 如果指定没有的字符会报错。 9 print(list_1.discard(0)) # 指定没有的不报错 10 11 输出显示如下： 12 {1, 899, 3, 4, 5, 9} 13 {1, 899, 3, 4, 5, 999, 9, 777, 888} 14 1 15 None 16 Non
方法拓补
1 使用remove()可以删除一项： 2 3 t.remove('H') 4 5 6 len(s) 7 set 的长度 8 9 x in s 10 测试 x 是否是 s 的成员 11 12 x not in s 13 测试 x 是否不是 s 的成员 14 15 s.issubset(t) 16 s <= t 17 测试是否 s 中的每一个元素都在 t 中 18 19 s.issuperset(t) 20 s >= t 21 测试是否 t 中的每一个元素都在 s 中 22 23 s.union(t) 24 s | t 25 返回一个新的 set 包含 s 和 t 中的每一个元素 26 27 s.intersection(t) 28 s & t 29 返回一个新的 set 包含 s 和 t 中的公共元素 30 31 s.difference(t) 32 s - t 33 返回一个新的 set 包含 s 中有但是 t 中没有的元素 34 35 s.symmetric_difference(t) 36 s ^ t 37 返回一个新的 set 包含 s 和 t 中不重复的元素 38 39 s.copy() 40 返回 set “s”的一个浅复制
文件操作
对文件操作流程
打开文件
得到文件句柄并赋值给一个变量
通过句柄对文件进行操作
关闭文件
语法：
f = open("song",encoding="utf-8") # 文件句柄
参数细节如下：
- “f”变量是一个包含了你要访问的文件名称的字符串值。
- “r”决定了打开文件的模式：只读,写入,追加等，所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
- buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。
读取
以只读方式打开文件，文件的指针将会放在文件的开头。这是默认模式.
1 #Author:Junce Liu 2 f = open("song",'r',encoding="utf-8") # 文件句柄,”r”查看。 3 print(f.read()) # 打印查看，实在太长这里自行忽略。
写入
打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件.
1 #Author:Junce Liu 2 f = open("song",'a',encoding="utf-8") # 文件句柄,”w”写入。 3 f.write("Chance favors the prepared mind.") # 指定写入的字符....
此时你想要直接打印文件看效果，是不行的.这是读写模式比较蛋疼的一点，固定只能同时出现一种模式能读不能写，能写不能读。
需要自己打开文件看，另外一点需要注意的是open存在的文件必须在脚本的同意目录下不然会报错。
贴图如下：
追加
打开一个文件用于追加,如果该文件已存在文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
1 #Author:Junce Liu 2 f = open("motto",'a',encoding="utf-8") # 文件句柄，"a"追加 3 f.write("天行健，君子以自强不息;") # 追加，换行 4 f.write("\n地势坤，君子以厚德载物。\n") 5 f.close() # 文件关闭 6 # 此时再看文件就出现了追加的内容 7 8 文件内容如下： 9 天行健，君子以自强不息; 10 地势坤，君子以厚德载物。
打印当前光标位置
1 #Author:Junce Liu 2 f = open("motto",'r',encoding="utf-8") # 文件句柄，"r" 阅读 3 print(f.tell()) # 打印当前贯标所在位置 4 print(f.readline().strip()) # 读取一行并打印 5 print(f.tell()) # 显示读完一行后的所在位置 6 7 输出结果： 8 伫倚危楼风细细， # 读取的一行 9 26 # 共26字符
返回到指定行，循环打印
1 #Author:Junce Liu 2 f = open("motto",'r',encoding="utf-8") # 文件句柄，"r" 阅读 3 print(f.tell()) # 打印当前贯标所在位置 4 print(f.readline()) # 读取一行并打印 5 print(f.readline()) 6 print(f.readline()) 7 print(f.tell()) # 显示读完一行后的所在位置 8 f.seek(0) # 返回到指定行 9 print(f.readline())
读写
打开一个文件用于读写，文件指针将会放在文件的开头。写入时默认追加形式写入.
1 #Author:Junce Liu 2 f = open("can",'r+',encoding="utf-8") # 文件句柄，定义"r+"追加,读写。 3 print(f.readline()) # 打印一行 4 f.write('\n-------good------\n') # 写入('\n-------good------\n') 5 print(f.readline()) # 再打印一行 6 7 此时执行脚本无报错，查看motto文件显示如下 8 9 衣带渐宽终不悔，为伊消得人憔悴。 10 junce Liu 11 -------good------
写读
这个用处不大.知道就好
打开一个文件用于读写，如果该文件已存在则将其覆盖，如果该文件不存在则创建新文件。
1 #Author:Junce Liu 2 f = open("can",'r+',encoding="utf-8") # 文件句柄，定义"r+"读写。 3 print(f.readline()) # 打印一行 4 f.write('\n-------cat------\n') # 写入('\n-------good------\n') 5 print(f.tell) # 显示当前光标位置 6 f.seek(10) # 光标回到第10字符
二进制格式读文件
以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
1 #Author:Junce Liu 2 f = open("can",'rb') # 文件句柄，定义"rb"二进制格式读取文件。 3 print(f.readline()) # 打印一行 4 5 输出结果如下： 6 b'Hello World!\r\n'
二进制格式写文件
以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
1 #Author:Junce Liu 2 f = open("can",'wb') # 文件句柄，定义"rb"二进制格式写入文件。 3 f.write("Hello World!\n".encode()) # 写入，因为文件是二进制格式的所以这里用到转码.encoade 注意哈，不写会报错的。 4 f.close() # 关闭文件 5 6 查看文件如下： 7 Hello World!
循环
1 方法 .readline 每次只读一行，要求打印前五行。 2 #Author:Junce Liu 3 f = open("motto",'r',encoding="utf-8") # 文件句柄，"r" 阅读 4 for i in range(5): # 打印前5行 5 print(f.readline()) 6 7 输出结果： 8 9 伫倚危楼风细细， 10 望极春愁，黯黯生天际。 11 草色烟光残照里，无言谁会凭栏意。 12 拟把疏狂图一醉， 13 对酒当歌，强乐还无味。 14 15 #Author:Junce Liu 16 f = open("motto",'r',encoding="utf-8") # 文件句柄，"r" 阅读 17 for line in f.readlines(): # 循环一遍 18 print(line.strip()) # 打印循环并去空行 19 20 输出结果： 21 22 伫倚危楼风细细， 23 望极春愁，黯黯生天际。 24 草色烟光残照里，无言谁会凭栏意。 25 拟把疏狂图一醉， 26 对酒当歌，强乐还无味。 27 衣带渐宽终不悔，为伊消得人憔悴。 28 29 #Author:Junce Liu 30 f = open("motto",'r',encoding="utf-8") # 文件句柄，"r" 阅读 31 for line in f: # 每次打印一行 32 print(line.strip()) # 打印循环并去空行
打印进度条
1 #Author:Junce Liu 2 import sys,time # 调用sys,time模块 3 for i in range(50): # 循环50次打印 4 sys.stdout.write("#") # 打印 # 符号 5 sys.stdout.flush() # 刷新写入 6 time.sleep(1) # 隔一秒打印一次
7 输出效果如下：
8 ##################################################
with 语句
为了避免打开文件后忘记关闭，可以通过管理上下文，即：
1 with open('log','r') as f:
如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。
在Python 2.7 后，with又支持同时对多个文件的上下文进行管理，即：
1 with open('log1') as obj1, open('log2') as obj2: 2 pass
作业：
程序1: 实现简单的shell sed替换功能
程序2:修改haproxy配置文件
需求：
1 1、查 2 输入：www.oldboy.org 3 获取当前backend下的所有记录 4 5 2、新建 6 输入： 7 arg = { 8 'bakend': 'www.oldboy.org', 9 'record':{ 10 'server': '100.1.7.9', 11 'weight': 20, 12 'maxconn': 30 13 } 14 } 15 16 3、删除 17 输入： 18 arg = { 19 'bakend': 'www.oldboy.org', 20 'record':{ 21 'server': '100.1.7.9', 22 'weight': 20, 23 'maxconn': 30 24 } 25 }
配置文件
1 global 2 log 127.0.0.1 local2 3 daemon 4 maxconn 256 5 log 127.0.0.1 local2 info 6 defaults 7 log global 8 mode http 9 timeout connect 5000ms 10 timeout client 50000ms 11 timeout server 50000ms 12 option dontlognull 13 14 listen stats :8888 15 stats enable 16 stats uri /admin 17 stats auth admin:1234 18 19 frontend oldboy.org 20 bind 0.0.0.0:80 21 option httplog 22 option httpclose 23 option forwardfor 24 log global 25 acl www hdr_reg(host) -i www.oldboy.org 26 use_backend www.oldboy.org if www 27 28 backend www.oldboy.org 29 server 100.1.7.9 100.1.7.9 weight 20 maxconn 3000
完成
1 需求 查 2 3 #Author:Junce Liu 4 with open("newfiles",'r',encoding="utf-8") as f : 5 for line in f.readlines(): 6 print(line.strip()) # 去空行循环文件
新建
#Author:Junce Liu
with open("newfiles",'r+',encoding="utf-8") as f ,\
open("dir",'w+',encoding="utf-8") as dir:
print(f.readline())
dir.write("\n arg ={"
"\n'bakend': 'www.oldboy.org','"
"\nrecord':{'server': '100.1.7.9',"
"\n 'weight': 20,'maxconn': 30""\n}\n""\n}" "\n")
print(f.readline())
删除，输入
#Author:Junce Liu
with open("newfiles",'r+',encoding="utf-8") as f ,\
open("dir",'w+',encoding="utf-8") as dir:
dir.truncate()
print(f.readline())
dir.write("\n arg = {"
"\n'bakend': 'www.oldboy.org',"
"\n'record':{"
"\n'server': '100.1.7.9',"
"\n'weight': 20,"
"\n'maxconn': 30""}""}")
print(f.readline())
字符编码与转码
详情链接：http://www.cnblogs.com/yuanchenqi/articles/5956943.html
需知:
1.在python2默认编码是ASCII, python3里默认是utf-8
2.unicode 分为 utf-32(占4个字节),utf-16(占两个字节)，utf-8(占1-4个字节)， so utf-8就是unicode
3.在py3中encode,在转码的同时还会把string 变成bytes类型，decode在解码的同时还会把bytes变回string
Python 2
1 #-*-coding:utf-8-*- 2 #Author:Junce 3 import sys 4 print(sys.getdefaultencoding()) 5 6 msg = "你好"
7 msg_gb2312 = msg.decode("utf-8").encode("gb2312") 8 gb2312_to_gbk = msg_gb2312.decode("gbk").encode("gbk") 9 print(msg) 10 print(msg_gb2312) 11 print(gb2312_to_gbk)
Python 3.5.2
1 #-*-coding:gb2312 -*- #这个也可以去掉 2 #Author：Junce 3 4 import sys 5 print(sys.getdefaultencoding()) 6 7 8 msg = "你好" 9 #msg_gb2312 = msg.decode("utf-8").encode("gb2312") 10 msg_gb2312 = msg.encode("gb2312") #默认就是unicode,不用再decode,喜大普奔 11 gb2312_to_unicode = msg_gb2312.decode("gb2312") 12 gb2312_to_utf8 = msg_gb2312.decode("gb2312").encode("utf-8") 13 14 print(msg) 15 print(msg_gb2312) 16 print(gb2312_to_unicode) 17 print(gb2312_to_utf8)
未完待更新.......
各位看博客的妹子们,现在页面是不是还丑了点？是的，我自己都不想看.....回头讲页面优化一并将这个做了。
747
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
