Category: Python

import random

def player_attack():
    print("攻撃！シュートする方向を選んでください:")
    print("1: 左\n2: 中央\n3: 右")
    try:
        choice = int(input("あなたの選択: "))
        if choice not in [1, 2, 3]:
            raise ValueError
    except ValueError:
        print("無効な入力です。中央にします。")
        choice = 2
    return choice

def cpu_defend():
    return random.randint(1, 3)

def cpu_attack():
    return random.randint(1, 3)

def player_defend():
    print("守備!相手のシュートを読む方向を選択してください:")
    print("1: 左\n2: 中央\n3: 右")
    try:
        choice = int(input("あなたの選択: "))
        if choice not in [1, 2, 3]:
            raise ValueError
    except ValueError:
        print("無効な入力です。中央にします。")
        choice = 2
    return choice

def game():
    player_score = 0
    cpu_score = 0

    print("== サッカー対決: 3ターンマッチ ==")
    for turn in range(1, 4):
        print(f"\n--- 第{turn}ターン ---")

        attack_dir = player_attack()
        defend_dir = cpu_defend()
        if attack_dir != defend_dir:
            print("ゴール!! 🎉")
            player_score += 1
        else:
            print("セーブされた!")

        attack_dir = cpu_attack()
        defend_dir = player_defend()
        if attack_dir != defend_dir:
            print("CPUがゴール!! 😱")
            cpu_score += 1
        else:
            print("ナイスセーブ!! 🎉")

    print(f"\n== 試合終了==\n あなた: {player_score}点\n CPU:{cpu_score}点")
    if player_score > cpu_score:
        print("勝利")
    elif player_score < cpu_score:
        print("敗北")
    else:
        print("引き分け")

if __name__ == "__main__":
    game()

$ python3 football.py
== サッカー対決: 3ターンマッチ ==

— 第1ターン —
攻撃！シュートする方向を選んでください:
1: 左
2: 中央
3: 右
あなたの選択: 1
ゴール!! 🎉
守備!相手のシュートを読む方向を選択してください:
1: 左
2: 中央
3: 右
あなたの選択: 2
CPUがゴール!! 😱

— 第2ターン —
攻撃！シュートする方向を選んでください:
1: 左
2: 中央
3: 右
あなたの選択: 1
ゴール!! 🎉
守備!相手のシュートを読む方向を選択してください:
1: 左
2: 中央
3: 右
あなたの選択: 3
ナイスセーブ!! 🎉

— 第3ターン —
攻撃！シュートする方向を選んでください:
1: 左
2: 中央
3: 右
あなたの選択: 2
セーブされた!
守備!相手のシュートを読む方向を選択してください:
1: 左
2: 中央
3: 右
あなたの選択: 1
ナイスセーブ!! 🎉

== 試合終了==
あなた: 2点
CPU:1点
勝利

abspathがファイルの絶対パス。

import os

current_path = os.path.abspath(__file__)
exec_path = current_path.replace('/python/post.py', '')
path = "{}/config/hoge.txt".format(exec_path)
print(path)

なるほど、パスの取得は色々あって便利やね。

json.dumps した後に、配列(json_list=[])に入れると、配列自体はjsonではないので、うまくいかない。
配列に入れてからjson.dumpsすると、jsonデータとして扱われる。

import json
import requests


json_list = []
with open('./data/names.txt') as f:
    for line in f:
        json_open = json.loads(line)
        json_list.append(json_open)
        
json_data = json.dumps(json_list)
print(json_data)

response = requests.post(
    "http://httpbin.org/post", 
    data=json_data,
    headers={'Content-type': 'application/json'}
)
print(response.status_code)
print(response.text)

これ解決するのに半日以上かかりましたorz…

import random
from typing import List, Tuple

def generate_coefficients(secret: int, threshold: int) -> List[int]:
    coefficients = [secret]
    for _ in range(threshold - 1):
        coefficients.append(random.randint(1, 256))
    return coefficients

def create_shares(
    secret: int, total_shares: int, threshold: int
) -> List[Tuple[int, int]]: 
    coefficients = generate_coefficients(secret, threshold)
    shares = []
    for x in range(1, total_shares + 1):
        y = sum(coeff * (x**exp) for exp, coeff in enumerate(coefficients))
        shares.append((x, y))
    return shares

