著者: 孤筝(lvbowen040427@163.com)

前順序、後順序による二分木のスレッド化

a. 問題分析

二分木の前順序スレッディングを実装する必要があります。スレッディングとは、二分リンクリストの空ポインタ領域を、特定の走査順序における前駆ノードまたは後続ノードを指すように変更する方法です。これにより、前順序、中順序、または後順序のいずれかのノードから開始することができ、根ノードからだけではなくなります。

b. アルゴリズム設計

私たちのアルゴリズムはまず二分木を作成し、その後それをスレッド化します。スレッド化のプロセスは再帰関数によって実装され、この関数は各ノードを走査し、その左右の子ノードが存在するかどうかをチェックします。存在しない場合、その左/右ポインタを前/次のノードに指向させます。最後に、スレッド化が成功したかどうかを確認するため、中間順走査を行います。

以下はスレッド化のコードスニペットです：

// スレッドを作成する関数
void createThread(Node* p) {
    if (p == NULL) { // ノードが空の場合、直接戻る
        return;
    }
    createThread(p->left); // 左部分木を再帰的に処理
    if (!p->left) { // 左子ノードが空の場合、左ポインタを前のノードに指向させ、左スレッドフラグを1に設定
        p->left = pre;
        p->ltag = 1;
    }
    if (pre && !pre->right) { // 前のノードの右子ノードが空の場合、その右ポインタを現在のノードに指向させ、右スレッドフラグを1に設定
        pre->right = p;
        pre->rtag = 1;
    }
    pre = p; // 前のノードを更新
    createThread(p->right); // 右部分木を再帰的に処理
}

c. データ構造設計

二分木のノードを表現するために、構造体を使用します。この構造体には、データフィールドと2つのポインタフィールドが含まれており、それぞれ左子ノードと右子ノードを指します。さらに、左右のポインタがスレッド化されているかどうかを示す2つのマークフィールドを追加しました。

以下はデータ構造のコードスニペットです：

// 二分木ノードの構造体を定義
struct Node {
    int data; // ノードのデータ
    Node* left; // 左子ノード
    Node* right; // 右子ノード
    int ltag, rtag; // 左右スレッドマーク
};

d. デバッグプロセス

まず二分木を作成し、それをスレッド化します。その後、中順走査を行い、スレッド化が成功したかどうかを確認します。走査結果が期待通りの結果と一致すれば、スレッド化は成功したと判断できます。

以下はデバッグプロセスのコードスニペットです：

int main() {
    // 二分木を作成
    Node n1, n2, n3, n4, n5;
    n1 = {1, &n2, &n3, 0, 0};
    n2 = {2, &n4, &n5, 0, 0};
    n3 = {3, NULL, NULL, 0, 0};
    n4 = {4, NULL, NULL, 0, 0};
    n5 = {5, NULL, NULL, 0, 0};
    // 二分木をスレッド化
    createThread(&n1);
    // スレッド化された二分木を中順走査
    inOrder(&n1);
    return 0;
}

e. 出力結果

プログラムの出力結果は二分木の中間順走査結果であるべきです。この例では、出力結果は 4 2 5 1 3 となるはずです。作成した二分木の中間順走査結果がこのシーケンスになります。

f. ソースコード

#include<iostream>
using namespace std;

// 二分木ノードの構造体を定義
struct Node {
    int data; // ノードのデータ
    Node* left; // 左子ノード
    Node* right; // 右子ノード
    int ltag, rtag; // 左右のスレッドマーク
};

// 前のノードを保存するためのグローバル変数preを定義
Node* pre = NULL;

// スレッドを作成する関数
void createThread(Node* p) {
    if (p == NULL) { // ノードが空の場合、直接戻る
        return;
    }
    createThread(p->left); // 左部分木を再帰的に処理
    if (!p->left) { // 左子ノードが空の場合、左ポインタを前のノードに指向し、左スレッドマークを1に設定
        p->left = pre;
        p->ltag = 1;
    }
    if (pre && !pre->right) { // 前のノードの右子ノードが空の場合、その右ポインタを現在のノードに指向し、右スレッドマークを1に設定
        pre->right = p;
        pre->rtag = 1;
    }
    pre = p; // 前のノードを更新
    createThread(p->right); // 右部分木を再帰的に処理
}

