系列文章目錄

文章目錄

• 系列文章目錄
• 前言
• 一、python實戰技巧
• • 1. 求字符差值
  • 2. 字符串反轉
  • 3. 數組元素計數
  • 4. 字典遍歷
  • 5. 初始化全0數組
  • 6. Counter計數
  • 7. bisect的用法
  • 8. 列表去重
  • 9. 列表轉化成字符串
  • 10. map函數
  • 11. collections.deque
  • 12. Priority Queue
  • 13. 二維list按某一列的值排序
  • 14. f-string的用法
  • 15. zip函數的用法
  • 16. 利用get()方法獲取字典value
  • 17. collections.OrderedDict有序字典
  • 18. 取字典最大value值對應key
  • 19. @lru_cache 裝飾器用法
  • 20. 字典的排序
  • 21. 判斷字符串是否全部有字母組成
  • 22. 對某個可迭代對象（字典，列表，元組，等）進行多步排序
  • 23. 列表不能作為字典的鍵，但是元組可以
  • 24. 原地交換兩個數字
  • 25. 鏈狀比較操作符
  • 26. 存儲列表元素到新的變量中
  • 27. 打印引入模塊的文件路徑
  • 28. 交互環境下的“—”操作符
  • 29. 如何用input輸入多個數據
  • 30. 同時獲取索引和下標
  • 31. 內存地址查詢
  • 32. 將兩個列表轉換為字典
  • 33. 列表元素頻率統計（利用字典）
  • 34. 對象占用內存量查詢
  • 35. 檢查是否有重復元素
  • 36. 查找列表中出現次數最多的數
  • 37. 反轉列表
  • 38. 合並列表的兩種方法
  • 39. 字典推導（Dictionary comprehensions）和集合推導（Set comprehensions）
  • 40. 自從python3.1起，我們可以使用同樣的語法來創建集合和字典表
  • 41. 迭代工具
  • 42. 調試腳本
  • 43. 如何用input輸入多個數據
• 總結

前言

一、python實戰技巧

1. 求字符差值

python不可以直接進行字符減運算，當需要進行字符之間的減運算時，我們可以使用ord()函數，ord()函數是python自帶的函數，無需導入。

print(ord('b')-ord('a'))
#result:1

2. 字符串反轉

string = 'leetcode'
print(string[::-1])
#result:edocteel

3. 數組元素計數

import collections
li = [1,2,2,4,5,5]
cnt = collections.Counter(li)
print(cnt)
#result:Counter({
2: 2, 5: 2, 1: 1, 4: 1})

4. 字典遍歷

cnt = {
1:4,2:3}
#遍歷鍵值對
for item in cnt.items():
print(item)
#遍歷鍵
for item in cnt.keys():
print(item)
#遍歷值
for item in cnt.values():
print(item)

result:

(1, 4)
(2, 3)
1
2
4
3

5. 初始化全0數組

li = [0]*length #第一種
li = [0 for i in range(length)] #第二種
li = [[0]*3 for i in range(4)] #二維數組

6. Counter計數

from collections import Counter
colors = ['red','blue','red','green','blue','blue']
c = Counter(colors)
print(c)
print(dict(c))

result:

Counter({
'blue': 3, 'red': 2, 'green': 1})
{
'red': 2, 'blue': 3, 'green': 1}

7. bisect的用法

bisect是python的內置模塊，用於有序序列的插入和查找
查找：bisect(array,item)
插入：bisect(array,item)

import bisect
a = [1,2,2,5,8]
position = bisect.bisect(a,7)
print(position)
#4
bisect.insort(a,4) #找到位置插入
print(a)
#[1,2,2,4,5,8]
bisect.bisect_left(a,2) #插到左側
#1
bisect.bisect_right(a,2) #插到右側
#3

8. 列表去重

l1 = [1,4,4,2,3,4,5,6,1]
l2 = list(set(l1))
print(l2)
#result:[1, 2, 3, 4, 5, 6]

9. 列表轉化成字符串

li = ['a','b','c']
print(' '.join(str(i) for i in li))

10. map函數

def square(x):
return x**2
a = list(map(square,[1,2,3,4,5])) #計算列表各元素的平方
b = list(map(lambda x:x**2,[1,2,3,4,5,])) #用lambda匿名函數
print(a,b)
#result:[1, 4, 9, 16, 25] [1, 4, 9, 16, 25]

11. collections.deque

deque是雙端隊列(double-ended queue)的縮寫，由於兩端都能編輯，deque既可以實現棧(stack),也可以實現隊列(queue)

from collections import deque
# que = collections.deque()
a=deque([1,2,3])
a.pop()
# [1,2]
a.append(4)
# [1,2,4]
a.popleft()
# [2,4]
a.appendleft(0)
# [0,2,4]

