subroutine add(a, b, result)
  implicit none
  real, intent(in) :: a, b
  real, intent(out) :: result

  result = a + b
end subroutine

def add(a, b):
    return a + b

def add(a, b):
    return a + b

def add(a: int, b: int) -> int:
    return a + b

from typing import Union

def add(a: Union[int, float], b: Union[int, float]) -> Union[int, float]:
    return a + b

from typing import Any

def add(a: Any, b: Any) -> Any:
    return a + b

f = open('file.txt', 'r')
content = f.read()
f.close() # close処理

with open('file.txt', 'r') as f:
    content = f.read()

def count_up_to(max):
    count = 1
    while count <= max:
        yield count # ジェネレータの利用
        count += 1

counter = count_up_to(5)
for number in counter:
    print(number)

# map と lambda の使用例
squares = map(lambda x: x**2, range(10))
print(list(squares)) # output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# filter の使用例
even_numbers = filter(lambda x: x % 2 == 0, range(10))
print(list(even_numbers)) # output: [0, 2, 4, 6, 8]

import numpy as np

if __name__ == '__main__':
  print("Hello world!")  # Hello world!

  # Python Build-in type

  a = 42  # integer no limit bit
  print(a, type(a))  # 42 <class 'int'>

  a = 3.14  # float 64bit
  print(a, type(a))  # 3.14 <class 'float'>

  a = 1 + 8j  # complex 64bit
  print(a, type(a))  # (1+8j) <class 'complex'>

  # Numpy type

  a = np.int32(7)  # numpy integer 32bit
  print(a, type(a))  # 7 <class 'numpy.int32'>

  a = np.float64(9.0)  # numpy float 64bit
  print(a, type(a))  # 9.0 <class 'numpy.float64'>

  a = np.complex128(1.0 + 2.0j)  # numpy complex 128bit
  print(a, type(a))  # (1+2j) <class 'numpy.complex128'>

  a = np.zeros(3, dtype='float64')  # numpy ndarray float 64bit
  print(a, type(a))  # [0. 0. 0.] <class 'numpy.ndarray'>

  # Numpy type is stronger than Build-in type

  a = 2.0
  b = np.float64(3.14)
  c = a * b
  print("{}, {}".format(c, type(c)))  # 6.28, <class 'numpy.float64'>

  # Simultaneous substitution (but it is slow)

  a, b = 3, np.float64(5.2)
  print(a, type(a))  # 3 <class 'int'>
  print(b, type(b))  # 5.2 <class 'float'>

  # Swap a and b

  a, b = b, a
  print(a, type(a))  # 5.2 <class 'numpy.float64'>
  print(b, type(b))  # 3 <class 'int'>

a = 42  # aは整数型
print(type(a))  # <class 'int'>
a = 3.14  # aは整数型から実数型に変わる
print(type(a))  # <class 'float'>

if __name__ == "__main__":

    # 定義・宣言
    x = [1, "af", 3.4, 1 + 2j, "a"]  # list (mutable)

    # 要素の読み出し
    y = x[1]
    print(y)  # "af"

    # 長さの取得
    y = len(x)
    print(y)   # 5

    # スライス操作 （どのようにコピーされるかは次章参照）
    y = x[1:3]
    print(y)  # ['af', 3.4]

    # 要素のインデックス取得
    y = x.index("a")
    print(y)  # 4

    # 代入方法
    x = [1, "af", 3.4, 1 + 2j, "a"]
    x[1] = "b"
    print(x)  # [1, 'b', 3.4, (1+2j), 'a']

    # 要素の追加
    x = [1, "af", 3.4, 1 + 2j, "a"]
    x.append("c")
    print(x)  # [1, 'af', 3.4, (1+2j), 'a', 'c']

    # 要素の削除
    x = [1, "af", "a", 3.5, 1 + 2j, "a"]
    x.remove("a")
    print(x)  # [1, 'af', 3.5, (1+2j), 'a']

if __name__ == "__main__":
    # 定義・宣言
    x = [1, [2, 3], [4, 5, 6], "a", 88]  # list (mutable)

    # スライス操作
    y = x[2:4]
    print(y)  # [[4, 5, 6], 'a']

    # yの要素（リスト）を変更
    print(x)  # [1, [2, 3], [4, 5, 6], "a", 88]
    y[0][1] = 999 # リストの要素[4,5,6]はmutableなので、参照元のxも変更される。
    y[1] = "t" # 文字はimmutableなので、参照元のxは変更されず、コピーされたyのみ変更される。

    print(x)  # [1, [2, 3], [4, 999, 6], 'a', 88]
    print(y)  # [[4, 999, 6], 't']

if __name__ == "__main__":

  x = [1, 2, 3, 4, 5, 6]

  element = x[2]  # 3（3番目の要素）

# 4. 関数の定義
def func(i: int) -> float:
    return 0.1 * i


if __name__ == '__main__':

    # 要素数を設定
    n = 10

    # 空の一次元リストを作成
    arr = [0 for _ in range(n)]

    # iのインデックスを要素に持つリストを作成
    for i in range(n):
        arr[i] = func(i)

    print(arr) # [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

if __name__ == "__main__":

  x = [
      [1, 2, 3],
      [4, 5, 6],
      [7, 8, 9]
  ]

  element = x[1][2]  # 6（2行目、3列目の要素）

def func(i: int, j: int) -> float:
    return 0.1 * i * j