// スレッド二分木を中順走査する関数
void inOrder(Node* p) {
    while (p) {
        while (!p->ltag) { // 最も左のノードを見つける
            p = p->left;
        }
        cout << p->data << " "; // ノードデータを出力
        while (p->rtag) { // 右ポインタがスレッドの場合、直接後続ノードにジャンプ
            p = p->right;
            cout << p->data << " ";
        }
        p = p->right; // 右部分木を処理
    }
}

int main() {
    // 二分木を作成
    Node n1, n2, n3, n4, n5;
    n1 = {1, &n2, &n3, 0, 0};
    n2 = {2, &n4, &n5, 0, 0};
    n3 = {3, NULL, NULL, 0, 0};
    n4 = {4, NULL, NULL, 0, 0};
    n5 = {5, NULL, NULL, 0, 0};
    // 二分木をスレッド化
    createThread(&n1);
    // スレッド二分木を中順走査
    inOrder(&n1);
    return 0;
}

グラフの隣接行列と隣接リストの記憶

a. 問題分析

私たちの目標は、C++でグラフの隣接行列と隣接リストの保存を実装することです。これには、配列（隣接行列用）とリンクリスト（隣接リスト用）という2つの異なるデータ構造が関わってきます。

b. アルゴリズム設計

隣接行列

二次元配列adj[MAX][MAX]を使用してグラフの隣接行列を格納します。各要素adj[i][j]は、ノードiからノードjへの辺が存在するかどうかを示します。存在する場合、adj[i][j] = 1、そうでない場合はadj[i][j] = 0となります。

for (i = 1; i <= max_edges; i++) {
    cin >> origin >> destin;
    if ((origin == -1) && (destin == -1))
        break;
    if (origin >= n || destin >= n || origin < 0 || destin < 0) {
        i--;
    } else {
        adj[origin][destin] = 1;
    }
}

隣接リスト

連結リストの配列list<int> *adjを使用してグラフの隣接リストを格納します。各要素adj[i]は、ノードiに隣接するすべてのノードを格納する連結リストです。

void Graph::addEdge(int v, int w) {
    adj[v].push_back(w);
}

c. データ構造設計

隣接行列

二次元配列int adj[MAX][MAX]を使用して隣接行列を格納します。MAXはグラフ内のノードの最大数です。

隣接リスト

リンクリストの配列list<int> *adjを使用して隣接リストを格納します。Vはグラフ内のノードの数です。

d. デバッグプロセス

コードの実装とデバッグの過程で、まず入力された辺が有効であることを確認しました。入力された辺が無効な場合（例えば、存在しないノードを参照している場合）、ユーザーに通知し、再入力を促します。

隣接行列または隣接リストに辺を追加する際には、配列やリンクリストの範囲外インデックスにアクセスしようとしないように、エラーチェックを使用しました。

e. 出力結果

最後に、隣接行列または隣接リストを出力して、コードが正しいかどうかを確認できます。隣接リストの場合、各ノードのリンクリストを走査し、すべての隣接ノードを出力します。

void Graph::printGraph() {
    for (int v = 0; v < V; v++) {
        cout << "\n Adjacency list of vertex " << v << "\n head ";
        for (auto x : adj[v])
            cout << "-> " << x;
        printf("\n");
    }
}

f. ソースコード

隣接行列による格納

#include<iostream>
#define MAX 20
using namespace std;

int adj[MAX][MAX];
int n;

void create_graph() {
    int i, max_edges, origin, destin;

    cout << "Enter number of nodes : ";
    cin >> n;
    max_edges = n * (n - 1);

    for (i = 1; i <= max_edges; i++) {
        cout << "Enter edge " << i << " (-1 -1 to quit) : ";
        cin >> origin >> destin;

        if ((origin == -1) && (destin == -1))
            break;

        if (origin >= n || destin >= n || origin < 0 || destin < 0) {
            cout << "Invalid edge!\n";
            i--;
        } else {
            adj[origin][destin] = 1;
        }
    }
}

隣接リストによる格納

#include<iostream>
#include<list>
using namespace std;

class Graph {
    int V;
    list<int> *adj;

public:
    Graph(int V);

    void addEdge(int v, int w);

    void printGraph();
};

Graph::Graph(int V) {
    this->V = V;
    adj = new list<int>[V];
}

void Graph::addEdge(int v, int w) {
    adj[v].push_back(w);
}

void Graph::printGraph() {
    for (int v = 0; v < V; v++) {
        cout << "\n Adjacency list of vertex " << v << "\n head ";
        for (auto x : adj[v])
            cout << "-> " << x;
        printf("\n");
    }
}

