Pythonで等差数列を簡単に作成する方法と実例8選

# 0から10まで、2ずつ増加する等差数列を生成
arithmetic_sequence = range(0, 11, 2)

# 結果を表示
print(list(arithmetic_sequence))

# 1から20まで、3ずつ増加する等差数列を生成
arithmetic_sequence = [i for i in range(1, 21, 3)]

# 結果を表示
print(arithmetic_sequence)

# 初項、公差、項数を設定
a1 = 2  # 初項
d = 5   # 公差
n = 6   # 項数

# 空のリストを用意
arithmetic_sequence = []

# forループで等差数列を生成
for i in range(n):
    term = a1 + i * d
    arithmetic_sequence.append(term)

# 結果を表示
print(arithmetic_sequence)

import numpy as np

# 0から10まで、0.5刻みの等差数列を生成
arithmetic_sequence = np.arange(0, 10.5, 0.5)

# 結果を表示
print(arithmetic_sequence)

[ 0.   0.5  1.   1.5  2.   2.5  3.   3.5  4.   4.5  5.   5.5  6.   6.5
  7.   7.5  8.   8.5  9.   9.5 10. ]

# 小数点を含む等差数列を生成する関数
def decimal_arithmetic_sequence(start, stop, step):
    sequence = []
    current = start
    while current <= stop:
        sequence.append(round(current, 2))  # 小数点以下2桁に丸める
        current += step
    return sequence

# 1.5から5.5まで、0.7刻みの等差数列を生成
result = decimal_arithmetic_sequence(1.5, 5.5, 0.7)

# 結果を表示
print(result)

# 負の公差を持つ等差数列を生成
def negative_step_sequence(start, stop, step):
    return list(range(start, stop - 1, step))

# 10から-5まで、-3刻みの等差数列を生成
result = negative_step_sequence(10, -6, -3)

# 結果を表示
print(result)

def arithmetic_sequence_sum(a1, d, n):
    """
    等差数列の和を計算する関数
    a1: 初項
    d: 公差
    n: 項数
    """
    an = a1 + (n - 1) * d  # 末項を計算
    return n * (a1 + an) // 2  # 等差数列の和の公式を使用

# 初項5、公差3、項数10の等差数列の和を計算
result = arithmetic_sequence_sum(5, 3, 10)

# 結果を表示
print(f"等差数列の和: {result}")

# 検証のため、実際の数列を生成して和を計算
verification = sum(range(5, 5 + 3 * 10, 3))
print(f"検証結果: {verification}")

等差数列の和: 185
検証結果: 185

import matplotlib.pyplot as plt
import numpy as np

# 等差数列を生成
x = np.arange(0, 10, 0.5)
y = 2 * x + 1  # y = 2x + 1 の直線

# グラフを描画
plt.figure(figsize=(10, 6))
plt.plot(x, y, 'ro-')  # 赤い丸と線でプロット
plt.title('等差数列のグラフ')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True)

# グラフを表示
plt.show()

# エラーを引き起こすコード
sequence = range(0, 10.5, 0.5)

import numpy as np

# NumPyを使用した解決策
sequence = np.arange(0, 10.5, 0.5)
print(list(sequence))

# 自作関数を使用した解決策
def float_range(start, stop, step):
    while start < stop:
        yield round(start, 2)
        start += step

sequence = list(float_range(0, 10.5, 0.5))
print(sequence)

[0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0, 7.5, 8.0, 8.5, 9.0, 9.5, 10.0]
[0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0, 7.5, 8.0, 8.5, 9.0, 9.5, 10.0]

# メモリエラーを引き起こす可能性のあるコード
huge_sequence = list(range(10**9))

# ジェネレータを使用した解決策
def huge_range(n):
    i = 0
    while i < n:
        yield i
        i += 1

# 最初の10個の要素だけを表示
for num in huge_range(10**9):
    print(num)
    if num == 9:
        break

0
1
2
3
4
5
6
7
8
9

# エラーを引き起こすコード
sequence = list(range(0, 10, 2))
print(sequence[10])  # インデックス10は範囲外

sequence = list(range(0, 10, 2))

# インデックスの有効性を確認
def safe_access(lst, index):
    if 0 <= index < len(lst):
        return lst[index]
    else:
        return None

print(safe_access(sequence, 2))  # 有効なインデックス
print(safe_access(sequence, 10))  # 範囲外のインデックス

# 例外処理を使用
try:
    print(sequence[10])
except IndexError:
    print("指定されたインデックスは範囲外です。")

4
None
指定されたインデックスは範囲外です。

class ArithmeticSequence:
    def __init__(self, start, step, length):
        self.start = start
        self.step = step
        self.length = length

    def __iter__(self):
        return self

    def __next__(self):
        if self.length <= 0:
            raise StopIteration
        result = self.start
        self.start += self.step
        self.length -= 1
        return result

# 使用例
seq = ArithmeticSequence(0, 2, 5)
for num in seq:
    print(num)

0
2
4
6
8

import multiprocessing as mp

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

def parallel_arithmetic_sequence(start, step, total_length, num_processes):
    pool = mp.Pool(processes=num_processes)
    chunk_size = total_length // num_processes
    tasks = [(start + i * chunk_size * step, step, chunk_size) for i in range(num_processes)]
    results = pool.starmap(generate_subsequence, tasks)
    return [num for sublist in results for num in sublist]

if __name__ == '__main__':
    result = parallel_arithmetic_sequence(0, 2, 10, 2)
    print(result)

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

def prime_arithmetic_sequence(start, step):
    current = start
    while True:
        if is_prime(current):
            yield current
        current += step

# 使用例
gen = prime_arithmetic_sequence(2, 1)
primes = [next(gen) for _ in range(10)]
print(primes)