Python Language
リスト

Django Flask HTML GNU/Linux matplotlib MySQL opencv pandas Regular Expressions tensorflow
サーチ…


前書き

Python リストは、Pythonプログラムで広く使用されている一般的なデータ構造です。それらは他の言語でも見つけられ、しばしば動的配列と呼ばれます 。それらは変更可能であり、それらを索引付けおよびスライスすることができるシーケンス・データ型です。リストには、他のリストオブジェクトを含むさまざまな種類のオブジェクトを含めることができます。

構文

  • [値、値、...]
  • リスト（[iterable]）

備考

listは特定のタイプの繰り返し可能ですが、Pythonに存在する唯一のものではありません。場合によっては、 set 、 tuple 、またはdictionaryを使う方が良いでしょう

listはPythonで動的配列に与えられた名前です（C ++のvector<void*>やJavaのArrayList<Object>似ています）。リンクされたリストではありません。

要素へのアクセスは一定の時間内に行われ、非常に高速です。リストの末尾に要素を追加すると一定時間が償却されますが、しばらくの間はlist全体の割り当てとコピーが必要になることがありlist 。

リスト内包表記はリストに関連しています。

リスト値へのアクセス

Pythonリストはゼロインデックス化され、他の言語の配列のように動作します。 

lst = [1, 2, 3, 4]
lst[0]  # 1
lst[1]  # 2

リストの境界外のインデックスにアクセスしようとすると、 IndexErrorます。 

lst[4]  # IndexError: list index out of range

負のインデックスは、リストの最後から数えて解釈されます。 

lst[-1]  # 4
lst[-2]  # 3
lst[-5]  # IndexError: list index out of range

これは機能的には

lst[len(lst)-1]  # 4

リストは、 スライス表記をlst[start:end:step]として使用することを可能にします。スライス表記の出力は、index startからend-1までの要素を含む新しいリストです。オプションが省略された場合、 startデフォルトのリストの先頭に、リストのendまで、そして1にstepします： 

lst[1:]      # [2, 3, 4]
lst[:3]      # [1, 2, 3]
lst[::2]     # [1, 3]
lst[::-1]    # [4, 3, 2, 1] 
lst[-1:0:-1] # [4, 3, 2]
lst[5:8]     # [] since starting index is greater than length of lst, returns empty list
lst[1:10]    # [2, 3, 4] same as omitting ending index

これを念頭に置いて、リストの逆のバージョンを

lst[::-1]    # [4, 3, 2, 1]

負の量のステップ長を使用する場合、開始インデックスは終了インデックスより大きくなければなりません。そうでない場合、結果は空のリストになります。 

lst[3:1:-1] # [4, 3]

負のステップインデックスを使用することは、次のコードと同じです。 

reversed(lst)[0:2] # 0 = 1 -1
                   # 2 = 3 -1

使用されるインデックスは、負のインデックス付けで使用されるインデックスよりも1つ少なく、逆になります。

高度なスライス

リストがスライスされると、リストオブジェクトの__getitem__()メソッドがsliceオブジェクトと共に呼び出されます。 Pythonには、スライスオブジェクトを生成するためのスライスメソッドが組み込まれています。これを使用してスライスを保存し 、後で再利用することができます。 

data = 'chandan purohit    22 2000'  #assuming data fields of fixed length 
name_slice = slice(0,19)
age_slice = slice(19,21)
salary_slice = slice(22,None)

#now we can have more readable slices
print(data[name_slice]) #chandan purohit     
print(data[age_slice]) #'22'
print(data[salary_slice]) #'2000'

このクラスでは、 __getitem__をオーバーライドすることで、オブジェクトにスライス機能を提供することで、この機能を__getitem__に活用できます。

リストメソッドとサポートされる演算子

与えられたリストから始めてa ： 

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

  1. append(value) - リストの最後に新しい要素を追加します。 

    # Append values 6, 7, and 7 to the list
a.append(6)
a.append(7)
a.append(7)
# a: [1, 2, 3, 4, 5, 6, 7, 7]

# Append another list
b = [8, 9]
a.append(b)
# a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]]

# Append an element of a different type, as list elements do not need to have the same type
my_string = "hello world"
a.append(my_string)
# a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9], "hello world"]

    append()メソッドは、リストの最後に新しい要素を1つだけ追加することに注意してください 。リストを別のリストに追加すると、追加するリストは最初のリストの最後に1つの要素になります。 

    # Appending a list to another list