この記事は2023-12-12に孤筝の温暖小家で公開され、最終更新日は2023-12-12です

本ブログのすべての文書は、特に指定されていない限り、BY-NC-SAライセンスに従っています。引用の際は出典を明記してください！

著者: 孤筝(lvbowen040427@163.com)

elemは単語element（要素）の略称であり、プログラムの定義では不確定な型、つまり抽象的なデータ型を表します。

リスト

定義

順番に並べられた要素からなるコンテナ

• 要素は任意の型で可能
• 要素は確定した順序で並び、順序性を持つ

リストの作成

空のリストインスタンスを作成してから要素を追加する

• list()
• .append()メソッド

>>>wife = list()#インスタンス化
>>>wife.append("西宮硝子")
>>>wife.append("櫻島麻衣")
>>>wife.append("愛莉希雅")
>>>wife
['西宮硝子','櫻島麻衣','愛莉希雅']

直接リストを定義して要素を埋める

>>> phones = ["Apple", "Huawei", "Xiaomi"]
>>> phones
['Apple', 'Huawei', 'Xiaomi']

要素の確認

1. インデックスの使用 $[i]$でi+1番目の要素を確認
2. index()メソッド $$name.index(x)$$ list name内で最初に値がxとなる要素を検索し、そのインデックスを返す
3. count()メソッド $$name.count(x)$$ list name内で値がxとなる要素がいくつあるかを確認し、その数を返す
4. len()メソッド $$name.len()$$ list name内の要素の総数を検索し、その数を返す

新しい要素の追加

1. append()メソッド $$name.append(x)$$ nameの末尾に要素xを追加する
2. insert()メソッド $$name.insert(i,x)$$ オブジェクトxをnameのインデックスiの位置に挿入し、元のiおよびi以降の要素を順番に後ろに移動させる
3. extend()メソッド $$name.extend(name2)$$ リストname2をリストnameの後ろに連結する

要素の変更

1. インデックスを指定して要素を直接代入して変更する

要素の削除

1. pop()メソッド $$name.pop()$$ デフォルトでlistの最後の要素を削除 $$name.pop(i)$$ インデックスがiの要素を削除し、後ろの要素を順番に前に移動
2. remove()メソッド $$name.remove(x)$$ 最初に値がxである要素を削除し、後ろの要素を順番に前に移動
3. clear()メソッド $$name.clear()$$ すべての要素を削除（listを空にする）
4. del文 $$del\ name[a:b]$$ delインデックス$[a,b)$の要素を削除、aを含みbを含まない $del\ name[:]$はlistを空にすることを意味する $$del\ name[i]$$ インデックスがiの要素を削除

リストの反転

1. reverse()メソッド $$name.reverse()$$ リストnameを反転させ、最後の要素が最初の要素になり、以降も同様に順番が逆になります。
2. スライス法

>>> nums=[1,2,3,4,5]
>>> new_nums=nums[::-1]
>>> new_nums
[5,4,3,2,1]

元のオブジェクトnumsは変更されず、反転されたリストとして新しいオブジェクトnew_numsが生成されます。

リストのソート

1. sort()メソッド $$name.sort()$$ $$name.sort(cmp=None,key=None,reverse=False)$$

• このメソッドは戻り値がなく、元のlistを直接変更します

• cmpはオプションのパラメータです

• keyは要素のどのパラメータを比較の重みとして使用するかを指定し、比較可能なオブジェクトから取られる単一のパラメータです

  • 比較要素elemが単一のパラメータ（数字や単一の文字など）のみを含む場合、keyパラメータは省略可能です。

# リストの2番目の要素を取得
def takeSecond(elem):
    return elem[1]
# リスト
random = [(2, 2), (3, 4), (4, 1), (1, 3)]

# 2番目の要素でソートを指定
random.sort(key=takeSecond)
#関数takeSecondを通じてタプルの2番目の要素（重み）を比較するように指定

# リストを出力
print('ソートされたリスト：')
print(random)

ソートされたリスト：
[(4, 1), (2, 2), (1, 3), (3, 4)]

• reverseはソートのルールで、デフォルトはFalseで昇順、Trueは降順です

タプル

定義

タプル（tuple）は、一連の要素を順番に並べて形成されるコンテナです。 タプルは不変（immutable）であり、リストは可変（mutable）です。

タプルの作成

1. 直接$()$ですべての要素を囲むことで作成、リストの作成は$[]$を使用
2. 時には$()$を使用しなくてもタプルを作成できる（非推奨）
3. タプルの内包表記

