Python 学習ノート | 1 データコンテナ

Python | 1 データコンテナ

この章の内容: list、tuple、str、set、dict などの Python のデータ コンテナー。

関連するコードはすべてhttps://github.com/hzyao/Python-Cookbook
で参照できます。学びと練習を同時に行い、やがて発見できるのは素晴らしいことです。一緒に食べるとさらに美味しいかも！

ところで、私のように Python を開いたときに R が恋しくなる人はどれくらいいるでしょうか?

データコンテナ

1 データコンテナとは

データ コンテナ: 複数の要素を格納できるデータ型。要素には、文字列、数値、ブール値など、任意の型のデータを指定できます。

データコンテナの種類: list (リスト)、tuple (タプル)、str (文字列)、set (セット)、dict (辞書) それぞれに特徴がありますが、いずれも複数の要素を収容できるという特徴を満たしています。

2 リスト

リスト内の各データは要素と呼ばれます。

• []識別子として
• リスト内の各要素を次のように,区切ります。
• リストには複数のデータを一度に保存でき、さまざまなデータ型を使用でき、ネストもサポートされます。

# 定义列表字面量
["yhz", "lr", "xmy", 666, True]

# 定义列表变量
my_list = ["yhz", "lr", "xmy", 666, True]
print(my_list)
print(type(my_list))

# 定义空列表
o_list = []
o_list = list()
print(o_list)
print(type(o_list))

# 定义一个嵌套的列表
my_list = [[1,2,3], [4,5,6]]
print(my_list)
print(type(my_list))

2.1 リストの添字インデックス

リストの各要素には番号があり、これを添え字インデックスと呼びます。列表[下标]取り出し可能です。ネストされたリストは添字インデックス付けもサポートします。

前から後ろに、0 から始まり、0、1、2、3... と順番に増加します。

後ろから前に、-1 から始まり、-1、-2、-3... の順に減少します。

# 列表的下标索引
my_list = ["yhz", "lr", "xmy", 666, True]
print(my_list[0])
print(my_list[1])
print(my_list[4])

# 倒序取出
print(my_list[-5])
print(my_list[-4])
print(my_list[-1])

# 取出嵌套列表元素
my_list = [[1,2,3], [4,5,6]]
print(my_list[0][1])

注: 添字インデックスの値の範囲に注意してください。範囲を超える要素は取得できません。必ず 0 から開始してください。

2.2 リストに対する一般的な操作

補足知識

関数とメソッド

関数は、特定の機能を提供するカプセル化されたコード単位です。

Python では、関数がクラスのメンバーとして定義されている場合、その関数は メソッド と呼ばれます。

# 函数
def add(x, y):
		return x + y

# 方法
class Student:
		def add(self, x, y):
				return x + y

メソッドには関数と同じ機能があり、受信パラメータと戻り値がありますが、メソッドの使用形式が異なります。

# 函数的使用
num = add(1, 2)

# 方法的使用
student = Student()
num = student.add(1, 2)

• クエリ機能

  機能: リスト内の指定された要素の添え字を検索し、見つからない場合はエラーを報告しますValueError。

  文法：列表.index(元素)

  indexリストオブジェクト（変数）の組み込みメソッド（関数）です。

• 変更機能

  機能: 特定の位置 (インデックス) の要素の値を変更し、指定された添字の値を再割り当てします。

  文法：列表[下标] = 值

• 挿入機能

  機能: 指定された要素を指定された添字位置に挿入します。

  文法：列表.insert(下标, 元素)

• 要素を追加

  機能: 指定された要素をリストの末尾に追加します。

  構文: 列表.append(元素)(1 つ追加)、列表.extend(其他数据容器)(他のデータ コンテナの内容を取り出し、順番にリストの最後に追加)

• 要素の削除

  構文: del 列表[下标], 列表.pop(下标)(リストから要素を削除), 列表.remove(元素)(リスト内で最初に出現した要素を削除)

• リストをクリアする

  文法：列表.clear()

• リスト内の要素の数を数える

  文法：列表.count(元素)

# 列表常用操作
## 查询元素下标
my_list = ["yhz", "lr", "xmy", 666, True]
my_list.index("lr")

## 修改元素
my_list[2] = "xiaomanyao"
print(my_list)

## 插入元素
my_list.insert(1, "loves")
print(my_list)

## 追加元素
my_list.append("耶")
print(my_list)

