Python3.*(第12課——Pythonの3種類の常用データ構造:リスト、メタグループ、辞書)

(本章ノートは総点の構成で記録学習を行うもので、総じて共通部分を表す)
Pythonでよく見られるシーケンスタイプには、リスト、メタグループ、辞書が含まれており、前に学習した文字列もよく使われるシーケンスです.
ディクショナリは、マッピング関係を持つデータを格納するために使用されます.
複数のデータ・アイテムを固定して保存する場合は、変更する必要はありません.メタ・グループを使用します.
変更が必要な場合は、リストを使用します.
(文字列も可変文字列)
リストとタプルの作成
構文の形式:
リスト:[ele 1,ele 2,ele 3,...]
メタグループ:(ele 1,ele 2,ele 3,...)
例:

#          
my_list = ['crazyit', 20, 'Python']
print(my_list)
#          
my_tuple = ('crazyit', 20, 'Python')
print(my_tuple)

要素を変更する操作にかかわらない限り、リストとメタグループの使い方は共通です.
索引による要素の使用
①インデックスはすべて0から始まり、1番目の要素のインデックスは0、2番目の要素のインデックスは1…となります
②最後から1番目のエレメントのインデックスは-1、最後から2番目のエレメントのインデックスは-2……となります.
③リストの要素は1つの変数に相当し、プログラムはその値を使用してもよいし、要素に値を付与してもよい.
④メタグループの要素は1つの定数に相当し、プログラムはその値しか使用できず、再付与できない.
例:(一般的な使い方)

a_tuple = ('crazyit', 20, 5.6, 'fkit', -17)
print(a_tuple)
#    1   
print(a_tuple[0]) # crazyit
#    2   
print(a_tuple[1]) # 20
#      1   
print(a_tuple[-1]) # -17
#      2   
print(a_tuple[-2]) # -fkit

サブシーケンス
リストとメタグループは、slice(スライスまたはスライス)と呼ばれるインデックスを使用して中間セグメントを取得することもできます.
構文:[start:end:step]
①startインデックスの要素から(含む)、endインデックスの要素まで(含まない)
②stepはステップ長を表し、負数を使っても意味がありません.
③stepパラメータを指定すると、step個の要素を隔てて要素を取り出すことができます.
例:

a_tuple = ('crazyit', 20, 5.6, 'fkit', -17)
#     2     4 （   ）    
print(a_tuple[1: 3]) # (20, 5.6)
#       3     1 （   ）    
print(a_tuple[-3: -1]) # (5.6, 'fkit')
#     2     2 （   ）    
print(a_tuple[1: -2]) # (20, 5.6)
#       3   5 （   ）    
print(a_tuple[-3: 4]) # (5.6, 'fkit')

b_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9)
#     3   9 （   ）、   2     
print(b_tuple[2: 8: 2]) # (3, 5, 7)
#     3   9 （   ）、   3     
print(b_tuple[2: 8: 3]) # (3, 6)
#     3     2 （   ）、   3     
print(b_tuple[2: -2: 2]) # (3, 5, 7)

加算
①加算の和は、2つのリストまたはメタグループに含まれる要素の合計です.
②リストはリストにしか加算できません.メタグループはメタグループにしか加算できません.
③タプルはリストに直接加算できません.
例:

a_tuple = ('crazyit' , 20, -1.2)
b_tuple = (127, 'crazyit', 'fkit', 3.33)
#       
sum_tuple = a_tuple + b_tuple
print(sum_tuple) # ('crazyit', 20, -1.2, 127, 'crazyit', 'fkit', 3.33)
print(a_tuple) # a_tuple     
print(b_tuple) # b_tuple     
#       
print(a_tuple + (-20 , -30)) # ('crazyit', 20, -1.2, -20, -30)
#       ：           
#print(a_tuple + [-20 , -30])
a_list = [20, 30, 50, 100]
b_list = ['a', 'b', 'c']
#       
sum_list = a_list + b_list
print(sum_list) # [20, 30, 50, 100, 'a', 'b', 'c']
print(a_list + ['fkit']) # [20, 30, 50, 100, 'fkit']

乗算＃ジョウサン＃
①リストとタプル乗算の意味は、それらに含まれる要素をN回繰り返すことであり、Nは乗算される倍数である.
②ユーザは、リスト、タプルに対して加算、乗算を同時に行うことができる
例:

