OmniAICreator/Qiita-1.07M huggingface dataset:
Pythonでの外れ値処理入門：方法と実装

# Pythonでの外れ値処理入門：方法と実装

**この記事のゴール**:  
データ分析の初心者でも、Pythonで外れ値の検出と処理ができるようになることがゴールです。外れ値の対処はデータの品質を向上させ、分析の精度を高める重要なステップです。このブログでは、外れ値の検出方法、処理方法、注意点について具体的なPythonコードを使いながら解説します。

---

**目次**  
1. [外れ値とは？](#外れ値とは？)  
2. [Pythonでの外れ値の検出方法](#Pythonでの外れ値の検出方法)  
   - Zスコア法
   - IQR法  
3. [外れ値の処理方法](#外れ値の処理方法)  
4. [外れ値処理時の注意点](#外れ値処理時の注意点)  
5. [参考文献](#参考文献)  

---

## 外れ値とは？

外れ値は、通常のデータ範囲から外れた極端な値のことです。これらの値は、データに誤差がある場合や異常な条件下で記録されたデータを示すことが多く、処理しないと結果に悪影響を及ぼすことがあります[1]。

---

## Pythonでの外れ値の検出方法

### 1. Zスコア法

Zスコア法では、データが平均からどれだけ離れているかを標準偏差の単位で計算します。通常、Zスコアの絶対値が3以上のデータを外れ値とみなします。

```python
import numpy as np

# サンプルデータの作成
data = np.array([10, 12, 13, 15, 100, 14, 12, 13, 11])

# Zスコアの計算
mean = np.mean(data)
std_dev = np.std(data)
z_scores = (data - mean) / std_dev  # Zスコア計算

# 外れ値の検出
outliers = data[np.abs(z_scores) > 3]  # Zスコアが3以上のデータを外れ値とする
print("外れ値 (Zスコア法):", outliers)
```

### 2. IQR法 (四分位範囲法)

IQR法では、四分位数を用いて外れ値を検出します。第1四分位数(Q1)と第3四分位数(Q3)を計算し、それぞれから1.5倍のIQR範囲を超えるデータを外れ値とみなします[3]。

```python
# 四分位数の計算
Q1 = np.percentile(data, 25)  # 第1四分位数
Q3 = np.percentile(data, 75)  # 第3四分位数
IQR = Q3 - Q1

# 外れ値の範囲
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR

# 外れ値の検出
outliers_iqr = data[(data < lower_bound) | (data > upper_bound)]
print("外れ値 (IQR法):", outliers_iqr)
```

---

## 外れ値の処理方法

### a) 外れ値の削除

外れ値を削除すると、データの一部を失いますが、分析がシンプルになります[4]。

```python
# 外れ値以外のデータを選択して新しいデータセットを作成
cleaned_data = data[(data >= lower_bound) & (data <= upper_bound)]
print("外れ値を除去したデータ:", cleaned_data)
```

### b) 外れ値の変換

対数変換やBox-Cox変換で外れ値の影響を軽減することも可能です。

```python
import numpy as np

# 対数変換
transformed_data = np.log(data + 1)  # log(0)を避けるために1を足す
print("対数変換後のデータ:", transformed_data)
```

### c) 補完による置き換え

外れ値を中央値や平均値で置き換えることで、データの損失を防ぎます[4]。

```python
# 中央値で外れ値を置き換える
median_value = np.median(data)
data_with_imputed_outliers = np.where((data < lower_bound) | (data > upper_bound), median_value, data)
print("補完後のデータ:", data_with_imputed_outliers)
```

### d) トリミング

両端から一定割合をカットすることで、外れ値の影響を排除します[5]。

---

## 外れ値処理時の注意点

1. **外れ値の検出方法を正しく選ぶ**:
   Zスコア法とIQR法のどちらを使うかはデータの性質によって変わります[1][3]。

2. **外れ値を除去するリスク**:
   外れ値が有意な情報を持つ場合もあるため、データを失うことによるリスクも考慮しましょう[1]。

3. **外れ値を可視化する**:
   外れ値の検出前後でデータの分布を確認し、意図通りの変化があるかチェックすることが重要です[5]。

---

## 参考文献

[1] "外れ値処理の考え方," Sales Analytics, https://www.salesanalytics.co.jp/column/no00397/  
[2] "データ分析における外れ値処理方法," Blog Since 2020, https://blog.since2020.jp/data_analysis/%E5%A4%96%E3%82%8C%E5%80%A4%E3%81%AE%E5%87%A6%E7%90%86%E6%96%B9%E6%B3%953%E9%81%B8%EF%BC%81/  
[3] "Pythonでの外れ値検出 (IQR法)," Codexa, https://www.codexa.net/python-outlier/  
[4] "外れ値の検出と処理方法," Note, https://note.com/united_code/n/n7c49170b882f  
[5] "データの外れ値処理に関するガイドライン," Gochikika, https://gochikika.ntt.com/Preprocessing/outlier.html  

---

## 引用

- **外れ値の検出方法**は「Pythonでの外れ値検出 (IQR法)」（Codexa）を参考にしています。
- **外れ値の処理方法における各手法のメリット・デメリット**については、「データ分析における外れ値処理方法」（Blog Since 2020）から引用しました。
- **注意点**の内容は「外れ値処理の考え方」（Sales Analytics）から参考にしています。

---

以上で、Pythonで外れ値を検出し、適切に処理する方法についての解説は終わりです。分析の精度を高めるため、外れ値を安易に削除せず、データの性質に合わせて慎重に処理するよう心がけましょう。
Pythonでの箱ひげ図とIQR法を使った外れ値検出法

# Pythonでの箱ひげ図とIQR法を使った外れ値検出法

**この記事のゴール**  
箱ひげ図とIQR法を使って、データの分布や外れ値を視覚的かつ数値的に確認できるようになることが目的です。これにより、データの異常値や傾向を効率的に把握し、データ分析の信頼性を高められるようになります。

---

**目次**  
1. [箱ひげ図とIQR法の基本](#箱ひげ図とIQR法の基本)  
2. [Pythonでの実装例](#Pythonでの実装例)  
3. [具体的な使用例](#具体的な使用例)  
4. [注意点](#注意点)  
5. [参考文献](#参考文献)  

---

## 箱ひげ図とIQR法の基本

箱ひげ図とIQR法はデータの分布を視覚的に示し、異常なデータ（外れ値）を見つける手法です。以下のステップで箱ひげ図の基本構成を説明します。

### 1. データの四分位数を計算
- **第1四分位数 (Q1)**: データの下位25%点  
- **第2四分位数 (Q2)**: 中央値  
- **第3四分位数 (Q3)**: データの上位75%点  

### 2. IQR (四分位範囲) の計算
IQR = Q3 - Q1

### 3. 外れ値の範囲の定義
- **下限**: Q1 - 1.5 * IQR  
- **上限**: Q3 + 1.5 * IQR  
この範囲外のデータポイントが外れ値として扱われます[1][3]。

### 4. 箱ひげ図の構成
- **箱**: Q1からQ3までの範囲を示す
- **中央の線**: 中央値 (Q2)
- **ひげ**: 箱の外に伸びる線で、上記の範囲内のデータを示す
- **点**: 外れ値として、範囲外のデータを示す

---

## Pythonでの実装例

ここでは、箱ひげ図の描画とIQR法での外れ値検出をPythonで行う方法を示します。

```python
import matplotlib.pyplot as plt
import numpy as np

# サンプルデータの作成
data = [12, 34, 57, 22, 97, 51, 69, 87, 72, 62, 100, 5]

# 箱ひげ図の描画
plt.figure(figsize=(10, 6))  # グラフのサイズを設定
plt.boxplot(data)  # 箱ひげ図の描画
plt.title('Box Plot Example')  # グラフのタイトル
plt.ylabel('Values')  # y軸ラベル
plt.show()

# IQRを用いた外れ値の検出
q1, q3 = np.percentile(data, [25, 75])  # 第1四分位数と第3四分位数の計算
iqr = q3 - q1  # IQRの計算
lower_bound = q1 - (1.5 * iqr)  # 下限を計算
upper_bound = q3 + (1.5 * iqr)  # 上限を計算

# 外れ値の検出
outliers = [x for x in data if x < lower_bound or x > upper_bound]  # 外れ値を抽出
print(f"外れ値: {outliers}")
```

### 解説
1. `plt.boxplot(data)` で箱ひげ図を描画し、データ分布を可視化しています。
2. 四分位数を用いて、下限と上限を計算し、範囲外のデータを外れ値として抽出しています。

---

## 具体的な使用例

1. **金融データの分析**  
   日々の株価変動を分析する際、異常な変動を検出するのにIQR法が用いられます。通常の範囲を超える変動は異常な取引活動や市場の変動を示している可能性があります[5]。

2. **製造プロセスの品質管理**  
   製品の寸法データなどで、基準値から外れる製品を特定するために箱ひげ図が活用されます。これにより、製造プロセスの異常を早期に検出できます[5]。

3. **気象データの分析**  
   日々の気温データを分析し、異常気象や突発的な温度変動を検出するのに役立ちます。IQR法を使って、季節外れの高温や低温の観測データを抽出します[5]。

4. **医療データの分析**  
   患者の血液検査結果やバイタルデータなどを分析する際に外れ値を確認し、追加検査の必要性を判断するために使用します[5]。

---

## 注意点

### 1. データの性質を考慮
IQR法は、データが正規分布に従うことを前提としています。非正規分布の場合は、他の方法も検討する必要があります[7]。

### 2. サンプルサイズの考慮
サンプルが小さい場合、IQR法による外れ値検出の信頼性が下がる可能性があるため、大きなサンプルでの使用が推奨されます[7]。

### 3. コンテキストの重要性
外れ値が単なる異常値ではなく、有意義な情報を持つ可能性もあります。データの背景や目的を理解し、単純に除外するのではなく、意味を慎重に考慮する必要があります[7]。

### 4. 他の手法との組み合わせ
IQR法単独ではなく、Zスコア法やその他の手法と組み合わせることで、より確実に外れ値を検出できます[5][6]。

---

## 参考文献

[1] "Pythonでの箱ひげ図の作成," Bridgedot, https://bridgedot.com/python/hakohige/  
[2] "箱ひげ図の基本," 総務省統計局, https://www.stat.go.jp/naruhodo/4_graph/shokyu/hakohige.html  
[3] "Matplotlibでのデータ可視化入門," Torus07, https://torus07.hatenablog.com/entry/matplotlib-02  
[4] "箱ひげ図の解説," Gomafree-tech, https://gomafree-tech.com/?p=2442  
[5] "データ分析における外れ値処理の重要性," Sales Analytics, https://www.salesanalytics.co.jp/column/no00397/  
[6] "Oracle CloudのIQRに関するドキュメント," Oracle, https://docs.oracle.com/cloud/help/ja/pbcs_common/PFUSU/insights_metrics_IQR.htm  
[7] "外れ値処理の実践ガイド," GMOリサーチ, https://gmo-research.ai/research-column/outlier  

---

以上、箱ひげ図とIQR法の基本とその活用方法について解説しました。IQR法や箱ひげ図は、データの全体的な傾向と異常値の両方を視覚的かつ簡単に把握できる強力なツールです。
複数のグラフを重ねて描画する際のエラーと解決方法

# 複数のグラフを重ねて描画する際のエラーと解決方法

**この記事の目的**  
Pythonで複数のデータを重ねてグラフに表示する際、エラーや意図しない表示が起こることがあります。本記事では、特に初心者が遭遇しやすいエラーとその解決方法をわかりやすく解説します。このブログを読むことで、エラーに対処し、複数のデータを効果的に1つのグラフに重ねて表示するためのスキルを学ぶことができます。

---

**目次**  
1. [グラフが重ならず別々に表示される問題](#グラフが重ならず別々に表示される問題)  
2. [x軸のデータが正しく対応していない問題](#x軸のデータが正しく対応していない問題)  
3. [凡例が表示されない問題](#凡例が表示されない問題)  
4. [グラフのスケールが合わない問題](#グラフのスケールが合わない問題)  
5. [ラベルが重なる問題](#ラベルが重なる問題)  
6. [参考文献](#参考文献)  

---

## 1. グラフが重ならず別々に表示される問題

### 問題点
`plt.figure()`を複数回呼び出してしまうと、新しいウィンドウが生成され、グラフが重ならず別々に表示されます。

### 解決方法
`plt.figure()`を1回だけ呼び出し、同じグラフ内で複数のデータを描画しましょう。

```python
# 間違い
plt.figure()
plt.plot(x1, y1)
plt.figure()  # 新しいグラフを作成してしまう
plt.plot(x2, y2)

# 正しい方法
plt.figure()
plt.plot(x1, y1)  # 1つ目のデータをプロット
plt.plot(x2, y2)  # 2つ目のデータをプロット
plt.show()        # グラフを表示
```

## 2. x軸のデータが正しく対応していない問題

### 問題点
`plt.plot(x, y1, y2)`のように誤って引数を指定すると、`y2`がx軸のデータとして解釈されてしまいます。

### 解決方法
`plt.plot(x, y1)`のように各データセットを個別に指定します。

```python
# 間違い
plt.plot(x, y1, y2)  # y2がx軸のデータとして解釈される

# 正しい方法
plt.plot(x, y1)  # 1つ目のデータをプロット
plt.plot(x, y2)  # 2つ目のデータをプロット
plt.show()       # グラフを表示
```

## 3. 凡例が表示されない問題

### 問題点
凡例が表示されないのは、`label`パラメータが設定されていないか、`plt.legend()`が呼び出されていない場合です。

### 解決方法
`label`パラメータを設定し、`plt.legend()`を呼び出します。

```python
plt.plot(x, y1, label='データ1')  # データ1にラベルを付ける
plt.plot(x, y2, label='データ2')  # データ2にラベルを付ける
plt.legend()                      # 凡例を表示
plt.show()                        # グラフを表示
```

## 4. グラフのスケールが合わない問題

### 問題点
y軸のスケールが大きく異なるデータを同じグラフに描画すると、1つのデータが小さく表示されてしまうことがあります。

### 解決方法
二軸グラフを使用し、異なるスケールで表示します。

```python
fig, ax1 = plt.subplots()        # メインのグラフ領域を作成
ax1.plot(x, y1, 'b-')            # 青色の線で1つ目のデータをプロット
ax1.set_ylabel('Y1', color='b')  # 左側のY軸ラベルを青色に設定

ax2 = ax1.twinx()                # 右側に別のY軸を追加
ax2.plot(x, y2, 'r-')            # 赤色の線で2つ目のデータをプロット
ax2.set_ylabel('Y2', color='r')  # 右側のY軸ラベルを赤色に設定
plt.show()                       # グラフを表示
```

## 5. ラベルが重なる問題

### 問題点
データポイントが多い場合やラベルが長い場合、軸のラベルが重なり視認性が低下します。

### 解決方法
ラベルを回転させるか、図のサイズを調整してラベルの間隔を広げます。

```python
plt.figure(figsize=(12, 6))  # 図のサイズを大きくしてスペースを確保
plt.xticks(rotation=45)      # x軸ラベルを45度回転
plt.plot(x, y1)              # データをプロット
plt.plot(x, y2)              # 別のデータをプロット
plt.show()                   # グラフを表示
```

---

## 参考文献

[1] yamac131, "Matplotlibでグラフを作成するときの注意点" https://qiita.com/yamac131/items/ac63268680cf0cb603a7  
[2] imanect, "Pythonで複数のグラフを重ねて表示する方法" https://blog.imanect.com/137-2/  
[3] Tech Academy, "複数グラフを並べて表示する方法" https://magazine.techacademy.jp/magazine/39544  
[4] natsutan, "Matplotlibの使い方: ラベルの回転方法" https://natsutan.hatenablog.com/entry/20110713/1310513258  
[5] How2Matplotlib, "重複しないバーラベルの設定" https://how2matplotlib.com/matplotlib-bar-chart-labels-overlap.html  

---

これらのポイントに注意しながら、複数のデータを重ねて表示する際のエラーを解決し、視覚的に効果的なグラフを作成しましょう。データの性質や目的に応じて適切な設定を行うことが、グラフをわかりやすくする秘訣です。
複数のグラフを重ねて描画する際の透明度設定方法

# 複数のグラフを重ねて描画する際の透明度設定方法

**この記事の目的**  
Pythonの`matplotlib`で複数のグラフを重ねて描画する際、透明度設定を使い分けることでデータの見やすさや可視性を向上させる方法について解説します。この記事を通して、さまざまな透明度設定を使いこなせるようになることを目指します。

---

**目次**  
1. [透明度設定の基本：alphaパラメータ](#透明度設定の基本：alphaパラメータ)  
2. [fill_betweenを使った塗りつぶしエリアの透明度設定](#fill_betweenを使った塗りつぶしエリアの透明度設定)  
3. [異なる透明度を重ねた視覚効果の作成](#異なる透明度を重ねた視覚効果の作成)  
4. [ヒストグラムの重ね合わせでの透明度設定](#ヒストグラムの重ね合わせでの透明度設定)  
5. [凡例の背景の透明度設定](#凡例の背景の透明度設定)  
6. [参考文献](#参考文献)  

---

## 1. 透明度設定の基本：alphaパラメータ

`alpha`パラメータは、グラフの透明度を設定するためのパラメータで、0（完全に透明）から1（完全に不透明）の範囲で値を指定します。

```python
import matplotlib.pyplot as plt
import numpy as np

# データ作成
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)

# 透明度を50%に設定してプロット
plt.plot(x, y1, alpha=0.5, label='sin(x)')
plt.plot(x, y2, alpha=0.5, label='cos(x)')
plt.legend()  # 凡例を表示
plt.show()    # グラフを表示
```

この例では、両方のグラフの透明度を50%に設定しています。これにより、グラフが重なった際にも両方のデータが見やすくなります 。

## 2. fill_betweenを使った塗りつぶしエリアの透明度設定

`fill_between`関数を使うと、2つの線グラフ間のエリアを塗りつぶすことができ、`alpha`で透明度も設定できます。

```python
plt.fill_between(x, y1, y2, alpha=0.3)  # y1とy2の間を塗りつぶし
plt.plot(x, y1, label='sin(x)')
plt.plot(x, y2, label='cos(x)')
plt.legend()
plt.show()
```

透明度を調整することで、データの重なり具合が視覚的にわかりやすくなります 。

## 3. 異なる透明度を重ねた視覚効果の作成

異なる透明度を設定して、複数のエリアを重ねると視覚的な強調が可能です。

```python
plt.fill_between(x, y1, y2, alpha=0.3, color='blue')
plt.fill_between(x, y2, y2 - 1, alpha=0.7, color='green')
plt.plot(x, y1, label='Upper Area')
plt.plot(x, y2, label='Lower Area')
plt.legend()
plt.show()
```

このコードでは、青色と緑色のエリアが異なる透明度で重なり、複雑な視覚効果を作成しています 。

## 4. ヒストグラムの重ね合わせでの透明度設定

ヒストグラムを重ねて表示する際も`alpha`を使うことで、重なり部分が見やすくなります。

```python
data1 = np.random.normal(0, 1, 100)
data2 = np.random.normal(1, 1.5, 100)

plt.hist(data1, alpha=0.5, label='data1')  # 透明度50%
plt.hist(data2, alpha=0.5, label='data2')  # 透明度50%
plt.legend()
plt.show()
```

これにより、重なり部分も区別しやすくなり、各データの分布がはっきりと見えます 。

## 5. 凡例の背景の透明度設定

`framealpha`を使って凡例の背景を半透明にすることも可能です。

```python
plt.plot(x, y1, label='sin(x)')
plt.plot(x, y2, label='cos(x)')
plt.legend(framealpha=0.7)  # 背景の透明度を70%に設定
plt.show()
```

凡例がグラフの視覚効果を損なわないように、背景を半透明にすることで、より見やすい表示ができます 。

---

## 参考文献

[1] How2Matplotlib, "Transparency Settings for fill_between" https://how2matplotlib.com/fill_between-transparency.html  
[2] GeeksforGeeks, "Change the Transparency of a Graph Plot in Matplotlib with Python" https://www.geeksforgeeks.org/how-to-change-the-transparency-of-a-graph-plot-in-matplotlib-with-python/  
[3] GeeksforGeeks, "Overlapping Histograms with Matplotlib in Python" https://www.geeksforgeeks.org/overlapping-histograms-with-matplotlib-in-python/  

---

透明度設定を適切に活用すると、複数のデータを視覚的にわかりやすく表示することができます。データの重なり具合を考慮しながら、見やすさと情報の多さを両立させることが重要です。
複数のグラフを重ねて描画する際の透明度設定方法

# 複数のグラフを重ねて描画する際の透明度設定方法

**目的**  
複数のグラフを重ねて描画する際、透明度（alpha）を利用することで、各データセットの可視性を高め、見やすいグラフを作成する方法について説明します。

---

**目次**  
1. [alphaパラメータの基本的な使用方法](#alphaパラメータの基本的な使用方法)  
2. [fill_betweenで塗りつぶしエリアの透明度を設定する](#fill_betweenで塗りつぶしエリアの透明度を設定する)  
3. [複数の透明度を組み合わせた視覚効果](#複数の透明度を組み合わせた視覚効果)  
4. [ヒストグラムの透明度を設定して重ねる](#ヒストグラムの透明度を設定して重ねる)  
5. [凡例の透明度設定](#凡例の透明度設定)  
6. [参考文献](#参考文献)  

---

## 1. alphaパラメータの基本的な使用方法

`alpha`パラメータは、グラフの透明度を設定するためのオプションです。値の範囲は0（完全に透明）から1（完全に不透明）です。

```python
import matplotlib.pyplot as plt
import numpy as np

# データの生成
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)

# alphaで透明度を設定してプロット
plt.plot(x, y1, alpha=0.5, label='sin(x)')  # sin関数の透明度50%
plt.plot(x, y2, alpha=0.5, label='cos(x)')  # cos関数の透明度50%
plt.legend()  # 凡例の表示
plt.show()    # グラフを表示
```

この例では、`alpha=0.5`を指定することで、両方のグラフを50%透明にしています。透明度を設定すると重なり合った部分も視覚的にわかりやすくなります  。

## 2. fill_betweenで塗りつぶしエリアの透明度を設定する

`fill_between`関数を使用してグラフ間のエリアを塗りつぶす際にも、`alpha`パラメータで透明度を設定することができます。

```python
plt.fill_between(x, y1, y2, alpha=0.3)  # sin(x)とcos(x)の間を塗りつぶし
plt.plot(x, y1, label='sin(x)')
plt.plot(x, y2, label='cos(x)')
plt.legend()
plt.show()
```

`fill_between`でエリアを塗りつぶす際に透明度を設定すると、重なり部分が見やすくなり、グラフの視認性が向上します  。

## 3. 複数の透明度を組み合わせた視覚効果

透明度を変えた複数のエリアを重ねると、視覚的に情報量の多いグラフが作成できます。

```python
# 透明度が異なる塗りつぶし
plt.fill_between(x, y1, y2, alpha=0.3, color='blue')     # 30%透明の青色エリア
plt.fill_between(x, y2, y2 - 1, alpha=0.7, color='green')  # 70%透明の緑色エリア
plt.plot(x, y1, label='Upper Area')
plt.plot(x, y2, label='Lower Area')
plt.legend()
plt.show()
```

異なる透明度でエリアを重ねると、データの境界がはっきりし、グラフがより視覚的にわかりやすくなります 。

## 4. ヒストグラムの透明度を設定して重ねる

ヒストグラムを重ね合わせて表示する際も、`alpha`を活用することで、重なり合う部分も見やすくなります。

```python
# ランダムデータを生成
data1 = np.random.normal(0, 1, 100)
data2 = np.random.normal(1, 1.5, 100)

# ヒストグラムの描画
plt.hist(data1, alpha=0.5, label='data1')  # 50%透明
plt.hist(data2, alpha=0.5, label='data2')  # 50%透明
plt.legend()
plt.show()
```

この方法では、異なるデータセットの分布が明確に区別でき、重なり部分も視覚的にわかりやすくなります 。

## 5. 凡例の透明度設定

凡例の背景透明度も、`framealpha`で設定できます。これにより、凡例の背景がグラフを邪魔しないように調整できます。

```python
plt.plot(x, y1, label='sin(x)')
plt.plot(x, y2, label='cos(x)')
plt.legend(framealpha=0.7)  # 背景の透明度を70%に設定
plt.show()
```

凡例の透明度を調整することで、グラフ上の情報を邪魔することなく、凡例を視覚的に統合できます 。

---

## 参考文献

1. How2Matplotlib, "Transparency Settings for fill_between" https://how2matplotlib.com/fill_between-transparency.html  
2. GeeksforGeeks, "Change the Transparency of a Graph Plot in Matplotlib with Python" https://www.geeksforgeeks.org/how-to-change-the-transparency-of-a-graph-plot-in-matplotlib-with-python/  
3. GeeksforGeeks, "Overlapping Histograms with Matplotlib in Python" https://www.geeksforgeeks.org/overlapping-histograms-with-matplotlib-in-python/  

---

透明度を適切に利用することで、複数のデータを1つのグラフに重ねて表示しても情報が見やすくなります。データの重なり具合や視覚化の目的に応じて透明度を設定し、見やすいグラフを作成してみましょう。
Pythonリスト操作の基本: append() メソッドの使い方と注意点

# Pythonリスト操作の基本: `append()` メソッドの使い方と注意点

### 目的
Pythonにおいて、リストの要素を追加するための基本メソッド `append()` は頻繁に使われる操作です。本記事では、`append()` メソッドの基本的な使い方や注意点、さらに利用する上での効率的なポイントについて、初心者向けにわかりやすく解説します。

---

## 目次
1. [append() メソッドの基本](#append-メソッドの基本)
2. [特徴](#特徴)
3. [使用例](#使用例)
4. [注意点](#注意点)
5. [まとめ](#まとめ)
6. [参考文献](#参考文献)

---

## append() メソッドの基本

`append()` メソッドは、Pythonリストの末尾に新しい要素を追加するために使用します。この操作は「インプレース」で行われ、リスト自体が直接変更されます。これはデータ操作の中でもシンプルかつ重要な機能です  。

```python
# 例: リストに新しいフルーツを追加
fruits = ['apple', 'banana', 'cherry']
fruits.append('orange')
print(fruits)  # ['apple', 'banana', 'cherry', 'orange']
```

---

## 特徴

- **単一要素の追加**  
  `append()` は一度に1つの要素を追加します。一度に複数要素を追加したい場合には他の方法が適しています 。

- **データ型の自由**  
  `append()` で追加するデータはどのような型でも構いません。リスト、辞書、文字列、数値など、Pythonオブジェクトなら何でも追加可能です  。

- **インプレース操作**  
  `append()` はリストを直接変更します。このため、リストは即座に変更され、メソッドの実行結果は戻り値として返りません 。

---

## 使用例

### 基本的な使用法

```python
# 基本の使い方：数値をリストに追加
numbers = [1, 2, 3]
numbers.append(4)
print(numbers)  # [1, 2, 3, 4]
```

### 異なるデータ型の追加

```python
# リストに異なるデータ型を追加
mixed = [1, 'two', 3.0]
mixed.append([4, 5])  # リストを追加
print(mixed)  # [1, 'two', 3.0, [4, 5]]
```

### リストの中にリストを追加

```python
# リスト内に新しいリストを追加
main_list = [1, 2, 3]
sub_list = [4, 5]
main_list.append(sub_list)
print(main_list)  # [1, 2, 3, [4, 5]]
```

---

## 注意点

### 1. **リストの連結には不適**  
`append()` は一度に1つの要素しか追加できません。複数の要素をまとめて追加する場合は `extend()` メソッドの使用が適しています 。

```python
# リストに複数の要素を追加する場合はextend()を使用
fruits = ['apple', 'banana']
fruits.extend(['cherry', 'orange'])  
print(fruits)  # ['apple', 'banana', 'cherry', 'orange']
```

### 2. **ループ内での使用**  
`for` ループと組み合わせて使うことで、リストに要素を動的に追加できます。

```python
# 0から4までの2乗をリストに追加
squares = []
for i in range(5):
    squares.append(i ** 2)
print(squares)  # [0, 1, 4, 9, 16]
```

### 3. **パフォーマンス**  
大量の要素を追加する場合は、リスト内包表記やジェネレータ式を検討すると効率が向上します 。

---

## まとめ

`append()` メソッドは、Pythonのリスト操作で基本的な機能です。シンプルですが、適切に使用することでデータの管理がより効率的になります。  
**主なポイント**:  
- `append()`は一度に1つの要素をリストの末尾に追加
- 他の方法（例: `extend()`）と適切に使い分けることで、リストの構築がより効率的になる

---

## 参考文献

1. W3Schools, "Python List append() Method" [W3Schools](https://www.w3schools.com/python/ref_list_append.asp)
2. Programiz, "Python List append()" [Programiz](https://www.programiz.com/python-programming/methods/list/append)
3. Real Python, "How to Use Python’s append() Method" [Real Python](https://realpython.com/python-append/)
4. Shift Inc., "appendメソッドの使い方" [Shift Inc.](https://freelance.shiftinc.jp/column/append-python)

`append()` の基本を理解し、適切に使うことで、Pythonでのリスト操作がさらに強力なものになります。
Pythonでリストに複数の要素を追加する方法

# Pythonでリストに複数の要素を追加する方法

### 目的
Pythonでリストに複数の要素を一度に追加する方法はいくつかあります。効率的にリストを操作するためには、目的や状況に応じて適切な方法を選ぶことが重要です。本記事では、主な方法とその特徴をわかりやすく解説します。

---

## 目次
1. [extend()メソッドを使用する方法](#extendメソッドを使用する方法)
2. [+ 演算子を使用する方法](#演算子を使用する方法)
3. [forループとappend()を組み合わせる方法](#forループとappendを組み合わせる方法)
4. [使用場面の選択](#使用場面の選択)
5. [参考文献](#参考文献)

---

## extend()メソッドを使用する方法

### 概要
`extend()`メソッドは、リストの末尾に複数の要素を一度に追加するのに最適な方法です。元のリストを直接変更するため、効率が良く大量のデータを扱う際にも推奨されます。

### 例
```python
# リストに複数の要素を追加
my_list = [1, 2, 3]
new_items = [4, 5, 6]
my_list.extend(new_items)
print(my_list)  # 結果: [1, 2, 3, 4, 5, 6]
```

### 特徴
- **効率的な処理**: 元のリストを直接変更し、複数要素の追加に最適化されています。
- **イテラブルオブジェクト対応**: 引数としてリストだけでなく、タプルやセットなどのイテラブルなオブジェクトを受け取ります  。

---

## + 演算子を使用する方法

### 概要
`+`演算子を使うと、2つのリストを結合して新しいリストを生成できます。この方法では元のリストは変更されないため、もとのリストを保持したい場合に有用です。

### 例
```python
# リスト同士の結合
my_list = [1, 2, 3]
new_items = [4, 5, 6]
combined_list = my_list + new_items
print(combined_list)  # 結果: [1, 2, 3, 4, 5, 6]
```

### 特徴
- **新しいリストを生成**: 元のリストには影響を与えず、新しいリストとして結果を得られます 。
- **メモリ使用**: 新しいリストを生成するため、大きなリストを扱う際にはメモリ消費量が増える可能性があります。

---

## forループとappend()を組み合わせる方法

### 概要
`append()`メソッドは一度に1つの要素しか追加できませんが、forループと組み合わせることで複数の要素を1つずつ追加できます。条件や加工が必要な場合に適しています。

### 例
```python
# forループとappend()でリストに追加
my_list = [1, 2, 3]
new_items = [4, 5, 6]
for item in new_items:
    my_list.append(item)
print(my_list)  # 結果: [1, 2, 3, 4, 5, 6]
```

### 特徴
- **1つずつ追加**: forループを使い、各要素を1つずつリストに追加するため、大量データの追加には適していません 。
- **柔軟性**: 要素ごとに加工や条件を追加できるため、複雑な追加処理が必要な場合に有効です。

---

## 使用場面の選択

| 方法            | 使用シーン                                                                                                                                      |
|-----------------|--------------------------------------------------------------------------------------------------------------------------------------------|
| `extend()`      | 元のリストを変更して効率的に要素を追加したい場合                                                                                                       |
| `+`演算子        | 元のリストを保持しつつ新しいリストを生成したい場合                                                                                                                                   |
| `for`+`append()` | 各要素に加工や条件処理を加えながら追加したい場合（例：複数の条件でリストを作成する場合）  |

状況に応じて適切な方法を選ぶことで、Pythonプログラムを効率的かつ柔軟に設計することが可能です  。

---

## 参考文献

1. Pierian Training, "How to Append Multiple Items to a List in Python" [Pierian Training](https://pieriantraining.com/python-tutorial-how-to-append-multiple-items-to-a-list-in-python/)
2. W3Schools, "Python List extend() Method" [W3Schools](https://www.w3schools.com/python/ref_list_extend.asp)
3. Programiz, "Python List extend()" [Programiz](https://www.programiz.com/python-programming/methods/list/extend)
4. Spark By Examples, "Python Append Multiple Items to List" [Spark by Examples](https://sparkbyexamples.com/python/python-append-multiple-items-to-list/)

各方法の特徴を理解し、適切な方法を選択することで、Pythonプログラムの処理効率や可読性を向上させることができます。
Pythonでリストに複数の要素を効率的に追加する方法

# Pythonでリストに複数の要素を効率的に追加する方法

## この記事の目的
Pythonで複数の要素をリストに追加する場合、操作の効率性やコードの可読性が重要です。本記事では、複数の要素を追加する際に推奨される方法とその特徴を解説します。

---

## 目次
1. [extend()メソッドを使用する方法](#extendメソッドを使用する方法)
2. [+ 演算子を使用する方法](#演算子を使用する方法)
3. [結論: どちらの方法が効率的か](#結論-どちらの方法が効率的か)
4. [参考文献](#参考文献)

---

## 1. extend()メソッドを使用する方法

### 概要
`extend()`メソッドは、リストの末尾に複数の要素を一度に追加でき、元のリストを直接変更するため非常に効率的です。

### 例
```python
# リストに複数の要素を一度に追加する方法
my_list = [1, 2, 3]
new_items = [4, 5, 6]
my_list.extend(new_items)  # extend()で複数の要素を一度に追加
print(my_list)  # 結果: [1, 2, 3, 4, 5, 6]
```

### 特徴
- **直接変更**: 元のリストを直接変更するため、メモリ効率が良いです  。
- **イテラブル対応**: 引数にはリストやタプルなど、複数のデータ構造を取ることができます 。
- **大量データに最適**: 大量の要素を追加する際に効率的です  。

---

## 2. + 演算子を使用する方法

### 概要
`+` 演算子を使うと、二つのリストを結合し新しいリストを作成できます。この方法は元のリストを変更せず、新しいリストとして結果を得られます。

### 例
```python
# リスト同士を結合して新しいリストを作成する方法
my_list = [1, 2, 3]
new_items = [4, 5, 6]
combined_list = my_list + new_items  # + 演算子でリストを結合
print(combined_list)  # 結果: [1, 2, 3, 4, 5, 6]
```

### 特徴
- **新しいリストを生成**: 元のリストは変更されず、新しいリストが作成されます 。
- **メモリ消費**: 新しいリストが生成されるため、大きなリストを扱う際にはメモリ効率が低下する可能性があります 。

---

## 3. 結論: どちらの方法が効率的か

複数の要素をリストに追加する際は、以下のように方法を選択することが推奨されます。

- **`extend()`メソッド**: 大量の要素を効率的に追加する必要がある場合や、元のリストを直接変更しても問題ない場合に適しています  。
- **`+` 演算子**: 元のリストを変更せず、新しいリストとして複数の要素を追加したい場合に適していますが、メモリ使用量に注意が必要です。

---

## 参考文献

1. Pierian Training, "How to Append Multiple Items to a List in Python" [Pierian Training](https://pieriantraining.com/python-tutorial-how-to-append-multiple-items-to-a-list-in-python/)
2. Spark By Examples, "Python Append Multiple Items to List" [Spark by Examples](https://sparkbyexamples.com/python/python-append-multiple-items-to-list/)
3. Scaler, "Extend vs Append in Python" [Scaler](https://www.scaler.com/topics/extend-vs-append-python/)
4. Educative, "How to Append Multiple Items to a List in Python" [Educative](https://www.educative.io/answers/how-to-append-multiple-items-to-a-list-in-python)
5. Geeks for Geeks, "Python List Extend vs Append" [Geeks for Geeks](https://www.geeksforgeeks.org/python-list-extend-vs-append/)

---
Pythonの星印式（*, **）の解説

Pythonの星印式（*, **）は、関数に可変長引数を与えるための強力なメカニズムです。初学者にとっては少し複雑に感じるかもしれませんが、一度理解すれば、Pythonプログラミングの幅が広がります。

### 単一のアスタリスク（*）

* **イテラブルオブジェクトの展開:** リスト、タプル、文字列などのイテラブルオブジェクトを、個々の要素に展開します。
   ```python
   numbers = [1, 2, 3]
   print(*numbers)  # 出力: 1 2 3
   ```
* **任意個数の位置引数:** 関数定義で*argsとすると、任意個の位置引数をタプルとして受け取ることができます。
   ```python
   def my_sum(*args):
       return sum(args)

   result = my_sum(1, 2, 3, 4)  # 出力: 10
   ```
* **タプルアンパッキング:** タプルを複数の変数にアンパッキングできます。
   ```python
   a, *b, c = (1, 2, 3, 4)  # a=1, b=[2, 3], c=4
   ```

### ダブルアスタリスク（**）

* **辞書の展開:** 辞書をキーワード引数として展開します。
   ```python
   d = {'x': 1, 'y': 2}
   print(**d)  # 出力: x=1 y=2
   ```
* **任意個数のキーワード引数:** 関数定義で**kwargsとすると、任意個のキーワード引数を辞書として受け取ることができます。
   ```python
   def my_func(**kwargs):
       for key, value in kwargs.items():
           print(f"{key}: {value}")

   my_func(a=1, b=2, c=3)
   ```

### まとめ

* ***args:** 任意個の位置引数をタプルとして受け取る
* **kwargs:** 任意個のキーワード引数を辞書として受け取る

これらの仕組みを組み合わせることで、非常に柔軟な関数を作成することができます。

### 深掘り

* **リスト内包表記:** *を使ってネストされたリストを平坦化できます。
* **ジェネレータ式:** *をジェネレータ式で使うこともできます。
* **関数呼び出し時の*:** 関数呼び出し時に、リストやタプルを展開して引数として渡すことができます。

### 注意事項

* *argsと**kwargsは慣習的な名前であり、他の名前でも使用できます。
* *argsは**kwargsの前に置く必要があります。
* 過度な使用はコードの可読性を低下させる可能性があります。

### 例題

```python
def my_func(*args, **kwargs):
    print(args)
    print(kwargs)

my_func(1, 2, 3, a=10, b=20)
```

**出力:**
```
(1, 2, 3)
{'a': 10, 'b': 20}
```

### まとめ

Pythonの星印式は、関数に柔軟性を与える強力なツールです。この概念を理解することで、より高度なPythonプログラミングが可能になります。


**この翻訳が、あなたのPython学習の一助となれば幸いです。**
Ruby method備忘録

よく忘れちゃうのでメモ。

# 配列関係
## インスタンス化
```Ruby
list = [1, 2, 3] # 正統派プリミティブ表現
list = %w(吾輩は猫である 名前は萬田太郎) # 文字列。%W()だと"#{変数}"みたいなのも展開してくれる
list = Array.new(5) # 五枠の配列になる。中身はnil。
# 初期値を渡すときは第二引数に指定できるが、全要素が同じオブジェクトを参照するようになる。
# 細かく指定したいならブロックを渡そう。
```

## 取得・検索
```Ruby
list[0] # 0番目
list[2, 3] # 2個目から3つ取り出す
list[2..3] # 2個目から3つ目まで
list[..3] # 最初から3つ目まで。負の数を指定したら最後から数えて、になる。
list.first # 0番目を取得。引数を渡すと最初からn個
list.last # 最後を取得。引数で最後からn個。
list.vatues_at(1, 3, 5) # 1つ目、3つ目、5つ目。
list.fetch(2, "ねえよ") # 2つ目、なかったら"ねえよ"が返る。
list.sample(2) # 無作為に2つ選んで返す。
list.find(ifnone) { |item| item.odd? } # 条件に一致するものを探して見つかった最初のものを返す。
# ifnoneはcall()を持つオブジェクト。渡されたとき、条件に一致するものが一つもない場合にcallback
list.find_all { |item| item.end_with?(".com") } # 条件に一致するものすべてを返す。さもなくば空配列。
list.reject { |item| item.empty? } # find_all()の逆。不一致なもののみ取り出す。
list.grep(/0-9+/)
list.index(val) # 要素中からvalを探してそのidx番号を返す。さもなくばnil
list.index { |v| v.lenght < 2} # ブロックもあり。rindex()では後ろから検索できる。
list.compact # nilを消したものを返す。
```

## 置換・削除・LIFO/FIFO
```Ruby
list[1..3] = ["犬", "猿", "雉"] # 範囲に詰め込む。過不足が出たら無理やりぶち込む。
list.insert(2, "わんこ") # 2つ目に"わんこ"を挿入。過不足が出たら無理やりぶち込む。
list.fill("教育", range) # 配列を"教育"で埋める。第二引数にはrangeを与えられる。
list.clear # 配列を空に
list.delete("わんこ") # 配列から"わんこ"を除外。
list.delete_at(2) # 2つめを削除
list.keep_if { |elem| elem.length > 3} # 三文字未満を消去
list.push(2) # 後ろに2を積む。
list.pop(3) # 後ろから3つ取り出す。
list.shift(2) # 前から2つ取り出す。
list.unshift(2) # 前に2を積む。
```

## 走査・反復処理
<details><summary>自白</summary>
実はもともと書きたかったのはここだけだったりする。その他は義務感。
</details>

```Ruby
list.each do |item|
    item.upcase if item.ascii_only?
end 
# JSのforEachと一緒。
# 因むとString#upcaseは大文字化、String#ascii_only?は文字列がascii文字のみか判定。
# Rubyではif文を後置できる。

list.each_with_index do |val, idx|
    puts "#{idx}:#{val}"
end
# index,valueの組を受け取れる。callbackの引数の順番がval, idxと直感的でないので注意。

list.each_index { |idx| statement }
list.reverse_each { |item| statement}
# 名前の通り。{}はdo...endの省略。命令が一行で済むときはこっちの方がいいんじゃないかな。

list.map.with_index(1) { |user, idx| statement }
# 疑似的にmap_with_index()を実現できる。

list.each_cons(3) { |ary| statement } 
# [1,2,3], [2,3,4], [3,4,5]のように配列を重複ありで3個ずつ切り出してブロックに渡す。

list.each_slice(2) { |items| statement } # 二つずつ配列に切り出しつつ走査。要素数に余剰が出ようとも続行する。

list.cycle(3) { |v| statement } # 配列を三週する。引数を与えないと無限に回しだすので注意。
```


## 要素の勘定
```Ruby
list.length # 要素数。
list.empty? # 配列が空か否か
list.count("犬") # list内にいくつ"犬"があるか。
list.tally # 要素ごとに分別して「要素:個数」の形式でハッシュ（連想配列）を返す。
```
【Django REST Framework】Serializerの使い分け 初心者🔰

# はじめに
バックエンド開発をしているとフロントエンドができるだけ処理しやすい形データを渡してあげたいなぁと思いますよね？（フロントエンドの開発したことないんですが。。。）
初学者だけど！

シリアライザの使いわけ方がわからなかった
　　　　　　　　＋
親子関係を持つモデルを返却する際に階層を揃える方法
の２点を備忘録として残しておきます。


# モデルのイメージ
以下のモデルがあったとします。
![ER図親子.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/737553/3123d782-662e-745c-9770-341654037a1e.png)


# データの取得
**大前提としてDjangoでは子テーブルから親テーブル参照することができます。**

https://qiita.com/shimayu22/items/1c0d9f0365ce6cc6488f

今回であれば以下のように、子から親を参照しに行くことができるんですね。
```python
data = テーブルA.objects.select_related("テーブルB", "テーブルC").all()
```

# -本題-　データ返却（Serializerの準備）
Serialzerを準備していきます。

### ・問題点
以下のようなシリアライザにすると次の様な形式で出力されてしまう。
```python
class TableBSerializer(serializers.ModelSerializer):
    """テーブルB(親)のシリアライザ"""
    class Meta:
        model = TableB
        fields = ["id", "value_b"]


class TableCSerializer(serializers.ModelSerializer):
    """テーブルC(親)のシリアライザ"""
    class Meta:
        model = TableC
        fields = ["id", "value_c"]


class TableASerializer(serializers.ModelSerializer):
    """テーブルA(子)のシリアライザ"""
    tableB = TableBSerializer() # テーブルBのシリアライザをネスト
    tableC = TableCSerializer() # テーブルCのシリアライザをネスト

    class Meta:
        model = TableA
        fields = ["id", "vlaue_a", "tableB", "tableC"]
```
レスポンスは以下の通り
```python
{
  # テーブルAのキーをマッピングできていない
  "id": 0,
  "vlaue_a": "string",
  
  "tableB": {
    "id": 0,
    "value_b": "value_b"
  },
  "tableC": {
    "id": 0,
    "value_c": "value_c"
  }
}
```

理想は`table_a`をキーとしてマッピングすることである。
```python
{
  "tableA": {
    "id": 0,
    "value_a": "value_a"
  },
  "tableB": {
  #~~~~~~~省略~~~~~~~~~~~
}
```


### ・ModelSerailzerは単一のモデルを扱うもの
`ModelSerializer`はモデルをネストもできるが基本的には単一モデルの操作向き

変更点：
ModelSerializerで内包するのではなく、Serializerで内包することにした
```python
class TableASerializer(serializers.ModelSerializer):
    """テーブルA(子)のシリアライザ"""
    class Meta:
        model = TableA
        fields = ["id", "vlaue_a"]


class TableBSerializer(serializers.ModelSerializer):
    """テーブルB(親)のシリアライザ"""
    class Meta:
        model = TableB
        fields = ["id", "value_b"]


class TableCSerializer(serializers.ModelSerializer):
    """テーブルC(親)のシリアライザ"""
    class Meta:
        model = TableC
        fields = ["id", "value_c"]


# serializers.Serializerに変更
class AllDataSerializer(serializers.Serializer):
    """新規追加: 返却用シリアライザ"""
    tableA = TableASerializer()
    tableB = TableBSerializer()
    tableC = TableCSerializer() 
```

```python
{
  "tableA": {
    "id": 0,
    "value_a": "value_a"
  },
  "tableB": {
    "id": 0,
    "value_b": "value_b"
  },
  "tableC": {
    "id": 0,
    "value_c": "value_c"
  }
}
```
フラットになりました


# おまけ
取得したデータはtableAを起点として取得したものである。
上記の修正を行ってもでエラーが発生する場合は、以下の追記をすることで解消することが可能である。
```python
class AllDataSerializer(serializers.Serializer):
    """返却用シリアライザ"""
    tableA = TableASerializer(source="*")
    tableB = TableBSerializer()
    tableC = TableCSerializer() 
```
※`source="*"`は自身のインスタンスを全て渡すオプションである。これによりソースを参照することができるようになる。
Ubuntu で Kubeadm により k8s 環境構築実験(2)

[Ubuntu で Kubeadm により k8s 環境構築実験(1)](https://qiita.com/intrajp/items/483fe317c5e89b5e99e9)からの続きです。

これまでで、kubernetes のコントロールプレーンの初期化には成功しているはずです。
To start using your cluster, you need to run the following as a regular user:
クラスターを始めるには、一般ユーザーで、次のコマンドを実行する必要があります。
```bash
  mkdir -p $HOME/.kube
  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  sudo chown $(id -u):$(id -g) $HOME/.kube/config
```
さて、クラスターに Pod network を追加する必要があります。
```bash
kubectl apply -f [podnetwork].yaml
```
これらのうちから選びます。
```bash
  /docs/concepts/cluster-administration/addons/
```
今回は、calico とします。
https://docs.tigera.io/calico/latest/getting-started/kubernetes/quickstart
```bash
kubectl create -f https://raw.githubusercontent.com/projectcalico/calico/v3.28.2/manifests/tigera-operator.yaml
kubectl create -f https://raw.githubusercontent.com/projectcalico/calico/v3.28.2/manifests/custom-resources.yaml
watch kubectl get pods -n calico-system
```
5 分ぐらい待ちます。
```bash
kubectl taint nodes --all node-role.kubernetes.io/control-plane-
kubectl get nodes -o wide
```
ワーカーノードを追加するには、ワーカーノードの候補となる VM で、このコマンドを実行します。
```bash
kubeadm join <control-plane-host>:<control-plane-port> --token <token> --discovery-token-ca-cert-hash sha256:<hash>
```  
実際は、こんな感じで出力されました。
```bash
kubeadm join 10.0.11.67:6443 --token <TOKEN> \
        --discovery-token-ca-cert-hash sha256:<HASH>
```
（参考）
[Creating a cluster with kubeadm](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/create-cluster-kubeadm/)

[Ubuntu で Kubeadm により k8s 環境構築実験(3)](https://qiita.com/intrajp/items/b4667d4456a6ca2413aa)につづく。
(SSD1306)「こんにちは...」を表示して遊ぶ。(M5StampS3)(M5UnitGLASS2)(M5Unified)



x 過去ログを見よ!!
x M5Unifiedのインストール
x M5UnitGLASS2のインストール


![o_coq570.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/840352/fbef7eac-1de1-2c6a-d3b8-0362740f9a1c.jpeg)



```c++


//SSD1306_rabian1_M5StampS3_1

#include <M5UnitGLASS2.h>
#include <M5Unified.h>

// Port.A SDA(G2), SCL(G1)
M5UnitGLASS2 SSD1306Display(13, 15);

void setup() {
  M5.begin();
  SSD1306Display.init();
  SSD1306Display.setFont(&fonts::lgfxJapanGothicP_16);
  SSD1306Display.println("こんにちは世界!!");
  SSD1306Display.setFont(&fonts::FreeMonoBold9pt7b);
  SSD1306Display.println("SSD1306\nGME12864-51");
}

void loop() {
}


```
Windows音声認識の活用シーン

　Ｗindows音声認識の弱点としてよく語られる点は、文章への変換精度が悪い、ということにあると思います。筆者も使ってみましたが正直、文章生成に関してはかなり厳しい部分があるように思えます。GoogleのVoiceInなどの大規模言語モデルから生成される文章の精度を見てしまえば、Ｗindows音声認識を使う理由が見つからないのも無理はないと思います。

　結論から言うと、Windows音声認識の使いどころは、ネットの繋がらない環境あるいは繋げられない環境で、数字あるいは決まった単語を入力する場面においては非常に適していると思います。しかもこれが非常に安い費用で実現してしまうのです。（せいぜいマイク代やヘッドセット代が必要になる程度）
<br>
`活用シーンその1`
　例えば、工場においては製品の検査工程が存在すると思いますが、不良品が出た場合、不良項目をカウントすることがあると思います。どの製品でどんな不良項目がどのくらい発生するのかを分析し、改善策を検討するにあたって大変重要なデータになります。たいていの場合は、手押しカウンターや定置型の数取り器などを用いて不良項目ごとの数量をカウントし、紙やPCに転記するという使い方が一般的かと思います。
 　だれでも使い方が簡単で教育コストのかからないことが利点ですが、不良品が見つかるたびに押しボタンに視線を移し、ボタンを選んで押し、再び検査に戻るという視線の動きが無駄になりますし、ボタンを探すこともストレスを蓄積する原因になります。
  これを音声で不良項目を入力することで製品から視線をそらすことなくPCに直接データをカウントさせることが可能となります。不良項目は無限にあるわけではなく、決まった単語でしかないため、辞書登録さえしてしまえば充分可能な方法となります。
<br>
`活用シーンその2`
　実験や検査において、実験データの数値をエクセルに大量に入力する場面を想定したいと思います。測定器具からPCにUSBケーブルや無線でつないでPCに直接データをインプットする機能があればそれを使うに越したことはないのですが、そうした機能のない測定器具も多数あります。
 　例えば寸法を測定するノギスで、USBケーブルでデータを送る機能がついていない場合を想定してみます。測定したらいったんノギスから手を離して、テンキーで数値を入力し、またノギスを持ち直すというわずらわしい手間が発生することになります。視線もいったんテンキーに移すため、試験体に視線を戻した際に「次の測定箇所はどこだったっけ？」と探すこともあると思います。
  これを音声で数値を入力することで、USBケーブルでデータ転送するのと遜色ないスピードで、視線を試験体からそらすことなく、次々にデータをインプットすることが可能となります。しかもUSBケーブルは1万円近くかかってしまうのですが、Windows音声認識の場合、Windowsの標準機能で搭載されているので無料でそれができてしまうのです。（マイクやヘッドセットの購入は必要ですが、安物で十分です。）
　また、二人の人員をかけて一人が測定して数値を読み上げ、もう一人が数値を入力するような場面では、この方法で一人で同じことができるようになります。 
<br>
`活用シーンその3`
　製品の在庫を置く場所が、品番ごとに決まった置き場所がない場合を想定してみます。在庫管理の点からは宜しくない状態ではありますが、そうはいってられない場合もあると思います。この状態でいろいろな場所にいろいろな品番を置いてしまうと、後で探すことに無駄な時間を使うことになります。
 　場所ごとに簡単な名前を付けておき（例：松の間、竹の間・・・）、品物を置く際に、品番と場所の名前を音声で入力すれば、PCにキーボード操作でインプットする操作を行わず入力することが可能となります。フォークリフトを運転しながらの場合であれば、フォークリフトにモバイルPCを設置し、音声で入力すれば、運転しながら製品の置き場所をインプットすることが可能になります。そこそこ大声で話す必要がある騒音のある環境でも、マイクの種類やマイクの調整で問題なく入力可能です。
  品番と場所をデータベース化することで、後で場所を検索することが容易になります。
<br>
　このように非常に安価な方法でありながら、かなり仕事がはかどる仕組みを作ることができるのですが、Windows音声認識はあまり日の目をみていない状況になっているように思います。

　今後の記事においては、どのように設定していくかとか、使い方のコツなどを紹介していきたいと思います。
[JavaScript] データ型とリテラル

# 環境
MacBook Pro (2.3 GHz 8コアIntel Core i9)
macOS 14.0（23A344）
Homebrew 4.3.8
gh 2.52.0

# 目次
- [データ型](#データ型)
- [リテラル](#リテラル)

# データ型
> JavaScriptは動的型付け言語に分類される言語であるため、静的型付け言語のような**変数の型**はありません。しかし、文字列、数値、真偽値といった**値の型**は存在します。これらの**値の型**のことを**データ型**と呼びます。

[データ型とリテラル](https://jsprimer.net/basic/data-type/)

## プリミティブ型
> プリミティブ型（基本型）は、真偽値や数値などの基本的な値の型のことです。 プリミティブ型の値は、一度作成したらその値自体を変更できないというイミュータブル（immutable）の特性を持ちます。 

[データ型とリテラル](https://jsprimer.net/basic/data-type/)

|型|例|
|--|--|
|真偽値(Boolean)|`true`、`false`|
|数値(Number)|`123`、`1.234`|
|巨大な整数(BigInt)|`9007199254740992n`|
|文字列(String)|`"JavaScript"`|
|undefined|値が未定義であること意味するデータ型|
|null|値が存在しないことを意味するデータ型|
|シンボル(Symbol)|一意で不変な値のデータ型|

~~~js:typeof演算子でデータ型(値の型)を調べた結果
console.log(typeof true);// => "boolean"
console.log(typeof 42); // => "number"
console.log(typeof 9007199254740992n); // => "bigint"
console.log(typeof "JavaScript"); // => "string"
console.log(typeof Symbol("シンボル"));// => "symbol"
console.log(typeof undefined); // => "undefined"
console.log(typeof null); // => "object"
~~~


## オブジェクト
> プリミティブ型ではないものをオブジェクト（複合型）と呼び、 オブジェクトは複数のプリミティブ型の値またはオブジェクトからなる集合です。 オブジェクトは、一度作成した後もその値自体を変更できるためミュータブル（mutable）の特性を持ちます。 オブジェクトは、値そのものではなく値への参照を経由して操作されるため、参照型のデータとも言います。

[データ型とリテラル](https://jsprimer.net/basic/data-type/)

|型|例|
|--|--|
|オブジェクト|`{name1 = "Alpha", name2 = "Beta"}`|
|配列|`["Alpha", "Beta"]`|
|関数|`function () {};`|
|クラス||
|正規表現||
|Date||

~~~js:typeof演算子でデータ型(値の型)を調べた結果
console.log(typeof { name1 = "Alpha", name2 = "Beta" }); // => "object"
console.log(typeof [ "Alpha", "Beta" ]); // => "object"
console.log(typeof function () {}); // => "function"
~~~


# リテラル
>プリミティブ型の値や一部のオブジェクトは、リテラルを使うことで簡単に定義できるようになっています。
リテラルとはプログラム上で数値や文字列など、データ型の値を直接記述できるように構文として定義されたものです。 たとえば、`"`と`"`で囲んだ範囲が文字列リテラルで、これは文字列型のデータを表現しています。

[データ型とリテラル](https://jsprimer.net/basic/data-type/)

## プリミティブ型
### 真偽値(Boolean)
- 真偽値には、`true`と`false`のリテラルがあります。
    ~~~js
    true; // => true
    false; // => false
    ~~~

### 数値(Number)
- 数値には、`42`のような整数リテラルと`3.14159`のような浮動小数点数リテラルがあります。
    - 整数リテラル
    ~~~js
    console.log(1); // => 1
    console.log(10); // => 10
    console.log(255); // => 255
    ~~~
    - 浮動小数点数リテラル
    ~~~js
    .123; // => 0.123
    ~~~

### 巨大な整数(BigInt)
- ES2020ではBigIntという新しい整数型のデータ型とリテラルが追加されました。
- BigIntでは2^53-1（9007199254740991）よりも大きな整数を正しく表現できます。
- BigIntリテラルは、数値の後ろにnをつけます。
    ~~~js
    console.log(1n); // => 1n
    // 2^53-1より大きな値も扱える
    console.log(9007199254740992n); // => 9007199254740992n
    ~~~

### 文字列(String)


### null
- nullリテラルはnull値を返すリテラルです。
- nullは「値がない」ということを表現する値です。
    ~~~js
    foo;// "ReferenceError: foo is not defined"
    const foo = null;
    console.log(foo); // => null
    ~~~

## オブジェクト

# 参考リンク
- [モダンJavaScriptの基礎から始める挫折しないためのReact入門
](https://www.udemy.com/course/modern_javascipt_react_beginner)
- [データ型とリテラル](https://jsprimer.net/basic/data-type/)
RxJS のcold/hot observable の動作確認して理解を深めるまで

## 前置き
cold/hot observable について、気になったあれこれを調べて動作確認をしたのでそのメモ。  
確認方法としては、下記ページを作成し、console.log の出力を見て確認した。  

https://magurouhiru.github.io/mysite/#/study/cold-hot-observable

## 本編
### cold observable
Subscription とストリームが1対1の関係。  
そのため、Observable を都度生成しても使いまわしてもSubscriber の挙動は同じ。  
ストリームがcomplete または、Subscription がunsubscribe すると両者破棄される。  

### hot observable
Subscription とストリームが多対1となりうる関係。  
そのため、Observable を  
都度生成すると、1対1となるため複数のSubscriber が異なる挙動をする。(cold と同じ)  
使いまわすと、多対1となるため複数のSubscriber が同じ挙動をする。  

また、ストリームがcomplete すると、ストリームとそれに紐づくSubscription の両者破棄される。(cold と同じ)  
しかし、あるストリームに紐づくSubscription すべてがunsubscribe すると、ストリームも破棄される場合とされない場合がある。  

### Angular でshareReplay を使うにあたって
`shareReplay(1)` は紐づくSubscription すべてがunsubscribe してもストリームが破棄されない。  
つまり、Async Pipe を使用していてもストリームが破棄されない。  
そういう時は`shareReplay({ bufferSize: 1, refCount: true })` を使用すれば、すべてがunsubscribe されたときにストリームも破棄される。  
または、`takeUntilDestroyed` を使用すればcomplete してくれるので問題ない。  

## 感想
楽しかった。  
あと、hot の挙動が直感と違って戸惑った。  

今回の記事は以上です。  

前回記事はこちら  

https://qiita.com/magurouhiru/items/3306f996e0fc990283d4

詳細見たい人はこちら  

https://github.com/magurouhiru/mysite/pull/51

https://magurouhiru.github.io/mysite/#/study/cold-hot-observable
【AWSセキュリティ必読！】今すぐできるルートユーザー保護の鉄則

## はじめに
こんにちは、uiroleです！  
今回はAWSのセキュリティには必須の、ルートユーザの管理についてまとめました。

AWSのルートユーザーは、AWSアカウント内で最も高い権限を持ち、アカウントの作成や削除、課金設定の変更など、通常のユーザーでは操作できない重要な操作が可能です。
ルートユーザーが攻撃を受けると、AWS全体のセキュリティが崩壊するリスクがあるため、今回は**AWSルートユーザーを保護するためのベストプラクティス**を紹介します。

### 対象者
- AWSアカウントのルートユーザー管理に不安を感じている人
- AWS環境のセキュリティ強化を目指している人
- AWSを利用しているシステム管理者、エンジニア、セキュリティ担当者

### 前提
- IAMユーザーやIAMロールを使用した権限管理の基本を知っている
- AWSの基本的な操作ができる

### 記事を読んで解決すること
- AWSルートユーザーのセキュリティリスクを正しく認識し、対策の重要性を理解する
- ルートユーザーを使用せずにAWSアカウントを安全に管理するためのベストプラクティスを実践できる
- 二段階認証の設定、IAMユーザーの適切な管理、ルートユーザーのアクセス制限など、具体的な保護方法を学ぶ

## ルートユーザーのリスクと必要性

AWSルートユーザーには、AWSアカウントの完全な管理権限があるため、適切な保護が行われていないと次のようなリスクが発生します。

- **アカウント乗っ取り**
　不正アクセスが発生すると、アカウントの全リソースが危険に晒される
- **課金設定の変更やリソース削除**
　意図しない課金増加や重要なデータ損失の可能性

### ルートユーザー使用の最小化
AWSでは、ルートユーザーの使用を極力避け、必要最低限に制限することが推奨されています。
日常業務はIAMユーザーやロールを使用し、ルートユーザーは特定の操作のみを行うべきです。

::: note info
AWSルートユーザーの権限は全サービスにアクセスできる「神の権限」で、悪意のあるユーザーが不正にアクセスした場合、深刻なセキュリティ事故が発生するリスクがあります。
不要なログインやアクセスを防ぐことが重要です。
:::

## AWSルートユーザー保護のベストプラクティス

### 1. MFA（多要素認証）の有効化
ルートユーザーに**MFA**を設定すると、ログイン時に通常のパスワードに加えて一時的なコードが必要になるため、セキュリティを強化できます。  
設定方法は以下。

1. **AWS管理コンソールにログイン**し、ルートユーザーを選択。
2. **[MFAの有効化]** をクリックし、MFAデバイス（スマートフォンやセキュリティキー）を設定。
3. 指示に従い、一時コードを入力して設定を完了。

### 2. ルートユーザーアクセスキーの削除
ルートユーザーには基本的にアクセスキーを発行せず、すでに発行されている場合は削除します。

- **アクセスキーの確認と削除手順**  
   1. AWS管理コンソールで「IAM」を選択
   2. 左サイドバーから「ルートユーザーのセキュリティ資格情報」を選択
   3. 発行されているアクセスキーがあれば削除を実行
::: note warn
アクセスキーが外部に流出すると、API操作を含むすべてのアクティビティが実行可能になり、セキュリティリスクが高まります。
:::

### 3. IAMユーザーとロールの活用
ルートユーザーの使用頻度を減らすため、**IAMユーザー**と**IAMロール**を活用します。
ルートユーザーが必要な操作以外はIAMユーザーやロールで代替することが可能です。

- IAMユーザーは**日常の業務**に使用し、特権操作は適切なポリシーで制限。
- ロールは必要なときにのみアサインし、作業後はロールを解除するようにします。

### 4. ルートユーザーのアクティビティ監視
AWS CloudTrailを使用して、ルートユーザーの**アクティビティを監視**します。  
CloudTrailにより、AWSのAPI操作がすべて記録され、不審な操作が発見しやすくなります。
1. **CloudTrailを有効化**して、すべてのリージョンでのログ記録を設定。
2. **特定のルートユーザー操作**（たとえば、S3のアクセスやIAM設定変更など）に対してアラートを設定する。
3. CloudWatch Alarmsで不審なアクティビティが発生した場合に通知を受け取る。

### 5. 緊急時のアクセス対策
ルートユーザーのアクセスを最小化しても、緊急時にはルートユーザー権限が必要な場合があります。  
そこで、緊急時には以下の対策を講じることで対応が容易になります。

- **ルートユーザーの認証情報**を**安全な場所**（例: セキュアなパスワードマネージャー）に保存
- **事前にIAMロール**を作成し、緊急時には管理者としてアサイン可能にする

## まとめ
::: note info
AWS環境のセキュリティを強化するためには、
- ルートユーザーの利用を最小限にする
- MFA設定やアクセスキーの削除
- アクティビティ監視　　　　　　　　　　　　　を行うことが重要です。  
安全なAWS環境を構築し、クラウドの利便性を安心して活用しましょう！
:::

もし記事が役に立てば、「いいね」やフォローをいただけると嬉しいです！
【Next.js】cookies()の使い方

## `cookies()`とは

`cookies()`は、Server Component、Server Actions、Route HandlersでCookieを操作するための非同期関数です。この関数を使用することで、Cookieを取得したり、新しいCookieを設定したり、既存のCookieを削除したりすることができます。

## Cookieの取得

特定のCookieを取得するには、`get('name')`を使用します。

```jsx
import { cookies } from 'next/headers';

export default async function Page() {
  const cookieStore = await cookies();
  const myCookie = cookieStore.get('myCookieName');

  // ...
}
```

この例では、`myCookieName`という名前のCookieを取得しています。

また、`getAll()`を使用するとすべてのCookieを取得できます。

```jsx
import { cookies } from 'next/headers'
 
export default async function Page() {
  const cookieStore = await cookies()
  return cookieStore.getAll().map((cookie) => (
    <div key={cookie.name}>
      <p>Name: {cookie.name}</p>
      <p>Value: {cookie.value}</p>
    </div>
  ))
}

```

## Cookieが存在するか判別

`has('name')`を使用することで指定したCookieが存在するか判定できます。

```jsx
import { cookies } from 'next/headers'
 
export default async function Page() {
  const cookieStore = await cookies()
  const hasCookie = cookieStore.has('theme')

  // ...
}
```

上記では`theme`というCookieが存在するか判定しています。

## Cookieの設定

新しいCookieを設定するには、`set(name, value, options)`を使用します。

```js
'use server'

import { cookies } from 'next/headers';

export async function create(data) {
  const cookieStore = await cookies();
  cookieStore.set('myCookieName', 'myCookieValue', {
    httpOnly: true,
    maxAge: 60 * 60 * 24,
  });

  // ...
}
```

この例では、`myCookieName`という名前のCookieを`myCookieValue`という値で設定しています。`httpOnly`オプションを指定することでJavaScriptからのアクセスを制限し、`maxAge`オプションでCookieの有効期限を設定しています。

`options`の値については以下のページを参照してください。

https://nextjs.org/docs/app/api-reference/functions/cookies#options

:::note warn
Server Action内でCookieを設定するとルーターキャッシュが無効になります。
[Building Your Application: Caching | Next.js](https://nextjs.org/docs/app/building-your-application/caching#invalidation-1)
:::

## Cookieの削除

特定のCookieを削除するには、`delete(name)`を使用します。

```js
'use server'
 
import { cookies } from 'next/headers'
 
export async function delete(data) {
  (await cookies()).delete('myCookieName')
}
```

```js
'use server'
 
import { cookies } from 'next/headers'
 
export async function delete(data) {
  (await cookies()).set('myCookieName', '')
}
```

```js
'use server'
 
import { cookies } from 'next/headers'
 
export async function delete(data) {
  (await cookies()).set('myCookieName', 'value', { maxAge: 0 })
}
```

上記の3つは`myCookieName`という名前のCookieを削除しています。

また、すべてのCookieを削除するには`clear()`を使用します。

```js
'use server'
 
import { cookies } from 'next/headers'
 
export async function delete(data) {
  (await cookies()).clear()
}
```

:::note warn
Server Action内でCookieを削除するとルーターキャッシュが無効になります。
[Building Your Application: Caching | Next.js](https://nextjs.org/docs/app/building-your-application/caching#invalidation-1)
:::
LiteLLMを活用してOllamaをGoogle Colabで効率的に運用する方法

## はじめに

ローカルLLMの運用において、OllamaとLiteLLMの組み合わせは非常に強力なソリューションとなっています。本記事では、Google Colab環境でこれらのツールを効率的に統合する方法を解説します。

## Ollamaとは

Ollamaは、ローカル環境でLLM（大規模言語モデル）を簡単に実行できるオープンソースのツールです。主な特徴として：

- 簡単なコマンドラインインターフェース
- 効率的なモデル管理
- 軽量な実行環境
- APIサーバーとしての機能

## LiteLLMを使う利点

LiteLLMを導入することで得られる主なメリット：

1. **統一されたインターフェース**
   - OpenAI
   - Anthropic
   - Ollama
   - その他の主要なLLMプロバイダーに同じコードで接続可能

2. **容易なプロバイダー切り替え**
   - モデルの指定を変更するだけで異なるプロバイダーに切り替え可能
   - 開発環境とプロダクション環境での柔軟な切り替え

3. **標準化されたエラーハンドリング**
   - 各プロバイダー固有のエラーを統一的に処理

## 実装手順

### 環境のセットアップ

```python
# Ollamaのインストール
!curl https://ollama.ai/install.sh | sh

# CUDAドライバーのインストール
!echo 'debconf debconf/frontend select Noninteractive' | sudo debconf-set-selections
!sudo apt-get update && sudo apt-get install -y cuda-drivers
```

### サーバーの起動とモデルのダウンロード

```python
# Ollamaサーバーの起動
!nohup ollama serve &

# モデルのダウンロード
!ollama pull llama3:8b-instruct-fp16
```

### LiteLLMを使用したモデル実行

```python
from litellm import completion

response = completion(
    model="ollama/llama3:8b-instruct-fp16", 
    messages=[{ "content": "respond in 20 words. who are you?","role": "user"}], 
    api_base="http://localhost:11434"
)
print(response)
```

## プロバイダーの切り替え例

LiteLLMを使用することで、以下のように簡単に異なるプロバイダーに切り替えることができます：

```python
# OpenAIの場合
response = completion(
    model="gpt-3.5-turbo", 
    messages=[{"content": "Hello!", "role": "user"}]
)

# Anthropicの場合
response = completion(
    model="claude-3-opus-20240229", 
    messages=[{"content": "Hello!", "role": "user"}]
)

# Ollamaの場合（ローカル実行）
response = completion(
    model="ollama/llama3:8b-instruct-fp16", 
    messages=[{"content": "Hello!", "role": "user"}],
    api_base="http://localhost:11434"
)
```

## 注意点とベストプラクティス

1. **リソース管理**
   - Google Colabの無料枠でも実行可能
   - GPUメモリの使用状況に注意

2. **セッション管理**
   - Colabのセッション切断時は再セットアップが必要
   - 長時間の実行にはPro版の使用を推奨

## まとめ

OllamaとLiteLLMの組み合わせは、ローカルLLMの運用を大幅に簡素化します。特に：

- 統一されたインターフェースによる開発効率の向上
- 異なるプロバイダー間での容易な切り替え
- Google Colab環境での簡単な実行

これらの利点により、プロトタイピングから本番環境まで、柔軟なLLMの活用が可能となります。

## ノートブック

https://colab.research.google.com/drive/1buTPds1Go1NbZOLlpG94VG22GyK-F4GW?usp=sharing

## リポジトリ

https://github.com/Sunwood-ai-labs/Llama-finetune-sandbox

## 参考サイト

https://note.com/masayuki_abe/n/n9640e08492ac
Windowsでディレクトリを右クリックしてTabbyで開きたい

## 前提
- [Tabby (https://tabby.sh/)](https://tabby.sh/)
- Windows10 or Windows11
- Windows11の場合はシフト+右クリックで表示されるようになります。

## 手順
### レジストリを開く(管理者権限必要)
ウィンドウズキー+R > regedit
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3669834/8d7c9043-1fa9-a72e-41a6-fd2dccc42767.png)

### アドレスバー入力
以下いずれかを選択してください。
- コンピューター\HKEY_CLASSES_ROOT\Directory\shell

ディレクトリのアイコンを右クリックしたときに表示されるコンテキストメニュー

- コンピューター\HKEY_CLASSES_ROOT\Directory\Background\shell

ディレクトリの背景をクリックしたときに表示されるコンテキストメニュー

この後の手順は変わりませんが、上のほうで説明します。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3669834/d57f346b-555f-2e53-befc-ed6f75474abd.png)


### キーの追加
shell右クリック > 新規 > キー(K)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3669834/0d8dddd5-9c84-e8fe-5808-dcb27db7879b.png)

tabbyとか適当な名前で登録してください

表示されている規定をダブルクリックし、表示名を設定。
ここで設定した名前がディレクトリを右クリックしたときにコンテキストメニューに表示される文字列になります。Open in TabbyとかそんなんでOK。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3669834/603f9298-a687-5bb7-6480-8e4cb2c53d7f.png)

Iconも追加しましょう。
exeの場所指定してあげれば大丈夫です。
右クリック > 新規 > 文字列
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3669834/02b7285a-427c-4edd-f46b-4c1c7e8b3d17.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3669834/17558765-704c-adeb-1edf-57968af9e0ed.png)

### 起動引数の設定
commandというキーを追加。
"C:\Program Files\Tabby\Tabby.exe" "%V"で追加。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3669834/50fe8d43-8e82-b030-9a08-e7d6d8ac41ad.png)


ここまですれば右クリックして表示されるはずです。
再起動はいらないはずですが、反映されなかったら試しみましょう。

## 結果
tabbyができました。やったぜ。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3669834/8be1d1ae-5a22-2664-fd11-abb7111585f3.png)


## 参考
ほとんど2個目の記事の直訳です。
- Windows 10 でコンテキストメニューを編集する方法
https://polygonote.com/2022_1109_18874/

- Add Tabby To Right Click Menu In Windows #6011
https://github.com/Eugeny/tabby/issues/6011