atuple=(i+1 for i in range(31,42))

4. 作成するタプルが1つのオブジェクトのみを含む場合、その後にカンマ$","$を追加 そうしないと、括弧付きオブジェクトのデータ型はタプルではなくオブジェクト型になる
5. 空のタプルを作成

a=tuple()
b=()

tupleは増減改査を許可しません

tupleとlistの変換

tuple->list

atuple=(1,'love',3.334,'Y')
list(atuple)
'''この時atupleは依然としてtuple型'''
alist=list(atuple)
'''alistはlist型'''
print(atuple)
出力(1, 'love', 3.334, 'Y')
print(alist)
出力[1, 'love', 3.334, 'Y']

list->tuple

alist=['I',2,3.1415,'polaris']
atuple=tuple(alist)
'''alistは依然としてlist、atupleはtuple'''

dict

定義

• 辞書（dict）、一連のキーと値のペア（key-value） で構成されるデータ構造です。
• キーはハッシュ可能な値でなければなりません。例えば==文字列==や数値など。
  • ハッシュ：任意の長さの入力をハッシュ（散列）アルゴリズムを通じて固定長の出力（ハッシュ値）に変換すること。 ハッシュは一種の圧縮マッピングです。
• 値は任意のオブジェクトを指定できます。

辞書の作成

1. 空の辞書を作成してから要素を追加する 識別子とオブジェクト（key&value）を等号で接続することに注意 この場合、keyは識別子であり、識別子の文字列には引用符を付けない
2. 直接中括弧$\{\}$を使用する keyとvalueをコロンで接続することに注意 この場合、コロンの前がkeyであり、文字列には引用符が必要
3. dict()関数を使用してキーと値のシーケンス（tuple、listなど）からdictを作成する

profile=dict(name='孤筝',age=19,爱好='明月栞那')

profile={name:'孤筝',age:19,爱好:'明月栞那'}

alist=[('name','孤筝'),('age',19),('爱好','明月栞那')]
profile=dict(alist)
この場合、alistはlistのまま、profileオブジェクトはdict

print(profile)
出力{'name':'孤筝','age':19,'爱好':'明月栞那'}

4. 辞書内包表記

adict={i:i**2 for i in range(2,5)}
print(adict)
出力{2:4,3:9,4:16,5:25}

要素の確認

1. $$dict[key]$$を使用 dictは辞書名、keyはキー keyが存在しない場合、KeyValueエラーが発生
2. $dict.get(key[,value])$を使用 dictは辞書名、keyはキー、valueはオプションパラメータで初期値 keyが存在しない場合、設定したvalueを返し、valueが設定されていない場合はNoneを返す ==キーが辞書に存在しない場合、キーが追加され、valueがデフォルト値に設定されます。==

新しい要素の追加

keyは新しいキーで、valueは対応する値です

要素の変更

要素の削除

1. $dict.pop(key)$ dictは辞書名、keyはキーで、文字列には引用符が必要
2. del関数 $$del\ dict[key]$$ dictは辞書名

その他の重要な方法

keyの存在を確認する

1. $in,not in$
2. $dict.has\_key()$関数 存在すればTrueを返し、存在しなければFalseを返す ==Python2でのみ使用可能、Python3では削除==

keyのデフォルト値を設定する

1. まずkeyがdictに存在するかどうかを確認し、存在しない場合は値を割り当てる

profile = {"name": "王炳明", "age": 27, "公众号": "Python编程时光"}

if "gender" not in profile:
    profile["gender"] = "male"

2. $setdefault()$メソッド $$dict.setdefault(key,default=None)$$ defaultはkeyが存在しない場合に設定する値で、デフォルトはNone

set

定義

集合（set）は、数学の集合と同じく、順序付けされていない、重複のない要素のシーケンスです。 ==question==：順序がない場合、print setの際に要素はどのような順序で表示され、保存時はどのような順序になるのでしょうか？

集合の作成

1. 波括弧を使用して作成します。$\{\}$内に重複した要素を含めることができますが、最終的にsetは重複を削除します。
2. set()メソッドを使用して作成します。

aset={1314,'520'}
print(aset)

出力：
{1314,'520'}

bset=set()#空の集合asetを作成
print(bset)

出力：
set()

cset=set(['I','love','ishimiya'])
print(cset)

出力：
{'I','love','ishimiya'}

要素の追加