## 追加一批元素
add_list = [1,2,3]
my_list.extend(add_list)
print(my_list)

## 删除元素
del my_list[9]
print(my_list)

## 从列表中取出元素并将其删除
delete = my_list.pop(8)
print(my_list)
print(delete)

## 删除某元素在列表中的第一个匹配项
my_list.remove(1) # 豁，1 就是 True 哈！帅的！
print(my_list)

## 清空列表
my_list.clear()
print(my_list)

## 统计某元素在列表中的数量
my_list = ["yhz", "lr", "xmy", 666, True, "lr"]
count = my_list.count("lr")
print(count)

## 统计列表中全部元素数量
count = len(my_list)
print(count)

概要:
列表.append(元素): 要素をリストに追加します;
列表.extend(容器): データ コンテナの内容を 1 つずつ取り出してリストの最後に追加します; :
列表.insert(下标,元素)指定された要素を指定された添え字に挿入します; :
del 列表[下标]指定された添え字要素をリストから削除します;
列表.pop(下标): 指定された添え字をリスト要素から削除します;
列表.remove(元素): この要素に最初に一致した項目を前から後ろに削除します;
列表.clear(): リストをクリアします;
列表.count(元素): この要素がリストに出現する回数をカウントします; :
列表.index(元素)指定された要素を検索し、リストの添え字で見つからない場合は、エラー ValueError を報告します;
len(列表): コンテナ内の要素の数をカウントします。

リスト機能:

1. 複数の要素を収容可能 (上限は 2**63-1)
2. さまざまなタイプの要素 (混合) に対応可能
3. データは順番に保存されます（下付きシリアル番号付き）
4. 重複データの存在を許可する
5. 要素は変更可能（追加または削除）

2.3 リストのループトラバーサル

トラバーサル: コンテナ内の要素を 1 つずつ取り出して処理することをトラバーサル操作と呼びます。while ループまたは for ループを使用できます。

while ループと for ループの比較

オンループ制御:

1. while ループはループ条件をカスタマイズし、それ自体を制御できます。
2. for ループはループ条件をカスタマイズできず、コンテナからデータを 1 つずつ取得することしかできません。

無限ループの場合:

1. while ループは条件付き制御を通じて無限にループできます。
2. 走査されるコンテナの容量は無限ではないため、for ループは理論的には不可能です。

使用シナリオでは:

1. while ループは、ループを実行するあらゆるシナリオに適しています。
2. for ループは、データ コンテナーの走査や単純な固定数ループ シナリオに適しています。

# while 循环遍历列表
my_list = ["yhz", "lr", "xmy", 666, True, "lr"]

def list_while(data):
    index = 0
    while index < len(data):
        element = data[index]
        print(element)
        index += 1

list_while(my_list)

# for 循环遍历列表
my_list = ["yhz", "lr", "xmy", 666, True, "lr"]

def list_for(data):
    for element in my_list:
        print(element)

list_for(my_list)

# 练习：遍历取偶数
list = [1,2,3,4,5,6,7,8,9,10]
new_list = []
i = 0
while i < len(list):
    if list[i] % 2 == 0:
        new_list.append(list[i])
    i += 1
print(new_list)

for i in list:
    if i % 2 == 0:
        new_list.append(i)
print(new_list)

3タプル

タプルは、リストと同様に、異なる型の複数の要素をカプセル化できます。最大の違いは、タプルが一度定義されると変更できないことです(リストがタプル内にネストされている場合、リスト内の要素は変更できます)。

タプルは別個のデータで()定義および,分離されます。データは異なるデータ型にすることができます。ネストと添え字インデックスもサポートしています。書き込み方法は同じです。

注: タプルにはデータが 1 つだけあり、このデータの後にカンマを追加する必要があります。そうでない場合、タプル タイプではありません。

# 定义元组字面量
("yhz", "lr", "xmy", 666, True)

# 定义元组变量
my_tuple = ("yhz", "lr", "xmy", 666, True)
print(my_tuple)
print(type(my_tuple))

# 定义空元组
o_tuple = ()
o_tuple = tuple()
print(o_tuple)
print(type(o_tuple))

# 定义单个元素的元组，切记后面加逗号
single_tuple = ("hello",)
type(single_tuple)

3.1 タプルに対する一般的な操作

index(): 特定のデータを検索し、データが存在する場合は対応する添字を返します。存在しない場合はエラーが報告されます。
count(): 現在のタプル内に特定のデータが出現する回数をカウントします。
len(元组): タプル内の要素の数をカウントします。