def reconstruct_secret(shares: List[Tuple[int, int]], threshold: int) -> int:
    def _lagrange_interpolation(x: int, x_s: List[int], y_s: List[int]) -> int:
        def _basis(j: int) -> int:
            num = 1
            den = 1
            for m in range(len(x_s)):
                if m != j:
                    num *= x - x_s[m]
                    den *= x_s[j] - x_s[m]
            return num // den

        result = 0
        for j in range(len(y_s)):
            result += y_s[j] * _basis(j)
        return result

    x_s, y_s = zip(*shares)
    return _lagrange_interpolation(0, x_s, y_s)

if __name__ == "__main__":
    secret = 2732
    total_shares = 5
    threshold = 2

    shares = create_shares(secret, total_shares, threshold)
    print("shares:", shares)

    selected_shares = shares[:threshold]
    print(zip(*selected_shares))
    x_s, y_s = zip(*selected_shares)
    print(x_s, y_s)
    recovered_secret = reconstruct_secret(selected_shares, threshold)
    print("Recovered Secret:", recovered_secret)

$ python3 test.py
shares: [(1, 2961), (2, 3190), (3, 3419), (4, 3648), (5, 3877)]

(1, 2) (2961, 3190)
Recovered Secret: 2732

$ pip3 install psycopg2
error: externally-managed-environment

× This environment is externally managed
╰─> To install Python packages system-wide, try apt install
python3-xyz, where xyz is the package you are trying to
install.

プロジェクトごとに仮想環境を作って、そこでインストールすることが推奨されている。
$ python3 -m venv venv
$ source venv/bin/activate
$ python3 -V
$ pip3 install psycopg2　
$ pip3 install python-dotenv
$ cd assets
$ python3 migration.py
$ deactivate

### 仮想環境を作らない方法
$ pip3 install psycopg2　–break-system-packages
これでもいける。

$ pip install python-dotenv

.env

PSQL_PASSWORD=hoge

import os
from dotenv import load_dotenv

load_dotenv('../.env')

PSQL_PASSWORD = os.getenv('PSQL_PASSWORD')

print(PSQL_PASSWORD)

$ python3 migration.py
hoge

bloom filterの全体像。ハッシュ化した値をインデックス番号にして、bloom_filterの値を更新する。
bloom filterにハッシュ値が入っているかどうか確認することで、bloom filterに登録されているかを判定する。

bloom_filter = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

def hash_a(val):
    return hash_val

def hash_b(val):
    return hash_val


val = "hello world"

a_hashed = hash_a(val) # 1
b_hashed = hash_b(val) # 4

bloom_filter[a_hashed] = 1
bloom_filter[b_hashed] = 1

[0, 1, 0, 0, 4, 0, 0, 0, 0, 0]

bloom_filter[a_hashed]
bloom_filter[b_hashed]

import functools

class BloomFilter:
    def __init__(self, filter_size):
        self.filter_size = filter_size
        self.bloom_filter = [0 for _ in range(filter_size)]

    def set_v(self, val):
        indexes = self.n_hash(val)
        for index in indexes:
            self.bloom_filter[index] = 1

    def n_hash(self, val):
        hashed = abs(hash(val))
        d_lst = [int(n) for n in str(hashed)]
        return [
            self._hash_common(lambda acc, d: acc + d, d_lst),
            self._hash_common(lambda acc, d: acc + 3 * d, d_lst),
        ]

    def _hash_common(self, func, d_lst):
        execed = abs(functools.reduce(func, d_lst, 0))
        while execed >= self.filter_size:
            execed = execed / self.filter_size
        return int(execed)

    def exist_v(self, val):
        indexes = self.n_hash(val)
        for index in indexes:
            if self.bloom_filter[index] == 0:
                return False
            return True

bf = BloomFilter(10)
print(bf.bloom_filter)
bf.set_v(3)
print(bf.bloom_filter)
print(bf.exist_v(3))
print(bf.exist_v(10))

$ python3 bloom_filter.py
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 1, 0, 0, 0, 0, 0, 1]
True
False

BTCではSPVがScriptPubKeyをbloomfilterにセットして、リモートノードがマッチングアルゴリズムで判定する。
-> リモートノード側では、トランザクションごとに、ScriptPubKey, Outpointがマッチするかを判定して、マッチする場合はブルームフィルタを更新している。

なるほど、直接pubkeyのデータをやり取りしない分、安全性が向上するということね。これをRustでやりたい。

文字列を数値に変換するには、文字列を数値として持っておいて、それを変換でしょうか。

static ASCII_LOWER: [char; 26] = [
    'a', 'b', 'c', 'd', 'e', 
    'f', 'g', 'h', 'i', 'j', 
    'k', 'l', 'm', 'n', 'o',
    'p', 'q', 'r', 's', 't', 
    'u', 'v', 'w', 'x', 'y', 
    'z',
];