if __name__ == '__main__':

    # 行数と列数を設定
    nrows, ncols = 4, 4

    # i行目j列目のインデックスを要素に持つリストを作成
    arr = [[func(i, j) for j in range(ncols)] for i in range(nrows)]

    for row in arr:
        print(row)

def func(i: int, j: int) -> float:
    return 0.1 * i * j


if __name__ == '__main__':

    # 行数と列数を設定
    nrows, ncols = 4, 4

    # 空の二次元リストを作成
    arr = [[0 for _ in range(ncols)] for _ in range(nrows)]

    # i行目j列目のインデックスを要素に持つリストを作成
    for i in range(nrows):
        for j in range(ncols):
            arr[i][j] = func(i, j)

    for row in arr:
        print(row)

    # [0.0, 0.0, 0.0, 0.0]
    # [0.0, 0.1, 0.2, 0.3]
    # [0.0, 0.2, 0.4, 0.6]
    # [0.0, 0.3, 0.6, 0.9]

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

first_row = matrix[0] # 一行目を取得
print(first_row)  # [1, 2, 3]

first_column = [row[0] for row in matrix]　# 一列目を取得
print(first_column)  # [1, 4, 7]

import numpy as np


def generate_sequence_np(start, step, count):
    stop = start + (count - 1) * step
    return np.linspace(start, stop, count).tolist()


if __name__ == "__main__":
    start_value = 3.0
    step_value = 0.5
    num_elements = 8

    sequence = generate_sequence_np(start_value, step_value, num_elements)
    print(sequence)   # [3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5]

def generate_sequence(start, step, count):
    return [start + i * step for i in range(count)]

if __name__ == "__main__":
    start_value = 3.0
    step_value = 0.5
    num_elements = 8

    sequence = generate_sequence(start_value, step_value, num_elements)
    print(sequence)  # [3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5]

if __name__ == "__main__":
    # 定義・宣言
    x = (1, "af", 3.4, 1 + 2j, "a")  # tuple (immutable)

    # 要素の読み出し
    y = x[1]
    print(y)

    # 長さの取得
    y = len(x)
    print(y)

    # スライス操作
    y = x[0:2]
    print(y)

    # 要素のインデックス取得
    y = x.index('p')
    print(y)

    # x[1] = 'b'  # タプルは不変であるため、代入不可
    # x.append(9)  # タプルは不変であるため、要素の追加は不可
    # x.remove('a')  # タプルは不変であるため、要素の削除は不可

if __name__ == "__main__":
  x = (1, 2, 3, 4, 5, 6)

  element = x[2]  # 3（3番目の要素）

if __name__ == "__main__":

  x = (
      (1, 2, 3),
      (4, 5, 6),
      (7, 8, 9)
  )

  element = x[1][2]  # 6（2行目、3列目の要素）

my_dict = {"apple": 1, "banana": 2, "cherry": 3}

print(my_dict["apple"])  # Output: 1

my_dict = {"apple": 1, "banana": 2, "cherry": 3}
my_dict["apple"] = 4  # Update existing key
my_dict["mango"] = 5  # Add new key-value pair

print(my_dict)
{'apple': 4, 'banana': 2, 'cherry': 3, 'mango': 5}

if "apple" in my_dict:
    print("Apple is in the dictionary.")

my_dict = {"apple": 1, "banana": 2, "cherry": 3}
for k in my_dict.keys():
    print(k, my_dict(k))
# apple 1
# banana 2
# cherry 3

my_dict = {str(i): i for i in range(5)}

my_dict = {key_expression : value_expression for item in iterable}

words = ['apple', 'banana', 'cherry']
length_dict = {word: len(word) for word in words}
print(length_dict)  # Output: {'apple': 5, 'banana': 6, 'cherry': 6}

words = ['apple', 'banana', 'cherry', 'kiwi']
length_dict = {word: len(word) for word in words if len(word) >= 5}
print(length_dict)  # Output: {'apple': 5, 'banana': 6, 'cherry': 6}

my_dict = {"fruits": ["apple", "banana", "cherry"], "numbers": [1, 2, 3]}

print(my_dict["fruits"])  # Output: ['apple', 'banana', 'cherry']

my_dict = {"fruits": ["apple", "banana", "cherry"], "numbers": [1, 2, 3]}
my_dict["fruits"].append("mango")
print(my_dict) # {'fruits': ['apple', 'banana', 'cherry', 'mango'], 'numbers': [1, 2, 3]}

my_dict = {"fruits": ["apple", "banana", "cherry"], "numbers": [1, 2, 3]}
my_dict["vegetables"] = ["carrot", "potato"]
print(my_dict) # {'fruits': ['apple', 'banana', 'cherry'], 'numbers': [1, 2, 3], 'vegetables': ['carrot', 'potato']}

my_dict = {"apple": 1, "banana": 2, "cherry": 3}
print(my_dict.get("apple", 0))  # Output: 1, キーが存在するので、appleの値1を返す。
print(my_dict.get("mango", 0))  # Output: 0, キーが存在しないので、デフォルト値0を返す。

dict1 = {"apple": 1, "banana": 2}
dict2 = {"cherry": 3, "mango": 4}
dict1.update(dict2)
print(dict1)  # Output: {'apple': 1, 'banana': 2, 'cherry': 3, 'mango': 4}

dict1 = {"apple": 1, "banana": 2}
dict2 = {"cherry": 3, "mango": 4}
combined_dict = {**dict1, **dict2}
print(combined_dict)  # Output: {'apple': 1, 'banana': 2, 'cherry': 3, 'mango': 4}