相比list實現的隊列，deque實現擁有更低的時間和空間復雜度。list實現出隊(pop)和插入(insert)時的空間
復雜度大約為O(n),deque在出隊(pop)和入隊(append)時的時間復雜度是O(1)。

12. Priority Queue

from queue import PriorityQueue
Q = PriorityQueue()
Q.put(3)
Q.put(2)
Q.put(1)
Q.get()

優先級隊列，默認是從小到大排序的

13. 二維list按某一列的值排序

li = [[1,3],[8,10],[2,6],[15,18]]
li.sort(key=lambda x:x[0])
li
print(li)
#result:[[1, 3], [2, 6], [8, 10], [15, 18]]

14. f-string的用法

name = 'python'
f'Hello {name}'
print(f'Hello {name}')

15. zip函數的用法

systems = ['windows','ubuntu','mac']
version = ['20.20','19.10','21.20']
countries = ['UK','Chinese','US']
for system,ver,country in zip(systems,version,countries):
print(f'{
system} plays in {
ver}.country:{
country}')

16. 利用get()方法獲取字典value

person = {
'name':'YQ','age':22}
print('Name:',person.get('name'))
print('Age:',person.get('age'))
print('Salary:',person.get('salary'))

result:

Name: YQ
Age: 22
Salary: None

17. collections.OrderedDict有序字典

from collections import OrderedDict
mydict = OrderedDict({
'a':2,'b':1,'c':0})
for key,value in mydict.items():
print(key,value)

result:

a 2
b 1
c 0

18. 取字典最大value值對應key

nums = [1,2,2,2,3,4,4]
from collections import Counter
cnt = Counter(nums)
print(max(cnt.keys(),key = cnt.get))
#result:2

19. @lru_cache 裝飾器用法

NameError: name 'lru_cache' is not defined
from functools import lru_cache

一個為函數提供緩存功能的裝飾器，直接用於一個用戶自定義函數，在下次以相同參數調用時直接返回上一次的結果
lru_cache maxsize 參數默認值為128.如果設為None，緩存可無限增長

from functools import lru_cache
@lru_cache(maxsize = None)
def fib(n):
if n < 2:
return n
return fib(n-1) + fib(n-2)

20. 字典的排序

#字典排序
a = {
'a':3,'c':89,'b':0,'d':34}
#按照字典的值進行排序
a1 = sorted(a.items(),key = lambda x: x[1])
#按照字典的鍵進行排序
a2 = sorted(a.items(),key = lambda x: x[0])
print('按值排序後結果',a1)
print('按鍵排序後結果',a2)
print('結果轉為字典格式',dict(a1))
print('結果轉為字典格式',dict(a2))

result：

按值排序後結果 [('b', 0), ('a', 3), ('d', 34), ('c', 89)]
按鍵排序後結果 [('a', 3), ('b', 0), ('c', 89), ('d', 34)]
結果轉為字典格式 {
'b': 0, 'a': 3, 'd': 34, 'c': 89}
結果轉為字典格式 {
'a': 3, 'b': 0, 'c': 89, 'd': 34}

21. 判斷字符串是否全部有字母組成

my_str = 'python'
my_str.isalpha()
print(my_str.isalpha())

22. 對某個可迭代對象（字典，列表，元組，等）進行多步排序

多步排序，例如：先按內容進行排序，如果內容一樣再按照ID排序

my_test = ["b:7","a:7","c:4","d:3"]
def f(log):
id_,rest = log.split(":",1)
return (rest,id_)
print(sorted(my_test,key=f))
#result:['d:3', 'c:4', 'a:7', 'b:7']

比如上面的例子，先按照字符串值進行排序，再按照字符串的id排序

23. 列表不能作為字典的鍵，但是元組可以

有時候需要用字典來統計一個列表中相同的元素的個數，但是可能元素也是一種列表，這種時候就不能直接使用
collections.Counter來統計，需要把原列表的元素轉為tuple

1、數組操作

1.1. 遍歷數組，枚舉索引和值

for i,j in enumerate([1,2,34,5,56,4]):
#i為索引
#j為值

1.2. 數組反轉

a = [1,2,3,4,5]
a[::-1]
a.reverse()

1.3. 數組排序

a = [1,2,6,8,0,3,4]
a.sort()
a = [[1,3],[2,4],[5,0]]
sort(key = lambda x:x[0]) #根據第一個數為key進行排序

1.4. 數組合並

a = [1,2,6,8,0,3,4]
b = [2,5,9]
a.extend(b)
a.[len(a):]=b

1.5. 構建棧和隊列

a = [1,2,6,8,0,3,4]
a.append() #數組尾部添加
a.insert(x,3) #在索引為x的位置插入3
a.pop() #刪除尾部元素
a.pop(0) #刪除索引為0的元素
a = [] #構建棧
a.append()
a.pop()
a = []
a.append()
a.pop(0)