a = [1, 2, 3, 4, 5, 6, 7, 7]
b = [8, 9]
a.append(b)
# a: [1, 2, 3, 4, 5, 6, 7, 7, [8, 9]]
a[8]
# Returns: [8,9]

  2. extend(enumerable) - 別の列挙可能要素から要素を追加してリストを拡張します。 

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

# Extend list by appending all elements from b
a.extend(b)
# a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]

# Extend list with elements from a non-list enumerable:
a.extend(range(3))
# a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10, 0, 1, 2]

    リストは、 +演算子と連結することもできます。元のリストは変更されません。 

    a = [1, 2, 3, 4, 5, 6] + [7, 7] + b
# a: [1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]

  3. index(value, [startIndex]) - 入力値が最初に出現したときのインデックスを取得します。入力値がリストにない場合、 ValueError例外が発生します。 2番目の引数が指定された場合、指定されたインデックスで検索が開始されます。 

    a.index(7)
# Returns: 6

a.index(49) # ValueError, because 49 is not in a.

a.index(7, 7)
# Returns: 7

a.index(7, 8) # ValueError, because there is no 7 starting at index 8

  1. insert(index, value) - 指定されたindex直前にvalue挿入しvalue 。したがって、挿入後、新しい要素は位置indexを占有する。 

    a.insert(0, 0)  # insert 0 at position 0
a.insert(2, 5)  # insert 5 at position 2
# a: [0, 1, 5, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]

  1. pop([index]) - indexの項目を削除して返します。引数がなければ、リストの最後の要素を削除して返します。 

    a.pop(2)
# Returns: 5
# a: [0, 1, 2, 3, 4, 5, 6, 7, 7, 8, 9, 10]
a.pop(8)
# Returns: 7
# a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# With no argument:
a.pop()
# Returns: 10
# a: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

  2. remove(value) - 指定された値の最初のオカレンスを削除します。提供された値が見つからない場合、 ValueErrorが発生します。 

    a.remove(0)
a.remove(9)
# a: [1, 2, 3, 4, 5, 6, 7, 8]
a.remove(10)
# ValueError, because 10 is not in a

  3. reverse() - リストをその場で反転し、 Noneを返します。 

    a.reverse()
# a: [8, 7, 6, 5, 4, 3, 2, 1]

    リストを逆転させる他の方法もあります 。

  4. count(value) - リスト内の値の出現回数を数えます。 

    a.count(7)
# Returns: 2

  5. sort() - リストを数値順および辞書順にソートし、 Noneを返します。 

    a.sort()
# a = [1, 2, 3, 4, 5, 6, 7, 8]
# Sorts the list in numerical order

    sort()メソッドのreverse=Trueフラグを使用してソートすると、リストを逆にすることもできます。 

    a.sort(reverse=True)
# a = [8, 7, 6, 5, 4, 3, 2, 1]

    あなたがアイテムの属性でソートしたい場合は、使用することができkeyキーワード引数を： 

    import datetime

class Person(object):
    def __init__(self, name, birthday, height):
        self.name = name
        self.birthday = birthday
        self.height = height

    def __repr__(self):
        return self.name

l = [Person("John Cena", datetime.date(1992, 9, 12), 175),
     Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
     Person("Jon Skeet", datetime.date(1991, 7, 6), 185)]

l.sort(key=lambda item: item.name)
# l: [Chuck Norris, John Cena, Jon Skeet]

l.sort(key=lambda item: item.birthday)
# l: [Chuck Norris, Jon Skeet, John Cena]

l.sort(key=lambda item: item.height)
# l: [John Cena, Chuck Norris, Jon Skeet]

    dictsのリストの場合、概念は同じです： 

    import datetime

