社区所有版块导航
Python
python开源   Django   Python   DjangoApp   pycharm  
DATA
docker   Elasticsearch  
aigc
aigc   chatgpt  
WEB开发
linux   MongoDB   Redis   DATABASE   NGINX   其他Web框架   web工具   zookeeper   tornado   NoSql   Bootstrap   js   peewee   Git   bottle   IE   MQ   Jquery  
机器学习
机器学习算法  
Python88.com
反馈   公告   社区推广  
产品
短视频  
印度
印度  
Py学习  »  Python

Python 面试必备基础知识-1

周萝卜 • 6 年前 • 350 次点击  
阅读 22

Python 面试必备基础知识-1

从今天开始,陆续分享一些 Python 相关的面试题,在学习的路上,与君共勉!

各位 Python 大佬请绕过啊!!当然如果能给些指点,那就再好不过了!

基础篇(一)

1. 为什么学习 Python

Python 语言简单易懂,上手容易,随着 AI 风潮,越来越火。

2. 解释型和编译型语言的区别

编译型语言:把做好的源程序全部编译成二进制的可运行程序。然后,可直接运行这个程序。如:C,C++

解释型语言:把做好的源程序翻译一句,然后执行一句,直至结束!如:Python, (Java 有些特殊,java程序也需要编译,但是没有直接编译称为机器语言,而是编译称为字节码,然后用解释方式执行字节码。)

3. 简述下 Python 中的字符串、列表、元组和字典

字符串(str):字符串是用引号括起来的任意文本,是编程语言中最常用的数据类型。

列表(list):列表是有序的集合,可以向其中添加或删除元素。

元组(tuple):元组也是有序集合,但是是无法修改的。即元组是不可变的。

字典(dict):字典是无序的集合,是由 key-value 组成的。

集合(set):是一组 key 的集合,每个元素都是唯一,不重复且无序的。

4. 简述上述数据类型的常用方法

字符串

  1. 切片
mystr='luobodazahui'
mystr[1:3]
复制代码

output

'uo'
复制代码
  1. format
mystr2 = "welcome to luobodazahui, dear {name}"
mystr2.format(name="baby")
复制代码

output

'welcome to luobodazahui, dear baby'
复制代码
  1. join

可以用来连接字符串,将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串。

mylist = ['luo', 'bo', 'da', 'za', 'hui']
mystr3 = '-'.join(mylist)
print(mystr3)
复制代码

outout

'luo-bo-da-za-hui'
复制代码
  1. replace

String.replace(old,new,count) 将字符串中的 old 字符替换为 New 字符,count 为替换的个数

mystr4 = 'luobodazahui-haha'
print(mystr4.replace('haha', 'good'))
复制代码

output

luobodazahui-good
复制代码
  1. split

切割字符串,得到一个列表。

mystr5 = 'luobo,dazahui good'
# 以空格分割
print(mystr5.split())
# 以h分割
print(mystr5.split('h'))
# 以逗号分割
print(mystr5.split(','))
复制代码

output

['luobo,dazahui', 'good']
['luobo,daza', 'ui good']
['luobo', 'dazahui good']
复制代码

列表

  1. 切片

同字符串

  1. append 和 extend

向列表中国添加元素

mylist1 = [1, 2]
mylist2 = [3, 4]
mylist3 = [1, 2]
mylist1.append(mylist2)
print(mylist1)
mylist3.extend(mylist2)
print(mylist3)
复制代码

outout

[1, 2, [3, 4]]
[1, 2, 3, 4]
复制代码
  1. 删除元素

del:根据下标进行删除

pop:删除最后一个元素

remove:根据元素的值进行删除

mylist4 = ['a', 'b', 'c', 'd']
del mylist4[0]
print(mylist4)
mylist4.pop()
print(mylist4)
mylist4.remove('c')
print(mylist4)
复制代码

output

['b', 'c', 'd']
['b', 'c']
['b']
复制代码
  1. 元素排序

sort:是将list按特定顺序重新排列,默认为由小到大,参数 reverse=True 可改为倒序,由大到小。

reverse:是将list逆置。