# 元组的常用操作
my_tuple = ("yhz", "lr", "xmy", 666, True, "lr")

## 查找元素对应下标
my_tuple.index(666)

## 统计元素在当前元组中出现的次数
my_tuple.count("lr")

## 统计当前元组内元素个数
len(my_tuple)

3.2 タプルのループトラバーサル

# 元组的遍历
my_tuple = ("yhz", "lr", "xmy", 666, True, "lr")

index = 0
while index < len(my_tuple):
        element = my_tuple[index]
        print(element)
        index += 1

for element in my_tuple:
        print(element)

# 元组中嵌套列表，列表中元素可修改
my_tuple = (["yhz", "lr", "xmy"], 666, True, "lr")
my_tuple[0][2] = "xiaomanyao"
my_tuple

4弦

私たちはすでに文字列に精通しています。簡単な紹介！

文字列は文字のコンテナです。文字列には任意の数の文字を格納できます。格納できるのは 文字列 のみです。添え字を使用してインデックスを付けることができ、走査することもできます。

タプルと同様、変更できないデータ コンテナです。指定された文字の変更、削除、追加などの操作は完了できません。そのような操作が必要な場合は、新しい文字列のみが取得され、古い文字列は変更できません。

4.1 文字列に対する一般的な操作

• 特定の文字列の開始添字インデックス値を検索します。字符串.index(字符串)
• 置換、文字列内のすべてを次の文字列に字符串1置き換えます字符串2。。 注: 文字列自体は変更されませんが、新しい文字列が取得されます。字符串.replace(字符串1, 字符串2)
• Split は、指定された文字列区切り文字に従って文字列を複数の文字列に分割し、リスト オブジェクトに格納します。注: 文字列自体は変更されませんが、リスト オブジェクトが取得されます。字符串.split(字符串分隔符)
• 正規化操作。字符串.strip()先頭と末尾のスペースを削除し、字符串.strip(字符串)先頭と末尾の指定された文字列を削除します。
• 字符串.count(某字符串)文字列内の特定の文字列の出現数を数え、len(字符串)文字列の長さを数えます。

# 通过下标索引取值
my_str = "xiao man yao"
value1 = my_str[3]
value2 = my_str[-1]
print(value1, value2)

# 获取元素起始下标
index = my_str.index("man")
print(index)

# 替换
new_my_str = my_str.replace("yao", "liu")
print(new_my_str)

# 分割
my_str_list = my_str.split(" ")
print(my_str_list)
print(type(my_str_list))

# 规整操作
## 去除前后空格
my_str = "  xiao man yao        "
new_my_str = my_str.strip()
print(new_my_str)

## 去除前后指定字符串
my_str = "axiao man yao"
new_my_str = my_str.strip("ao")
print(new_my_str)

# 统计某字符串在字符串中的出现次数
my_str = "xiao man yao"
count = my_str.count("ao")
print(count)

lenth = len(my_str)
print(lenth)

概要:
字符串[下标]:添え字インデックスに基づいて特定の位置にある文字を取得します;
字符串.index(字符串):指定された文字に最初に一致する添え字を検索します;
字符串.replace(字符串1, 字符串2):文字列内のすべての文字列 1 を文字列 2 に置き換えます; 元の文字列は変更されませんが、新しい文字列を取得しますone;
字符串.split(字符串): 指定された文字列に従って、文字列を区切っても元の文字列は変更されませんが、新しいリストが取得されます; : 先頭
字符串.strip() / 字符串.strip(字符串)と末尾のスペースと改行を削除するか、文字列を指定します;
字符串.count(字符串): 特定の文字列の出現回数をカウントしますa string;
len(字符串): 文字列内の文字数をカウントします。

5 シーケンス

シーケンス: コンテンツが連続的で順序付けされており、添字を使用してインデックスを付けることができるデータ コンテナーのタイプ。リスト、タプル、文字列はすべてシーケンスとみなすことができます。

5.1 シーケンスのスライス

シーケンスはスライスをサポートします。つまり、リスト、タプル、文字列はすべてスライス操作をサポートします。

スライス: シーケンスからサブシーケンスを削除します。

構文:序列[起始下标:结束下标:步长]
指定された位置から始まり、指定された位置で終わるシーケンスから要素を削除して、新しいシーケンスを取得することを意味します。