my_dict = {"apple": 1, "banana": 2, "cherry": 3}
reversed_dict = {v: k for k, v in my_dict.items()}
print(reversed_dict)  # Output: {1: 'apple', 2: 'banana', 3: 'cherry'}

import numpy as np

if __name__ == "__main__":

  x = [1, 2, 3, 4, 5, 6]

  element = x[2]  # 3（3番目の要素）

import numpy as np

length = 4
indices = np.arange(length)
print(indices) # [0 1 2 3]

import numpy as np

def generate_sequence_np(start, step, count):
    stop = start + (count - 1) * step
    return np.linspace(start, stop, count)

if __name__ == "__main__":
    start_value = 3.0
    step_value = 0.5
    num_elements = 8

    sequence = generate_sequence_np(start_value, step_value, num_elements)
    print(sequence)   # [3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5]

import numpy as np

# 関数の定義
def func(x: float) -> float:
    return x * 2 + 1

# 関数のベクトル化
vectorized_func = np.vectorize(func)

if __name__ == '__main__':
    # xの配列を生成
    x = np.linspace(0, 5, 6)  # [0. 1. 2. 3. 4. 5.]
    print(x)

    # 配列xに関数を適用してyの配列を生成
    y = vectorized_func(x)

    print(y)  # [ 1.  3.  5.  7.  9. 11.]

import numpy as np

if __name__ == "__main__":

  x = np.array([
      [1, 2, 3],
      [4, 5, 6],
      [7, 8, 9]
  ])

  element = x[1, 2]  # 6（2行目、3列目の要素）

import numpy as np


# 関数の定義
def func(i:int, j:int) -> float:
    return 0.1 * i * j

# 関数のベクトル化
vectorized_func = np.vectorize(func)

if __name__ == '__main__':

    # i行目j列目のインデックスを要素に持つ配列を作成、0始まりで作成される
    rows, cols = np.indices((4, 4))
    # rows += 1  # 行インデックスを1始まりにする場合
    # cols += 1  # 列インデックスを1始まりにする場合

    arr = vectorized_func(rows, cols)
    print(arr)

[[0.  0.  0.  0. ]
 [0.  0.1 0.2 0.3]
 [0.  0.2 0.4 0.6]
 [0.  0.3 0.6 0.9]]

import numpy as np

# 関数の定義
def func(i, j):
    return 0.1 * i * j

if __name__ == '__main__':

  # 4x4の実数型二次元配列を作成
  arr = np.zeros((4, 4), dtype=float)

  # 配列の要素に代入
  for i in range(arr.shape[0]):
      for j in range(arr.shape[1]):
          arr[i, j] = func(i,j)

  print(arr)

import numpy as np

def add_five(arr: np.ndarray) -> np.ndarray:
    return arr + 5 # ndarrayに整数を足す操作は、ndarrayの特別な操作 = 内部的にベクトル演算となっている

# NumPyのndarrayを使ってテスト
array = np.array([0, 1, 2, 3, 4])
result = add_five(array)
print(result)  # [5 6 7 8 9]

import numpy as np

def add_five(arr: np.ndarray) -> np.ndarray:
    result = np.empty_like(arr)
    for i, value in enumerate(arr): # 各要素にアクセスする操作は、ベクトル演算に対応していない
        result[i] = value + 5
    return result

# NumPyのndarrayを使ってテスト
array = np.array([0, 1, 2, 3, 4])
result = add_five(array)
print(result)  # [5 6 7 8 9]

import numpy as np


# 関数の定義
def func(i: int) -> float:
    return 0.1 * i


# 関数のベクトル化
vectorized_func = np.vectorize(func)

