今回は仕事でも使えそうな
Pythonのテクニック集となります。

解説動画はこちら




今回は
・リスト
・辞書
これを使ったテクニック集となっています。


リスト関連

リストの順番をひっくり返す
リスト[::-1]
# リストのひっくり返し
data = [1 , 3 , 4 , 5,  2 , 6]

print(data[::-1])
[6, 2, 5, 4, 3, 1]



リストのキーでソート
sorted(リスト , key=lambda x:x[インデックス])
# 多重リストの2つ目の値でのソート
data = [[1,3,8],[4,5,9],[2,6,7]]

for l in sorted(data,key=lambda x:x[1]):
    print(l)
[1, 3, 8]
[4, 5, 9]
[2, 6, 7]


# 多重リストの3つ目の値でのソート
data = [[1,3,8],[4,5,9],[2,6,7]]

for l in sorted(data,key=lambda x:x[2]):
    print(l)
[2, 6, 7]
[1, 3, 8]
[4, 5, 9]



3重リストのソート
sorted(リスト , key=lambda x:x[インデックス][インデックス])

# 3重リストの中のリストの値でのソート
data = [[[1,3],[4,5],[2,6]],[[7,8],[0,1],[9,5]]]

for l in sorted(data,key=lambda x:x[1][0]):
    print(l)
[[7, 8], [0, 1], [9, 5]]
[[1, 3], [4, 5], [2, 6]]



リストの連続値での繰り返し
zip(リスト , リスト[1:])
# リストの連続値での繰り返し
data = [1, 2, 3, 4, 5]

for d0, d1 in zip(data, data[1:]):
    print(d0 , d1)
1 2
2 3
3 4
4 5



リストの展開
変数 ,  ・・ =zip(*リスト)
# 2要素のリストの展開
data = [[1,2],[3,4],[5,6],[7,8]]

a,b = zip(*data)
print(a,b)
(1, 3, 5, 7) (2, 4, 6, 8)


# 3要素のリストの展開
data = [[1,2,3],[4,5,6],[7,8,9],[0,1,2]]

a,b,c = zip(*data)
print(a,b,c)
(1, 4, 7, 0) (2, 5, 8, 1) (3, 6, 9, 2)



2次元リストの転置
list(map(list, zip(*データ)))
# 2次元リストの転置
data = [[1,2,3,4],[5,6,7,8]]

for d in list(map(list, zip(*data))):
    print(d)

[1, 5]
[2, 6]
[3, 7]
[4, 8]



リストの要素をつなげて繰り返す
chain(*リスト)
# 多重リストを1次元に展開して繰り返しに
from itertools import chain

data = [[1, 3], [], [2, 5], [4,6,9], [], [8,0,7]]
for d in chain(*data):
    print(d)
1
3
2
5
4
6
9
8
0
7



多重リストを1次元に展開して判定
# 多重リストを1次元に展開して判定
data = [[0],[0,1],[],[0,0,0],[0,0]]

print(any(chain(*data)))

print(all(chain(*data)))
True
False


ランレングス圧縮

連続して現れる符号を
繰り返し回数を表す値に置き換える方式
from itertools import groupby

text = 'aaabbcccab'

answer = list((g, str(len(list(it)))) for g, it in groupby(text))

print(answer)

print(''.join([''.join(a) for a in answer]))

[('a', '3'), ('b', '2'), ('c', '3'), ('a', '1'), ('b', '1')]
a3b2c3a1b1


関数化してみる
from itertools import groupby

# ランレングス圧縮した結果をリストで返す
def rl_encode(text):
    res = []
    for k, v in groupby(text):
        res.append((k, int(len(list(v)))))
    return res

# ランレングス圧縮したリストを元に戻す
def rl_decode(data):
    res = ""
    for c, n in data:
        res += c * int(n)
    return res

# ランレングス圧縮した結果を文字列で返す
def rl_tostring(text):
    res = ""
    for k, v in groupby(text):
        res += k + str(len(list(v)))
    return res


リストの要素の数え上げ
Counter(リスト)
from collections import Counter

data_a = [5,4,3,3,3,2,1,1,1]
data_b = [6,7,5,2,1,1,]

a = Counter(data_a)
b = Counter(data_b)

print(a)
print(b)
print(a + b)
print(a - b)
print(b - a)

Counter({3: 3, 1: 3, 5: 1, 4: 1, 2: 1})
Counter({1: 2, 6: 1, 7: 1, 5: 1, 2: 1})
Counter({1: 5, 3: 3, 5: 2, 2: 2, 4: 1, 6: 1, 7: 1})
Counter({3: 3, 4: 1, 1: 1})
Counter({6: 1, 7: 1})



リストの要素の最大個数の値を調べる
# 最大個数を調べる
from collections import Counter

data = [5,4,4,3,3,3,3,2,2,1,1,1]