1.6. 數組去重

#轉化為set,再轉化為list
a = [1,1,1,3,4,4]
a = list(set(a))

1.7. 查找數組

a.index(3)

2、字符串操作

2.1. 去除空格

a = ' hello world '
a.strip() #去除兩邊所有空格
a.lstrip() #去除左邊空格
a.rstrip() #去除右邊空格

2.2. 替換字符

#將a中的x替換為yyy，可以將空格' '替換為''等於去除空格
a.replace('x','yyy')

2.3. 合並字符

a = 'hello'
b = 'world'
c = a + b

2.4. 判斷字符組成

#如果string只包含數字則返回true,否則返回False
a.isdigit()
#如果string至少有一個字符並且所有字符都是字母或數字則返回True，否則返回False
a.isalnum()
#如果string至少有一個字符並且所有字符都是字母則返回True，否則返回False
a.isalpha()

2.5. 數組轉化為字符

#以string作為分隔符，將seq中所有的元素（的字符串表示）合並為一個新的字符串
#string.join(seq)
a = [1,2,3,4]
#''.join(a) #結果為'1234'
print(' '.join('%s' %id for id in a))

24. 原地交換兩個數字

python 提供了一個直觀的在一行代碼中賦值與交換（變量值）的方法

x,y = 10,20
print(x,y)
x,y = y,x
print(x,y)

賦值的右側形成了一個新的元組，左側立即解析（unpack）那個（未被引用的）元組到變量和，一旦賦值完成，新的元組變成了未被引用狀態並且被標記為可被垃圾回收，最終完成了變量的交換

25. 鏈狀比較操作符

比較操作符的聚合是另一個有時很方便的技巧：

n = 10
result = 1<n<20
print(result) #True
result = 1>n<=9
print(result) #False

26. 存儲列表元素到新的變量中

我們可以使用列表來初始化多個變量，在解析列表時，變量的數目不應該超過列表中元素個數：[元素個數與列表長度應該嚴格相同]

testList =[1,2,3]
x,y,z = testList
print(x,y,z) #1 2 3

27. 打印引入模塊的文件路徑

如果你想知道引用到代碼中模塊的絕對路徑可以使用

import threading
import socket
print(threading)
print(socket)

28. 交互環境下的“—”操作符

這是一個我們大多數人不知道的有用特性，在python控制台，不論何時我們測試一個表達式或調用一個方法，結果都會分配一個臨時變量：_

29. 如何用input輸入多個數據

#方法一：
#List = eval(input('輸入若干個數字，用逗號分隔：'))
#方法二：
#List = List(map(int,input('輸入數字，以空格分隔').split()))
#int可以換為float等，得到的數據也隨之為相應類型
#解釋：
#1. map()
#map()函數接受兩個參數，一個是函數，一個是序列，map將傳入的函數依次作用到序列的每個元素，並把結果作為新的list返回
#2. split()
#拆分字符串，通過指定分隔符對字符串進行切片，並返回分隔後的字符串列表
#3. map(function,input("以空格分開").split())
#由於input()輸出的是用空格分開的字符串，split()會分隔開各個值並放到列表中，此時在列表中的值是字符串，如果要運算，那麼必須在map()中利用int()或float()等處理再賦值

30. 同時獲取索引和下標

List = [1,2,3,4,5,6]
for i,j in enumerate(List): #i為下標，j為相應的數據
print("data:",end=' ')
print("index",i)

result:

data: index 0
data: index 1
data: index 2
data: index 3
data: index 4
data: index 5

31. 內存地址查詢

a = 123
b = 'blue'
print(id(a)) #不同電腦，值應該不同
print(id(b))

32. 將兩個列表轉換為字典

a = ['A','B','C','D','E']
b = [1,2,3,4,5]
#方法一：
c1 = dict(zip(a,b))
#方法二
c2 = {
key:value for key,value in zip(a,b)}
#方法三
c3 = {
} #初始化一個空字典
for k,v in zip(a,b):
if k not in c3.keys(): #判斷k是否在c3字典的鍵中
c3[k] = v
print(c1)
print(c2)
print(c3)

result:

