【Python】List(リスト)の基本(生成・参照と更新~連結・比較)【データ構造】

# []を使ったリスト作成の基本

# 要素が整数の場合
numbers = [4, 8, 15, 16, 23, 42]
print(numbers)
# ➀>> [4, 8, 15, 16, 23, 42]

# 要素が文字列の場合
colors = ["red", "green", 'blue']
print(colors)
# ➁>> ['red', 'green', 'blue']

# 要素が整数と文字列、ブール値の混在
mixture = [1, 2, 3, "a", "b", "c", True, False]
print(mixture)
# ➂>> [1, 2, 3, 'a', 'b', 'c', True, False]

a = 10      # 変数を初期化する
b = 20
c = 30
d = 'ABC'
e = True

#----------------------------------------------------------------------
# 変数を要素に指定してリストを定義する

result = [a, b, c, d, e]
print(result)

# ➃>> [10, 20, 30, 'ABC', True] 変数の値を要素とするリストが作成される

list_obj = [1, 2, 4]
dict_obj = {"key1": 1, "key2" : 2}
tuple_obj = ('a', 'b', 'c')

#----------------------------------------------------------------------
# リスト, 辞書(ミュータブル), タプル(イミュータブル)を要素にする

print([list_obj, dict_obj, tuple_obj])
# ➄>> [[1, 2, 4], {'key1': 1, 'key2': 2}, ('a', 'b', 'c')]

# list関数の引数にイテラブルなオブジェクトを使ったリストの作成例

# 引数にrangeオブジェクト(始点,終点)を指定
list_range = list(range(-2, 2))
print(list_range)
# ➀>> [-2, -1, 0, 1]

# 引数にrangeオブジェクト(始点,終点,ステップ)を指定
list_even = list(range(0, 10, 2))
print(list_even)
# ➁>> [0, 2, 4, 6, 8]

# 引数にrangeオブジェクトを指定し3の倍数をもつリストを生成
list_x3 = list(range(0, 15, 3))
print(list_x3)
# ➂>> [0, 3, 6, 9, 12]

#-----------------------------------------------------------------------------------------------
# list関数の引数にその他イテラブルなオブジェクトを使ったリストの作成

# 引数にタプルを指定
list_tuple = list((1,2,3,4))
print(list_tuple)
# ➃>> [1, 2, 3, 4]

# 引数に辞書を指定(keyのみ要素となることに注意)
list_dict = list({'key1':1, 'key2':2})
print(list_dict)
# ➄>> ['key1', 'key2']

# list関数の引数に文字列を指定したリストの作成例

list_words = list("日月火水木金土")
print(list_words)
# >> ['日', '月', '火', '水', '木', '金', '土']

list_words = list("Hello World")
print(list_words)
# >> ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']

#-----------------------------------------------------------------------------------------------
# list関数の引数を省略した場合

list_brank = list()    #引数なし
print(list_brank)
# >> []

# 単純(一次)リストの参照と更新

#--------------------------------------------------------------------
# インデックスをつかったリストの参照

words = ["blue", "red", "green", "yellow"] # 元のリスト

#インデックスを前方基準で参照する場合

print(words[0])     # >>blue  先頭の要素のインデックスを「0」とする
print(words[1])     # >>red
print(words[2])     # >>green
print(words[3])     # >>yellow


#インデックスを後方基準で参照する場合

print(words[-1])    # >>yellow　末尾の要素のインデックスを「-1」とする
print(words[-2])    # >>green
print(words[-3])    # >>red
print(words[-4])    # >>blue

print(words)        # >>['blue', 'red', 'green', 'yellow'] 元のリストは維持される

# インデックスをつかったリストの更新

# 先頭要素を「1234」に切り替える
words[0] = 1234
print(words)       # ➀>> [1234, 'red', 'green', 'yellow']

# 末尾の要素を「4321」に切り替える
words[-1] = 4321
print(words)       # ➁>> [1234, 'red', 'green', 4321]

# 多重リスト（２次元）の参照と更新

#--------------------------------------------------------------------
# 元のリスト

list_a = [["apple", "peach", "orange"], ["cabbage", "carrot", "potato"]]
print(list_a)   # >>[['apple', 'peach', 'orange'], ['cabbage', 'carrot', 'potato']]

#---------------------------------------------------------------------
# 親要素の参照

print(list_a[0])    # >>['apple', 'peach', 'orange']
print(list_a[1])    # >>['cabbage', 'carrot', 'potato']

#---------------------------------------------------------------------
# 子要素の参照

# 親要素インデックス「0」の子要素の参照
print(list_a[0][0])    # >> apple
print(list_a[0][1])    # >> peach
print(list_a[0][2])    # >> orange

# 親要素インデックス「1」の子要素の参照
print(list_a[1][0])    # >> cabbage
print(list_a[1][1])    # >> carrot
print(list_a[1][2])    # >> potato

# 親要素の更新--------------------------------