• 開始添え字はどこから開始するかを示します。空白のままでも構いません。空白のままにした場合は、最初から開始すると見なされます。
• 終了添字 (含まれていません) は、どこで終了するかを示します。空白のままでも構いません。空白のままにした場合、最後までインターセプトされたものとみなされます。
• ステップ サイズは、要素間の間隔が順番に取得されることを示します。
  • ステップ サイズ 1 は、要素を 1 つずつ取得することを意味します (デフォルトのステップ サイズは 1 で、省略できます)
  • ステップ サイズ 2 は、1 つの要素がスキップされて取得されるたびに意味します。
  • ステップ サイズ N は、取得するたびに N-1 個の要素がスキップされることを意味します。
  • ステップ長が負の数の場合、逆方向に取得されます (開始添え字と終了添え字も逆にマークする必要があることに注意してください)。

注: この操作はシーケンス自体には影響しませんが、新しいシーケンスが作成されます。

# 切片
my_list = [0, 1, 2, 3, 4, 5, 6]
result = my_list[1:4] # 步长默认为1，可以省略不写
print(result)

my_tuple = (0, 1, 2, 3, 4, 5, 6)
result = my_tuple[::2] # 起始和结束不写表示从头到尾
print(result)

my_str = "012, 3, 4,5,6"
result = my_str[:]
print(result)

re_result = my_str[::-1]
print(re_result)

re_result = my_tuple[:2:-1]
print(re_result)

# 可以传递链式巴拉巴拉
my_str = "小蛮腰,是要要要,润要蛮小,冲啊"

result = my_str.split(",")[2].replace("润", "")[::-1]
print(result)

6コレクション

なぜあなたはそれが必要なのですか！

特徴を見てみましょう:

• リストは変更可能で、繰り返しの要素をサポートし、順序付けされています。
• タプルと文字列は変更できず、繰り返し要素をサポートし、順序付けされます。

制限事項: どちらも繰り返し要素をサポートしています。シーンでコンテンツの重複排除が必要な場合、リスト、タプル、文字列はさらに不便です。コレクションの主な特徴は、要素の繰り返しがサポートされていないこと (重複排除機能が組み込まれている)、コンテンツに順序がないことです。

基本的にはリスト、タプル、文字列などと同じ定義です。

• リスト：[]
• タプル:()
• 弦：””
• 集める：{}

# 定义集合变量
my_set = {
    
    "yhz", "lr", "xmy", "yhz", "lr", "xmy", "yhz", "lr", "xmy"}
print(my_set)
print(type(my_set))

# 定义空集合
o_set = set()
print(o_set)
print(type(o_set))

o_set = {
    
    }
print(o_set)
print(type(o_set)) # 惊现字典！！！！！

6.1 コレクションに対する一般的な操作

まず、コレクションは順序付けされていないため、コレクションは添字インデックスアクセスをサポートせず、重複データの存在を許可しません。ただし、リストと同様に変更が可能です。

• 指定された要素をコレクションに追加します (コレクション自体が変更されます)。集合.add(元素)
• 指定された要素をコレクションから削除します (コレクション自体が変更されます)。集合.remove(元素)
• コレクションから要素をランダムに削除すると要素が生成され、同時にコレクションが変更され、要素が削除されます。集合.pop()
• コレクションをクリアします。集合.clear()
• 2 つのセットの差分を取り、新しいセットを取得します。集合1.difference(集合2)(セット 1 には存在するがセット 2 には存在しないものを取得し、セット 1 とセット 2 は変更されません)
• 2 つのセットの差をなくします。集合1.difference_update(集合2)(セット 1 では、セット 2 と同じ要素を削除し、セット 1 は変更され、セット 2 は変更されません)
• セットをマージし、セットを結合して新しいセットを形成しても、元のセットは変更されません。集合1.union(集合2)

# 添加元素
my_set = {
    
    "yhz", "lr"}
my_set.add("xmy")
print(my_set)

my_set.add("lr") # 添加已有元素会自动去重，相当于没添加
print(my_set)

# 移除元素
my_set.remove("xmy")
print(my_set)

# 随机取出元素
element = my_set.pop()
print(element)
print(my_set)

# 清空集合
my_set.clear()
print(my_set)

# 取两个集合的差集
set_1 = {
    
    1,2,3}
set_2 = {
    
    5,2,0}
set_3 = set_1.difference(set_2)
print(set_1)
print(set_2)
print(set_3)

