Pythonのデータタイプの第三章（下）

前の我々はいくつかの基本的なデータ型とメソッドを紹介します。
この中で、我々のpython-特定のデータ型と下にその方法を理解する必要があります。

3.4リスト（一覧）

リストは配列PowerShellのと少し似て、より多くのデータを保存することができます

文字列は、リストとして見ることができます

names = ["name1","name2","name3"]  # 有点像数组

print(names[0])  # 可以用下标来调用

3.4.1機能一覧（注文、変数）

リストには、次のような特徴を持っています

1. 複数の値を格納することができます。（また、その他の値のリスト、タプルであってもよいです）
2. 注文：0インデックスから始まり、左から右へ。
3. 変数：指定されたインデックス値に対応する修正されてもよいです。
4. 容量：どのくらいのメモリがはるかに、のpython3 int型に類似を保存することができます。

方法3.4.2リスト

以下の点（CRUD）を使用して、メソッドのリストを示します。

1.増加：追加、挿入、拡張

追加、挿入、結果を返しませ延長、それはNoneを返します

1. リストの最後にオブジェクトを、リストに直接割り当て：.append（自己、オブジェクト）を添加し

2. オブジェクトは、インデックス位置に挿入され、直接割り当てのリスト：.insert（自己、インデックス、オブジェクト）が挿入されています

3. .extend（自己、反復可能）合併（拡張）：元のリストの反復可能（リスト）合併、直接元のリストに割り当てられました

s = [1, 2, 3, 4]
b = [1,2,3,4]

s.extend(b)  # 这里直接把合并后的列表赋值给s
print(S)

---

デル、ポップ、削除、クリア：2.削除

1. デル削除：パイソンの一般的な方法を

del list1  # 删除整个列表
del list2[2]  # 删除一个元素

1. エラーがない場合.remove（自己、オブジェクト）は、（左から右に見て）一致する最初の要素を削除します

s = ['a', 'b', 'c', 'd']
s.remove('c')
print(s)

s.remove('e')  # 报错:ValueError

1. .pop（自己、インデックス）がポップアップ表示されます：要素を削除し、返します

list1.pop(3)  # 删除并返回索引指定的元素
list1.pop()  # 删除并返回最后一个元素

1. .clear（自己）一覧をクリアします

---

3.変更（割当）：=

「=」代入を直接使用することができます
list01[2] = "name250"

4.お問い合わせ先：LEN、インデックス、カウント、

• .INDEX最初のオブジェクトの最初に戻り（セルフ、オブジェクト、開始、停止）は、左のインデックスと一致し、開始および終了位置を設けてもよいです。

  検索要素が存在しない場合は、エラーとValueError

s = ['a', 'b', 'c', 'd']
print(s.index('c'))
print(s.index('c', 0, 2))  # 范围中没有'c'，报错

• .count（自己、オブジェクト）オブジェクトの数を返します。

s = ['a', 'b', 'c', 'd']
print(s.count('c'))  # 有1个'c'，返回1
print(s.count('e'))  # 没有'e'，返回0

• IN /ていないオペレータに含むか否かを判断します

s = ['a', 'b', 'c', 'd']
print('a' in s)

• LEN（O）は、長さ0を返します

s = ['a', 'b', 'c', 'd']
print(len(s))

5.その他の機能は、ソート、逆

• .reverse（）
  達成する-リスト反転の要素が[1 ::] LIST1も使用することができます

s = ['a', 'b', 'c', 'd']
a = ['a', 'b', 'c', 'd']
print(id(s), id(a))  # 显示s和a的内存地址

s.reverse()  # 反转s内元素

a1 = a[::-1]  # 拷贝一份反转了的a给a1

print(s, a1)  #输出一样
print(id(s), id(a1))  # 两种实现方式的区别：s地址不变，a1地址和a不同

• .sort（自己、キー、逆）ソートされたリスト内の要素のみソートデータの同じタイプの、リストに割り当てられた（内部使用のために、比較演算子です）

s = ['a', 'd', 'b', 'c', 5, 7, 3]
s.sort()  # 数据类型不同，报错：TypeError: '<' not supported between instances of 'int' and 'str'

s = ['a', 'd', 'b', 'c']