mylist5 = [1, 5, 2, 3, 4]
mylist5.sort()
print(mylist5)
mylist5.reverse()
print(mylist5)
复制代码

output

[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]
复制代码

字典

  1. 清空字典

dict.clear()

dict1 = {'key1':1, 'key2':2}
dict1.clear()
print(dict1)
复制代码

output

{}
复制代码
  1. 指定删除

使用 pop 方法来指定删除字典中的某一项

dict1 = {'key1':1, 'key2':2}
d1 = dict1.pop('key1')
print(d1)
print(dict1)
复制代码

output

1
{'key2': 2}
复制代码
  1. 遍历字典
dict2 = {'key1':1, 'key2':2}
mykey = [key for key in dict2]
print(mykey)
myvalue = [value for value in dict2.values()]
print(myvalue)
key_value = [(k, v) for k, v in dict2.items() ]
print(key_value)



    
复制代码

output

['key1', 'key2']
[1, 2]
[('key1', 1), ('key2', 2)]
复制代码
  1. fromkeys

用于创建一个新字典,以序列中元素做字典的键,value 为字典所有键对应的初始值

keys = ['zhangfei', 'guanyu', 'liubei', 'zhaoyun']
dict.fromkeys(keys, 0)
复制代码

output

{'zhangfei': 0, 'guanyu': 0, 'liubei': 0, 'zhaoyun': 0}
复制代码

5. 简述 Python 中的字符串编码

计算机在最初的设计中,采用了8个比特(bit)作为一个字节(byte)的方式。一个字节能表示的最大的整数就是255(二进制11111111=十进制255),如果要表示更大的整数,就必须用更多的字节。 最早,计算机只有 ASCII 编码,即只包含大小写英文字母、数字和一些符号,这些对于其他语言,如中文,日文显然是不够用的。后来又发明了Unicode,Unicode把所有语言都统一到一套编码里,这样就不会再有乱码问题了。当需要保存到硬盘或者需要传输的时候,就转换为UTF-8编码。UTF-8 是隶属于 Unicode 的可变长的编码方式。 在 Python 中,以 Unicode 方式编码的字符串,可以使用 encode() 方法来编码成指定的 bytes,也可以通过 decode() 方法来把 bytes 编码成字符串。

encode

"中文".encode('utf-8')
复制代码

output

b'\xe4\xb8\xad\xe6\x96\x87'
复制代码

decode

b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
复制代码

output

'中文'
复制代码

6. 一行代码实现数值交换

a = 1
b = 2
a, b = b, a
print(a, b)
复制代码

output

2 1
复制代码

7. is和==的区别

先来看个例子

c = d = [1,2]
e = [1,2]
print(c is d)
print(c == d)
print(c is e)
print(c == e)
复制代码

output

True
True
False
True
复制代码

== 是比较操作符,只是判断对象的值(value)是否一致,而 is 则判断的是对象之间的身份(内存地址)是否一致。对象的身份,可以通过 id() 方法来查看。

id(c)
id(d)
id(e)
复制代码

output

188748080
288748080
388558288
复制代码

可以看出,只有 id 一致时,is 比较才会返回 True,而当 value 一致时,== 比较就会返回 True

8. Python 函数中的参数类型

位置参数,默认参数,可变参数,关键字参数

9. *arg和**kwarg作用

允许我们在调用函数的时候传入多个实参

def test(*arg, **kwarg):
    if arg:
        print("arg:", arg)
    if kwarg:
        print("kearg:", kwarg)
test('ni', 'hao', key='world')
复制代码

output

arg: ('ni', 'hao')
kearg: {'key': 'world'}
复制代码

可以看出, *arg会把位置参数转化为tuple **kwarg会把关键字参数转化为dict

10. 一行代码实现1-100之和

sum(range(1, 101))
复制代码

11. 获取当前时间

import time
import datetime
print(datetime.datetime.now())
print(time.strftime('%Y-%m-%d %H:%M:%S'))
复制代码

output

12019-06-07 18:12:11.165330
22019-06-07 18:12:11
复制代码

12. PEP8 规范