d = dict(Counter(data))

max_k = max(d, key=d.get)
min_k = min(d, key=d.get)

print(max_k)
print(min_k)
3
5


辞書関連

集計を行う
    if キー in 結果の辞書:
        結果の辞書[キー] += 1
    else:
        結果の辞書[キー] = 1


# 辞書で集計する
data = [5,4,4,3,3,3,3,2,2,1,1,1]

result_dict = {}
for d in data:
    if d in result_dict:
        result_dict[d] += 1
    else:
        result_dict[d] = 1
        
print(result_dict)
{5: 1, 4: 2, 3: 4, 2: 2, 1: 3}


リストから辞書に変換
{a:値 for a in リスト}
dict(zip(リスト , リスト))

# 1つのリストから辞書を作る
data1 = [1,2,3,4,1,2]

d = {a:0 for a in data1}
print(d)
{1: 0, 2: 0, 3: 0, 4: 0}

# 2つのリストから辞書を作る
data1 = [1,2,3,4,5]
data2 = [9,8,7,6,5]

d = dict(zip(data1 , data2))
print(d)
{1: 9, 2: 8, 3: 7, 4: 6, 5: 5}



複合データのソート
# 辞書のキーpで昇順ソート
Adic = {'C134':{"p":30,"s":"1000","r":200 ,"a":[110,20,30,50]}, 
             'C623':{"p":80,"s":"1100" ,"r":600 ,"a":[100,10,30,50]},
             'C430':{"p":70,"s":"5000","r":100 ,"a":[160,11,120,6]},
             'C115':{"p":10,"s":"2400","r":400 ,"a":[800,15,10,6]}}

for p in sorted(Adic.items(), key=lambda x: x[1]['p']):
    print(p)
('C115', {'p': 10, 's': '2400', 'r': 400, 'a': [800, 15, 10, 6]})
('C134', {'p': 30, 's': '1000', 'r': 200, 'a': [110, 20, 30, 50]})
('C430', {'p': 70, 's': '5000', 'r': 100, 'a': [160, 11, 120, 6]})
('C623', {'p': 80, 's': '1100', 'r': 600, 'a': [100, 10, 30, 50]})


# 辞書のキーsで降順ソート
Adic = {'C134':{"p":30,"s":"1000","r":200 ,"a":[110,20,30,50]}, 
             'C623':{"p":80,"s":"1100" ,"r":600 ,"a":[100,10,30,50]},
             'C430':{"p":70,"s":"5000","r":100 ,"a":[160,11,120,6]},
             'C115':{"p":10,"s":"2400","r":400 ,"a":[800,15,10,6]}}

for s in sorted(Adic.items(), key=lambda x: int(x[1]['s']),reverse=True):
    print(s)
('C430', {'p': 70, 's': '5000', 'r': 100, 'a': [160, 11, 120, 6]})
('C115', {'p': 10, 's': '2400', 'r': 400, 'a': [800, 15, 10, 6]})
('C623', {'p': 80, 's': '1100', 'r': 600, 'a': [100, 10, 30, 50]})
('C134', {'p': 30, 's': '1000', 'r': 200, 'a': [110, 20, 30, 50]})

# 辞書のキーaの2個目の値で降順ソート
Adic = {'C134':{"p":30,"s":"1000","r":200 ,"a":[110,20,30,50]}, 
             'C623':{"p":80,"s":"1100" ,"r":600 ,"a":[100,10,30,50]},
             'C430':{"p":70,"s":"5000","r":100 ,"a":[160,11,120,6]},
             'C115':{"p":10,"s":"2400","r":400 ,"a":[800,15,10,6]}}

for a in sorted(Adic.items(), key=lambda x: x[1]['a'][1],reverse=True):
    print(a)
('C134', {'p': 30, 's': '1000', 'r': 200, 'a': [110, 20, 30, 50]})
('C115', {'p': 10, 's': '2400', 'r': 400, 'a': [800, 15, 10, 6]})
('C430', {'p': 70, 's': '5000', 'r': 100, 'a': [160, 11, 120, 6]})
('C623', {'p': 80, 's': '1100', 'r': 600, 'a': [100, 10, 30, 50]})

jsonで辞書と文字の変換
json.dumps(辞書)
json.loads(文字列)
# JSON文字列にシリアライズ
import json

data = {"キー1": "1","キー2": "2"}

jst = json.dumps(data)

print(jst)
{"\u30ad\u30fc1": "1", "\u30ad\u30fc2": "2"}

# JSON文字列から辞書にデシリアライズ
import json

dic_data = json.loads(jst)

print(dic_data)
{'キー1': '1', 'キー2': '2'}




こんな感じです

毎日使うものではないですが
覚えておくといつか捗る時が来るかもしれません

お役に立てば幸いです

それでは。