# 親要素のインデックス「0」を更新
list_a[0] = [123, 456]
print(list_a)      # ➀>>[[123, 456], ['cabbage', 'carrot', 'potato']]

# 子要素の更新--------------------------------

# 親要素のインデックス「1」、子要素のインデックス「1」を更新
list_a[1][1] = 456
print(list_a)      # ➁>>[[123, 456], ['cabbage', 456, 'potato']]

# 多重リスト（３次元）の参照と更新

#--------------------------------------------------------------------
# 元のリスト
list_b = [[["a", "b"], ["c", "d"]], [["e", "f"], ["g", "h"]]]
print(list_b) # >>[[['a', 'b'], ['c', 'd']], [['e', 'f'], ['g', 'h']]]

#---------------------------------------------------------------------
# 親要素の参照

print(list_b[0])        # ➀_1>> [['a', 'b'], ['c', 'd']]
print(list_b[1])        # ➀_2>> [['e', 'f'], ['g', 'h']]

#---------------------------------------------------------------------
# 子要素の参照

print(list_b[0][0])     # ➁_1>> ['a', 'b']
print(list_b[0][1])     # ➁_2>> ['c', 'd']
print(list_b[1][0])     # ➁_3>> ['e', 'f']
print(list_b[1][1])     # ➁_4>> ['g', 'h']

#---------------------------------------------------------------------
# 孫要素の参照

print(list_b[0][0][0])  # ➂_1>> a
print(list_b[0][0][1])  # ➂_2>> b
print(list_b[0][1][0])  # ➂_3>> c
print(list_b[0][1][1])  # ➂_4>> d
print(list_b[1][0][0])  # ➂_5>> e
print(list_b[1][0][1])  # ➂_6>> f
print(list_b[1][1][0])  # ➂_7>> g
print(list_b[1][1][1])  # ➂_8>> h

#---------------------------------------------------------------------
# 親要素の更新

list_b[0] = [1, [2, 3]]
print(list_b)      # ➃>> [[1, [2, 3]], [['e', 'f'], ['g', 'h']]]

# 子要素の更新
list_b[1][1] = 4
print(list_b)      # ➄>> [[1, [2, 3]], [['e', 'f'], 4]]

# 孫要素の更新
list_b[1][0][1] = 5
print(list_b)      # ➅>> [[1, [2, 3]], [['e', 5], 4]]

# スライスによるリストの参照(インデックスの前方基準)

words = ["blue", "red", "green", "yellow", "pink", "black", "white"] # 元のリスト
#-------------------------------------------------------------------------------------

# 開始・終了位置を省略した場合は、「要素全てを抽出」
print(words[:])     # ➀>> ['blue', 'red', 'green', 'yellow', 'pink', 'black', 'white']

# 終了位置を省略した場合は末尾までが範囲　「インデックス３～末尾迄の要素」
print(words[3:])    # ➁>> ['yellow', 'pink', 'black', 'white']

# 開始位置を省略した場合は先頭からが反に　「先頭～インデックス３の要素」
print(words[:3])    # ➂>> ['blue', 'red', 'green']

# インデックス３～５の間の要素
print(words[3:5])    # ➃>> ['yellow', 'pink']

#-------------------------------------------------------------------------------------

# 元のリストはそのまま変更されることはない
print(words)         # ➄>> ['blue', 'red', 'green', 'yellow', 'pink', 'black', 'white']

# スライスによるリストの参照(インデックスの後方基準)

words = ["blue", "red", "green", "yellow", "pink", "black", "white"] # 元のリスト
#-------------------------------------------------------------------------------------

# 最後の要素
print(words[-1:])               # ➀>> ['white']

# 最後から２番目～最後の要素
print(words[-2:])               # ➁>> ['black', 'white']

# 最後から3番目～最後の要素
print(words[-3:-1])             # ➂>> ['pink', 'black']

# 最後の要素を除く全ての要素
print(words[:-1])               # ➃>> ['blue', 'red', 'green', 'yellow', 'pink', 'black']

# スライスによるリストの参照(ステップを指定した場合)

letters = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j" ] # 元のリスト
#-------------------------------------------------------------------------------------

# 先頭から末尾まで１個飛ばしの要素を抽出
print(letters[::2])        # ➀>> ['a', 'c', 'e', 'g', 'i']

# 2番目の要素から末尾まで１個飛ばしの要素を抽出
print(letters[1::2])        # ➁>> ['b', 'd', 'f', 'h', 'j']

# 2番目の要素から8番目の要素まで１個飛ばしの要素を抽出
print(letters[1:7:2])        # ➂>> ['b', 'd', 'f']

#-------------------------------------------------------------------------------------

# ステップ数に1を指定すると、stepを省略した結果と変わらない
print(letters[::1])         # ➃>> ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

# +演算子, +=代入演算子を使ったリストの連結

#--------------------------------------------------------
# +演算子によるリストの連結

