1.字符串處理
將字符串中的數字替換成其兩倍的值，例如：
修改前："AS7G123m (d)F77k"
修改后："AS14G246m (d)F154k"
? 個人思路：先用正則表達式將其中的數字匹配出來進行乘2操作，然后將字符串根據其中的數字進行切割，得到一個字符列表，最終將乘以2后的數字和原有的字符進行拼接得到最后的結果。（我腦子比較笨，想不到別的，如果您有更好更簡便的方法，希望可以分享一下！）
1
import
re
2
3
text =
"
AS7G123m (d)F77k
"
4
nums = re.findall(r
'
(\d+)
'
, text)
#
取出字符串中數字
5
double_nums = [2 * int(i)
for
i
in
nums]
#
乘以2
6
the_str = []
#
字符列表
7
for
i
in
nums:
8
the_str.append(text.split(i, 1
)[0])
9
text = text.split(i, 1)[1
]
10
result =
""
#
結果
11
for
i
in
range(len(double_nums)):
12
result += the_str[i] +
str(double_nums[i])
13
result +=
text
14
print
(result)
?
2.Python傳參是值傳遞還是引用傳遞？
? 答案是Python中傳遞參數是引用傳遞，那么要證明是引用傳遞呢？可以參考下面這個例子：
1
def
f(x):
2
print
(id(x))
3
4
5
a = 1
6
print
(id(a))
7
f(a)
8
#
140716760159264
9
#
140716760159264
這里分別打印了兩個地址，一個是對象a的地址，一個是傳入的參數x的地址，可以看到兩個地址是一樣的，這也就說明Python中的傳參使用的引用傳遞！需要注意的是： 對于不可變類型，在函數中對其操作并不會對原對象產生影響，但對于可變類型，在函數中對其操作則可能會改變其值 ，如下：
1）傳入的參數是不可變類型：
1
def
f(x):
2
x +=
"
666
"
#
這里會創建一個新的對象
3
print
(x)
4
5
6
s =
"
777
"
#
字符串不可變
7
print
(s)
8
f(s)
9
print
(s)
10
11
#
777
12
#
777666
13
#
777
2）傳入的參數是可變類型：
1
def
f(x):
2
x.append(4)
#
修改原對象的值
3
print
(x)
4
5
6
s = [1, 2, 3]
#
列表可變
7
print
(s)
8
f(s)
9
print
(s)
10
11
#
[1, 2, 3]
12
#
[1, 2, 3, 4]
13
#
[1, 2, 3, 4]
?
3.淺拷貝與深拷貝的那些事
在Python中，淺拷貝與深拷貝是一定要分清楚的！對于淺拷貝和深拷貝，可以這么理解：
1） 淺拷貝：創建一個對象，但其中包含的是原對象中所包含項的引用，如果用引用的方式修改了其中的對象，就會對原對象進行改變。
2） 深拷貝：創建一個對象，并且遞歸復制原對象中所包含的對象，此時修改數據不會對原對象產生影響。
在下面的代碼中包含了賦值、淺拷貝和深拷貝，在Python中賦值即引用對象，所以對c操作也就是對原對象a進行操作，對于淺拷貝對象b和d，對其中的引用進行操作會改變對a中的對象，而對深拷貝對象e進行操作就與原對象a無關了。
1
import
copy
2
3
a = [1, [2], 3
]
4
b = a[:]
#
使用切片操作，淺拷貝
5
c = a
#
賦值操作，即引用
6
d = a.copy()
#
淺拷貝
7
e = copy.deepcopy(a)
#
深拷貝
8
9
b.append(4
)
10
c.append(5
)
11
d.append(6
)
12
d[1].append(2
)
13
e.append(7
)
14
e[1].append(3
)
15
16
print
(a)
#
[1, [2, 2], 3, 5]
17
print
(b)
#
[1, [2, 2], 3, 4]
18
print
(c)
#
[1, [2, 2], 3, 5]
19
print
(d)
#
[1, [2, 2], 3, 6]
20
print
(e)
#
[1, [2, 3], 3, 7]
?
?4.Python一行式能干嘛？
下面是一些Python一行式的示例，從中可以看出Python是非常簡潔和強大的！
1）一行代碼輸出一百以內的奇數：
print([x for x in range(100) if x % 2])
2）一行代碼求水仙花數：
print([x for x in range(100, 1000) if int(str(x)[0])**3 + int(str(x)[1])**3 + int(str(x)[2])**3 == x])
3）一行代碼打印九九乘法表：
print("".join(["{} * {} = {}\t".format(x, y, x * y) if x != y else "{} * {} = {}\n".format(x, y, x * y) for x in range(1, 10) for y in range(1, x + 1)]))
4）一行代碼實現IP地址轉換，如將192.168.12.1轉換成0b11000000 10101000 00001100 00000001：
print("0b"+" ".join(("00000000" + bin(int(i)).replace("0b", ""))[-8:] for i in ip.split(".")))
5）一行代碼求1到10的和：
from functools import reduce; print(reduce(lambda x, y: x + y, [i for i in range(1, 11)]))
?
?5.下面這段代碼的結果是什么？
1
def
mul():
2
return
[
lambda
x: x * i
for
i
in
range(4
)]
3
4
5
print
([m(2)
for
m
in
mul()])
以上這段代碼輸出的結果是[6, 6, 6, 6]，而不是[0, 2, 4, 6]！
產生這個問題的原因在于Python閉包的延遲綁定。這意味著內部函數被調用時，參數的值在閉包內進行查找。所以當mul()返回的函數被調用時，i的值會在返回的函數里查找，而for循環完成后i的值為3，也就是i最終賦值為3。因此，每次返回的函數乘以傳入的值就是最后的結果，得到的結果就是[6, 6, 6, 6]。
如果要解決這個問題，可以參考以下方法：
1）使用Python生成器。
1
def
mul():
2
for
i
in
range(4
):
3
yield
lambda
x: x *
i
4
5
6
print
([m(2)
for
m
in
mul()])
2）創造一個閉包，利用默認函數進行綁定。
1
def
mul():
2
return
[
lambda
x, i=i: x * i
for
i
in
range(4
)]
3
4
5
print
([m(2)
for
m
in
mul()])
?
更多文章、技術交流、商務合作、聯系博主
微信掃碼或搜索：z360901061
微信掃一掃加我為好友
QQ號聯系： 360901061
您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。
【本文對您有幫助就好】元
