Python リストの学習に役立つ記事

この記事の内容は Python のリストを学習するための記事です。一定の参考価値があります。困っている友人は参考にしてください。お役に立てれば幸いです。

千マイルも一歩から始まります。全てを見通す目を養うためには、まず基礎的な技術を地に足のついた方法で学ばなければなりません。今日は、Python リストを注意深く確認していきます。過去を振り返ることで新しいことを学ぶことができるのはそのためです。

もちろん、配列のインデックスが 0 から始まる理由など、一見重要ではない従来の言語習慣の背後に多くの歴史がある可能性があるため、復習する際には多岐に渡って考える必要もあります。何が起こっているのかを知るには、なぜそれが起こっているのかも知る必要があります。ニャーニャーニャー~~~

最後に、基本的な知識に加えて、ジェネレーター式の学習など、高度な知識も探索する必要があります。基本をよりしっかりと理解できるようになり、これらを統合して、より包括的な認知機能のアップグレードを実現できます。

Python のリストとは何ですか?

#リストは、いつでも要素を追加、検索、削除できる順序付けされたコレクションです。

List は、数値、文字列、リスト、タプルなど、さまざまなデータ型の要素の追加をサポートします。

リストは、順序付けされたインデックスを介してすべての要素を横断できます。前から後ろに数えると、インデックスは [0, n-1] です。後ろから前に数えると、インデックスは [-1, -n] です。ここで、n はリストの長さです。

リストは要素のない空のリストにすることも、要素が多すぎることもできます (メモリ サイズがサポートしている場合)。

list_a = []   # 空列表，即len(list_a) == 0
list_b = [2018, 10, '2018-10-1', ['hi', 1, 2], (33, 44)]
# list_b 长度为5，包含2个数字元素、1个字符串元素、1个列表元素和1个元组元素
len(list_b) == 5
list_b[0] == list_b[-5] == 2018
lits_b[3] == list_b[-2] == ['hi', 1, 2] 
lits_b[4] == list_b[-1] == (33, 44)

Python でリストを操作するにはどうすればよいですか?

1) リストを作成します:

要素を角括弧 [] で囲み、要素をカンマで区切ります。

list() メソッドを使用してリストを変換および生成します。

リスト生成/リスト分析/リスト理解、リストを生成します。

list_a = [1, 2, 3]
list_b = list("abc") # list_b == ['a', 'b', 'c']
list_c = list((4, 5, 6)) # list_c == [4, 5, 6]
list_d = [i for i in list_a]  # list_d == [1, 2, 3]
list_e = [i*j for i in list_a for j in list_c] # list_e == [4,5,6,10,12,12,15,18]
list_f = [i*j for i,j in zip(list_a,list_c)] # list_f == [4, 10, 18]
list_g = [i for i in list_a if i%2 == 0] # list_g == [2]

# 结合range()函数，range(start, stop[, step])
list_h = list(range(3)) # list_h == [0, 1, 2]
list_i = list(range(3,7)) # list_i == [3, 4, 5, 6]
list_j = list(range(3,9,2)) # list_j == [3, 5, 7]

# 找出100以内的能够被3整除的正整数
list_k = list(range(3,100,3)) # list_k == [3, 6, 9, ..., 96, 99]

2) リストを展開します:

append() メソッドを使用して、リストの末尾に 1 つの新しい要素を追加します。

insert() メソッドを使用して、リスト内の指定された位置に要素を追加します。

「 」演算子を使用して、2 つのリストを新しいリストに結合します。

extend() メソッドを使用して、あるリストを別のリストに結合します。

# 以下分别添加2个元素
list_a = []
list_a.append('happy')  # list_a == ['happy']
list_a.insert(0, 'very') # list_a == ['very', 'happy']

# 以下两种扩充列表方式
list_1 = ['I', 'am']
list_2 = ['very', 'happy']
list_3 = list_1 + list_2  # 新列表 list_3 == ['I', 'am', 'very', 'happy']
list_1.extend(list_2)  # 原列表1扩充，list_1 == ['I', 'am', 'very', 'happy']

3) リストを削除し、リストを破棄します。

del list[m] ステートメントを使用して、指定されたインデックス m の要素を削除します。

remove() メソッドを使用して、指定された値を持つ要素 (最初に一致した項目) を削除します。

pop() メソッドを使用して、リストの末尾にある 1 つの要素を取り出して削除します。

pop(m) メソッドを使用して、インデックス値 m の要素を削除します。

clear() メソッドを使用して、リストの要素をクリアします。 (カップはまだそこにありますが、水は空です)

del list ステートメントを使用してリスト全体を破棄します。 (コップも水もなくなった)

# 以下4种删除列表元素方式
list_1 = list_2 = list_3 = list_4 = ['I', 'am', 'very', 'happy']
del list_1[0]  # list_1 == ['am', 'very', 'happy']
list_2.remove('I') # list_2 == ['am', 'very', 'happy']
list_3.pop()  # list_3 == ['I', 'am', 'very']
list_4.pop(0)  # list_4 == ['am', 'very', 'happy']