a_tuple = ('crazyit' , 20)
#     
mul_tuple = a_tuple * 3
print(mul_tuple) # ('crazyit', 20, 'crazyit', 20, 'crazyit', 20)
a_list = [30, 'Python', 2]
mul_list = a_list * 3
print(mul_list) # [30, 'Python', 2, 30, 'Python', 2, 30, 'Python', 2]

#          、  
order_endings = ('st', 'nd', 'rd')\
    + ('th',) * 17 + ('st', 'nd', 'rd')\
    + ('th',) * 7 + ('st',)
#     st、nd、rd、17 th、st、nd、rd、7 th、st
print(order_endings)
day = input("    (1-31)：")
#         
day_int = int(day)
print(day + order_endings[day_int - 1])

③要素が1つしかないタプルを表すには、一意のタプル要素の後に英語のカンマを追加する必要があります.
in演算子
in演算子は、リストまたはメタグループに要素が含まれているかどうかを判断するために使用されます.
例:

s=(23,34,56,7,8,90,12)
print(3 not in s) # true
print(34 in s) # true

a_tuple = ('crazyit' , 20, -1.2)
print(20 in a_tuple) # True
print(1.2 in a_tuple) # False
print('fkit' not in a_tuple) # True

長さ、最大値、最小値
①len()、max()、min()グローバル関数を使用して、メタグループまたはリストの長さ、最大値、および最小値を取得します.
②上記の3つの関数を使用する場合、メタグループ、リストの要素は同じタイプで、サイズを比較できる必要があります.
③Pythonは、文字列の各文字に対応する符号化順に文字列の大きさを比較する.(文字列比較サイズ)
例:

#          
a_tuple = (20, 10, -2, 15.2, 102, 50)
#      
print(max(a_tuple)) # 102
#      
print(min(a_tuple)) # -2
#     
print(len(a_tuple)) # 6
#           
b_list = ['crazyit', 'fkit', 'Python', 'Kotlin']
#      （         ASCII  ，        ，   ，         ，    ）
print(max(b_list)) # fkit（26      ASCII  97~122）
#      
print(min(b_list)) # Kotlin （26      ASCII  65~90）
#     
print(len(b_list)) # 4

シーケンスエンベロープとシーケンスデパッケージ
①プログラムが複数の値を1つの変数に割り当てると、Pythonは自動的に複数の値をメタグループにカプセル化します.
この機能はシーケンスパッケージと呼ばれます.
②プログラムでは、シーケンス(メタグループやリストなど)を複数の変数に直接割り当てることができます.この場合、シーケンスの各要素は、各変数(要求シーケンスの要素個数と変数個数が等しい)に順次割り当てられます.この機能をシーケンスデパッケージと呼ぶ.
例:

#     ： 10、20、30         vals
vals = 10, 20, 30
print(vals) # (10, 20, 30)
print(type(vals)) # 
print(vals[1]) # 20
a_tuple = tuple(range(1, 10, 2))
#     :  a_tuple           a、b、c、d、e  
a, b, c, d, e = a_tuple
print(a, b, c, d, e) # 1 3 5 7 9
a_list = ['fkit', 'crazyit']
#     :  a_list           a_str、b_str  
a_str, b_str = a_list
print(a_str, b_str) # fkit crazyit

3賦値にシーケンスエンベロープとシーケンス解包メカニズムを併用することで,賦値演算子に複数の値を同時に複数の変数に付与することをサポートさせることができる.

#  10、20、30     x、y、z
x, y, z = 10, 20, 30
print(x, y, z) # 10 20 30
#  y,z, x     x、y、z
x, y, z = y, z, x
print(x, y, z) # 20 30 10

このメカニズムを用いて交換変数を実現できる
④シーケンス解包時に一部の変数のみを解出し、残りはリスト変数で保存してもよい.割り当てられた変数の前に「*」を追加すると、その変数はリストを表します.

# first、second   2   ，rest         
first, second, *rest = range(10)
print(first) # 0
print(second) # 1
print(rest) # [2, 3, 4, 5, 6, 7, 8, 9]
# last        ，begin         
*begin, last = range(10)
print(begin) # [0, 1, 2, 3, 4, 5, 6, 7, 8]
print(last) # 9
# first       ，last        ，middle         
first, *middle, last = range(10)
print(first) # 0
print(middle) # [1, 2, 3, 4, 5, 6, 7, 8]
print(last) # 9