简单列举10条:

  • 尽量以免单独使用小写字母'l',大写字母'O',以及大写字母'I'等容易混淆的字母。

  • 函数命名使用全部小写的方式,可以使用下划线。

  • 常量命名使用全部大写的方式,可以使用下划线。

  • 使用 has 或 is 前缀命名布尔元素,如: is_connect = True; has_member = False

  • 不要在行尾加分号, 也不要用分号将两条命令放在同一行。

  • 不要使用反斜杠连接行。

  • 顶级定义之间空2行, 方法定义之间空1行,顶级定义之间空两行。

  • 如果一个类不继承自其它类, 就显式的从 object 继承。

  • 内部使用的类、方法或变量前,需加前缀'_'表明此为内部使用的。

  • 要用断言来实现静态类型检测。

13. Python 的深浅拷贝

浅拷贝

import copy
list1 = [1, 2, 3, [1, 2]]
list2 = copy.copy(list1)
list2.append('a')
list2[3].append('a')
print(list1, list2)
复制代码

output

[1, 2, 3, [1, 2, 'a']] [1, 2, 3, [1, 2, 'a'], 'a']
复制代码

能够看出,浅拷贝只成功”独立“拷贝了列表的外层,而列表的内层列表,还是共享的

深拷贝

import copy
list1 = [1, 2, 3, [1, 2]]
list3 = copy.deepcopy(list1)
list3.append('a')
list3[3].append('a')
print(list1, list3)
复制代码

output

[1, 2, 3, [1, 2]] [1, 2, 3, [1, 2, 'a'], 'a']
复制代码

深拷贝使得两个列表完全独立开来,每一个列表的操作,都不会影响到另一个。

14. 查看下面代码的输出

def num():
    return [lambda x:i*x for i in range(4)]
print([m(1) for m in num()])
复制代码

output

[3, 3, 3, 3]
复制代码

通过运行结果,可以看出 i 的取值为3,很神奇

15. 可变类型与不可变类型

可变数据类型:list、dict、set

不可变数据类型:int/float、str、tuple

16. 打印九九乘法表

for i in range(1, 10):
    for j in range(1, i+1):
        print("%s*%s=%s " %(i, j, i*j), end="")
    print()
复制代码

output

11*1=1 
22*1=2 2*2=4 
33*1=3 3*2=6 3*3=9 
44*1=4 4*2=8 4*3=12 4*4=16 
55*1=5 5*2=10 5*3=15 5*4=20 5*5=25 
66*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 
77*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 
88*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 
99*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81 
复制代码

print 函数,默认是会换行的,其有一个默认参数 end,如果像例子中,我们把 end 参数显示的置为"",那么 print 函数执行完后,就不会换行了,这样就达到了九九乘法表的效果了。

17. filter、map、reduce 的作用

filter 函数用于过滤序列,它接收一个函数和一个序列,把函数作用在序列的每个元素上,然后根据返回值是True还是False决定保留还是丢弃该元素。

mylist = [1, 2, 3, 4, 5, 6, 7, 8, 9]
list(filter(lambda x: x%2 == 1, mylist))
复制代码

output

[1, 3, 5, 7, 9]
复制代码

保留奇数列表

map 函数传入一个函数和一个序列,并把函数作用到序列的每个元素上,返回一个可迭代对象

mylist = [1, 2, 3, 4, 5, 6, 7, 8, 9]
list(map(lambda x: x*2, mylist))
复制代码

output

[2, 4, 6, 8, 10, 12, 14, 16, 18]
复制代码

reduce 函数用于递归计算,同样需要传入一个函数和一个序列,并把函数和序列元素的计算结果与下一个元素进行计算。

from functools import reduce
reduce(lambda x, y: x+y, range(101))
复制代码

output

15050
复制代码

可以看出,上面的三个函数与匿名函数相结合使用,可以写出强大简洁的代码。

18. re 的 match 和 search 区别

match()函数只检测要匹配的字符是不是在 string 的开始位置匹配,search()会扫描整个 string 查找匹配

19. 面向对象中__new__ 和__init__ 区别

__new__是在实例创建之前被调用的,因为它的任务就是创建实例然后返回该实例对象,是个静态方法。

__init__是当实例对象创建完成后被调用的,然后设置对象属性的一些初始值,通常用在初始化一个类实例的时候。是一个实例方法。