s.sort()
print(s)

s.sort(reverse=True)  # reverse = False 升序（默认）,reverse = True 降序
print(s)

素子が多値データとするときタプルタイプ等である場合、標準のどのキー要素を指定するために使用することができます

def takeSecond(elem):
    return elem[1]
 
# 列表
s = [(2, 2), (3, 4), (4, 1), (1, 3)]
 
# 指定第二个元素排序
s.sort(key=takeSecond)
 
# 输出类别
print(s)

3.4.3リストのスライス（関わらず、尾のケアに）

スライスはリストのリスト部分（リストはコピー後に撮影された）取られます

データスライスタイプは、することができます。list（リスト）、タプル（タプル）、文字列（STR）。

コピー：他の場所でメモリをデータを構築します

list1[start:end:step]

---

• スライス：
  • スタートが開始インデックスで、終了インデックスは、実際には（フルカットを開始するために端から）要素の始まりから控除されます
  • 負端を使用し、相互差し引かれ-2 2
  • 最初から始まるバックそのすべてを取るために最後に書き込まないでください
  • スタートを書いてはいけません、すべての要素の最後まで取ることです
  • から負を取ることができるステップに前（すなわち、逆さまにカット）

list1 = ["0","1","2","3","4","5","6"]

print(list1[3:4]) # 从索引3开始取，索引4开始切掉不要：结果只剩下索引3的元素["3"]
print(list1[3:-2])  # -2表示倒数第2个，也就是从倒数第2个往后切掉不要：结果["3","4"]
print(list1[1:])  # 从索引1开始到最后
print(list1[:3])  # 从开始到索引2，索引3开始切掉不要
print(list1[-4:-2])  # 从倒数第4个开始取，倒数第二个开始往后切掉不要
print(list1[1:5:2])  # 从索引1开始，隔1(步长-1)个取1个，索引5开始切掉不要
print(list1[-2:-4:-1])  # 从倒数第2个开始从后往前取，从倒数第4个开始切掉不要：结果["5","4"]

結果：

['3']
['3', '4']
['1', '2', '3', '4', '5', '6']
['0', '1', '2']
['3', '4']
['1', '3']
['5', '4']

---

• スライスの特殊な使用

文字列を逆にする、（（）逆に同様の）リストをリバース

print(list1[::-1])  # 把列表反转过来(拷贝)
# 因为字符串也可以看做是一个列表(但是不可变)，所以也可以用来**反转字符串**

リストのコピー

list2 = list1[:]  # 把list1的拷贝赋值给list2

割り当てを挿入

list1 = [1,2,3,4,5,6,7,8,9,0]
list1[1:6] = 'abcdefghijk'  # 先把1-5切掉，然后把'abcdefghijk'的元素插进去。
# 切掉的位数和插入的位数没有直接关系，只是插入这个切掉的空间罢了。这可能导致插入后，后面的索引发生变化。
# list1[1] = 'abc' 是单纯的列表赋值，不要搞错了哦
print(list1)

結果：

[1, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 7, 8, 9, 0]

---

3.5辞書（辞書）