l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'height': 175},
 {'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'height': 180},
 {'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'height': 185}]

l.sort(key=lambda item: item['name'])
# l: [Chuck Norris, John Cena, Jon Skeet]

l.sort(key=lambda item: item['birthday'])
# l: [Chuck Norris, Jon Skeet, John Cena]

l.sort(key=lambda item: item['height'])
# l: [John Cena, Chuck Norris, Jon Skeet]

    サブディクトで並べ替え： 

    import datetime

l = [{'name':'John Cena', 'birthday': datetime.date(1992, 9, 12),'size': {'height': 175, 'weight': 100}},
 {'name': 'Chuck Norris', 'birthday': datetime.date(1990, 8, 28),'size' : {'height': 180, 'weight': 90}},
 {'name': 'Jon Skeet', 'birthday': datetime.date(1991, 7, 6), 'size': {'height': 185, 'weight': 110}}]

l.sort(key=lambda item: item['size']['height'])
# l: [John Cena, Chuck Norris, Jon Skeet]

attrgetterとitemgetterを使ってソートする方が良い

リストも使用して選別することができるattrgetterとitemgetterオペレータモジュールから機能します。これらは、読みやすさと再利用性を向上させるのに役立ちます。下記は用例です、 

from operator import itemgetter,attrgetter

people = [{'name':'chandan','age':20,'salary':2000},
          {'name':'chetan','age':18,'salary':5000},
          {'name':'guru','age':30,'salary':3000}]
by_age = itemgetter('age')
by_salary = itemgetter('salary')

people.sort(key=by_age) #in-place sorting by age
people.sort(key=by_salary) #in-place sorting by salary

itemgetterはインデックスをitemgetterこともできます。これは、タプルのインデックスに基づいてソートする場合に便利です。 

list_of_tuples = [(1,2), (3,4), (5,0)]
list_of_tuples.sort(key=itemgetter(1))
print(list_of_tuples) #[(5, 0), (1, 2), (3, 4)]

オブジェクトの属性でソートする場合は、 attrgetter使用します。 

persons = [Person("John Cena", datetime.date(1992, 9, 12), 175),
           Person("Chuck Norris", datetime.date(1990, 8, 28), 180),
           Person("Jon Skeet", datetime.date(1991, 7, 6), 185)] #reusing Person class from above example

person.sort(key=attrgetter('name')) #sort by name
by_birthday = attrgetter('birthday')
person.sort(key=by_birthday) #sort by birthday

  1. clear() - リストからすべての項目を削除します。 

    a.clear()
# a = []

  2. 複製 - 既存のリストを整数で掛け合わせることで、元の数多くのコピーからなるより大きなリストが生成されます。これは、リストの初期化などに便利です。 

    b = ["blah"] * 3
# b = ["blah", "blah", "blah"]
b = [1, 3, 5] * 5
# [1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5, 1, 3, 5]

    あなたのリストにオブジェクトへの参照が含まれている場合（リストのリストなど）は、 Common Pitfalls - List乗算と共通参照を参照してください 。

  3. 要素の削除 - delキーワードとスライス表記を使用して、リスト内の複数の要素を削除することができます。 

    a = list(range(10))
del a[::2]
# a = [1, 3, 5, 7, 9]
del a[-1]
# a = [1, 3, 5, 7]
del a[:]
# a = []

  4. コピー

    デフォルトの割り当て "="は、元のリストの参照を新しい名前に割り当てます。つまり、元の名前と新しい名前の両方が同じリストオブジェクトを指しています。いずれかを介して加えられた変更は、別のものにも反映されます。これはしばしばあなたが意図したものではありません。 

    b = a
a.append(6)
# b: [1, 2, 3, 4, 5, 6]

    リストのコピーを作成する場合は、以下のオプションがあります。

    スライスすることができます： 

    new_list = old_list[:]

    組み込みのlist（）関数を使うことができます： 

    new_list = list(old_list)

    一般的なcopy.copy（）を使うことができます： 

    import copy
new_list = copy.copy(old_list) #inserts references to the objects found in the original.

    これは、old_listのデータ型を最初に見つけ出さなければならないので、list（）より少し遅いです。

    リストにオブジェクトが含まれていて、それらもコピーしたい場合は、generic copy.deepcopy（）を使用します。 

    import copy
new_list = copy.deepcopy(old_list) #inserts copies of the objects found in the original.

    明らかに最も遅く、最もメモリを必要とする方法ですが、時には避けられないものです。

Python 3.x 3.0

copy() - リストの浅いコピーを返します。 

    aa = a.copy()
    # aa = [1, 2, 3, 4, 5]

リストの長さ

リストの1次元の長さを取得するには、 len()を使用します。 

len(['one', 'two'])  # returns 2

len(['one', [2, 3], 'four'])  # returns 3, not 4

len()は、文字列、辞書、およびリストに似た他のデータ構造でも機能します。

len()はビルトイン関数であり、リストオブジェクトのメソッドではありません。

また、 len()コストはO(1)であり、長さに関係なくリストの長さを取得するのに同じ時間がかかることに注意してください。

リストを反復する

Pythonは、 forループをリスト上で直接使用することforサポートしてforます： 

my_list = ['foo', 'bar', 'baz']
for item in my_list:
    print(item)

# Output: foo
# Output: bar
# Output: baz

あなたは同時に各項目の位置を得ることができます： 

for (index, item) in enumerate(my_list):
    print('The item in position {} is: {}'.format(index, item))
 
# Output: The item in position 0 is: foo
# Output: The item in position 1 is: bar
# Output: The item in position 2 is: baz

インデックス値に基づいてリストを反復するもう1つの方法： 

for i in range(0,len(my_list)):
    print(my_list[i])
#output:
>>>
foo
bar
baz

反復処理中にリスト内の項目を変更すると、予期しない結果が生じる可能性があることに注意してください。 

for item in my_list:
    if item == 'foo':
        del my_list[0]
    print(item)

# Output: foo
# Output: baz

この最後の例では、最初の反復で最初のアイテムを削除しましたが、そのためにbarがスキップされました。

アイテムがリストに含まれているかどうかの確認

Pythonは、項目がリストにあるかどうかをチェックするのがとても簡単です。単純にin演算子を使用inます。 

lst = ['test', 'twest', 'tweast', 'treast']

'test' in lst
# Out: True

'toast' in lst
# Out: False

注意：集合のin演算子はリストより漸近的に高速です。潜在的に大きなリストに何度も使用する必要がある場合は、 listをsetに変換し、 set上のエレメントの存在をテストすることができます。 

slst = set(lst)
'test' in slst
# Out: True

リスト要素を逆転する

反復されたリストに反復子を返すreversed関数を使うことができます： 

In [3]: rev = reversed(numbers)

In [4]: rev
Out[4]: [9, 8, 7, 6, 5, 4, 3, 2, 1]

リスト "数字"はこの操作によって変更されず、本来の順序と同じ順序にとどまることに注意してください。

逆にするには、 reverseメソッドを使用することもできます。

スライシング構文を使用して3番目の引数（ステップ）を-1に設定することで、リストを逆転することもできます（実際にはコピーを取得し、元のリストは影響を受けません） 

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

In [2]: numbers[::-1]
Out[2]: [9, 8, 7, 6, 5, 4, 3, 2, 1]

リストが空であるかどうかのチェック

リストの空白はブール値False関連付けられているので、 len(lst) == 0をチェックする必要はありませんが、 lstまたはnot lstだけをチェックします

lst = []
if not lst:
    print("list is empty")

# Output: list is empty

リストの連結と結合

  1. list1とlist2 を連結する最も簡単な方法は次のとおりです。 

    merged = list1 + list2

  2. zipはタプルのリストを返します 。ここで、i番目のタプルには引数のシーケンスまたはiterableのそれぞれからi番目の要素が入ります。 

    alist = ['a1', 'a2', 'a3']
blist = ['b1', 'b2', 'b3']

for a, b in zip(alist, blist):
    print(a, b)
 
# Output:
# a1 b1
# a2 b2
# a3 b3

    リストの長さが異なる場合、結果には最短のものと同じ数の要素だけが含まれます。 

    alist = ['a1', 'a2', 'a3']
blist = ['b1', 'b2', 'b3', 'b4']
for a, b in zip(alist, blist):
    print(a, b)

# Output:
# a1 b1
# a2 b2
# a3 b3

alist = []
len(list(zip(alist, blist)))

# Output:
# 0

    最長のものと等しくない長さのパディングリストのNone sが使用itertools.zip_longest （ itertools.izip_longestパイソン2） 

    alist = ['a1', 'a2', 'a3']
blist = ['b1']
clist = ['c1', 'c2', 'c3', 'c4']

for a,b,c in itertools.zip_longest(alist, blist, clist):
    print(a, b, c)

# Output: 
# a1 b1 c1
# a2 None c2
# a3 None c3
# None None c4

  1. 特定のインデックス値に挿入： 

     alist = [123, 'xyz', 'zara', 'abc']
 alist.insert(3, [2009])
 print("Final List :", alist)

    出力： 

     Final List : [123, 'xyz', 'zara', 2009, 'abc']

すべてとすべて

all()を使用すると、iterable内のすべての値がTrueであるかどうかを判断できます

nums = [1, 1, 0, 1]
all(nums)
# False
chars = ['a', 'b', 'c', 'd']
all(chars)
# True

同様に、 any()は、iterable内の1つ以上の値がTrue 

nums = [1, 1, 0, 1]
any(nums)
# True
vals = [None, None, None, False]
any(vals)
# False

この例ではリストを使用していますが、これらのビルトインはジェネレータを含む任意のイテレートで動作することに注意することが重要です。 

vals = [1, 2, 3, 4]
any(val > 12 for val in vals)
# False
any((val * 2) > 6 for val in vals)
# True

リスト内の重複値を削除する

リスト内の重複した値を削除するには、リストをset （別個のオブジェクトの順不同のコレクション）に変換します。 listデータ構造体が必要な場合は、関数list()を使用してその集合をリストに戻すことができます。 

names = ["aixk", "duke", "edik", "tofp", "duke"]
list(set(names))
# Out: ['duke', 'tofp', 'aixk', 'edik']

リストをセットに変換すると、元の順序が失われることに注意してください。

リストの順序を保持するために、 OrderedDict 

import collections
>>> collections.OrderedDict.fromkeys(names).keys()
# Out: ['aixk', 'duke', 'edik', 'tofp']

ネストされたリストの値へのアクセス

3次元のリストから始める： 

alist = [[[1,2],[3,4]], [[5,6,7],[8,9,10], [12, 13, 14]]]

リスト内の項目へのアクセス： 

print(alist[0][0][1])
#2
#Accesses second element in the first list in the first list

print(alist[1][1][2])
#10
#Accesses the third element in the second list in the second list

サポート操作の実行： 

alist[0][0].append(11)
print(alist[0][0][2])
#11
#Appends 11 to the end of the first list in the first list

ネストされたforループを使用してリストを印刷する： 

for row in alist: #One way to loop through nested lists
    for col in row:
        print(col)
#[1, 2, 11]
#[3, 4]
#[5, 6, 7]
#[8, 9, 10]
#[12, 13, 14]

この操作はリストの理解や効率化のためのジェネレータとしても使用できます。 

[col for row in alist for col in row]
#[[1, 2, 11], [3, 4], [5, 6, 7], [8, 9, 10], [12, 13, 14]]

外側のリストのすべての項目がリスト自体である必要はありません。 

alist[1].insert(2, 15)
#Inserts 15 into the third position in the second list

ネストされたforループを使用する別の方法。他の方法はより良いですが、私は機会にこれを使用する必要があります： 

for row in range(len(alist)): #A less Pythonic way to loop through lists
    for col in range(len(alist[row])):
       print(alist[row][col])

#[1, 2, 11]
#[3, 4]
#[5, 6, 7]
#[8, 9, 10]
#15
#[12, 13, 14]

ネストされたリストでのスライスの使用： 

print(alist[1][1:])
#[[8, 9, 10], 15, [12, 13, 14]]
#Slices still work

最後のリスト： 

print(alist)
#[[[1, 2, 11], [3, 4]], [[5, 6, 7], [8, 9, 10], 15, [12, 13, 14]]]

リストの比較

比較演算子を使用してリストと他のシーケンスを辞書的に比較することは可能です。どちらのオペランドも同じ型でなければなりません。 

[1, 10, 100] < [2, 10, 100]
# True, because 1 < 2
[1, 10, 100] < [1, 10, 100]
# False, because the lists are equal
[1, 10, 100] <= [1, 10, 100]
# True, because the lists are equal
[1, 10, 100] < [1, 10, 101]
# True, because 100 < 101
[1, 10, 100] < [0, 10, 100]
# False, because 0 < 1

一方のリストが他方のリストの先頭に含まれる場合、最短のリストが勝ちます。 

[1, 10] < [1, 10, 100]
# True

固定数の要素へのリストの初期化

不変要素（例えば、 None 、文字列リテラルなど）の場合： 

my_list = [None] * 10
my_list = ['test'] * 10

変更可能な要素の場合、同じ構造体はリストのすべての要素を、例えばセットの場合と同じオブジェクトを参照します。 

>>> my_list=[{1}] * 10
>>> print(my_list)
[{1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}, {1}]
>>> my_list[0].add(2)
>>> print(my_list)
[{1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}]

代わりに、固定数の異なる可変オブジェクトでリストを初期化するには、次のようにします。 

my_list=[{1} for _ in range(10)]


Modified text is an extract of the original Stack Overflow Documentation
ライセンスを受けた CC BY-SA 3.0
所属していない Stack Overflow