1、__new__至少要有一个参数 cls,代表当前类,此参数在实例化时由 Python 解释器自动识别。

2、__new__必须要有返回值,返回实例化出来的实例,这点在自己实现__new__时要特别注意,可以 return 父类(通过 super(当前类名, cls))__new__出来的实例,或者直接是 object 的__new__出来的实例。

3、__init__有一个参数 self,就是这个__new__返回的实例,__init__在__new__的基础上可以完成一些其它初始化的动作,__init__不需要返回值。

4、如果__new__创建的是当前类的实例,会自动调用__init__函数,通过 return 语句里面调用的__new__函数的第一个参数是 cls 来保证是当前类实例,如果是其他类的类名,;那么实际创建返回的就是其他类的实例,其实就不会调用当前类的__init__函数,也不会调用其他类的__init__函数。

20. 三元运算规则

a, b = 1, 2
# 若果 a>b 成立  就输出  a-b  否则 a+b
h = a-b if a>b else a+b
复制代码

output

13
复制代码

21. 生成随机数

print(random.random())
print(random.randint(1, 100))
print(random.uniform(1,5))
复制代码

output

10.03765019937131564
218
31.8458555362279228
复制代码

22. zip 函数用法

zip() 函数将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的列表

list1 = ['zhangfei', 'guanyu', 'liubei', 'zhaoyun']
list2 = [0, 3, 2, 4]
list(zip(list1, list2))
复制代码

output

[('zhangfei', 0), ('guanyu', 3), ('liubei', 2), ('zhaoyun', 4)]
复制代码

23. range 和 xrange 的区别

range([start,] stop[, step]),根据 start 与 stop 指定的范围以及 step 设定的步长,生成一个序列。 而 xrange 生成一个生成器,可以很大的节约内存。

24. with 方法打开文件的作用

开文件在进行读写的时候可能会出现一些异常状况,如果按照常规的 f.open 写法,我们需要 try,except,finally,做异常判断,并且文件最终不管遇到什么情况,都要执行 finally f.close() 关闭文件,with 方法帮我们实现了 finally 中 f.close。

25. 什么是正则的贪婪匹配

Python 中默认是贪婪匹配模式。

贪婪模式:正则表达式一般趋向于最大长度匹配。

非贪婪模式:在整个表达式匹配成功的前提下,尽可能少的匹配。

26. 为什么不建议函数的默认参数传入可变对象

例如:

def test(L=[]):
    L.append('test')
    print(L)
复制代码

output

test() # ['test']
test() # ['test', 'test']
复制代码

默认参数是一个列表,是可变对象[],Python 在函数定义的时候,默认参数 L 的值就被计算出来了,是[],每次调用函数,如果 L 的值变了,那么下次调用时,默认参数的值就已经不再是[]了。

27. 字符串转列表

mystr = '1,2,3'
mystr.split(',')
复制代码

output

['1', '2', '3']
复制代码

28. 字符串转整数

mylist = ['1', '2', '3']
list(map(lambda x: int(x), mylist))
复制代码

output

[1, 2, 3]
复制代码

29. 删除列表中的重复值

mylist = [1, 2, 3, 4, 5, 5]
list(set(mylist))
复制代码

30. 字符串单词统计

from collections import Counter
mystr = 'sdfsfsfsdfsd,were,hrhrgege.sdfwe!sfsdfs'
Counter(mystr)
复制代码

output

 Counter({'s': 9,
          'd': 5,
          'f': 7,
          ',': 2,
          'w': 2,
          'e': 5,
          'r': 3,
          'h': 2,
          'g': 2,
         '.': 1,
         '!': 1})
复制代码

31. 列表推导,求奇偶数

[x for x in range(10) if x%2 == 1]
复制代码

output

[1, 3, 5, 7, 9]
复制代码

32. 一行代码展开列表

list1 = [[1,2],[3,4],[5,6]]
[j for i in list1 for j in i]
复制代码

output

[1, 2, 3, 4, 5, 6]
复制代码

33. 实现二分法查找函数