{
'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5}
{
'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5}
{
'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5}

33. 列表元素頻率統計（利用字典）

a = [1,2,3,1,2,4,6,5,6,6,7,9,10,10]
b = {
}
for i in a:
if i not in b.keys():
b[i] = 1
else:
b[i] =b[i] + 1
print(b)
#result:{
1: 2, 2: 2, 3: 1, 4: 1, 6: 3, 5: 1, 7: 1, 9: 1, 10: 2}

34. 對象占用內存量查詢

from sys import getsizeof
a = 100
b = 'green'
print(getsizeof(a)) #28
print(getsizeof(b)) #54

35. 檢查是否有重復元素

List1 = [1,2,3,4,56]
List2 = [1,1,3,4,5,5]
print("有重復元素:",len(List1) != len(set(List1))) #有重復元素：False
print("有重復元素:",len(List2) != len(set(List2))) #有重復元素：True

解釋：set(x)函數可以用於集合生成，其中的參數可以為任意數據類型，返回結果是一個無重復且排序任意的集合，
也就是說，如果輸入數據有重復，那麼返回的結果也會把重復的數據變得不重復

36. 查找列表中出現次數最多的數

#方法一：
List1 = [1,2,3,4,56,11,2,3,4,5,6,7,1,2,3,1,1,1,19]
print(max(set(List1),key = List1.count)) #1
#方法二：
from collections import Counter #python的內置庫
ct = Counter(List1)
print(ct.most_common(1)) #輸出頻率最高的一個 #[(1,5)] 1出現5次

37. 反轉列表

List1 = [1,2,5,4,7,6]
List2 = List1[::-1]
print(List2) #[6, 7, 4, 5, 2, 1]

38. 合並列表的兩種方法

list1=[1,2,5,4,7,6]
list2=['A','B','C','D']
list3=list1+list2#直接加
list4=list1.extend(list2)#調用列表的extend方法
print(list3) #[1, 2, 5, 4, 7, 6, 'A', 'B', 'C', 'D']
print(list4) #None
print(list1) #[1, 2, 5, 4, 7, 6, 'A', 'B', 'C', 'D']

解釋：為什麼list4為None？其實，這裡非常重要，列表的append和extend方法都會對原有列表進行修改，是不會返回一個新的列表的，返回值為None。

39. 字典推導（Dictionary comprehensions）和集合推導（Set comprehensions）

大多數的python程序員都知道且使用過列表推導list comprehensions，如果你對list comprehensions不熟，更簡短：

some_list = [1,2,3,4,5]
another_list = [x + 1 for x in some_list]
print(another_list) #[2, 3, 4, 5, 6]

40. 自從python3.1起，我們可以使用同樣的語法來創建集合和字典表

some_list = [1,2,3,4,5,2,5,1,4,8]
even_set = {
x for x in some_list if x %2 == 0}
print(even_set) #{
8, 2, 4}
set([8,2,4])
d = {
x: x%2 == 0 for x in range(1,11)}
print(d) #{
1: False, 2: True, 3: False, 4: True, 5: False, 6: True, 7: False, 8: True, 9: False, 10: True}

在第一個例子裡，我們以some_list為基礎，創建了一個具有不重復元素的集合，而且集合裡只包含偶數，而在字典表中，我們創建了
一個key是不重復復的1到10之間的整數，value是布爾型，用來指示key是否是偶數
這裡另一個值得注意的是集合的字面量表示法，我們可以簡單的用這種方法創建一個集合

my_set = {
1,2,1,2,3,4}
print(my_set) #{
1, 2, 3, 4}

41. 迭代工具

和collections庫一樣，還有一個庫較itertools，對某些問題真能高效的解決，其中一個用例是查找所有組合

from itertools import combinations
teams = ["Packers","49ers","Ravens","Patriots"]
for game in combinations(teams,2):
print(game)

result:

('Packers', '49ers')
('Packers', 'Ravens')
('Packers', 'Patriots')
('49ers', 'Ravens')
('49ers', 'Patriots')
('Ravens', 'Patriots')

42. 調試腳本

我們可以在模塊的幫助下在python腳本中設置斷點

import pdb
pdb.set_trace()

43. 如何用input輸入多個數據

#方法一：
#List = eval(input('輸入若干個數字，以逗號分隔：')) #輸入個數任意，都保存到list中
#方法二：
#List = list(map(int(input('輸入數字，以空格隔開').split())))
#int可以換成float等，得到的數據也隨之為相應類型
#解釋：
1.map()
map函數接收兩個參數，一個是函數，一個是序列，map將傳入的函數依次作用到序列的每個元素，並把結果作為新的list返回
2.split()
split拆分字符串，通過指定分隔符對字符串進行切片，並返回分割後的字符串列表
3.map(function,input("以空格分開").split())
由於input()輸出的是用空格分開的字符串，split()會分割開各個值並放到列表中，此時在列表中的值是字符串\
如果要用於運算，那麼必須在map()中利用int()或float()等處理，再賦值

總結

分享：
經驗是我們創新的一個潛在條件。嚴格地說，有經驗而不受經驗制約時，經驗才是創新的一個條件，否則，經驗就會成為阻礙創新的障礙。經驗是有不同層次的。為了升華智慧，應盡可能借鑒高層次的經驗—
這不僅為我們提供了前進的方向，還提供了選擇的思路，使之成為觸發新成功的起點。