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'
複製程式碼

2. format

mystr2 = "welcome to luobodazahui, dear {name}"
mystr2.format(name="baby")
複製程式碼

output

'welcome to luobodazahui, dear baby'
複製程式碼

3. join

可以用來連線字串，將字串、元組、列表中的元素以指定的字元(分隔符)連線生成一個新的字串。

mylist = ['luo', 'bo', 'da', 'za', 'hui']
mystr3 = '-'.join(mylist)
print(mystr3)
複製程式碼

outout

'luo-bo-da-za-hui'
複製程式碼

4. replace

String.replace(old,new,count) 將字串中的 old 字元替換為 New 字元，count 為替換的個數

mystr4 = 'luobodazahui-haha'
print(mystr4.replace('haha', 'good'))
複製程式碼

output

luobodazahui-good
複製程式碼

5. 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. 切片

同字串

2. 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]
複製程式碼

3. 刪除元素

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']
複製程式碼

4. 元素排序

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

{}
複製程式碼

2. 指定刪除

使用 pop 方法來指定刪除字典中的某一項

dict1 = {'key1':1, 'key2':2}
d1 = dict1.pop('key1')
print(d1)
print(dict1)
複製程式碼

output

1
{'key2': 2}
複製程式碼

3. 遍歷字典

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)]
複製程式碼

4. 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'
複製程式碼

面試題系列第一部分就到這裡了，我們下次見！

歡迎關注我的微信公眾號--蘿蔔大雜燴，或者掃描下方的二維碼，大家一起交流，學習和進步！