1. $.add()$関数

   $$set.add(elem)$$

   ==question==：elemが既存のset要素の場合、何が起こるか？ 注意：追加する要素がset集合内の要素と重複する場合、何の効果もないが、エラーは発生しない。

   追加する要素は不変型でなければならない。可変型の要素を追加するとエラーが発生する。

2. $.update()$関数

   $$set.update(ElemType)$$

   ElemTypeはシーケンス（string、list、tuple、dict、setなど）でなければならない。

aset={'朱冰倩'}
aset.add('suki')
aset.update({'for'})
'''集合{'for'}を追加'''
aset.update([10000])
'''リスト[10000]を追加'''
aset.update(('years',))
'''タプルを追加、要素が1つの場合カンマを付ける'''
aset.update({'name':'guzheng','age':19})
'''辞書を追加、keyのみsetに追加される'''
print(aset)

出力：
{'朱冰倩','suki','for',10000,'years','name','age'}

要素の削除

1. $.remove()$

aset={'朱冰倩','suki','for',10000,'years','name','age'}
aset.remove('name')

aset.remove('爱')
'''存在しない要素をremoveするとエラーが発生する'''
KeyError: '愛'

2. $.discard()$ 要素が存在すれば削除し、存在しなくてもエラーにならない

aset={'朱冰倩','suki','for',10000,'years','age'}
aset.discard('age')
aset.discard('love')

3. $.pop()$ 集合からランダムに要素を削除し、パラメータを渡すことはできない

aset={'朱冰倩','suki','for',10000,'love'}
aset.pop()
print(aset)

出力例：
{'朱冰倩','suki','for',10000}

4. $.clear()$ 集合内の要素をすべて削除する $$set.clear()$$

要素の変更

セット内の要素は順序がないため、集合にはインデックスがなく、要素を変更することはできず、追加または削除のみ可能です。

要素の確認

同上、インデックスなしでは要素を確認できません。 要素数の確認

セット内の要素数を返します

集合演算

和集合

$union$関数を使用して2つの集合を結合し重複を削除し、結合後の集合Cを返します

同等

差集合

$difference$関数を使用して差集合を求めます：==集合Aに存在する==が==集合Bには存在しない==要素を見つけ、新しい集合Cとして返します。

同等

積集合

1. $intersection$関数を使用して積集合を求めます：==集合AとBの両方に存在する==要素を見つけ、集合Cとして返します。 $$aset.intersection(bset)$$ または $$bset.intersection(aset)$$ 同等 $$aset\ \&\ bset$$ $$bset\ \&\ aset$$
2. $intersection\_update$関数を使用して積集合を求めます：積集合を見つけasetに代入し、積集合を返しません。 $$aset.intersection\_update()$$
3. $\&$を使用し、積集合を返しますがaset、bsetは変更しません $$aset\ \&\ bset$$

対称差集合

1. $symmetric\_difference$関数を使用し、対称差集合を返します $$aset.symmetric\_difference(bset)$$
2. $symmetric\_difference\_update$関数を使用し、対称差集合をasetに返します $$aset.symmetric\_difference\_update(bset)$$

その他

1. setが特定の要素を含むかどうかを判断するには、inを使用します $$print(elem\ in\ aset)$$
2. 2つのsetに共通の要素があるかどうかを判断します $$aset.isdisjoint(bset)$$ 共通の要素がある場合はFalseを返します
3. bsetがasetの部分集合かどうかを判断します $$bset.issubset(aset)$$ bsetがasetの部分集合である場合、Trueを返します

イテレータ

イテレータ

反復可能オブジェクト

forループを利用できるオブジェクトは、すべて反復可能オブジェクトと呼ばれます。

反復可能プロトコル

1. 最初のシナリオ：あるオブジェクトが内部で__iter__()メソッドを実装し、イテレータインスタンスを返す場合、そのオブジェクトは反復可能オブジェクトです。
   1. このシナリオでは、isinstance(my_list,Iterable)はTrueを返します
2. 2番目のシナリオ：あるオブジェクトが__iter__()を実装していない場合、Pythonインタプリタは__getitem__()メソッドを使用して要素を取得します。これが可能であれば、そのオブジェクトも反復可能オブジェクトです。
   1. このタイプの反復可能オブジェクトの場合、isinstance(my_list,Iterable)はFalseを返します

イテレータオブジェクト

反復可能なオブジェクトに対してiter関数を使用すると、イテレータオブジェクトが返されます。イテレータオブジェクトに対してはnext関数を使用して要素を取得できます。実行するたびに1つずつ要素を取得し、すべて取得し終わるとStopIterationが発生し、これ以上要素がないことが通知されます。