二分查找算法也称折半查找,基本思想就是折半,对比大小后再折半查找,必须是有序序列才可以使用二分查找。 递归算法

 def binary_search(data, item):
     # 递归
     n = len(data)
     if n > 0:
         mid = n // 2
         if data[mid] == item:
             return True
         elif data[mid] > item:
             return binary_search(data[:mid], item)
        else:
            return binary_search(data[mid+1:], item)
    return False
list1 = [1,4,5,66,78,99,100,101,233,250,444,890]
binary_search(list1, 999)
复制代码

非递归算法

 def binary_search(data, item):
     # 非递归
     n = len(data)
     first = 0
     last = n - 1
     while first <= last:
         mid = (first + last)//2
         if data[mid] == item:
             return True
        elif data[mid] > item:
            last = mid - 1
        else:
            first = mid + 1
    return False
list1 = [1,4,5,66,78,99,100,101,233,250,444,890]
binary_search(list1, 99)
复制代码

34. 字典和 json 转换

字典转 json

import json
dict1 = {'zhangfei':1, "liubei":2, "guanyu": 4, "zhaoyun":3}
myjson = json.dumps(dict1)
myjson
复制代码

output

'{"zhangfei": 1, "liubei": 2, "guanyu": 4, "zhaoyun": 3}'
复制代码

json 转字典

mydict = json.loads(myjson)
mydict
复制代码

output

{'zhangfei': 1, 'liubei': 2, 'guanyu': 4, 'zhaoyun': 3}
复制代码

35. 列表推导式、字典推导式和生成器

import random
td_list=[i for i in range(10)]
print("列表推导式", td_list, type(td_list))
ge_list = (i for i in range(10))
print("生成器", ge_list)
dic = {k:random.randint(4, 9)for k in ["a", "b", "c", "d"]}
print("字典推导式",dic,type(dic))
复制代码

output

列表推导式 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] <class 'list'>
生成器 <generator object <genexpr> at 0x0139F070>
字典推导式 {'a': 6, 'b': 5, 'c': 8, 'd': 9} <class 'dict'>
复制代码

36. 简述 read、readline、readlines 的区别

read 读取整个文件

readline 读取下一行,使用生成器方法

readlines 读取整个文件到一个迭代器以供我们遍历

37. 打乱一个列表

list2 = [1, 2, 3, 4, 5, 6]
random.shuffle(list2)
print(list2)
复制代码

output

[4, 6, 5, 1, 2, 3]
复制代码

38. 反转字符串

str1 = 'luobodazahui'
str1[::-1]
复制代码

output

'iuhazadoboul'
复制代码

39. 单下划线和双下划线的作用

__foo__:一种约定,Python 内部的名字,用来区别其他用户自定义的命名,以防冲突,就是例如__init__()和__del__()及__call__()这些特殊方法。

_foo:一种约定,用来指定变量私有。不能用 from module import * 导入,其他方面和公有变量一样访问。

__foo:这个有真正的意义:解析器用_classname__foo 来代替这个名字,以区别和其他类相同的命名,它无法直接像公有成员一样随便访问,通过对象名._类名__xxx 这样的方式可以访问。

40. 新式类和旧式类

a. 在 python 里凡是继承了 object 的类,都是新式类

b. Python3 里只有新式类

c. Python2 里面继承 object 的是新式类,没有写父类的是经典类

d. 经典类目前在 Python 里基本没有应用

41. Python 面向对象中的继承有什么特点

a. 同时支持单继承与多继承,当只有一个父类时为单继承,当存在多个父类时为多继承。

b. 子类会继承父类所有的属性和方法,子类也可以覆盖父类同名的变量和方法。

c. 在继承中基类的构造(__init__())方法不会被自动调用,它需要在其派生类的构造中专门调用。

d. 在调用基类的方法时,需要加上基类的类名前缀,且需要带上 self 参数变量。区别于在类中调用普通函数时并不需要带上 self 参数。

42. super 函数的作用

super() 函数是用于调用父类(超类)的一个方法。

 class A():
     def funcA(self):
         print("this is func A")
 class B(A):
     def funcA_in_B(self):
         super(B, self).funcA()
 
     def funcC(self):
         print("this is func C")

ins = B()
ins.funcA_in_B()
ins.funcC()
复制代码

