1. 数字类型 ：int
数字主要是用于计算、运算。
1.1 bit_length()将十进制转化为二进制站的位数
''' 二进制 十进制 0000 0001 1 0000 0010 2 0000 0011 3 0000 0100 4 ''' x = 1 print(x.bit_length()) y = 10 print(y.bit_length()) z = 100 print(z.bit_length())
1.2 数字与字符串转化： int ---> str : str(int) str ---> int : int(str) str必须全部是数字组成
int ---> str : str(int) str ---> int : int(str) str必须全部是数字组成 count = 1 print(str(count)) letter = '18' print(int(letter))
2. 布尔值 ： bool
布尔值就两种：True，False。就是反应条件的正确与否。
2.1 布尔型与数字、字符串转化：
int ---> bool： 0 ---> False 非0 ---> True bool---> int ： int(True) ---> 1 int(False)---> 0 str ---> bool： 空字符串 ---> False 非空字符串---> True print(int(True)) # >>> 1 print(int(False)) # >>> 0 print(bool(18)) # >>> True print(bool(0)) # >>> False print(bool('a')) # >>> True print(bool('')) # >>> False
3. 字符串：str 可迭代，不可变的
3.1 字符串的拼接
字符串拼接：字符串只能进行"相加"和"相乘"运算。
x = 'Hello' y = 'World ' z = '！' print(x+y+z) # HelloWorld！ x = 'Hello ' print(x*10) # HelloHelloHelloHelloHelloHelloHelloHelloHelloHello
3.2 字符串的索引
索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。
l = 'Hello World！' l1 = l[0] l2 = l[-1] l3 = l[-2] print(l1) # H print(l2) # ！ print(l3) # d
3.3 字符串的切片
切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾首不顾尾）。
l[起始索引:结束索引+1:步长]
l = 'Hello World！' l1 = l[0:5] # 第1个字符到第4个字符 l2 = l[:5] # 第1个字符到第4个字符，0可以省略 l3 = l[0:] # 第1个字符到最后一个字符，结尾可以省略 l4 = l[:] # 第一个字符到最后一个字符，开头和结尾都可以省略 l5 = l[0:-1] # 第一个字符到最后1个字符，不顾尾 l6 = l[0:7:2] # 第1个字符到第6个字符，步长为2 l7 = l[7:0:-2] # 反向取字符串，加反向步长 print(l1) # Hello print(l2) # Hello print(l3) # Hello World！ print(l4) # Hello World！ print(l5) # Hello World print(l6) # HloW print(l7) # o le
3.4 字符串的常用方法
3.4.1 upper() 字母全部大写 lower() 字母全部小写
l = 'Hello World！' print(l.upper()) # HELLO WORLD！ print(l.lower()) # hello world！ #例：验证码不区分大小写 code = 'aBcD'.upper() your_code = input('请输入验证码：').upper() if your_code == code: print('验证成功')
3.4.2 strartswith() 判断以什么为开头 endswith() 判断以什么为结尾
l = 'Hello World！' print(l.startswith('h')) # False print(l.endswith('！')) # True print(l.startswith('l',2,5)) # True print(l.endswith('World！')) # True
3.4.3 strip() 去除首尾的空格，制表符\t，换行符\n。不仅仅是去除空格，去除的元素可自定制。
l = ' Hello World！' l1 = '\tHello World！\n' l2 = '**Hello World！**' l3 = 'niuHello World！uin' print(l.strip()) # Hello World！ print(l1.strip()) # Hello World！ print(l2.strip('*')) # Hello World！ print(l2.lstrip('*')) # Hello World！** print(l2.rstrip('*')) # **Hello World！ print(l3.strip('inu')) # Hello World！ # 迭代无序的去除首尾的‘i’‘n’‘u’ 注：input都加strip # 例：登录输入用户名密码清空收尾空格 name = input('请输入姓名：').strip() pwd = input('请输入密码：').strip() if name == 'niu' and pwd == '123': print('登录成功') print(name) print(pwd)
3.4.4 replace() 把字符串的旧字符串替换成新的字符串，如果指定第三个参数max，则替换不超过max次。
语法：str.replace(old,new,[max])
l = 'HellO WOrld！' print(l.replace('O','o')) # 默认全部替换 print(l.replace('O','o',1)) # 替换1次，只能从前往后替换，指定替换次数，不能指定替换
3.45 split() 字符串 转化 列表 切分
以什么分割，最终形成一个列表此列表不含有这个分割的元素。
l = 'Hello World！' print(l.split()) # ['Hello','World！'] # 默认以空格分隔 print(l.split('o')) # ['Hell','W','rld！'] # 默认全部分割 print(l.split('o',1)) # ['Hell','World！'] # 分割1次，第1
3.4.6 join()将列表 转化 字符串 切分
l = 'Hello World！' l1 = ''.join(l) print(l1,type(l1)) # Hello World！ <class 'str'> l2 = '+'.join(l) print(l2,type(l2)) # H+e+l+l+o+ +W+o+r+l+d+！ <class 'str'> s = ['Hello','World','！'] s1 = ''.join(s) print(s1,type(s1)) # HelloWorld！ <class 'str'> s2 = '+'.join(s) print(s2,type(s)) Hello+World+！ <class 'str'>
3.4.7 find() 通过元素找索引 找不到返回-1 index() 通过元素找索引 找不到元素会报错
l = 'Hello World!' l1 = l.find('llo',2,6) l2 = l.find('ii') print(l1,type(l1)) # 2 <class 'int'> 返回的找到的元素的索引 print(l2) # -1 找不到返回-1 l3 = l.index('llo',2,6) l4 = l.index('ii') # substring not found 找不到报错 print(l3) # 2 返回的找到的元素的索引 # print(l4) # substring not found 找不到报错
3.4.8 center() 内容居中，总长度自己设定，默认填充为None
l = 'Hello World！' l1 = l.center(30,) l2 = l.center(30,'*') print(l1) # Hello World！ print(l2) # *********Hello World！*********
3.4.9 capitalize 首字母大写其余字母小写
l = 'hello World!' print(l.capitalize()) # Hello world!
3.4.10 swapcase() 大小写翻转
l = 'Hello World！' print(l.swapcase()) # hELLO wORLD！
3.4.11 title()非字母隔开的每个单词的首字母大写
l = 'helloworld！2hellochina！*hellobeijing！、hello沙河hello！' print(l.title()) #Hello World！ Hello China！ Hello Beijing！Hello 沙河
3.4.12 format() 格式化输出 三种方法
# 第一种：直接输入 l = '我叫{},今年{}岁，爱好{}' print(l.format('niu','18','吃')) # 第二种：通过索引赋值 l1 = '我叫{0}，今年{1}，爱好{2}，希望永远{1}岁！' print(l1.format('niu',18,'吃')) # 第三种：通过键赋值 l2 = '我叫{name}，今年{age}，爱好{hobby}，希望永远{age}岁！' print(l2.format(name='niu',age=18,hobby='吃'))
3.4.13 is系列
l = 'niu123' print(l.isdigit()) # False # 字符串由数字组成 print(l.isalnum()) # True # 字符串由字母或数字组成 print(l.isalpha()) # False # 字符串由字母组成
3.4.14 len() 返回对象的长度或项目个数； count() 数字字符串的元素出现的个数
l = 'Hello World！ Hello China！ Hello Beijing！' print(len(l)) # 40 print(l.count('H')) # 3 print(l.count('H',0,20)) # 2 # 可切片
4. 列表：list
列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：
li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。
定义：[]内可以有多个任意类型的值，逗号分隔
4.1 列表的增
append() 追加 l1 = ['hello',123,[11,22,'ABC']] l1.append(0) # #增加到最后 l1.append('abc') # #增加到最后 l1.append(['add',123]) # #增加到最后 print(l1) # ['hello', 123, [11, 22, 'ABC'], 0, 'abc', ['add', 123]] insert() 按照索引插入 l = ['Hello','World','！',123,[11,22,33]] l.insert(0,'niu') # 按照索引去增加 print(l) # ['niu', 'Hello', 'World', '！', 123, [11, 22, 33]] extend() 迭代的加 l2 = [1,['aa',2],'abc'] l2.extend('0') l2.extend(['abc',0]) l3 = ['123',0] l2.extend(l3) # 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） l2.extend('xxx') # 迭代的增 print(l2) # [1, ['aa', 2], 'abc', '0', 'abc', 0, '123', 0, 'x', 'x', 'x']
4.2 列表的删
pop() 按照索引删除，返回被删除的值，增删改查中唯一一个有返回值的 l = [1,2,'a,b',['ab',0]] print(l.pop(3)) # ['ab', 0] remove() 按照元素去删除 l = [1,2,'a,b',['ab',0]] l.remove('a,b') # 删除 字符串元素 l.remove(['ab',0]) # 删除 列表元素 print(l) # [1, 2] cleat() 清空列表 l = [1,2,'a,b',['ab',0]] l.clear() print(l) # [] del() # 按照索引、按照切片删除，也可删除列表没有返回值 del() 按索引删除 l = [1,2,'a,b',['ab',0]] del l[0] # 按照索引去删除，没有返回值 print(l) # [2, 'a,b', ['ab', 0]] del() 按切片删除 l = [1,2,'a,b',['ab',0]] del l[2:4] # 按着切片删除，没有返回值 print(l) # [1,2] del() 删除列表 l = [1,2,'a,b',['ab',0]] del l # 删除列表 print(l) # name 'l' is not defined
4.3 列表的改
按照索引改 l = ['hello','world','！'] l[0] = ('Hello') print(l) # ['Hello', 'world', '！'] l[2] = 'Hello World！' print(l) # ['Hello', 'world', 'Hello World！'] 按照切片去改 l = ['Hello','World','！'] l[:2] = 'abc' print(l) # ['a', 'b', 'c', '！'] l[:2] = ['Hello World！',11] print(l) # ['Hello World！', 11, 'c', '！'] 切片加步长去改，加步长 必须一一对应 l = ['H','e','l','l','o',' ','W','o','r','l','d','！'] l[:10:2] = ['bacde',1,2,3,4] #加步长 必须一一对应 print(l)
4.4 列表的查
# 按照索引去查 l = ['Hello World！',5566,['abc',12]] print(l[1]) # 5566 print(l[-1]) # ['abc', 12] # 按照切片查询 l = ['Hello World！',5566,['abc',12]] print(l[:1]) # ['Hello World！'] # 切片 print(l[:3:2]) # ['Hello World！', ['abc', 12]] # 切片加步长 # for 循环遍历 l = ['Hello World！',5566,['abc',12]] for item in l: print(item)
4.5 其他方法
# len() 长度 l = ['a','b','c','d','e','a'] print(len(l)) # count() 某个元素出现的次数 print(l.count('a')) # sort() 正序排序(从大到小) l.sort() print(l) reverse()倒叙排序 l.sort(reverse=True) # 倒叙排序（从小到大） print(l) # reverse() 翻转 l.reverse() print(l)
4.6 列表的嵌套
l1 = [1, 2, 'abc', ['qUIt ','niu', 99], 6] # 1,将abc该成Abc l1[2] = l1[2].capitalize() print(l1) #2，将'qUIt变成全部大写。 l1[3][0] = l1[3][0].upper() print(l1) # 3，99让其通过数字加1的方式变成 '100'. l1[-2][-1] = str(l1[-2][-1] + 1) print(l1) # 4，99让其通过字符串相加方式变成'100' l1[-2][-1] = str(l1[-2][-1] )+ '9' print(l1)
5. 元组：tuple
python的元组与列表类型，不同之处在于元组的元素不能修改（增删改）。
元组使用小括号()，列表使用方括号[]。只读列表，
元组创建很简单，只需要在括号里添加元素，并使用逗号隔开即可。
tu = (1,2,3,'abc',[5566],0)
5.1 元组的查
5.1.1 通过索引去查
print(tu[-2])
5.1.2 通过切片去查
print(tu[3:4]) # 切片 print(tu[:4:2]) # 切片加步长
5.1.3 循环查询
for i in tu: print(i) index() 通过元素找索引 count() 元素出现的个数 len() 元素的个数 print(tu.index(2)) # 1 print(tu.count('abc')) # 1 print(tu.count('a')) # 0 print(len(tu)) # 6 元素里的元素可以修改 tu[-2].append(7788) print(tu) # (1, 2, 3, 'abc', [5566, 7788], 0)
5.2 range 自定义范围
print(range(100)) # 打印 0-99 for i in range(100): print(i) # 打印 0-100 for i in range(1,101): print(i) 加步长 打印1-100的偶数 for i in range(2,101,2): print(i) 倒着取值，打印100-0 for i in range(100,0,-1): print(i)
6. 字典：dic
字典的key是唯一的。key必须是不可变的数据类型，value是任意数据类型。
数据类型分类：
不可变数据类型（可哈希）：str，bool,tuple,int。
可变数据类型（不可哈希）：dict，list，set。
容器类数据类型：list，tuple，dict，set。
字典：存储数据多，关系型数据，查询速度快(二分查找)
二分查找：也称折半查找（Binary Search），它是一种高效率的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中的元素按关键字有序排列。
备注：python3.5以前 (包含3.5)，字典无序
python3.6以后 (包含3.6)，进行了优化，不清楚到底是有序还是无序
6.1 字典的增
dic = { 'name':'niu' , 'age':18, 'job':'test' }
6.1.1 输入键增加
dic['hobby'] = '吃' # 无则增加 print(dic) dic['name'] = 'zs' # 有则修改 print(dic)
6.1.2 setdefault 在字典中添加键值对，如果只有键那对应的值是none,但是如果原字典中存在设置的键值对，则不会更改或者覆盖。
dic.setdefault('name','ls') print(dic) # {'name': 'niu', 'age': 18, 'job': 'test'} dic.setdefault('sex') print(dic) # {'name': 'niu', 'age': 18, 'job': 'test', 'sex': None} dic.setdefault('sex','male') print(dic) # {'name': 'niu', 'age': 18, 'job': 'test', 'sex': None} dic.setdefault('high',178) print(dic) # {'name': 'niu', 'age': 18, 'job': 'test', 'sex': None, 'high': 178}
6.2 字典的删
dic = { 'name':'niu' , 'age':18, 'job':'test' }
6.2.1 pop() 通过键删除
print(dic.pop('name')) # niu # 返回值 print(dic.pop('name',None)) # niu
6.2.2 popitem() 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回，在python3.6以后，默认删除最后一个键值对
print(dic.popitem()) # 删除最后一个
6.2.3 clear() 清空字典
dic.clear() print(dic) # {}
6.2.4 del() 删除字典，也可按键删除
del dic # 删除字典 内存级别删除 print(dic) # name 'dic' is not defined 报错，因为在内存级别已经删除 按键删除 del dic['name'] print(dic)
6.3 字典的改
dic = { 'name':'niu' , 'age':18, 'job':'test' }
6.3.1 通过键修改
dic['name'] = 'zs' # 无责增加，有责修改。 print(dic) # 将dic里面的键值对覆盖并更新到dic2中，dic不变 。
6.3.2 update() 覆盖并更新
dic = {'name':'niu' , 'age':18,'job':'test'}
dic1 = {'name':'zs','sex':'male','hobby':'吃'}
dic1.update(dic) # 将dic里面的键值对覆盖并更新到dic1中，dic不变 。
print(dic)
print(dic1)
6.4 字典的查
dic = {'name':'niu' ,'age':18,'job':'test'}
6.4.1 通过键去查，查不到键会报错
print(dic['name']) # niu print(dic['name1']) # niu 查不到键会报错
6.4.2 get() 查不到不会报错，返回None
print(dic.get('name')) # niu print(dic.get('name1')) # None print(dic.get('name1','没有此键')) # 没有此键
6.4.3 键keys() 值values() 键值对items()
# 类似于列表的一个容器，没有索引 dic = { 'name':'niu' ,'age':18,'job':'test'} print(dic.keys()) # dict_keys(['name', 'age', 'job']) print(list(dic.keys())) # ['name', 'age', 'job'] print(dic.values()) # dict_values(['niu', 18, 'test']) print(list(dic.values())) # ['niu', 18, 'test'] print(dic.items()) # dict_items([('name', 'niu'), ('age', 18), ('job', 'test')]) print(list(dic.items())) # [('name', 'niu'), ('age', 18), ('job', 'test')]
6.4.4 for循环取值
dic = { 'name':'niu' ,'age':18,'job':'test'}
for k in dic.keys():
print(k) # name age job
for v in dic.values():
print(v) # niu 18 test
for i in dic.items():
print(i) # ('name', 'niu') ('age', 18) ('job', 'test')
for k,v in dic.items():
print(k,v) # name niu # age 18 # job test
6.4.5 分别赋值
a,b = 1,3 print(a,b) # 1 3 a,b = [11,22] print(a,b) # 11,22 a,b = b,a print(a,b) # 3,1 a, b, c, d = ['niu', 'zs', 'li', 'ww'] print(a, b, c, d) # niu zs li ww
6.4.6 公共方法 len()
dic = { 'name':'niu' ,'age':18,'job':'test'}
print(len(dic)) # 3
6.4.7 fromkeys() 创建字典一种，以fromkeys()创建的键值对，如果值是列表的话，多个共用的都是一个列表
dic = dict.fromkeys('abc','666') print(dic) # {'a': '666', 'b': '666', 'c': '666'} dic1 = dic.fromkeys(['a','b','c'],'666') print(dic1) # {'a': '666', 'b': '666', 'c': '666'} dic2 = dic.fromkeys('abc',[]) dic2['a'].append('666') print(dic2) # {'a': ['666'], 'b': ['666'], 'c': ['666']}
6.5 字典的嵌套
dic = {'name_list':['zs','ls'],
'l':{
'name':'ww',
'high':178,
}
}
#['zs','ls'] 追加一个元素'niu'，
dic['name_list'].append('niu')
print(dic)
# {'name':'ww','high':178,}增加一个键值对'sex': man，
dic['l']['sex'] = 'man'
print(dic)
7. 集合
集合：无序不重复的数据类型。它里面的元素必须是可哈希的，但是集合本身是不可哈希的。
集合是无序的，没有索引，不能改，只能‘增删查’
1、关系测试，交集，并集，子集，差集
2、去重（列表的去重）
set1={1,'alex',False,(1,2,3)}
l1=[1,1,2,2,3,3,4,5,6,6]
l2=(list(set(l1)))
print(l2)#>>>[1, 2, 3, 4, 5, 6]
7.1 增删查
# 集合的增 无序 set1={'Lily','Lucy'} set1.add('Lucas') print(set1) # {'Lucas','Lily','Lucy'} # 迭代着增加update() set1={'Lily','Lucy'} set1.update('Lucas') print(set1) # {'a','Lily','u','c','L','s','Lucy'} # 集合的删 # remove()按照元素删除 set1={'Lily','Lucy'} set1.remove('Lucy') print(set1)#>>>{'Lily'} # pop()随机删除一个元素 set1={'Lily','Lucy'} set1.pop() print(set1)#>>>{'Lucy'} # clear()清空集合 set1={'Lily','Lucy'} set1.clear() print(set1)#>>>set() # del()内存级别删除集合 set1={'Lily','Lucy'}24delset125print(set1)#报错
# 集合的查
# for循环
for i in set1:
print(i)
7.2 集合其他操作
7.21 交集
set1={1,2,3,4,5}
set2={4,5,6,7,8}
print(set1 & set2 )#>>>{4, 5}
print(set1.intersection(set2))#>>>{4, 5}
7.22 并集
set1={1,2,3,4,5}
set2={4,5,6,7,8}
print(set1 | set2)#>>>{1, 2, 3, 4, 5, 6, 7, 8}
print(set1.union(set2))#>>>{1, 2, 3, 4, 5, 6, 7, 8}
7.23 差集
set1={1,2,3,4,5}
set2={4,5,6,7,8}
print(set1 - set2)#>>>{1, 2, 3}
print(set1.difference(set2))#>>>{1, 2, 3}
7.24 反交集
set1={1,2,3,4,5}
set2={4,5,6,7,8}
print(set1 ^ set2 )#>>>{1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))#>>>{1, 2, 3, 6, 7, 8}
7.25 子集
set1={1,2,3}
set2={1,2,3,4,5,6}
print(set1 < set2)#>>>True
print(set1.issubset(set2))#>>>True
7.26 超集
set1={1,2,3}
set2={1,2,3,4,5,6}
print(set2 > set1)#>>>True
print(set2.(set1))#>>>True
7.27 frozenset不可变集合，让集合变成不可变类型
s=frozenset('abc') s1=frozenset({4,5,6,7,8}) print(s,type(s))#>>>frozenset({'c', 'b', 'a'}) <class 'frozenset'> print(s1,type(s1))#>>>frozenset({4, 5, 6, 7, 8}) <class 'frozenset'>
8. 数据类型的补充
# 将索引为奇数对应的元素删除。 l = [11, 22, 33, 44, 55] del l[1::2] print(l) # 在循环一个列表时，不要改变列表的大小，这样会影响结果。 # 从后往前删 l1 = [11, 22, 33, 44, 55] for i in range(len(l1)-1,-1,-1): if i % 2 == 1: del l1[i] print(l1) # 在循环一个字典时，不要改变字典的大小，这样会影响结果。 dic={'k1':'v1','k2':'v2','k3':'v3','a1':'b1'} l1 = [] for i in dic: if 'k' in i: l1.append(i) for i in l1: del dic[i] print(dic) #tu元组 如果元组里面只有一个元素并且没有逗号隔开，name他的数据类型与该元素一致 tu1=(1) print(tu1,type(tu1))#>>>1 <class 'int'> tu2=('Lucy') print(tu2,type(tu2))#>>>Lucy <class 'str'> tu3=(['alex',1,2]) print(tu3,type(tu3))#>>>['alex', 1, 2] <class 'list'>
9. 深浅Copy
9.1 先看赋值运算
l1 = [1,2,3,['barry','alex']] l2 = l1 l1[0] = 111 print(l1) # [111, 2, 3, ['barry', 'alex']] print(l2) # [111, 2, 3, ['barry', 'alex']] l1[3][0] = 'wusir' print(l1) # [111, 2, 3, ['wusir', 'alex']] print(l2) # [111, 2, 3, ['wusir', 'alex']]
# 对于赋值运算来说，l1与l2指向的是同一个内存地址，所以他们是完全一样的。
9.2 浅拷贝copy
l1 = [1,2,3,['barry','alex']] l2 = l1.copy() print(l1,id(l1)) # [1, 2, 3, ['barry', 'alex']] 2380296895816 print(l2,id(l2)) # [1, 2, 3, ['barry', 'alex']] 2380296895048 l1[1] = 222 print(l1,id(l1)) # [1, 222, 3, ['barry', 'alex']] 2593038941128 print(l2,id(l2)) # [1, 2, 3, ['barry', 'alex']] 2593038941896 l1[3][0] = 'wusir' print(l1,id(l1[3])) # [1, 2, 3, ['wusir', 'alex']] 1732315659016 print(l2,id(l2[3])) # [1, 2, 3, ['wusir', 'alex']] 1732315659016
# 对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。
9.3 深拷贝deepcopy
import copy l1 = [1,2,3,['barry','alex']] l2 = copy.deepcopy(l1) print(l1,id(l1)) # [1, 2, 3, ['barry', 'alex']] 2915377167816 print(l2,id(l2)) # [1, 2, 3, ['barry', 'alex']] 2915377167048 l1[1] = 222 print(l1,id(l1)) # [1, 222, 3, ['barry', 'alex']] 2915377167816 print(l2,id(l2)) # [1, 2, 3, ['barry', 'alex']] 2915377167048 l1[3][0] = 'wusir' print(l1,id(l1[3])) # [1, 222, 3, ['wusir', 'alex']] 2915377167240 print(l2,id(l2[3])) # [1, 2, 3, ['barry', 'alex']] 2915377167304
3241
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