{}] [時間値と、辞書によって定義されます

3.5.1辞書機能（順不同、キーユニークキー不変の種類、クエリの速度）

辞書には、次の特性があります。

1. キーインデックスだけではなく。キーと値の構造

2. キーは不変のデータ型（文字列、タプル数）はユニークでなければなりません。

   理由：変数のハッシュは意味：ハッシュ操作のみ不変型操作することができます。

3. 任意の数は一意でなくてもよく、値を変更することができ、値を格納することができます
4. 非順序（インデックスがないので）

5. クエリの速度は非常に高速で、かつdictのサイズ（どのように多くの同じ速度についてのお問い合わせに関係なく）に影響されません

   理由：ソートの辞書辞書ハッシュキーが固定長のハッシュ値を介して生成されるハッシュ値は、（数）のdictう番号にチェックリストと、「要素A」場合、最初の要素次にハッシュそれ、およびそれに対応する番号のリストで見つけデジタル二分法を生成します。※挿入後にリストを並べ替えるために、ゆっくりとハッシュ価値をデータを挿入することが必要。

二分法搜索的比较次数： 如果 2**n >= 数据总量，那么 n 次比较就可以找到相应数据

3.5.2辞書のアプローチ

以下の点（CRUD）を使用して、メソッドのリストを示します。

1.作成：直接定義された「{}、辞書、fromkeys

1. 直接定義
   person = {"name":"Alex","age":22} # 注意这里用":"来连接key和value

2. dictの（）
   person = dict(name="Alex",age=22) # 注意这里用"="来连接key和value ,并且key没有引号

3. 直接）（+辞書を定義します
   person = dict({"name":"Alex","age":22}) # 把方法1的定义放在方法2的函数中

4. fromkeys（）ボリューム生成辞書

keys = [0,1,2,3,4,5]
{}.fromkeys(keys,100)  # 每个key 都赋给 100 的value ，如果不写赋值，value就都是"None"

結果：
{0: 100, 1: 100, 2: 100, 3: 100, 4: 100, 5: 100}

注：アレイの場合fromkeysで辞書を作成（）、値。
時間の追加的な要素を持つ配列への追加は、すべてのキー値が追加されている与えます。
参照

2.増加：=は、SetDefault

1. 定義された「=」DIRECT

person = {"name":"Alex","age":22}
person["job"] = "Teacher"  # 如果字典里存在指定的key，就会覆盖原有的value`

注意：キーが存在する場合、それは元の値が上書きされます

1. .setdefault（自己、K、デフォルト）を添加し、キー値（デフォルト）とした戻り値。キーがある場合は、元の値を上書きしません。

person = {"name":"Alex","age":22}
person.setdefault("salary",[1,2,3])  # 添加key和value，并且返回value`

より安全な方法は、元の値を上書きしません。

3.削除：デル、ポップ、popitemは、明確な

1. デル削除：パイソンの一般的な方法を

person = {"name":"Alex","age":22}  # 创建字典
del person["name"]  # 删除指定key，value
del person  # 删除字典

1. .pop（自己、k）がポップアップ表示されます：あなたはエラーが報告される指定しない場合、指定されたキーを削除し、値を返します。

person = dict(name="Alex",age=22)  # 创建字典

print(person.pop("name"))  # 弹出name,并返回'Alex'
#输出: 'Alex'

person.pop()  # 报错：必须指定参数

1. .popitemは、（自己）ランダムにポップアップ：削除して、ランダムな要素を返し、タプルの形式で返す（キー、値）を。空の辞書は文句を言うでしょう（KeyError例外）

person = dict(name="Alex",age=22)  # 创建字典

print(person.pop('name'))  # 弹出
item1 = person.popitem()  # 取得返回的结果
print(type(item1))  # 打印返回结果的类型：tuple
print(person.popitem())  # 弹出
print(person.popitem())  # 报错：KeyError

1. .clear（）空の辞書

person = dict(name="Alex",age=22)  # 创建字典

person.clear()  # 清空

4.変更します。=、更新

1. 「=」修飾割り当て

person = {"name":"Alex","age":22}
person["name"] = "aaaa"  # 修改name的Alex->aaaa

1. .update（自己、__m、kwagrs）
   更新（連結）：あなたが同じキーを持っている場合は、元の値を上書きし、その後、2つの辞書をマージ。

dict1 = dict(name="aaaa",age=22) 
dict2 = dict(a="bbbb",age=23)

dict1.update(dict2)  #  #如果有重复的key，dict1的值会被dict2的值覆盖 （用dict2来更新dict1）
print(dict1)

5.クエリ：取得するには、キー、値、アイテム

1. 指定された値kを得るために.get（自己、K）。ない場合は、（デフォルトはNoneです）指定されたデフォルト値を返します

dict1 = dict(name="Alex",age=22) 

print(dict1.get('name'))  # 返回'Alex'
print(dict1.get('aaaa'))  # 'aaaa'不存在，返回None
print(dict1.get('aaaa', 'lalalala'))  # 'aaaa'不存在，返回'lalalala'
# 最后一行也可以写成：
# print(dict1.get(k='aaaa', default='lalalala'))

結果：

Alex
None
lalalala

1. .keys（自己）すべてのキー（dict_keysタイプ）を返します

2. .values（自己）のすべての値（dict_valuesタイプ）を返します

3. .items（自己）のすべての項目（dict_itemsタイプ）を返します

dict1 = dict(name="Alex",age=22) 

k = dict1.keys()
v = dict1.values()
i = dict1.items()

print(k, v, i)
print(type(k), type(v), type(i))

# print(k[0])  # 因为不是列表类型，会报错：TypeError
# print(v[0])  # 因为不是列表类型，会报错：TypeError
# print(i[0])  # 因为不是列表类型，会报错：TypeError

for k_ in k:  # 可以用for来访问
    print(k_)

結果：

dict_keys(['name', 'age'])
dict_values(['Alex', 22])
dict_items([('name', 'Alex'), ('age', 22)])
<class 'dict_keys'> <class 'dict_values'> <class 'dict_items'>
name
age

知識を展開

person = dict(name="Alex",age=22)  # 定义一个字典

# 方式1 官方推荐，效率最高

for i in person:
    print(i)  # 只会输出key
    print(i,person[i]  # 这样会打印key和value

# 方式2 
for i in person.keys():

# 方式3.1
for i in person.items():                
    print(i)  # 这样会以元组的形式打印出所有（key，vaule）

# 方式3.2
# for可以声明复数个临时变量，不过in后面的变量必须有对应的值

for k,v in person.items():  # 声明两个临时变量分别储存key和value  
    print(k,v)

注：順不同辞書、あなたがスライスすることはできませんので、

3.6元のセット（組）

読み取り専用のリストと同等実際にはタプル。

3.6.1特性タプル（変更されていません）

タプルの特長はリストに似ている、唯一の違いはあります

• 唯一のクエリ、変更することはできません

  スライスすることができます自然のスライスがコピーされますので、変更されていません

3.6.2メソッドのタプル

メソッドのリストを示します（チェックはそれだけであるため、読み取り専用）次の点を使用します。

1.作成：直接定義 '（）'、タプル

1. 直接定義

tuple1 = (99,12,32,["name1","name2"],12,43)  # 用()定义

1. タプル（）関数は、この方法はまた、INT（）、STR（）などの他の同様のデータ型を持つ>変換します。

list1 = ['a', 'b', 'c', 'd']
str1 = 'abcde'
tuple1 = tuple(list1)
tuple2 = tuple(str1)

print(tuple1)
print(tuple2)

結果：

('a', 'b', 'c', 'd')
('a', 'b', 'c', 'd', 'e')

タプル要素は一度だけである場合、ないタプルと見なされます。

a = ('aaa')
print(a,type(a))  # 结果是str型
# 正确的定义方法
a = ('aaa',)  # 加个,就是元组了

2.クエリ：LEN、で、インデックス、カウント

同じクエリとタプルのリスト、3.4.2を参照してください。

3.6.3変数のデータ・タイプタプル

タプルは、可変データ型要素を含む場合、これらの要素は変更することができる：例えば、リストを含みます。

なぜ？：要素は、（例えば、リストのような）別の容器である容器の内容および管理できない場合、タプルは、各要素のメモリアドレスに格納されているので

data = (99,12,32,["name1","name2"],12,43)
data[3][0] = "Alex"
print(data)

結果： (99, 12, 32, ['Alex', 'name2'], 12, 43)

3.7コレクション（セット）

コレクションは、非常に特徴的なデータ型です。

セット（要素不変タイプ、デエンファシス、障害）の3.7.1特性

コレクションには、次の特性があります。

1. 要素は、不変のデータ・タイプでなければなりません（ただし、追加または削除することができます）

   ··可変データの種類：リスト（一覧）、辞書（dictの）（キーを変更することはできません）・不変データタイプ：タプル（タプル）、コレクション（セット）、int型、float型、STR - 変数データと不変データ型の区別はハッシュかどうかです。不変のデータ・タイプは、ハッシュすることができ

2. 繰り返されるために生まれ（要素の集合には重複しません）

   定義された時間の重複要素がある場合、それは自動的に重くなります

3. 不規則

コレクションの特徴によると、私たちは頻繁に行うためにそれを使用します

• 重複除外：しかし、注意してください順不同コレクションであります
• 関係演算子：あなたは、二組の交差点などを取ることができます

3.7.2収集方法

今回我々は、調査の順序を変更する方法のリストを作成、追加または削除する必要があります。

、直接定義「{elems}」に設定1.作成

1. 直接定義： set1 = {1,2,3,4,5,'rain','alex'}

   注意：我々はセットを使用することができません定義するときset1 = {}、それは辞書を定義しますので、。空のセットの定義、我々が使用しますset1 = set()。

2. セット（）

list1 = ['aaa', 'bbb']
tuple1 = ('ccc', 'ddd')
dict1 = {'a': 1, 'b': 2}

set1 = set()
set2 = set(list1)
set3 = set(tuple1)
set4 = set(dict1)  # 只把key放入集合里

print(set1, type(set1))
print(set2)
print(set3)
print(set4)  # 输出key的集合

結果：

set() <class 'set'>
{'bbb', 'aaa'}
{'ccc', 'ddd'}
{'b', 'a'}

2.増加：追加

1. .add（自己、要素）コレクション要素に追加され

set1 = {1,2,3,4,5,'rain','alex'}  # 定义

set1.add(5)  # 不报错，因为重复只是不增加元素
set1.add([1,2,3])  # 报错，元素不能被hash -> 原因：可变的数据类型不能被添加
set1.add((1,2,3))  

3.削除：破棄、削除、ポップ

1. .discard（自己、要素）が
   指定された要素を削除し

set1 = {1,2,3,4,5,'rain','alex'}

set1.discard(5)  # 删除 5 
set1.discard(5)  # 删除不存在的元素不会报错

1. .remove（自己、エレメント）が指定された要素（指定された要素が存在しない：エラー）削除

set1 = {1,2,3,4,5,'rain','alex'}

set1.remove(4)  # 删除 4
set1.remove(4)  # 报错，KeyError

1. .pop（自己）は
   、ランダムな要素を削除するには、戻り（実際には、ハッシュ値シーケンスを？）：ポップアップ表示します

set1 = {1, 2, 'rain', 'alex'}

print(set1.pop())
print(set1.pop())
print(set1.pop())
print(set1.pop())  
print(set1.pop())  # 报错：对空集合pop报错-KeyError

4.クエリ：で、用

以下のためのトラバース要素を含んで指定した要素かどうかを決定する際に使用

コレクションをスライスすることはできません、修正することはできません（なぜなら障害）

関係演算子3.7.3のセット

1.交差点＆

二組とリターンの交差点を取ります。.intersectionと同じです（）

set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8, 89, 10}

temp_set = set1 & set2
print(temp_set)

2.コレクション（組合）|

コレクションとリターンの2セットを取ります。.unionと同じです（）

set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8, 89, 10}