alist=['人','生','若','只','如','初','見']
gen=iter(alist)
for i in alist:
    print(next(gen))

出力：
人
生
若
只
如
初
見

for i in alist:
    print(i)

出力：
人
生
若
只
如
初
見

反復可能オブジェクトとイテレータオブジェクト

1. 反復可能オブジェクトは全体を指し、例えばリストのようなものです。
2. イテレータオブジェクトはiter()関数によって返されるオブジェクトで、このオブジェクトに対してnext()関数を使用して要素を次々と取得できます。

generator

ジェネレータは、イテレータのようにforループを使用して要素を取得できる関数です。

ジェネレータの作成

リスト内包表記

alist=[i for i in range(5)]
print(alist)
出力：
[0,1,2,3,4]
'''
[]を使用してリストオブジェクトを作成
'''

alist=(i for i in range(5))
print(alist)
出力：
0
'''
この場合、alistはジェネレータオブジェクト
'''

yield

yieldとrenturnの違い

• 関数がyieldに到達すると、関数の実行は一時停止し、yieldの後の値が返されます。
• yieldに何も値が続いていない場合、Noneが返されます。
• yieldは値を返しますが、関数は終了しません。この関数を割り当てた識別子を再度呼び出すと、関数は実行を継続します。

def generator():
    top=5
    i=0
    while i<top:
        print('現在の値：'+str(i))
        i+=1
        yield i
    raise StopIteration
gen=generator()

for i in range(6):
    print(next(gen))

この記事は2023-08-27に孤筝の温暖小家で公開され、最終更新日は2023-08-27です

本ブログのすべての文書は、特に指定されていない限り、BY-NC-SAライセンスに従っています。引用の際は出典を明記してください！

著者: 孤筝(lvbowen040427@163.com)

関数の引数渡し

Pythonでは、関数に引数を渡すことは本質的に代入操作です

def func(arr)
    arr = 1
    print(arr)
a=2
func(a)
print(a)

1. 最初に2つの変数arrとaがあり、2つのオブジェクト1と2があります
2. aは2にバインドされ、func(a)はaがバインドしているオブジェクト2にarrというラベルを貼ります
3. この時点で、オブジェクト1はまだ作成されておらず、2にはaとarrのラベルが貼られています
4. $arr=1$操作により、2からarrラベルが剥がされ、オブジェクト1が作成されてarrラベルが貼られます
5. 出力結果

1
2

入力と出力

print()関数

>>>print("文字列")
文字列
>>>print("str1","str2","str3")
str1 str2 str3#カンマがスペースに置き換わる
print(a+b**c)#数値を計算してから出力
print(sum(a,b/c))#sum()関数が優先的に実行

==プロトタイプ==

• sepパラメータ：区切り文字、複数の出力結果（戻り値）間の区切り文字、デフォルトはスペースで手動設定可能
• endパラメータ：印刷後の終了方法、デフォルトは$\n$改行、’ ‘に設定すると改行なし

input()関数

ユーザー入力を取得し、==文字列==として保存 数字が入力された場合、int()でオブジェクトを数字に変換可能

>>>age=input("年齢を入力してください:")
年齢を入力してください:18
>>>print(age)
'18'#type(age)==<class'str'>
>>>age=int(age)
>>>print(age)
18