# ➀ +演算子でリストを連結(後置)
list_a = ['a','b','c']
list_a = list_list + [1, 2, 3]
print(list_a)    # >>['a', 'b', 'c', 1, 2, 3]

# ➁ +演算子でリストを連結(前置)
list_a = [4, 5, 6] + list_a
print(list_a)    # >>[4, 5, 6, 'a', 'b', 'c', 1, 2, 3, 1, 2, 3]

# ➂ 連結できるリスト数に制限はない
list_b = [1, 2] + ['a', 'b'] + [3, 4] + ['c', 'd']
print(list_b)    # >>[1, 2, 'a', 'b', 3, 4, 'c', 'd']

#--------------------------------------------------------

# ➃ +=代入演算子によるリストの連結
list_c = []
list_c += ['abc']
list_c += ['efg', 1, 2, 3]    
print(list_c)    # >>['abc', 'efg', 1, 2, 3]

# 同じ要素が繰り返し入ってくるリストを作る

# 0の要素を10個もつリストをつくる
nums = [0]*10
print(nums)
# >> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

# "xyz"の要素を10個もつリストをつくる
strs = ["xyz"]*5
print(strs)
# >> ['xyz', 'xyz', 'xyz', 'xyz', 'xyz']

# 1, 2, 3の組合せの要素を3つもつリストをつくる
data = [1,2,3]*3
print(data)
# >>[1, 2, 3, 1, 2, 3, 1, 2, 3]

# extend()メソッドを使ったリストの連結

data_1 = [1, 2, 3]
data_2 = ['a', 'b', 'c']

# ➀ extend()メソッドの実行(data_1にdata_2を連結)
data_1.extend(data_2)
print(data_1)            # >>[1, 2, 3, 'a', 'b', 'c']

data_1 = [1, 2, 3] # 元リストの初期化

# ➁ extend()メソッドの実行(data_2にdata_1を連結)
data_2.extend(data_1)
print(data_2)            # >>['a', 'b', 'c', 1, 2, 3]

# append()メソッドとの違い

data_1 = [1, 2, 3]
data_2 = ['a', 'b', 'c']

# append()メソッドの実行(data_1にdata_2を追加)
data_1.append(data_2)
print(data_1)            # >>[1, 2, 3, ['a', 'b', 'c']]

# リストオブジェクトの比較

# 値(要素)が全く同じリストオブジェクトを定義
list_a = ['a', 'b', 'c']
list_b = ['a', 'b', 'c']

# (1)----------------------------------------------------------
# 値の比較する演算子「==」ではTrueとなり等しいと判定
print(list_a == list_b) # >>True

# (2)----------------------------------------------------------
# オブジェクトを比較する演算子 「is」ではFalseとなり等しくない
print(list_a is list_b) # >>False

# オブジェクトのIDは不一致である
print(id(list_a)) # 2248836469000     (2)-1 オブジェクトID
print(id(list_b)) # 2248837134088     (2)-2 オブジェクトID

# (3)----------------------------------------------------------
# 別オブジェクトであることを確かめる
list_a.append('d') # list_aの要素に変更を加える

print(list_a) # >>['a', 'b', 'c', 'd']  (3)-1
print(list_b) # >>['a', 'b', 'c']　  (3)-2 list_bにはlist_aの変更は反映されない

# リストオブジェクトの比較

# 値(要素)が全く同じリストオブジェクトを定義
list_a = ['a', 'b', 'c']

list_b = list_a # list_aの参照先をList_bと共有する

# (1)----------------------------------------------------------
# 値の比較する演算子「==」ではTrueとなり等しいと判定
print(list_a == list_b) # >>True

# (2)----------------------------------------------------------
# オブジェクトを比較する演算子 「is」ではTrueとなり等しいと判定
print(list_a is list_b) # >>True

# オブジェクトのIDは一致する
print(id(list_a)) # 2248838681480     (2)-1 オブジェクトID
print(id(list_b)) # 2248838681480     (2)-2 オブジェクトID

# (3)----------------------------------------------------------
# 同一オブジェクトであることを確かめる
list_a.append('d') # list_aの要素に変更を加える

print(list_a) # >>['a', 'b', 'c', 'd']  (3)-1
print(list_b) # >>['a', 'b', 'c', 'd']  (3)-2 ※list_bにもlist_aの変更が反映される

import array

arr_int = array.array('i', [0, 1, 2])
print(arr_int)
# >>array('i', [1, 2, 3])

arr_float = array.array('f', [0.0, 0.1, 0.2])
print(arr_float)
# >>array('f', [0.10000000149011612, 0.20000000298023224, 0.30000001192092896])

import numpy as np

ndarr_1d = np.array([1, 2, 3])
print(ndarr_1d)
# >>[1 2 3]

ndarr_2d = np.array([[1, 2, 3], [4, 5, 6]])
print(ndarr_2d)
# >>[[1 2 3]
# >> [4 5 6]]