temp_set = set1 | set2
print(temp_set)

3.違いを設定します -

要素の合計セットから控除し、[保存]を返します。）（.differenceと同じ

set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8, 89, 10}

temp_set = set1 - set2    # 从set1 中扣去 set1和set2都有的元素
print(temp_set)

4.対称差^

交差点以外の要素とは、リターンを取ります。）（.symmetric_differenceと同じ

set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8, 89, 10}

temp_set = set1 ^ set2    # 除了set1和set2共有的元素，其他都保留
print(temp_set)

5. .intersection_update、.difference_update

リレーショナル操作とカバー
交差点：.intersection_update（）
差分セット：.difference_update（）
set1.difference_update(set2) # 作用是取完差集，并且将结果赋值给set1

isdisjoint、issubset：6のセットを分析

1. .isdisjoint（自己、秒）が
   決定互いに素である：真の互いに素を返します。

2. .issubset（自己、s）が
   決定されたサブセットです：左と右のは彼らのリターンが真であります

7.演算子== <>

単に意味オペレータは、関係の二組を備え、
python3解释器执行 {2, 3, 4} >= {2, 3}和执行{2, 3, 4} > {2, 3}的结果为:True,True

---

3.8パブリック・ファンクション

• LEN（）＃デジタルデータタイプよりBOOLして使用することができます
• ＃できませんインデックスコレクション指数（障害）
• ＃リスト、タプル、文字列をスライス
• ステップ＃リスト、タプル、文字列
• 外ループ＃int型のために、すべてのBOOL