# 清空与销毁
list_a = [1, 2, 3]
list_b = [1, 2, 3]
list_b.clear()   # list_b == []
del list_a  # 没有list_a了，再使用则会报错

4) リストのスライス:

基本的な意味:

i 番目の位置から開始して、右に進みます。 after 最大 n 個の要素、m 間隔でフィルタリング

基本形式: [i : i n : m]; i はスライスの開始インデックス値で、スライスの最初の場合は省略できます。リスト; i n はスライスの終わり 位置はリストの最後の位置である場合は省略できます; m を指定する必要はありません. デフォルト値は 1 で、0 は許可されません. m が負の数の場合、リストが反転します。注: これらの値はリストの長さよりも大きくなる可能性があり、範囲外として報告されません。

li = [1, 4, 5, 6, 7, 9, 11, 14, 16]

# 以下写法都可以表示整个列表，其中 X >= len(li)
li[0:X] == li[0:] == li[:X] == li[:] == li[::] == li[-X:X] == li[-X:]

li[1:5] == [4,5,6,7] # 从1起，取5-1位元素
li[1:5:2] == [4,6] # 从1起，取5-1位元素，按2间隔过滤
li[-1:] == [16] # 取倒数第一个元素
li[-4:-2] == [9, 11] # 从倒数第四起，取-2-(-4)=2位元素
li[:-2] == li[-len(li):-2] == [1,4,5,6,7,9,11] # 从头开始，取-2-(-len(li))=7位元素

# 注意列表先翻转，再截取
li[::-1] == [16,14,11,9,7,6,5,4,1] # 翻转整个列表
li[::-2] == [16,11,7,5,1] # 翻转整个列表，再按2间隔过滤
li[:-5:-1] == [16,14,11,9] # 翻转整个列表，取-5-(-len(li))=4位元素
li[:-5:-3] == [16,9] # 翻转整个列表，取-5-(-len(li))=4位元素，再按3间隔过滤

li[::0]  # 报错（ValueError: slice step cannot be zero）

5) その他の操作:​​

len() メソッドを使用して、すべての要素の数を数えます。

count() メソッドを使用して、指定した値を持つ要素の数をカウントします。

max() メソッドを使用して、要素内の最大値をカウントします (要素の型が同じである必要があります。数値型は直接比較され、他の型は ID と比較されます)

min() メソッドを使用して、要素内の最大値をカウントします。 最小値 (要素の型が同じである必要があります。数値型は直接比較され、他の型は ID と比較されます)

インデックスを使用します。 () メソッドを使用して、指定された値を持つ要素 (最初に一致したもの) のインデックス位置を検索します。

reverse() メソッドを使用して、リスト内の要素を反転します。

copy() メソッドを使用して、浅くコピーして新しいリストを生成します。

deepcopy() メソッドを使用してディープ コピーし、新しいリストを生成します。

sort() メソッドを使用して、元のリストに基づいて並べ替えます。

新しいリストに基づいて元のリストの要素を並べ替えるには、sorted() メソッドを使用します。

list_1 = [2018, 10, '2018-10-1', ['hi', 1, 2], (33, 44)]
len(list_1) == 5
list_1.count(10) == 1 # 元素10的数量为1
list_1.index(10) == 1 # 元素10的索引为1
list_1.reverse() # list_1 == [(33, 44), ['hi', 1, 2], '2018-10-1', 10, 2018]


# 比较浅拷贝与深拷贝
import copy
list_a = [2018, 10, '2018-10-1', ['hi', 1, 2], (33, 44)]
list_b = ['hi', 1, 2]
list_c = list_a.copy() # list_c == [2018, 10, '2018-10-1', ['hi', 1, 2], (33, 44)]
list_d = copy.deepcopy(list_a) # list_d == [2018, 10, '2018-10-1', ['hi', 1, 2], (33, 44)]
# 改变原列表中的可变对象元素
list_a[3].append('new') # list_a == [2018, 10, '2018-10-1', ['hi', 1, 2, 'new'], (33, 44)]
# 浅拷贝中的可变对象会随原列表变化而变化
list_c == [2018, 10, '2018-10-1', ['hi', 1, 2, 'new'], (33, 44)]
# 深拷贝中的可变对象不会随原列表变化而变化
list_d == [2018, 10, '2018-10-1', ['hi', 1, 2], (33, 44)]
# 比较sort() 与 sorted()
list_1 = list_2 = [2,1,4,6,5,3]
list_1.sort() # 原列表变化：list_1 == [1,2,3,4,5,6]
list_3 = sorted(list_2) # 原列表不变：list_2 == [2,1,4,6,5,3]; list_3 == [1,2,3,4,5,6]

Python リストのインデックスが 0 から始まるのはなぜですか?

信頼できる説明は、Guido van Rossum (Python の父) のブログ投稿「Python が 0 から始まるインデックスを使用する理由」から引用されています。