# 消除两个集合的差集
set_1.difference_update(set_2)
print(set_1)
print(set_2)

# 合并集合
set_1 = {
    
    1,2,3}
set_2 = {
    
    5,2,0}
set_3 = set_1.union(set_2)
print(set_3)

# 统计集合元素数量
print(len(set_3))

注: コレクションは添え字インデックスをサポートしていません。また、while ループは使用できませんが、for ループを使用して走査することができます。

# 集合的遍历：集合不支持下标索引，不能用 while 循环，可以使用 for 循环遍历
my_set = {
    
    "yhz", "lr", "xmy"}

for elemnet in my_set:
    print(elemnet)

要約:

集合.add(元素): 要素をコレクションに追加します。

集合.remove(元素): 指定された要素をコレクションから削除します。

集合.pop(): セットから要素をランダムに削除します。

集合.clear(): コレクションをクリアします。

集合1.difference(集合2): 2 つのセットの差分セットを含む新しいセットを取得します。元の 2 つのセットの内容は変更されません。

集合1.difference_update(集合2): セット 1 で、セット 2 に存在する要素を削除します。セット 1 は変更され、セット 2 は変更されません。

集合1.union(集合2): 2 つのコレクションのすべての要素を含む新しいコレクションを取得します。元の 2 つのコレクションの内容は変更されません。

len(集合): セット内の要素の数を記録する整数を取得します。

7 辞書

Dictionary: 同様に使用されます{}が、格納される要素はキーと値のペア{"key": value, "key": value, "key": value}です。

コレクションと同様、ディクショナリでは添字インデックスを使用できませんが、 をkey介して取得できますvalue。

key複製は禁止されており、追加を繰り返すことは元のデータを上書きすることと同じです。

ディクショナリのkey合計はvalue任意のデータ型 (ディクショナリ** 以外) にすることができる**keyため、ディクショナリをネストすることができます。

# 定义字典
my_dict = {
    
    "yhz": 99, "lr": 88, "xmy": 77}
print(my_dict)
print(type(my_dict))

# 定义空字典
o_dict = {
    
    }
print(o_dict)
print(type(o_dict))
o_dict = dict()
print(o_dict)
print(type(o_dict))

# 通过key获取value
score = my_dict["lr"]
print(score)

# 嵌套字典
score_dict = {
    
    
    "yhz":{
    
    
    "history": 33,
    "math": 99,
    "art": 99
    },
    "lr":{
    
    
    "history": 99,
    "math": 66,
    "art": 55
    },
    "xmy":{
    
    
    "history": 33,
    "math": 88,
    "art": 77
    }
}
print(score_dict)

# 从嵌套字典中获取信息
lr_math = score_dict["lr"]["math"]
print(lr_math)

7.1 辞書に対する共通操作

• 新しい要素が追加され、同時に辞書が変更されます。注: ディクショナリは繰り返すことができないため、key既存のディクショナリに対してkeyこの操作を実行すると更新になりますvalue。字典[key] = value
• 要素の更新と辞書の変更を同時に行った場合も上記と同様の動作となるが、その理由については上で詳述した。字典[key] = value
• 要素を削除すると辞書が変更され、指定したキーのデータが削除されます。字典.pop(key)
• 要素がクリアされ、辞書が変更されます。字典.clear()
• 全部入手してくださいkey。字典.keys()

# 字典的常用操作
my_dict = {
    
    "yhz": 99, "lr": 88, "xmy": 77}

# 新增元素
my_dict["run"] = 66
print(my_dict)

# 更新元素
my_dict["xmy"] = 33
print(my_dict)

# 删除元素
score = my_dict.pop("xmy")
print(score)
print(my_dict)

# 清空元素
my_dict.clear()
print(my_dict)

# 获取全部key
my_dict = {
    
    "yhz": 99, "lr": 88, "xmy": 77}
keys = my_dict.keys()
print(keys)

# 遍历字典
for key in keys:
    print(key)
    print(my_dict[key])

for key in my_dict:
    print(key)
    print(my_dict[key])

# 统计字典内元素数量
count = len(my_dict)
print(count)

要約:

字典[Key]: 指定された Key に対応する Value 値を取得します。

字典[Key]=Value: キーと値のペアを追加または更新します。

字典.pop(Key): キーに対応する値を取り出し、辞書内のこのキーのキーと値のペアを削除します。

字典.clear(): 辞書をクリアします。