if __name__ == '__main__':

    # i番目のインデックスを要素に持つ配列を作成、0始まりで作成される
    x = np.arange(4)

    # 下記のように書くと、ベクトル演算ではない
    arr1 = np.zeros(x.shape[0])
    for i, val in enumerate(x):
        arr1[i] = func(i)
    print(arr1)

    # 下記のように書くと、ベクトル演算
    # （ただし、np.vectorize()によるベクトル化だと処理速度は向上しない）
    arr = vectorized_func(x)
    print(arr)```

map(function, iterable)

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

def double(x):
    return x * 2

doubled_numbers = list(map(double, numbers))
print(doubled_numbers) # [2, 4, 6, 8, 10]

numbers = [1, 2, 3, 4, 5]
doubled_numbers = list(map(lambda x: x * 2, numbers))
print(doubled_numbers) # [2, 4, 6, 8, 10]

filter(function, iterable)

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def is_even(x):
    return x % 2 == 0

even_numbers = list(filter(is_even, numbers))
print(even_numbers) # [2, 4, 6, 8, 10]

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)

[expression for item in iterable if condition]

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
doubled_evens = [x * 2 for x in numbers if x % 2 == 0]
print(doubled_evens) # [4, 8, 12, 16, 20]

a = (1,4,8) #tuple, immutable
# a(0) = 2 # 不可
# a(1) = 3 # 不可
# a(2) = 9 # 不可
a = (2,3,9) # 可（動的型付けで、新たなタプルを作成）

a = [1,4,8] #list, immutable
a[0] = 2 # 可
a[1] = 3 # 可
a[2] = 9 # 可
print(a) # [2,3,9]
a = [7,6,1] # 可（動的型付け）

import numpy as np

c = np.complex128(3 + 4j)

# 実部を取得してfloat64にキャスト
real_part = np.float64(c.real)
print(real_part)  # 3.0

# 虚数部を取得してfloat64にキャスト
imag_part = np.float64(c.imag)
print(imag_part)  # 4.0

import numpy as np

mixed_list = [1, 2.0, 3 + 4j]
mixed_array = np.array(mixed_list) # リストをnp.ndarrayに変換

print(mixed_array) # Output: [1.+0.j 2.+0.j 3.+4.j]

import numpy as np

x = np.array([[1, 2], [3, 4]])
lst = list(x)
print(lst)  # [array([1, 2]), array([3, 4])]
# リストの第一要素にndarray[1,2]が格納、第二要素にndarray[3,4]が格納。

import numpy as np

x = np.array([[1, 2], [3, 4]])
lst = x.tolist()
print(lst)  # [[1, 2], [3, 4]]
# リストの第一要素にリスト[1,2]が格納、第二要素にリスト[3,4]が格納。

n = 7
x = 89.0123

print("{} {}".format(n, x)) # 書式指定せずにターミナル出力
print("{:d} {:.6f}".format(n, x)) # 書式指定してターミナル出力

n = 7
x = 89.0123

with open("output.txt", "w") as file: # ファイル出力
    file.write("{:d} {:.6f}".format(n,x))

integers = np.array([1, 2, 3], dtype=int)
floats1 = np.array([1.0/3.0, 4.00, 2.123456789012345], dtype=float)
floats2 = np.array([0.1234567890123456, -1.234567890123456, 3.141592653589793],   dtype=float)

combined_array = np.column_stack((integers, floats1, floats2))

with open("output_e_f.txt", "w") as file:
    np.savetxt(file, combined_array, fmt=("%d", "%f", "%e"))
with open("output_17f_17e.txt", "w") as file:
    np.savetxt(file, combined_array, fmt=("%d", "%.17f", "%.17e"))

# output_e_f.txt
1 0.333333 1.234568e-01
2 4.000000 -1.234568e+00
3 2.123457 3.141593e+00

# output_17f_17e.txt
1 0.33333333333333315 1.23456789012345605e-01
2 4.00000000000000000 -1.23456789012345602e+00
3 2.12345678901234512 3.14159265358979312e+00

x = np.array([1.234567, 89.012345, 678.901234], dtype=float)
y = np.array([9.876543, 21.098765, 432.109876], dtype=float)
z = np.array([0.123456, 7.890123, 654.321098], dtype=float)
n = np.array([1,2,3], dtype=int)

# for 文で逐次的に出力：遅い
with open("output.txt", "w") as file:
    for i in range(len(x)):
        file.write("{} {} {} {}\n".format(n[i], x[i], y[i], z[i]))

# 同一の型で同一サイズの場合、結合して出力：型・サイズが同一の場合のみ
data = np.column_stack((x, y, z))
with open("output.txt", "w") as file:
    np.savetxt(file, data, fmt="%.6f", delimiter=" ")

# 異なる型, 結合, 書式指定：サイズは同一の場合のみ
combined_array = np.column_stack((n, x, y))
with open("output.txt", "w") as file:
    np.savetxt(file, combined_array, fmt=("%d", "%.2f", "%.3f"))

n1 = 10
n2 = -71
n3 = 0
print("{},{},{}".format(n1, n2, n3)) # 10,-71,0
print("{:d},{:d},{:d}".format(n1, n2, n3)) # 10,-71,0
print("{:5d},{:5d},{:5d}".format(n1, n2, n3)) # ␣␣␣10,␣␣-71,␣␣␣␣0

n4 = 1234567890123456789012345678901234567890123456789012345678901234567890
print("{}".format(n4)) # 1234567890123456789012345678901234567890123456789012345678901234567890
print("{:d}".format(n4)) # 1234567890123456789012345678901234567890123456789012345678901234567890
print("{:5d}".format(n4)) # 1234567890123456789012345678901234567890123456789012345678901234567890

n1 = 10; n2 = -71; n3 = 0

y = 1.0 / 3.0
print("{},{}".format(y, y)) # 0.3333333333333333,0.3333333333333333
print("{:f},{:e}".format(y, y)) # 0.333333,3.333333e-01
print("{:.3e},{:.3e}".format(y, y)) # 0.333,3.333e-01
print("{:.17f},{:.17e}".format(y, y)) # 0.33333333333333331,3.33333333333333315e-01
z = 4.0
print("{},{}".format(z, z)) # 4.0,4.0
print("{:f},{:e}".format(z, z)) # 4.000000,4.000000e+00
print("{:.3f},{:.3e}".format(z, z))  # 4.000,4.000e+00
print("{:.17f},{:.17e}".format(z, z))# 4.00000000000000000,4.00000000000000000e+00
w = (1.0 / 3.0) * 1e150
print("{},{}".format(w, w)) # 3.333333333333333e+149,3.333333333333333e+149
print("{:f},{:e}".format(w, w)) # 333333333333333311802(...150桁分)9120.000000,3.333333e+149
print("{:.3f},{:.3e}".format(w, w)) # 333333333333333311802(...150桁分)9120.000,3.333e+149
print("{:.17f},{:.17e}".format(w, w)) # 333333333333333311802(...150桁分)9120.00000000000000000,3.33333333333333312e+149

x1 = 1.07; x2 = -23.4; x3 = 0

x1 = 2.0/3.0 *1e150; x2 = -23.4; x3 = 0

str1 = "hello"
str2 = "this is"
str3 = "a"
print("{},{},{}".format(str1, str2, str3)) # hello,this is,a
print("{:10s},{:10s},{:10s}".format(str1, str2, str3)) # hello     ,this is   ,a

str1 = "hello";  str2 = "this is";  str3 = "a"

x = np.array([1.234567, 89.012345, 678.901234], dtype=float)
y = np.array([9.876543, 21.098765, 432.109876], dtype=float)
n = np.array([1,2,3], dtype=int)

# 最も推奨
combined_array = np.column_stack((n, x, y))
with open("output_17f_17e.txt", "w") as file:
    np.savetxt(file, combined_array, fmt=("%d", "%.17f", "%.17e"))

# for 文で逐次的に出力：明解だが遅い
with open("output_for.txt", "w") as file:
    for i in range(len(x)):
        file.write("{} {} {}\n".format(n[i], x[i], y[i]))

# 同一の型で同一サイズの場合、結合して出力：型・サイズは同一の場合
data = np.column_stack((x, y))
with open("output_same.txt", "w") as file:
    np.savetxt(file, data, fmt="%.6f", delimiter=" ")

# 異なる型, 結合, 書式指定：サイズは同一の場合
combined_array = np.column_stack((n, x, y))
with open("output_each.txt", "w") as file:
    np.savetxt(file, combined_array, fmt=("%d", "%.2f", "%.3f"))

import numpy as np

if __name__ == '__main__':
    # 4x4の二次元配列を作成
    xx = np.random.rand(4, 4)

    # 方法1. 連結して出力、早い
    row_indices = np.arange(xx.shape[0])  # 行番号の配列を作成
    array_with_row_indices = np.column_stack((row_indices, xx))  # 横方向に連結
    np.savetxt("output_with_row_indices.txt", array_with_row_indices, fmt="%d %.4f %.4f %.4f %.4f")

    # 方法2. for文で愚直に：明解だが遅い
    with open("output_direct_access.txt", "w") as file:
        for i in range(xx.shape[0]):
            file.write(f"{i:d} ")  # 行番号を書き込み, f-string使用
            for j in range(xx.shape[1]):
                file.write(f"{xx[i, j]:.4f} ")  # 配列の要素を直接書き込み, f-string使用
            file.write("\n")  # 改行

# output_with_row_indices.txt, output_direct_access.txtの出力例
0 0.1567 0.0359 0.8930 0.3195
1 0.5033 0.6877 0.7716 0.9325
2 0.7364 0.5647 0.0922 0.9466
3 0.0662 0.9055 0.7820 0.5955

import csv
import numpy as np

# 各列のデータ
integers = np.array([1, 2, 3])
strings = np.array(["apple", "banana", "cherry"])
floats = np.array([1.5, 2.5, 1.0/3.0])
complex_numbers = np.array([complex(1, 2), complex(3, 4), complex(5, 6)])

# CSVファイルにデータを書き込む
with open("mixed_data.csv", mode="w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    for i, s, f, c in zip(integers, strings, floats, complex_numbers):
        writer.writerow([i, s, f, c.real, c.imag])

integers,strings,floats,complex_real,complex_imag
1,apple,1.5,1.0,2.0
2,banana,2.5,3.0,4.0
3,cherry,0.3333333333333333,5.0,6.0

import pandas as pd
import numpy as np

# CSVファイルを読み込む
df = pd.read_csv("mixed_data.csv", header=None, names=["integers", "strings", "floats", "complex_real", "complex_imag"])

# 各列をそれぞれの型のndarrayに変換する
integer_array = df["integers"].values
string_array = df["strings"].values
float_array = df["floats"].values
complex_array = df["complex_real"].values + 1j * df["complex_imag"].values

print("Integer array:", integer_array)
print("String array:", string_array)
print("Float array:", float_array)
print("Complex array:", complex_array)

import csv
import numpy as np

# タイトル名
titles = ["integers", "strings", "floats", "complex_real", "complex_imag"]

# 各列のデータ
integers = np.array([1, 2, 3])
strings = np.array(["apple", "banana", "cherry"])
floats = np.array([1.5, 2.5, 3.5])
complex_numbers = np.array([complex(1, 2), complex(3, 4), complex(5, 6)])

# CSVファイルにデータを書き込む
with open("mixed_data_with_titles.csv", mode="w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)

    # タイトル名を書き込む
    writer.writerow(titles)

    # データを書き込む
    for i, s, f, c in zip(integers, strings, floats, complex_numbers):
        writer.writerow([i, s, f, c.real, c.imag])

integers,strings,floats,complex_real,complex_imag
1,apple,1.5,1.0,2.0
2,banana,2.5,3.0,4.0
3,cherry,3.5,5.0,6.0

import pandas as pd
import numpy as np

# CSVファイルを読み込む
df = pd.read_csv("mixed_data_with_titles.csv")

# 各列をそれぞれの型のndarrayに変換する
integer_array = df["integers"].values
string_array = df["strings"].values
float_array = df["floats"].values
complex_array = df["complex_real"].values + 1j * df["complex_imag"].values

print("Integer array:", integer_array)
print("String array:", string_array)
print("Float array:", float_array)
print("Complex array:", complex_array)

data = np.column_stack((x, y, z))
np.savetxt("output_np.txt", data, fmt="%.6f", delimiter=" ")

import numpy as np

# ファイルを読み込む
data = np.loadtxt("output_np.txt")

# 配列をx, y, zに分割する
x, y, z = data[:, 0], data[:, 1], data[:, 2]

import numpy as np

# data.txtを読み込み、各列をそれぞれの型に変換
data = np.loadtxt("data.txt", dtype='object', comments=None, delimiter=" ")

# 各列を指定した型のndarrayに変換
n = data[:, 0].astype(int)
x = data[:, 1].astype(float)
z_real = data[:, 2].astype(float)
z_imag = data[:, 3].astype(float)
z = z_real + z_imag * 1j  # 複素数型のndarrayに変換
str_array = data[:, 4].astype(str)

# 確認
print("n:", n)
print("x:", x)
print("z:", z)
print("str_array:", str_array)

with open('./test.txt') as f:
    for line in f:
       print(line, type(line))

sin cos
11223
959.202

re q 22
11 404

sin cos
 <class 'str'>
11223
 <class 'str'>
959.202
 <class 'str'>

 <class 'str'>
re q 22
 <class 'str'>
11 404
 <class 'str'>

import numpy as np

# 5x5の二次元ndarrayの実数行列を作成
matrix = np.random.rand(5, 5)

# テキストファイルに行列を書き出す
np.savetxt('matrix.txt', matrix, fmt='%f')

0.598899 0.791573 0.453733 0.156499 0.541144
0.499096 0.553211 0.029028 0.189387 0.489296
0.333952 0.274784 0.667436 0.169884 0.937856
0.563854 0.839040 0.982666 0.650543 0.770184
0.213031 0.653024 0.021765 0.205727 0.701766

import numpy as np

# テキストファイルから行列を読み込む
loaded_matrix = np.loadtxt('matrix.txt')

print(type(loaded_matrix))
print(loaded_matrix)

<class 'numpy.ndarray'>
[[0.598899 0.791573 0.453733 0.156499 0.541144]
 [0.499096 0.553211 0.029028 0.189387 0.489296]
 [0.333952 0.274784 0.667436 0.169884 0.937856]
 [0.563854 0.83904  0.982666 0.650543 0.770184]
 [0.213031 0.653024 0.021765 0.205727 0.701766]]

for i in range(5):
    print(i) # out: 0 1 2 3 4 (改行は省略)

my_list = ['apple', 'banana', 'cherry']

for item in my_list:
    print(item) # apple banana cherry (改行は省略)

my_list = ['apple', 'banana', 'cherry']

for index, item in enumerate(my_list):
    print(f"{index} {item}")

0 apple
1 banana
2 cherry

squares = [x**2 for x in range(5)]
print(squares) # [0, 1, 4, 9, 16]

list1 = [1, 2, 3]
list2 = [4, 5, 6]

for a, b in zip(list1, list2):
    print(a, b)

1 4
2 5
3 6

list1 = ['a', 2, 3.0]
list2 = [4.0, 5.1, 6]
list3 = ['g', 'h', 'i']

for index, (elem1, elem2, elem3) in enumerate(zip(list1, list2, list3)):
    print(f"{index}  {elem1} {elem2} {elem3}")

0  a 4.0 g
1  2 5.1 h
2  3.0 6 i

x = 10

if x > 5:
    print("x is greater than 5")

# "x is greater than 5"

x = 10

if x > 20:
    print("x is greater than 20")
elif x > 10:
    print("x is greater than 10 but less than or equal to 20")
else:
    print("x is less than or equal to 10")

# "x is less than or equal to 10"

x = 10
result = "x is even" if x % 2 == 0 else "x is odd"
print(result) # 0

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
even_squares = [x ** 2 for x in numbers if x % 2 == 0]
print(even_squares)  # [4, 16, 36, 64]

x = 5
y = 10

print(x == y)  # False
print(x != y)  # True
print(x < y)   # True
print(x > y)   # False
print(x <= y)  # True
print(x >= y)  # False

x = 5

# andの使用例
if x > 0 and x < 10:
    print("x is between 0 and 10")

# orの使用例
if x < 0 or x > 10:
    print("x is outside the range of 0 to 10")
else:
    print("x is within the range of 0 to 10")

# notの使用例
if not (x == 0):
    print("x is not equal to 0")

fruits = ["apple", "banana", "orange"]

if "apple" in fruits:
    print("Apple is in the list of fruits")
else:
    print("Apple is not in the list of fruits")

# Apple is in the list of fruits

text = "Hello, world!"

if "o, worl" in text:
    print("The word 'world' is in the text")
else:
    print("The word 'world' is not in the text")

# The word 'o, worl' is in the text

fruits = ["apple", "banana", "orange"]

if "grape" not in fruits:
    print("Grape is not in the list of fruits")
else:
    print("Grape is in the list of fruits")

# Grape is not in the list of fruits

x = [1, 2, 3]
y = [1, 2, 3]
z = x

if x is y:
    print("x and y are the same object")
else:
    print("x and y are different objects")

# x and y are different objects

if x is z:
    print("x and z are the same object")
else:
    print("x and z are different objects")

# x and z are the same object

x = [1, 2, 3]
y = [1, 2, 3]

if x is not y:
    print("x and y are not the same object")
else:
    print("x and y are the same object")

import numpy as np

def func(i:int, j:int) -> float:
    return 10.0 *i * j

if __name__ == '__main__':
    x = func(3,5)
    print(x) # 150.0

import numpy as np

def func(i, j):
    return 10.0 *i * j

if __name__ == '__main__':
    x = func(3,5)
    print(x) # 150.0

def func(i: int, j: int) -> float:
    return 0.1 * i * j

from typing import List, Tuple


def example_function(tuple_arg: Tuple[int, int], list_arg: List[int]) -> None:
    print(f"Tuple argument: {tuple_arg}")
    print(f"List argument: {list_arg}")


if __name__ == "__main__":
    example_tuple = (1, 2)  # mutable
    example_list = [3, 4, 5]  # immutable

    example_function(example_tuple, example_list)

import numpy as np


def matrix_multiply(n: np.int32, A: np.ndarray, B: np.ndarray) -> np.ndarray:
    C = n * np.dot(A, B)
    return C


if __name__ == "__main__":

    A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float64)
    B = np.array([2, 3, 4], dtype=np.float64)

    result = matrix_multiply(np.int64(2), A, B)
    print(result) # Out: [ 40.  94. 148.]

from numpy.typing import NDArray
def myfunc(t: np.float64, x: NDArray[np.float64]) -> None:

from my_class import MyClass
def myfunc(p: MyClass) -> int:

def func(i, j):
    return 0.1 * i * j

def func(i: int, j: int) -> float:
    """
    Calculate the product of i and j, multiplied by 0.1.

    Args:
        i (int): The first integer.
        j (int): The second integer.

    Returns:
        float: The result of the calculation.
    """
    return 0.1 * i * j

import numpy as np


def matrix_multiply(n: np.int32, A: np.ndarray, B: np.ndarray) -> np.ndarray:
    """
    Calculate the product of a 2D NxN ndarray A and a 1D N-row ndarray B.

    Parameters:
    n (np.int32): Scalar multiplier
    A (numpy.ndarray): A 2D NxN ndarray
    B (numpy.ndarray): A 1D N-row ndarray

    Returns:
    numpy.ndarray: The resulting product of the matrix multiplication
    """
    C = n * np.dot(A, B)
    return C


if __name__ == "__main__":

    A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=np.float64)
    B = np.array([2, 3, 4], dtype=np.float64)

    result = matrix_multiply(np.int64(2), A, B)
    print(result) # Out: [ 40.  94. 148.]

from typing import Union

def process_input(value: Union[int, str]) -> int:
    if isinstance(value, int):
        return value
    elif isinstance(value, str):
        return len(value)
    else:
        raise TypeError("Invalid input type. Expected int or str.")

try:
    # ここにエラーが発生する可能性のあるコードを書く
    x = 1 / 0
except:
    # ここにエラーが発生したときの処理を書く
    print("An error occurred")

if drink_type == "tea":
    # teaの場合の処理
elif drink_type == "coffee":
    # coffeeの場合の処理
else:
    raise ValueError(f"Unexpected component: your drink_type = {drink_type}")

try:
    # ここにエラーが発生する可能性のあるコードを書く
    x = 1 / 0
except ZeroDivisionError:
    # ゼロ除算エラーが発生したときの処理を書く
    print("Divided by zero")
except TypeError:
    # 型エラーが発生したときの処理を書く
    print("Wrong type")
# ...

try:
    # ここにエラーが発生する可能性のあるコードを書く
    x = 1 / 0
except ZeroDivisionError:
    # ゼロ除算エラーが発生したときの処理を書く
    print("Divided by zero")
finally:
    # ここには、エラーが発生しようがしまいが、必ず実行されるコードを書く
    print("This will always be printed")

Divided by zero
This will always be printed

try:
    try:
        # 内側のtryブロック
        x = 1 / 0
    except ValueError:
        print("This will not catch a division by zero error")
    # その他のコード...
except ZeroDivisionError:
    print("This will catch the division by zero error")

This will catch the division by zero error

class Person:
    def __init__(self, name: str, age: int): # コンストラクタ
        self.name = name # インスタンス変数
        self.age = age   # インスタンス変数

    def greet(self):     # クラスメソッド
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")


class Student(Person):   # Personクラスの継承 (Personクラスが基底、StudentクラスがPersonクラスの派生)
    def __init__(self, name: str, age: int, student_id: int): # コンストラクタ
        super().__init__(name, age)   # super()は、基底クラスの関数を呼び出すための関数
        self.student_id = student_id  # インスタンス変数

    def greet(self):     # クラスメソッド
        super().greet()  # 基底クラスのメソッドの呼び出し
        print(f"My student ID is {self.student_id}.")


if __name__ == "__main__":
    person = Person("Alice", 30)
    person.greet()

    student = Student("Bob", 20, 12345)
    student.greet()

Hello, my name is Alice and I am 30 years old.
Hello, my name is Bob and I am 20 years old.
My student ID is 12345.

import math

class Vector2D:
    def __init__(self, x: float, y: float):
        self.x = x # インスタンス変数
        self.y = y # インスタンス変数

    def length(self) -> float: # クラスメソッド
        return math.sqrt(self.x ** 2 + self.y ** 2)

    def dot_product(self, other: 'Vector2D') -> float: # クラスメソッド
        return self.x * other.x + self.y * other.y

    def __str__(self) -> str: # 特殊メソッド（オブジェクトを文字列形式で表現する際に使用される。オブジェクトの文字列表現がカスタマイズされる）
        return f"({self.x}, {self.y})"


class UnitVector2D(Vector2D): # Vector2Dの派生クラス
    def __init__(self, x: float, y: float): # コンストラクタ
        length = math.sqrt(x ** 2 + y ** 2)
        super().__init__(x / length, y / length) # 基底クラスのコンストラクタ継承

    def length(self) -> float: # 基底クラスのlengthメソッドをoverride
        return 1.0


if __name__ == "__main__":
    vector1 = Vector2D(3, 4)
    vector2 = Vector2D(1, 2)

    print("Vector 1:", vector1)
    print("Vector 2:", vector2)
    print("Dot product:", vector1.dot_product(vector2))

    unit_vector1 = UnitVector2D(3, 4)
    print("Unit vector 1:", unit_vector1)
    print("Length of unit vector 1:", unit_vector1.length())

Vector 1: (3, 4)
Vector 2: (1, 2)
Dot product: 11
Unit vector 1: (0.6, 0.8)
Length of unit vector 1: 1.0

import math

class Vector2D:
    num_vectors = 0  # クラス変数

    def __init__(self, x: float, y: float):
        self.x = x  # インスタンス変数
        self.y = y  # インスタンス変数
        Vector2D.num_vectors += 1  # クラス変数の更新

    def magnitude(self) -> float:
        return math.sqrt(self.x**2 + self.y**2)

    @classmethod  # クラスメソッドのデコレータ
    def num_vectors_created(cls) -> int:
        return cls.num_vectors

# 継承
class NamedVector2D(Vector2D):
    def __init__(self, x: float, y: float, name: str):
        super().__init__(x, y)  # コンストラクタの継承
        self.name = name  # インスタンス変数

    def __str__(self):
        return f"{self.name}: ({self.x}, {self.y})"

if __name__ == "__main__":
    vec1 = NamedVector2D(3, 4, "vec1")
    vec2 = NamedVector2D(5, 12, "vec2")
    print(vec1)  # vec1: (3, 4)
    print(vec2)  # vec2: (5, 12)
    print(f"Total vectors created: {Vector2D.num_vectors_created()}")  # Total vectors created: 2

class Person:
    _population = 0 # クラス変数の定義

    def __init__(self, name: str, age: int):
        self._name = name # インスタンス変数
        self._age = age # インスタンス変数
        Person._population += 1 # クラス変数の更新

    @property # ゲッター (getter)
    def name(self) -> str:
        return self._name

    @property # ゲッター (getter)
    def age(self) -> int:
        return self._age

    @age.setter # セッター (@<attribute>.setterデコレータ)
    def age(self, age: int):
        if age >= 0:
            self._age = age
        else:
            raise ValueError("Age must be a positive integer.")

    @classmethod # クラスメソッド
    def get_population(cls) -> int:
        return cls._population

    @staticmethod # 静的メソッド
    def is_adult(age: int) -> bool:
        return age >= 18


if __name__ == "__main__":
    alice = Person("Alice", 30)
    bob = Person("Bob", 15)

    print("Alice's name:", alice.name)
    print("Alice's age:", alice.age)
    print("Bob's name:", bob.name)
    print("Bob's age:", bob.age)

    bob.age = 18
    print("Bob's new age:", bob.age)

    print("Is Alice an adult?", Person.is_adult(alice.age))
    print("Is Bob an adult?", Person.is_adult(bob.age))

    print("Total population:", Person.get_population())

Alice's name: Alice
Alice's age: 30
Bob's name: Bob
Bob's age: 15
Bob's new age: 18
Is Alice an adult? True
Is Bob an adult? True
Total population: 2

class MyClass:
    def __init__(self, arg1, arg2):
        self.arg1 = arg1
        self.arg2 = arg2

class MyClass:
    # ...

    def some_method(self, x):
        return self.arg1 * x + self.arg2

class MyClass:
    class_variable = "Shared value"

    def __init__(self, arg1, arg2):
        self.instance_variable1 = arg1
        self.instance_variable2 = arg2

class MyBaseClass:
    def method1(self):
        pass

class MyDerivedClass(MyBaseClass):
    def method2(self):
        pass

class MyClass:
    def __init__(self, x:int):
        self._x = x

    @property
    def x(self) -> int:
        print("Getting x value")
        return self._x

    @x.setter
    def x(self, value):
        print("Setting x value")
        self._x = value

obj = MyClass(10)
print(obj.x)  # Getting x value と出力された後、10が出力される
obj.x = 20    # Setting x value と出力される

class MyClass:
    def __init__(self, x):
        self.x = x

obj = MyClass(10)
print(obj.x)  # 10が出力される
obj.x = 20

class Circle:
    def __init__(self, radius):
        self.radius = radius

    @property
    def diameter(self):
        return 2 * self.radius

    @diameter.setter
    def diameter(self, value):
        self.radius = value / 2

circle = Circle(5)
print(circle.diameter)  # 10
circle.diameter = 12
print(circle.radius)  # 6

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def get_diameter(self):
        return 2 * self.radius

    def set_diameter(self, value):
        self.radius = value / 2

circle = Circle(5)
print(circle.get_diameter())  # 10
circle.set_diameter(12)
print(circle.radius)  # 6

class MyClass:
    class_var = 0

    def __init__(self, x):
        self.instance_var = x

obj = MyClass(10)
print(obj.instance_var)  # インスタンス変数にアクセス：10
print(MyClass.class_var)  # クラス変数にアクセス：0

project_directory/
│
├── main.py
├── my_module0.py
│
└── my_package/
    └── my_module1.py

def function0():
    return "Hello from function0 in my_module0!"

def function1():
    return "Hello from function1 in my_module1!"

from my_module0 import function0
from my_package.my_module1 import function1

print(function0())  # Outputs: Hello from function0 in my_module0!
print(function1())  # Outputs: Hello from function1 in my_module1!