一文で要約: インデックス作成の開始0 から、スライスの使用法は非常にシンプルです。

翻訳の本質は次のとおりです:

私が Python で 0 から始まるインデックスを使用することにした理由の 1 つは、スライス表記です。

まずスライスの使い方を見てみましょう。おそらく最も一般的な使用法は、「最初の n 個の要素を取得する」または「i 番目の位置からインデックスを付けて最後の n 個の要素を取得する」ことです (前者の使用法は、実際には i== 開始位置の特別な使用法です)。これら 2 つの使用法を、式の中で醜い 1 や -1 を使用せずに実装できれば、非常にエレガントになります。

0 ベースのインデックス付け、半開間隔スライス、およびデフォルトの一致間隔 (Python が最終的にこの方法を採用) を使用すると、上記の 2 つの状況でのスライス構文は非常に美しくなります: a[:n ] と a [i:i n]、前者は a[0:n] の略称です。

如果使用1-based的索引方式，那么，想让a[:n]表达“取前n个元素”的意思，你要么使用闭合区间切片语法，要么在切片语法中使用切片起始位和切片长度作为切片参数。半开区间切片语法如果和1-based的索引方式结合起来，则会变得不优雅。而使用闭合区间切片语法的话，为了从第i位索引开始取后n个元素，你就得把表达式写成a[i:i+n-1]。

……

特别是当两个切片操作位置邻接时，第一个切片操作的终点索引值是第二个切片的起点索引值时，太漂亮了，无法舍弃。例如，你想将一个字符串以i，j两个位置切成三部分，这三部分的表达式将会是a[:i]，a[i:j]和a[j:]。

其它编程语言的索引？

索引从0开始的编程语言：C、C++、Python、Java、PHP、Ruby、Javascript...

索引从1开始的编程语言：ABC、Matlab、VB、易语言、大部分shell语言...

索引从其它值开始的编程语言：Pascal、Lua...

还有像表示星期、月份等序列结构的数据，各种编程语言也划分成了不同阵营。

它们出于何种考虑？

C语言：索引从0开始，可以大大提升内存寻址计算的效率，详细分析参考《C语言数组元素下标为何从0开始》

大部分shell语言：大多数是从1开始，来源参考stackexchange这篇问答

Pascal、Lua：默认从1开始，但支持改变起始索引值，原因据说是对非专业的开发者更友好，来源参考这篇知乎问答

以上列举的原因是最审慎的、体面的解释，话题应该到此终结，因为“索引应该从几开始最好”这个问题的破坏性不亚于“哪种编程语言是最好的”......

优雅漂亮的结尾：生成器表达式

列表生成式是一种漂亮优雅的东西，然而它有一个致命的缺点：它一次性把所有元素加载到内存中，当列表过长的时候，便会占据过多的内存资源，而且，我们通常仅需要使用少数的元素，这样未使用的元素所占据的绝大部分的内存，就成了不必要的支出。

生成器是一种更高级更优雅的东西，它使用“懒加载”的原理，并不生成完整的列表，而是迭代地、即时地、按需地生成元素，这样不仅能极大地节省内存空间，而且，在理论上，它可以生成一个无穷大的列表！

大多数生成器是以函数来实现的，然而，它并不返回（return）一个值，而是生成（yield）一个值，并挂起程序。然后，通过next()方法生成并马上返回一个元素，或者通过for循环，逐一生成和返回全部元素。

next()效率太低，且调用次数越界时会抛出StopIteration的异常，而for循环会自动捕捉这个异常，并停止调用，所以使用更佳。

# 计算斐波那契数列的生成器
def fibon(n):
a = b = 1
for i in range(n):
yield a  # 使用yield
a, b = b, a + b

# 计算前1000000个数，通过next()函数，按顺序每次生成一个数
g = fibon(1000000)
next(g)  # 1
next(g)  # 1
next(g)  # 2
next(g)  # 3
next(g)  # 5
# 以此类推，但若调用超过1000000次，就会报异常StopIteration
# 计算前1000000个数，通过for循环逐一打印生成数
for x in fibon(1000000):
print(x)

生成器表达式与列表生成式极其形似，只是把[]改成了()，但背后的原理大不相同。

l = [x*2 for x in range(5)]  # 列表生成式，4以内整数的2倍数
g = (x*2 for x in range(5))  # 生成器表达式
type(l)   # 结果：<type &#39;list&#39;>
type(g)   # 结果：<type &#39;generator&#39;>

print(l)  # 结果：[0,2,4,6,8]
print(g)  # 结果：<generator object at 0x000002173F0EBC50>
next(g)   # 0
next(g)   # 2
next(g)   # 4
next(g)   # 6
next(g)   # 8
next(g)   # Traceback (most recent call last): ....StopIteration

for x in g:
print(x, end=' ')  # 结果：0 2 4 6 8

以上がPython リストの学習に役立つ記事の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。