Python面试题目收集

Python

4、L = [1, 2, 3, 11, 2, 5, 3, 2, 5, 3]，用一行代码得出 [11, 1, 2, 3, 5]

list(set(L))

5、L = [1, 2, 3, 4, 5]，L[10:] 的结果是？

答： 空列表(当时有点紧张，一直在“空列表”和“索引超出范围”两个答案之间徘徊）。

6、L = [1, 2, 3, 5, 6]，如何得出 '12356'？

答： 注意，个人觉得这个题有坑，列表的元素不是字符串，所以不能 ''.join(L)。以下是过程：

s = ''
for i in L:
    s = s + str(i)
print(s)
print(type(s))

>>> 12356
>>> <class 'str'>

备注

L = ['1', '2', '3', '4', '5']
''.join(L)

>>> 12356

7、列表和字典有什么区别？

答： 一般都是问列表和元组有什么不同。 （1）获取元素的方式不同。列表通过索引值获取，字典通过键
获取。 （2）数据结构和算法不同。字典是 hash 算法，搜索的速度特别快。 （3）占用的内存不同。

8、如何结束一个进程？
答：（1）调用 terminate 方法。 （2）使用 subProcess 模块的 Popen 方法。使用简单，具体用法，这
里不展开。

9、进程、线程有什么区别？什么情况下用进程？什么情况下用线程？
答：（1）区别：
① 地址空间和其它资源（如打开文件）：进程之间相互独立，同一进程的各线程之间共享。某进程内的线
程在其它进程不可见。
② 通信：进程间通信 IPC，线程间可以直接读写进程数据段（如全局变量）来进行通信——需要进程同步
和互斥手段的辅助，以保证数据的一致性。
③ 调度和切换：线程上下文切换比进程上下文切换要快得多。
④ 在多线程操作系统中，进程不是一个可执行的实体。
（2）使用场景：同时操作一个对象的时候，比如操作的是一个全局变量，我用线程，因为全局变量是所有
线程共享的。

3、列出5个 python 标准库

os：提供了不少与操作系统相关联的函数

sys: 通常用于命令行参数

re: 正则匹配

math: 数学运算

datetime：处理日期时间

6、python 实现列表去重的方法

先通过集合去重，在转列表

lst = [11, 12, 13, 12, 15, 16, 13]
a = set(lst)
# 集合去重
print(a)
uniq_lst = [x for x in a]
print(uniq_lst)

>>> {11, 12, 13, 15, 16}
>>> [11, 12, 13, 15, 15]

10、python 内建数据类型有哪些？

• 整型 int
• 布尔型 bool
• 字符串 str
• 列表 list
• 元组 tuple
• 字典 dict

12、简述 with 方法打开处理文件帮我我们做了什么？

f = open("./1.txt", "wb")
try:
    f.write("hello world!")
except:
    pass
finally:
    f.close()

打开文件在进行读写的时候可能会出现一些异常状况，如果按照常规的 f.open

写法，我们需要try,except,finally，做异常判断，并且文件最终不管遇到什么情况，都要执行 finally: f.close() 关闭文件，with 方法帮我们实现了 finally 中 f.close

（当然还有其他自定义功能，有兴趣可以研究 with 方法源码）

13、列表[1, 2, 3, 4, 5]，请使用 map() 函数输出 [1, 4, 9, 16, 25]，并使用列表推导式提取出大于10的数，最终输出[16, 25]

map() 函数第一个参数是 fun，第二个参数是一般是 list，第三个参数可以写 list，也可以不写，根据需求

lst = [1, 2, 3, 4, 5]
def fn(x):
    return x**2
res = map(function = fn, iterable = lst)
res = [i for i in res if i > 10]
print(res)

>>> [16, 25]

14、python中生成随机整数、随机小数、0--1之间小数方法

• 随机整数：random.randint(a,b)，生成区间内的整数
• 随机小数：习惯用numpy库，利用np.random.randn(5)生成5个随机小数
• 0-1随机小数：random.random()，括号中不传参

import random
import numpy as np
res_int = random.randint(10, 20)
# 区间
res_flt = np.random.randn(5)
res_01 = random.random()
# 不传参数

15、避免“转义”给字符串加哪个字母表示原始字符串？

r，表示需要原始字符串，不转义特殊字符

ex_string = r"str"

19、10个Linux常用命令

ls pwd cd touch rm mkdir tree cp mv cat more grep echo

21、列出python中可变数据类型和不可变数据类型，并简述原理

不可变数据类型：

1. 数值型
2. 字符串型string
3. 元组tuple

不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象，而对于相同的值的对象，在内存中则只有一个对象（一个地址），如下图用id()方法可以打印对象的id

a = 3
b = 3
id(a)
id(b)

>>> 1365598496
>>> 1365598496

可变数据类型：

1. 列表list
2. 字典dict；

允许变量的值发生变化，即如果对变量进行append、+=等这种操作后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。

a = 3
b = 3
id(a)
id(b)

22、s = "ajldjlajfdljfddd"，去重并从小到大排序输出"adfjl"

set 去重，去重转成 list ，利用 sort 方法排序，reeverse = False是从小到大排

list 是不变数据类型，s.sort 时候没有返回值，所以注释的代码写法不正确

s = "ajldjlajfdljfddd"
s = set(s)
print(s)
s = list(s)
s.sort(reverse = False)
#s = s.sort(reverse = False)
res = "".join(s)
print(res)

>>> {'f', 'a', 'd', 'l', 'j'}
>>> adfjl

23、用 lambda 函数实现两个数相乘

sum = lambda a, b: a*b
print(sum(5, 4))

>>> 20

24、字典根据键从小到大排序

dic = {"name":"zs", "age":18, "city":"深圳", "tel":"1362626627"}
lst = sorted(dic.items(), key = lambad i:i[0], reverse = False)
print(lst)
dict(lst)

>>> 

25、利用collections库的Counter方法统计字符串每个单词出现的次数"kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h"

from collections import Counter
a = "kjalfj;ldsjafl;hdsllfdhg;lahfbl;hl;ahlf;h"
res = Counter(a)
print(res)

>>>

26、字符串 a = "not 404 found 张三 99 深圳"，每个词中间是空格，用正则过滤掉英文和数字，最终输出"张三 深圳"

顺便贴上匹配小数的代码，虽然能匹配，但是健壮性有待进一步确认

27、filter方法求出列表所有奇数并构造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def fn(a):
    return a%2 == 1
newlst = filter(fn, a)
print(newlst)
newlst = [i for i in newlst]
print(newlst)

<filter at 0x1f1928e3f28>
[1, 3, 5, 7, 9]

28、列表推导式求列表所有奇数并构造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
res = [i for i in a if i%2 == 1]
print(res)

>>> [1, 3, 5, 7, 9]

29、正则re.complie作用

re.compile 是将正则表达式编译成一个对象，加快速度，并重复使用

30、a=（1，）b=(1)，c=("1") 分别是什么类型的数据？

type((1))
type(("1"))
type((1,))

>>> int
>>> str
>>> tuple

31、两个列表 [1,5,7,9] 和 [2,2,6,8] 合并为 [1,2,2,3,6,7,8,9]

extend 可以将另一个集合中的元素逐一添加到列表中，区别于 append 整体添加

lst1 = [1, 5, 7, 9]
lst2 = [2, 2, 6, 8]
lst1.extend(lst2)
print(lst1)

>>> [1, 5, 7, 9, 2, 2, 6, 8]

lst1.sort(reverse = False)
# 升序排列
print(lst1)

>>> [1, 2, 2, 5, 6, 7, 8, 9]

32、用python删除文件和用linux命令删除文件方法

python：

os.remove(文件名)

linux:

rm 文件名

33、log日志中，我们需要用时间戳记录error,warning等的发生时间，请用datetime模块打印当前时间戳 “2018-04-01 11:38:54”

顺便把星期的代码也贴上了

import datetime
a = str(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')) + '星期：' +  str(datetime.datetime.now().isweekday()) 
print(a)

>>>

35、请列出你会的任意一种统计图（条形图、折线图等）绘制的开源库，第三方也行

pyecharts、matplotlib

36、写一段自定义异常代码

自定义异常用raise抛出异常

# raise 自定义异常
def fn():
    try:
        for i in range(5):
            if i > 2:
                raise Exception("数字大于2了")
    except Exception as ret:
        print(ret)
    except 
fn()

>>> 数字大于2了

37、正则表达式匹配中，(.*) 和 (.*?)匹配区别？

（.*）是贪婪匹配，会把满足正则的尽可能多的往后匹配

（.*?）是非贪婪匹配，会把满足正则的尽可能少匹配

42、python中交换两个数值

a, b = 3, 4
print(a, b)

>>> 3 4

a, b = b, a
print(a, b)

>>> 4 3

40、x="abc",y="def",z=["d","e","f"],分别求出x.join(y)和x.join(z)返回的结果

join() 括号里面的是可迭代对象，x插入可迭代对象中间，形成字符串，结果一致，有没有突然感觉字符串的常见操作都不会玩了

顺便建议大家学下os.path.join()方法，拼接路径经常用到，也用到了join，和字符串操作中的join有什么区别，该问题大家可以查阅相关文档，后期会有答案

x = "abc"
y = "def"
z = ["d", "e", "f"]
# str.join(sequence) 中 sequence 为待插入序列，str为插入的字符串
m = x.join(sequence = y)
n = x.join(sequence = z)
print(m)
print(n)

>>> dabceabcf
>>> dabceabcf

41、举例说明异常模块中try except else finally的相关意义

• try..except..else没有捕获到异常，执行else语句
• try..except..finally不管是否捕获到异常，都执行finally语句

54、保留两位小数

题目本身只有a="%.03f"%1.3335，让计算a的结果，为了扩充保留小数的思路，提供round方法（数值，保留位数）

a = "%.03f"%1.3335
print(a, type(a))
b = round(float(a), 1)
print(b, type(b))
c = round(float(a), 2)
print(c, type(c))

56、列出常见的状态码和意义

• 200 OK 请求正常处理完毕
• 204 No Content 请求成功处理，没有实体的主体返回
• 206 Partial Content GET范围请求已成功处理
• 301 Moved Permanently 永久重定向，资源已永久分配新URI
• 302 Found 临时重定向，资源已临时分配新URI
• 303 See Other 临时重定向，期望使用GET定向获取
• 304 Not Modified 发送的附带条件请求未满足
• 307 Temporary Redirect 临时重定向，POST不会变成GET
• 400 Bad Request 请求报文语法错误或参数错误
• 401 Unauthorized 需要通过HTTP认证，或认证失败
• 403 Forbidden 请求资源被拒绝
• 404 Not Found 无法找到请求资源（服务器无理由拒绝）
• 500 Internal Server Error 服务器故障或Web应用故障
• 503 Service Unavailable 服务器超负载或停机维护

58、使用 pop 和 del 删除字典中的 name字段，dic = {"name": "zs", "age": 18}

dic = {"name": "zs", "age": 18}
dic.pop("name")
print(dic)

>>> {'age': 18}

dic = {"name": "zs", "age": 18}
del dic["name"]
print(dic)

>>> {'age': 18}

62、简述 cookie 和 session 的区别

1，session 在服务器端，cookie 在客户端（浏览器）

2、session 的运行依赖 session id，而 session id 是存在 cookie 中的，也就是说，如果浏览器禁用了 cookie ，同时 session 也会失效，存储Session时，键与Cookie中的sessionid相同，值是开发人员设置的键值对信息，进行了base64编码，过期时间由开发人员设置

3、cookie安全性比session差

64、简述any()和all()方法

any():只要迭代器中有一个元素为真就为真

all():迭代器中所有的判断项返回都是真，结果才为真

python中什么元素为假？

答案：（0，空字符串，空列表、空字典、空元组、None, False）

65、IOError、AttributeError、ImportError、IndentationError、IndexError、KeyError、SyntaxError、NameError 分别代表什么异常

• IOError：输入输出异常
• AttributeError：试图访问一个对象没有的属性
• ImportError：无法引入模块或包，基本是路径问题
• IndentationError：语法错误，代码没有正确的对齐
• IndexError：下标索引超出序列边界
• KeyError:试图访问你字典里不存在的键
• SyntaxError:Python代码逻辑语法出错，不能执行
• NameError:使用一个还未赋予对象的变量

66、python 中 copy 和 deepcopy 区别

1、复制不可变数据类型，不管 copy 还是 deepcopy，都是同一个地址当浅复制的值是不可变对象（数值，字符串，元组）时和=“赋值”的情况一样，对象的id值与浅复制原来的值相同。

70、a = "hehheh "，去除收尾空格

a = "hehheh "
a.strip()
print(a)

>>> hehheh

85、python 字典和 json 字符串相互转化方法

json.dumps() 字典转json字符串，json.loads() json转字典

import json
dic = {"name": "zs"}
res = json.dumps(obj = dic)
print(res, type(res))
ret = json.loads(res)
print(ret, type(ret))

87、统计字符串中某字符出现次数

88、字符串转化大小写

105、单引号、双引号、三引号用法

1、单引号和双引号没有什么区别，不过单引号不用按shift，打字稍微快一点。表示字符串的时候，单引号里面可以用双引号，而不用转义字符，反之亦然。

a = 'She said:"Yes." ' 
b = "She said: 'Yes.' "
print(a)
print(b)

2、但是如果直接用单引号扩住单引号，则需要转义，像这样：

' She said:\'Yes.\' '

3、三引号可以直接书写多行，通常用于大段，大篇幅的字符串

"""
hello
world
"""

1、将元组 (1, 2, 3) 和集合 {4, 5, 6} 合并成一个列表。

list((1, 2, 3)) + list({4, 5, 6})

>>> [1, 2, 3, 4, 5, 6]

2、在列表 [1, 2, 3, 4, 5, 6] 首尾分别添加整型元素 7 和 0。

a = [1, 2, 3, 4, 5, 6]
a.insert(index = 0, obj = 7)
a.append(0)
print(a)

>>> [7, 1, 2, 3, 4, 5, 6, 0]

3、反转列表 [0, 1, 2, 3, 4, 5, 6, 7] 。

a = [0, 1, 2, 3, 4, 5, 6, 7]
a.reverse()
a

>>> [7, 6, 5, 4, 3, 2, 1, 0]

a[::-1]

>>> [0, 1, 2, 3, 4, 5, 6, 7]

4、反转列表 [0, 1, 2, 3, 4, 5, 6, 7] 后给出中元素 5 的索引号。

[0,1,2,3,4,5,6,7][::-1].index(5)

>>> 2

5、分别统计列表 [True, False, 0, 1, 2] 中 True,False,0,1,2的元素个数，发现了什么？

6、从列表 [True, 1, 0, ‘x’, None, ‘x’, False, 2, True] 中删除元素‘x’。

7、从列表 [True,1,0,‘x’,None,‘x’,False,2,True] 中删除索引号为4的元素。

8、删除列表中索引号为奇数（或偶数）的元素。

清空列表中的所有元素。#

9、对列表 [3,0,8,5,7] 分别做升序和降序排列。

10、将列表 [3,0,8,5,7] 中大于 5 元素置为1，其余元素置为0。
遍历列表 [‘x’,‘y’,‘z’]，打印每一个元素及其对应的索引号。
将列表 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 拆分为奇数组和偶数组两个列表。
分别根据每一行的首元素和尾元素大小对二维列表 [[6, 5], [3, 7], [2, 8]] 排序。
从列表 [1,4,7,2,5,8] 索引为3的位置开始，依次插入列表 [‘x’,‘y’,‘z’] 的所有元素。
快速生成由 [5,50) 区间内的整数组成的列表。
若 a = [1,2,3]，令 b = a，执行 b[0] = 9， a[0]亦被改变。为何？如何避免？
将列表 [‘x’,‘y’,‘z’] 和 [1,2,3] 转成 [(‘x’,1),(‘y’,2),(‘z’,3)] 的形式。
以列表形式返回字典 {‘Alice’: 20, ‘Beth’: 18, ‘Cecil’: 21} 中所有的键。
以列表形式返回字典 {‘Alice’: 20, ‘Beth’: 18, ‘Cecil’: 21} 中所有的值。
以列表形式返回字典 {‘Alice’: 20, ‘Beth’: 18, ‘Cecil’: 21} 中所有键值对组成的元组。
向字典 {‘Alice’: 20, ‘Beth’: 18, ‘Cecil’: 21} 中追加 ‘David’:19 键值对，更新Cecil的值为17。
删除字典 {‘Alice’: 20, ‘Beth’: 18, ‘Cecil’: 21} 中的Beth键后，清空该字典。
判断 David 和 Alice 是否在字典 {‘Alice’: 20, ‘Beth’: 18, ‘Cecil’: 21} 中。
遍历字典 {‘Alice’: 20, ‘Beth’: 18, ‘Cecil’: 21}，打印键值对。
若 a = dict()，令 b = a，执行 b.update({‘x’:1})， a亦被改变。为何？如何避免？
以列表 [‘A’,‘B’,‘C’,‘D’,‘E’,‘F’,‘G’,‘H’] 中的每一个元素为键，默认值都是0，创建一个字典。
将二维结构 [[‘a’,1],[‘b’,2]] 和 ((‘x’,3),(‘y’,4)) 转成字典。
将元组 (1,2) 和 (3,4) 合并成一个元组。
将空间坐标元组 (1,2,3) 的三个元素解包对应到变量 x,y,z。
返回元组 (‘Alice’,‘Beth’,‘Cecil’) 中 ‘Cecil’ 元素的索引号。
返回元组 (2,5,3,2,4) 中元素 2 的个数。
判断 ‘Cecil’ 是否在元组 (‘Alice’,‘Beth’,‘Cecil’) 中。
返回在元组 (2,5,3,7) 索引号为2的位置插入元素 9 之后的新元组。
创建一个空集合，增加 {‘x’,‘y’,‘z’} 三个元素。
删除集合 {‘x’,‘y’,‘z’} 中的 ‘z’ 元素，增j加元素 ‘w’，然后清空整个集合。
返回集合 {‘A’,‘D’,‘B’} 中未出现在集合 {‘D’,‘E’,‘C’} 中的元素（差集）。
返回两个集合 {‘A’,‘D’,‘B’} 和 {‘D’,‘E’,‘C’} 的并集。
返回两个集合 {‘A’,‘D’,‘B’} 和 {‘D’,‘E’,‘C’} 的交集。
返回两个集合 {‘A’,‘D’,‘B’} 和 {‘D’,‘E’,‘C’} 未重复的元素的集合。
判断两个集合 {‘A’,‘D’,‘B’} 和 {‘D’,‘E’,‘C’} 是否有重复元素。
判断集合 {‘A’,‘C’} 是否是集合 {‘D’,‘C’,‘E’,‘A’} 的子集。
去除数组 [1,2,5,2,3,4,5,‘x’,4,‘x’] 中的重复元素。
返回字符串 ‘abCdEfg’ 的全部大写、全部小写和大下写互换形式。
判断字符串 ‘abCdEfg’ 是否首字母大写，字母是否全部小写，字母是否全部大写。
返回字符串 ‘this is python’ 首字母大写以及字符串内每个单词首字母大写形式。
判断字符串 ‘this is python’ 是否以 ‘this’ 开头，又是否以 ‘python’ 结尾。
返回字符串 ‘this is python’ 中 ‘is’ 的出现次数。
返回字符串 ‘this is python’ 中 ‘is’ 首次出现和最后一次出现的位置。
将字符串 ‘this is python’ 切片成3个单词。
返回字符串 ‘blog.csdn.net/xufive/article/details/102946961’ 按路径分隔符切片的结果。
将字符串 ‘2.72, 5, 7, 3.14’ 以半角逗号切片后，再将各个元素转成浮点型或整形。
判断字符串 ‘adS12K56’ 是否完全为字母数字，是否全为数字，是否全为字母，是否全为ASCII码。
将字符串 ‘there is python’ 中的 ‘is’ 替换为 ‘are’。
清除字符串 ‘\t python \n’ 左侧、右侧，以及左右两侧的空白字符。
将三个全英文字符串（比如，‘ok’, ‘hello’, ‘thank you’）分行打印，实现左对齐、右对齐和居中对齐效果。
将三个字符串（比如，‘Hello, 我是David’, ‘OK, 好’, ‘很高兴认识你’）分行打印，实现左对齐、右对齐和居中效果。
将三个字符串 ‘15’, ‘127’, ‘65535’ 左侧补0成同样长度。
提取 url 字符串 ‘https://blog.csdn.net/xufive’ 中的协议名。
将列表 [‘a’,‘b’,‘c’] 中各个元素用’|'连接成一个字符串。
将字符串 ‘abc’ 相邻的两个字母之间加上半角逗号，生成新的字符串。
从键盘输入手机号码，输出形如 ‘Mobile: 186 6677 7788’ 的字符串。
从键盘输入年月日时分秒，输出形如 ‘2019-05-01 12:00:00’ 的字符串。
给定两个浮点数 3.1415926 和 2.7182818，格式化输出字符串 ‘pi = 3.1416, e = 2.7183’。
将 0.00774592 和 356800000 格式化输出为科学计数法字符串。
将十进制整数 240 格式化为八进制和十六进制的字符串。
将十进制整数 240 转为二进制、八进制、十六进制的字符串。
将字符串 ‘10100’ 按照二进制、八进制、十进制、十六进制转为整数。
求二进制整数1010、八进制整数65、十进制整数52、十六进制整数b4的和。
将列表 [0,1,2,3.14,‘x’,None,’’,list(),{5}] 中各个元素转为布尔型。
返回字符 ‘a’ 和 ‘A’ 的ASCII编码值。
返回ASCII编码值为 57 和 122 的字符。
将二维列表 [[0.468,0.975,0.446],[0.718,0.826,0.359]] 写成名为 csv_data 的 csv 格式的文件，并尝试用 excel 打开它。
从 csv_data.csv 文件中读出二维列表。
向 csv_data.csv 文件追加二维列表 [[1.468,1.975,1.446],[1.718,1.826,1.359]]，然后读出所有数据。
交换变量 x 和 y 的值。
判断给定的参数 x 是否是整形。
判断给定的参数 x 是否为列表或元组。
判断 ‘https://blog.csdn.net’ 是否以 ‘http://’ 或 ‘https://’ 开头。若是，则返回 ‘http’ 或 ‘https’；否则，返回None。
判断 ‘https://blog.csdn.net’ 是否以 ‘.com’ 或 ‘.net’ 结束。若是，则返回 ‘com’ 或 ‘net’；否则，返回None。
将列表 [3,‘a’,5.2,4,{},9,[]] 中 大于3的整数或浮点数置为1，其余置为0。
a,b 是两个数字，返回其中较小者或最大者。
找到列表 [8,5,2,4,3,6,5,5,1,4,5] 中出现最频繁的数字以及出现的次数。
将二维列表 [[1], [‘a’,‘b’], [2.3, 4.5, 6.7]] 转为 一维列表。
将等长的键列表和值列表转为字典。
使用链状比较操作符重写逻辑表达式 a > 10 and a < 20。
写一个函数，以0.1秒的间隔不换行打印30次由函数参数传入的字符，实现类似打字机的效果。
数字列表求和。
返回数字列表中的最大值和最小值。
计算 5 的 3.5 方和 3 的立方根。
对 3.1415926 四舍五入，保留小数点后5位。
判断两个对象是在内存中是否是同一个。
返回给定对象的属性和方法。
计算字符串表达式 ‘(2+3)*5’ 的值。
实现字符串 ‘x={“name”:“David”, “age”:18}’ 包含的代码功能。
使用 map 函数求列表 [2,3,4,5] 中每个元素的立方根。
使用 sys.stdin.readline() 写一个和 input() 函数功能完全相同的函数。
使用二维列表描述9x9围棋局面，'w’表示白色棋子，‘b’表示黑色棋子，’-'表示无子，打印成下图左所示的文本棋盘。
对于9x9围棋盘，用a-i标识各行，用1-9标识各列，设计函数go()，输入位置和颜色，即输出文本棋盘，模拟围棋对弈的过程。
下图中是国际跳棋的初始局面，10x10的棋盘上只有50个深色格子可以落子，'w’表示白色棋子，‘b’表示黑色棋子，’-'表示无子，字符串 phase = ‘b’*20 + ‘-’*10 + ‘w’*20 表示下图中的局面，请将 phase 打印成下图右所示的样子。