• $input()$には文字列を渡せば、入力プロンプトとして表示される
• $int()$を使用する際、余分なスペースがあれば$strip()$メソッドで除去可能、文字列オブジェクト保存時も同様
• $input()$は改行を消費し、プログラム実行を一時停止するために使用可能 [[データ型と演算子#文字列フォーマット]]

ユーティリティ関数

id()

例 [[データ型と演算子#代入方法]] id(変数名)で変数がバインドするオブジェクトのメモリアドレスを取得 変数がバインドするオブジェクトが変更されると、クエリ結果も変更され、元のオブジェクトのメモリアドレスは変わらない

type()

• 1つの引数でオブジェクトの型を返す
• 3つの引数で新しいオブジェクト型を返す
  • type(name,bases,dict)
  • name – クラスの名称
  • bases – 基底クラスのタプル
  • dict – 辞書、クラス内で定義された名前空間変数

# パラメータの一例

```python
>>> type(1)

<type 'int'>
>>> type('runoob')
<type 'str'>
>>> type([2])
<type 'list'>
>>> type({0:'zero'})
<type 'dict'>
>>> x = 1
>>> type( x ) == int # 型が等しいかどうかを判断する
True
# 3つの引数
>>> class X(object):
    ... a = 1 
    ...
>>> X = type('X', (object,), dict(a=1)) # 新しい型 X を生成する
>>> X
<class '__main__.X'>

next()

[[基礎データ構造#イテレータオブジェクト]]

文字列関数

文字列オブジェクトの組み込み関数

1. 先頭と末尾の空白または文字を削除する$lstrip()$,$rstrip()$,$strip()$

str="    人生苦短，我用Python。    "
print(str.lstrip())#左側の空白を削除して出力
print(str.rstrip())#右側の空白を削除して出力
print(str.strip())#左右の空白を削除して出力

str_1='333与君相别离，不知何日是归期，我如朝露转瞬晞。333'
print(str_1.strip('3'))#左右のすべての文字'3'を削除して出力

==注意：この関数は本質的に文字列の一部を切り取るものであり、元のオブジェクトを変更するものではない== $lstrip()$は、文字列の左側の空白または指定された文字を削除した新しい文字列を返します。

str="    人生苦短，我用Python。    "
str.lstrip()#関数を呼び出すだけで代入も出力も行わない
print(str)
'''
この場合の出力結果は依然として
    人生苦短，我用Python。    
左右ともに空白を含む
オブジェクトが変更されていないことを示す
'''

2. 文字列が特定の文字列で始まる/終わるかどうかを判定する$startswith()$,$endswith()$ 該当すればTrue、しなければFalseを返す

str="山有木兮木有枝，心悦君兮君不知。"
print(str.starswith("山"))#Trueを返して出力
print(str.endswith('不知'))#'。'がないためFalseを返して出力

3. 文字列をフォーマットする

   $$f"文字列内容{他の文字列変数名}文字列内容"$$

   フォーマットされた文字列を返す 未記入

4. 文字列を分割する$split()$ 特定の文字で文字列をいくつかの部分文字列に分割し、部分文字列には区切り文字を含まず、文字列リストを返す

str='根，紧握在地下，叶，相触在云里，每一阵风过，我们都互相致意。'
strP=str.split('，')#中英文の句読点に注意
print(str)#元の文字列オブジェクトを出力
print(strP)#分割して得られた文字列リストを出力
print(strP[1])#"紧握在地下"を出力

数値処理関数

1. 絶対値 $$abs()$$
2. 切り捨て $$int()$$
3. 四捨五入（整数を返す） $$round()$$
4. 大小・真偽の判定（ブール関数） $$bool()$$ [[データ型と演算子#ブール値と空値]]

データ型変換関数

1. $$int(x [,base])$$ xは元のオブジェクト、baseはオプションのパラメータで、デフォルトは10（10進数を表す）
2. $$float(x)$$
3. $$complex(real[,imag])$$ realは実部、imagはオプションの虚部パラメータ
4. $$str(x)$$
5. $$repr(x)$$ オブジェクトxを式の文字列に変換（Pythonインタプリタが読み取れる形式）
6. $$chr(x)$$ 整数を1文字に変換
7. $$ord(x)$$ 1文字をその整数値に変換
8. $$hex(x)$$ 整数xを16進形式の文字列に変換
9. $$oct(x)$$ 整数xを8進形式==文字列==に変換
10. $$eval(str)$$ 文字列内の有効なPython式を評価し、オブジェクトを返す
11. $$tuple(s)$$ シーケンスsをタプルに変換して返す
12. $$list(s)$$
13. $$set(s)$$ シーケンスsを可変集合に変換
14. $$frozenset(s)$$ シーケンスsを不変集合に変換
15. $$dict(d)$$ (key,value)形式のタプルシーケンスdをdictに変換

データ型の高低

1. 「高いデータ型」と「低いデータ型」は==暗黙的な型変換==においてデータの精度を説明するための概念。

2. ==精度==はデータ型が表現できる情報量や詳細度と理解できる。Pythonでは、データ型の「高」「低」は主にその精度によって判断される。

3. ここでの「高い」データ型とは、より多くの情報（またはより正確な情報）を表現できるデータ型を指し、「低い」データ型は表現できる情報が少ない。 具体的には、浮動小数点数は整数よりも「高い」、なぜなら浮動小数点数は整数だけでなく小数も表現できるから。したがって、例では整数は自動的に浮動小数点数に変換され、情報が失われないよう保証される。

4. また、複素数（complex）は浮動小数点数（float）や整数（int）よりも「高い」、なぜなら複素数は実数と虚数を表現できるが、浮動小数点数と整数は実数のみを表現できるから。演算時にオペランドに複素数が含まれる場合、他の浮動小数点数や整数は複素数に変換される。

5. 一般的に、Pythonのデータ型の「高低」は以下の順序で理解できる： ブール（bool）< 整数型（int） < 浮動小数点型（float）< 複素数型（complex）。 この順序は主にデータ型が表現できる情報範囲と精度によって決定される。

異なるデータ型間で自由に変換できるか

Pythonはいくつかの組み込み関数を提供して異なるデータ型間の変換を実現しているが、例えば$int(), float(), str(), list(), tuple(), set()$など、すべての型のデータが他の任意の型に変換できるわけではない。変換が可能かどうかは、主にデータ自体が目標の型を表現するのに十分な情報を含んでいるかによる。

例： 整数を文字列に簡単に変換できる、なぜならすべての整数には明確な文字列表現があるから（例えば、整数123は文字列"123"として表現できる）。

同様に、数字のみを含む文字列（例：“123”）は整数や浮動小数点数に変換できる、なぜならこの文字列には数字を表現するのに十分な情報が含まれているから。

しかし： 数字以外の文字列（例：“Hello”）は整数や浮動小数点数に変換できない、なぜならこの文字列には数字を表現する情報が含まれていないから。

リストやタプルは、（その要素が不変であれば）集合に変換できるが、整数には変換できない、なぜなら集合やリストの要素を単一の数字として合理的に表現できないから。

総じて、データ型の変換は==無制限ではない==、それは元のデータが目標の型を表現するのに十分な情報を提供できるかによる。プログラミングで型変換を行う際、この点に注意が必要。

判断とループ文

$if,elif,else$文

if condition1:
    条件1が成立する場合の操作
elif condition2:
    条件1が不成立で条件2が成立する場合の操作
else:
    条件1,2ともに不成立の場合の操作

例:

name=input('Who are you?')
age=input('How ord are you?')
if name=='朱冰倩'and age>=19:
    print('Daring,long time no see.')
elif name=='朱冰倩' and age==18:
    print('Thank you for being in my life.')
else:print('こんにちわ。')

• 偽値: None、空リスト、空集合、空辞書、空タプル、空文字列、0、Falseなど
• 真値: 非空リスト、非空集合、非空辞書、非空タプル、非空文字列、非0数値、Trueなど

$for,break,continue$文

通常のループ

for x in シーケンス(list, dict, string, tupleなど):
    実行コードブロック

• forはシーケンス中の要素を順番にxに代入する

インデックス付きループ

• ループ中にインデックスも取得したい場合、$enumerate()$関数を使用できる
• $enumerate()$関数は、リストやタプル、文字列などの反復可能オブジェクトをインデックス付きで返す
  • Python 2.3以上で使用可能、2.6でstartパラメータ追加
• $$enumerate(sequence,[start=0])$$
  • sequence: 反復可能オブジェクト
  • start(オプション): インデックスの開始値、デフォルトは0

galgames=['咖啡馆','千恋万花','天使骚骚']
for index,galgame in enumerate(galgames,1):
    print(f'今日は{index}番目の作品{galgame}をプレイ。')

出力: 今日は1番目の作品咖啡馆をプレイ。 今日は2番目の作品千恋万花をプレイ。 今日は3番目の作品天使骚骚をプレイ。

break

現在のループを中断、異なる階層のbreakは異なるループを中断する

continue

continueは後続のコード実行を停止し、次のループに移行する

for-else

• forループ後にforと同じ階層のelseを記述、forループが正常終了した場合、自動的にelseに入る
• breakで中断された場合(continueは正常と見なす)、else分岐に入らない

while文

while 条件式:
    実行文

条件式が成立(True)している間、実行文をループ実行；不成立の場合、ループを抜ける ==無限ループを避けるため、実行文がループ条件を破るかbreakをトリガーできるか確認==

while-else

for-elseと同様、breakで中断されずにwhileループが終了した場合、後続のelse分岐を実行；異常終了した場合elseは実行されない

この記事は2023-06-27に孤筝の温暖小家で公開され、最終更新日は2023-06-27です

本ブログのすべての文書は、特に指定されていない限り、BY-NC-SAライセンスに従っています。引用の際は出典を明記してください！