output

this is func A
this is func C
复制代码

43. 类中的各种函数

主要分为实例方法、类方法和静态方法

实例方法:

定义:第一个参数必须是实例对象,该参数名一般约定为“self”,通过它来传递实例的属性和方法(也可以传类的属性和方法);

调用:只能由实例对象调用。

类方法:

定义:使用装饰器@classmethod。第一个参数必须是当前类对象,该参数名一般约定为“cls”,通过它来传递类的属性和方法(不能传实例的属性和方法);

调用:实例对象和类对象都可以调用。

静态方法:

定义:使用装饰器@staticmethod。参数随意,没有“self”和“cls”参数,但是方法体中不能使用类或实例的任何属性和方法;

调用:实例对象和类对象都可以调用。

静态方法是类中的函数,不需要实例。静态方法主要是用来存放逻辑性的代码,主要是一些逻辑属于类,但是和类本身没有交互。即在静态方法中,不会涉及到类中的方法和属性的操作。可以理解为将静态方法存在此类的名称空间中。 类方法是将类本身作为对象进行操作的方法。他和静态方法的区别在于:不管这个方式是从实例调用还是从类调用,它都用第一个参数把类传递过来。

44. 如何判断是函数还是方法

与类和实例无绑定关系的 function 都属于函数(function) 与类和实例有绑定关系的 function 都属于方法(method)

普通函数:

def func1():
    pass
print(func1)
复制代码

output

<function func1 at 0x01379348>
复制代码

类中的函数:

 class People(object):
     def func2(self):
         pass
     @staticmethod
     def func3():
         pass
     @classmethod
     def func4(cls):
         pass
people = People()
print(people.func2)
print(people.func3)
print(people.func4)
复制代码

output

<bound method People.func2 of <__main__.People object at 0x013B8C90>>
<function People.func3 at 0x01379390>
<bound method People.func4 of <class '__main__.People'>>
复制代码

45. isinstance 的作用以及与 type()的区别

isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()。

区别:

type() 不会认为子类是一种父类类型,不考虑继承关系。

isinstance() 会认为子类是一种父类类型,考虑继承关系。

 class A(object):
     pass
 class B(A):
     pass
 a = A()
 b = B()
 print(isinstance(a, A))
 print(isinstance(b, A))
 print(type(a) == A)
 print(type(b) == A)
复制代码

output

True
True
True
False
复制代码

46. 单例模式与工厂模式

单例模式:主要目的是确保某一个类只有一个实例存在。

工厂模式:包涵一个超类,这个超类提供一个抽象化的接口来创建一个特定类型的对象,而不是决定哪个对象可以被创建。

47. 查看目录下的所有文件

import os
print(os.listdir('.'))
复制代码

48. 计算1到5组成的互不重复的三位数

 # 1到5组成的互不重复的三位数
 k = 0
 for i in range(1, 6):
     for j in range(1, 6):
         for z in range(1, 6):
             if (i != j) and (i != z) and (j != z):
                 k += 1
                 if k%6:
                     print("%s%s%s" %(i, j, z), end="|")
                else:
                    print("%s%s%s" %(i, j, z))
复制代码

output

 1123|124|125|132|134|135
 2142|143|145|152|153|154
 3213|214|215|231|234|235
 4241|243|245|251|253|254
 5312|314|315|321|324|325
 6341|342|345|351|352|354
 7412|413|415|421|423|425
 8431|432|435|451|452|453
 9512|513|514|521|523|524
10531|532|534|541|542|543
复制代码

49. 去除字符串首尾空格

str1 = "   hello nihao    "
str1.strip()
复制代码

output

'hello nihao'
复制代码

50. 去除字符串中间的空格

str2 = "hello you are good"
print(str2.replace(" ", ""))
"".join(str2.split(" "))
复制代码

output




    
helloyouaregood
'helloyouaregood'
复制代码

面试题系列第一部分就到这里了,我们下次见!

欢迎关注我的微信公众号--萝卜大杂烩,或者扫描下方的二维码,大家一起交流,学习和进步!

Python社区是高质量的Python/Django开发社区
本文地址:http://www.python88.com/topic/35268
 
350 次点击