字典.keys(): 辞書のすべての Kev を取得します。これは、for ループで辞書を走査するために使用できます。

len(字典): 辞書内の要素の数をカウントします。

# 练习：升职加薪
salary = {
    
    
    "wly":{
    
    
    "bm":"kjb",
    "gz":3000,
    "jb":1
    },
    "zjl":{
    
    
    "bm":"scb",
    "gz":50000,
    "jb":2
    },
    "ljj":{
    
    
    "bm":"scb",
    "gz":7000,
    "jb":3
    },
    "zxy":{
    
    
    "bm":"kjb",
    "gz":4000,
    "jb":1
    },
    "ldh":{
    
    
    "bm":"scb",
    "gz":6000,
    "jb":2
    },
}
print(salary)

for key in salary:
    if salary[key]["jb"] == 1:
        salary[key]["gz"] += 1000
        salary[key]["jb"] += 1

print(salary)

8 データコンテナの概要と比較

	リスト	タプル	弦	集める	辞書
要素の数	複数のサポート	複数のサポート	複数のサポート	複数のサポート	複数のサポート
要素の種類	任意	任意	文字のみ	任意	キー: 値 (キー: 辞書を除く任意の型、値: 任意の型)
添字インデックス	サポート	サポート	サポート	サポートしません	サポートしません
繰り返し要素	サポート	サポート	サポート	サポートしません	サポートしません
修正可能性	サポート	サポートしません	サポートしません	サポート	サポート
データを順番に並べる	はい	はい	はい	いいえ	いいえ
使用するシーン	変更可能で反復可能なバッチデータ記録シナリオ	変更不可で反復可能なバッチデータ記録シナリオ	文字列の収録風景	反復不可能なデータ記録シナリオ	キーを使用して値を取得するためのデータ記録シナリオ

9 データコンテナの共通操作

データ コンテナーにはそれぞれ独自の特性がありますが、共通の操作もいくつかあります。

1. まず、トラバーサルに関しては、5 種類のデータ コンテナーすべてがループ トラバーサルをサポートしています。リスト、タプル、文字列は while ループをサポートしますが、コレクションと辞書はサポートしません (インデックスに添え字を付けることはできません)。トラバーサルにはさまざまな形式がありますが、それらはすべてトラバーサル操作をサポートしています。

2. トラバーサルの共通性に加えて、一般的な関数メソッドが多数あります。

   len(容器): コンテナ内の要素の数をカウントします。

   max(容器): 統計コンテナの最大の要素

   min(容器): 統計コンテナの最小要素

   list(容器):指定されたコンテナをリストに変換します

   str(容器): 指定されたコンテナを文字列に変換します

   tuple(容器):指定されたコンテナをタプルに変換します

   set(容器): 指定されたコンテナをコレクションに変換します

   注: 文字列への辞書変換はvalue保持され、それ以外はすべてそのまま残りますkey。

3. Sort: sorted(容器, reverse=True)、指定されたコンテナを並べ替えます。注: ソートされた結果はリストになります。

# 除遍历外，还有超多通用的功能方法
my_list = [1, 2, 3]
my_tuple = (1, 2, 3, 4)
my_str = "12345"
my_set = {
    
    1, 2, 3, 4, 5}
my_dict = {
    
    "key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}

print(len(my_list))
print(len(my_tuple))
print(len(my_str))
print(len(my_set))
print(len(my_dict))

print(max(my_list))
print(max(my_tuple))
print(max(my_str))
print(max(my_set))
print(max(my_dict))

print(min(my_list))
print(min(my_tuple))
print(min(my_str))
print(min(my_set))
print(min(my_dict))

print(list(my_str))
print(type(list(my_str)))

print(str(my_list))
print(type(str(my_list)))

print(tuple(my_set))
print(type(tuple(my_set)))

print(set(my_dict))
print(type(set(my_dict)))

my_set = {
    
    4, 5, 3, 7, 0, 2}
print(sorted(my_set))
print(sorted(my_set, reverse=True))

要約:

一般的な for ループ: コンテナーを走査します (辞書はキーを走査します)。

max(): コンテナ内の最大の要素。

min(): コンテナ内の最小の要素。

len():コンテナ要素の数。

list():リストに変換します。

tuple():タプルに変換します。

str(): 文字列に変換します。

set():セットに変換します。

sorted(序列, [reverse=True]): ソート。reverse=True降順にソートされたリストが取得されることを示します。