Skip to content
This page has been auto-translated and may contain errors.View in English

文字列

docs.scrimba.com

テキストはほぼすべてのプログラムに登場します。名前、メッセージ、スコア、ラベル。Pythonでは、テキストの一部を文字列と呼びます。引用符で囲んだすべての値です。シングルでもダブルでも、どちらでも同じように機能します。

文字列はPythonの主要なテキス型です。ユーザー名からURLパスからフォーマット済みの出力まで、すべてを扱います。シングルクォートとダブルクォートは同じ結果を生成します。どちらを選ぶかはスタイルの問題です。

strはすべてのシステム境界に存在します。ターミナルI/O、ファイル内容、ネットワークレスポンス、シリアル化されたデータです。これはPythonの不変(作成後は変更不可能)なUnicodeシーケンス型です。両方の引用符スタイルは同じオブジェクトを生成するため、その選択は純粋にスタイル的なものです。

python
greeting = "Hello, world"
username = 'tanaka'

引用符の選択が重要になるのは、テキストに引用符が含まれている場合のみです。エスケープを避けるために反対のスタイルを使用してください。

コミュニティの慣例はダブルクォートです。スタイルを切り替える実用的な理由は、その文字が含まれている場合にエスケープを避けることです。

慣例はダブルクォートで、BlackやRuffなどのフォーマッターが自動的に強制します。手で書く唯一の理由は、コンテンツがデリミタを含むときにバックスラッシュエスケープを避けることです。

python
note = "It's a great day"      # アポストロフィの内側、ダブルクォートを使用
message = 'She said "hello"'   # ダブルクォートの内側、シングルクォートを使用
escaped = "She said \"hello\""  # またはバックスラッシュでエスケープ

不変性

文字列は不変です。一度作成したら、それを変更することはできません。文字列を作成した瞬間に永久に固定されたものと考えてください。文字列を変更しているように見えるすべての操作は、実は新しい文字列を生成しているだけです。元の文字列は正確に保たれます。

文字列は不変です。メソッドが文字列をその場で変更することはありません。テキストを変換するすべての操作は新しい文字列を返し、元の文字列は変わりません。実用的な結果として、どこにも割り当てないメソッド呼び出しは、何にも影響を与えません。

strオブジェクトは不変です。作成後その内容は固定されており、何も書き込むことはできません。これにより、文字列に2つの実際に使用するプロパティが与えられます。ハッシュ可能(内容が変わらない値はその内容でファイルできるため、文字列は辞書キーまたはセットメンバーとして機能することができます)で、内容が変わらないため、名前の間で安全に渡すことができます。

python
name = "tanaka"
name = name.upper()   # "TANAKA"は新しい文字列、"tanaka"は変わらない

直接的な結果:特定の位置の文字を変更することはできません。Pythonは試行時にエラーを発生させます。

python
name = "tanaka"
name[0] = "T"   # TypeError: 'str' object does not support item assignment

変更された文字列を取得するには、スライスまたはメソッドを使用して新しい文字列を構築します。両方とも以下で説明されています。

文字の割り当ての試みが制約を直接示しています。

python
name = "tanaka"
name[0] = "T"   # TypeError: 'str' object does not support item assignment

変更されたバージョンが必要な場合、標準的なツールは位置編集のためのスライスと連結、および置換のためのreplace()です。両方とも新しい文字列を生成し、元の文字列は変わりません。

位置への割り当て(name[0] = "T")は毎回TypeErrorを発生させ、例外はありません。位置編集の場合、変更したい部分の周りをスライスして新しい文字列を構築します。name[:1].upper() + name[1:]は最初の文字を大文字にします。文字列内のどこかで置換する場合は、replace()を使用します。

Juno不変性 文字列は存在後は決して変わりません。それを編集しているように見えるすべてのものは、代わりに新しい文字列を渡すため、結果を割り当てるか、それは失われます。私を早くに捕まえたものの1つ:name[0] = "T"は機能しません。TypeErrorを発生させます。
Juno不変性 文字列メソッドは場所で編集しません。すべてのメソッドは新しい文字列を返し、元の文字列は変わりません。したがって、name.upper()単独では有用ではありません。割り当てる必要があります。そしてname[0] = "T"TypeErrorを発生させます。場所での文字スワップはありません。
Juno不変性 不変性により、文字列はハッシュ可能で、辞書キーとして機能し、コピーなしで共有して安全です。実用的な結果:すべての変換メソッドの結果を割り当てます。元に影響を与えないため、位置編集の場合、その部分の周りをスライスして再構築します。項目割り当ては常にTypeErrorを発生させるためです。

インデックスとスライス

文字列のすべての文字には、ゼロから始まる番号付きの位置があります。その位置番号を角括弧に入れることで、個々の文字を読むことができます。負の数は末尾から逆向きにカウントされます。

文字列はゼロベースのインデックスを持つシーケンスです。負のインデックスは末尾からカウントされます。スライスは単一の式で任意の連続範囲を抽出し、範囲外の値でエラーを発生させることはありません。

文字列は順序付きシーケンスのようにインデックスとスライスを作成できます。単一の位置(s[i])を読む場合、インデックスが末尾を指している場合、IndexErrorを発生させます。スライス(s[start:stop:step])の動作は異なります。範囲外の境界は存在するものに自動的に固定されるため、スライスはIndexErrorを発生させることはできません。その違いが実用的なものです。インデックスアクセスは厳密で、スライスは寛容です。

python
word = "Python"
#       012345

print(word[0])    # "P"
print(word[2])    # "t"
print(word[5])    # "n"
print(word[-1])   # "n"  (最後の文字)
print(word[-2])   # "o"  (最後から2番目)

-1は常に最後の文字、-2は最後から2番目、というように続きます。正確な長さを知らずに文字列の末尾にアクセスしたい場合に便利です。

負のインデックスはラップします。-1len(s) - 1-2len(s) - 2です。手動で長さを計算したくない場合に最も便利な末尾アンカー付きアクセスです。範囲外の負のインデックスは、正のインデックスと同じく、IndexErrorを発生させます。

負のインデックスは境界チェック前にlen(s) + iに変換されるため、-1は最後の文字に置かれ、-2はその前の文字に置かれます。範囲外に出すと、正でも負でもIndexErrorを発生させます。スライスのみがそれを許します。プレーンインデックスは許しません。

スライスはチャンクを抽出します。[start:stop]startを含み、stopは除外します。

python
word = "Python"

print(word[0:2])   # "Py"     (位置0と1)
print(word[2:])    # "thon"   (位置2から末尾まで)
print(word[:3])    # "Pyt"    (開始から位置2まで)
print(word[:])     # "Python" (文字列全体のコピー)
print(word[::2])   # "Pto"    (毎秒番目の文字)
print(word[::-1])  # "nohtyP" (反転)

最も使用する3つのパターン:最初のn文字にはword[:n]、位置nからそれ以降のすべてにはword[n:]、最後のn文字にはword[-n:]word[::-1]は文字列を反転させます。最初は奇妙に見えますが、それはイディオマティックなPythonで、頻繁に見かけます。

直接インデックスとは異なり、スライスはIndexErrorを発生させません。Pythonは範囲外のインデックスを静かに固定するため、短い文字列のword[100:]はクラッシュするのではなく、""を返します。ステップ引数は歩幅を制御します。word[::2]は1文字おきを取得し、word[::-1]は逆に走査されます。

s[start:stop:step]では、省略した部分はデフォルトで「進む方向の自然な末尾」になり、固定された0len()ではありません。正のステップでは開始から末尾を意味します。負のステップでは反転され、startが最後の文字になり、stopが先頭から走ります。これはs[::-1]がバウンドを書かずに全文字列を逆に走査する理由であり、s[::-2]が後ろから毎秒文字を与える理由です。

Junoインデックスとスライス 位置はゼロから始まります。word[0]は最初の文字で、word[-1]は最後です。スライスは範囲をグラブします。word[start:stop]startを保ち、stopの直前で停止します。word[::-1]は文字列を反転させ、最初は奇妙に見えて、その後ずっと使用します。
Junoインデックスとスライス ゼロからインデックスを作成するか、word[-1]が最後の文字である負から末尾を作成します。スライスはstartを含み、stopを除外する範囲を取得します。3番目のstepが歩幅を設定するため、word[::-1]は反転します。覚える価値のあるキャッチ:末尾を超えてインデックスを作成するとIndexErrorが発生しますが、スライスは代わりに存在するものを返します。
Junoインデックスとスライス プレーンインデックスは厳密で、範囲外で`IndexError`を発生させます。スライスは寛容で、存在するものに固定されるため、`word[100:]`は`""`を返し、発生させるのではなく、より多くを返します。スライス部分を省略するとステップの方向の自然な末尾がデフォルトになります。これは`word[::-1]`がバウンドを書かずに反転する理由です。空の入力や短い入力でクラッシュしたくない場合は、スライスに到達してください。

基本的な文字列メソッド

文字列には、組み込みメソッドのセットが付属しています。任意の文字列値で直接呼び出す操作です。文字列(またはそれを保持する変数)、ドット、メソッド名を書きます。各メソッドは新しい文字列を返します。元の文字列は決して変わりません。

文字列メソッドはstr型に接続された関数です。文字列は不変であるため、すべてのメソッドは元の文字列を変更するのではなく、新しい文字列を返します。割り当てたり、どこかに渡さないメソッド呼び出しは、持続的な効果を持ちません。

すべての変換メソッドは新しいstrを返し、元を変わりなく残します。これは不変性から直接続きます。また、コードポイント(生データを保存するために使用される生バイトではなく、文字そのもの)で機能するため、メソッドは特に何もしなくても、アクセント付きおよび非ラテンテキストで正しく動作します。トレードオフは、各メソッドが新しい文字列を割り当てるため、大量のテキストで多くのものを連結すると多くの割り当てが発生することです。

ケース

python
text = "Hello, World"

text.lower()       # "hello, world"
text.upper()       # "HELLO, WORLD"
text.title()       # "Hello, World"  (各単語を大文字化)
text.capitalize()  # "Hello, world"  (最初の単語のみ)

lower()upper()はあなたが最も使うであろう2つです。lower()は特に、テキストを比較する場合に便利です。"Tanaka""tanaka"は両側で.lower()を呼び出すと同じになります。

lower()は比較または保存前の標準的な正規化ステップです。title()は各単語の最初の文字を大文字化します。粗いルールを使用し、縮約で失敗します。"it's""It'S"になります。ディスプレイのみのフォーマットとして扱ってください。

lower()はUnicodeの完全なケース変換を適用します。大文字小文字を区別しない比較の場合、casefold()はより正確です。lower()がスキップする追加の変換(例えば、ドイツの ß は ss になります)を適用します。title()は任意の英数字以外の文字の後を大文字化するため、縮約と連字符で囲まれた名前を誤処理します。正しいタイトルケースの場合、ロジックを手動で実装してください。

空白

python
text = "  hello  "

text.strip()    # "hello"    (両側)
text.lstrip()   # "hello  "  (左のみ)
text.rstrip()   # "  hello"  (右のみ)

strip()は文字列の両側からスペースを削除します。ユーザー入力またはファイルからテキストを処理するとき、ほぼ毎回それを使用します。余分なスペースはサイレント失敗を引き起こすため。"tanaka" != "tanaka "です。

strip()は両側から先頭および後続のすべての空白(スペース、タブ、および改行)を削除します。方向性のあるバリアントでは、一方の側のみを清掃できます。後続の改行をストリップするが、インデントに影響を与えない場合に便利です。3つすべてが、オプションの文字引数を受け入れて、代わりに特定の文字をストリップします。

引数がない場合、strip()はプレーンスペースだけでなく、非ASCII空白を含む、両側から空白のすべての種類を削除します。文字引数を使用すると、終端から文字を削除し、それが罠です。引数は削除する文字のセットであり、一致するプレフィックスではありません。"xxhelloxx".strip("x")"hello"を返しますが、"https://".strip("https")はプレフィックス"https"を削除しません。両側からhtpsをすべてストリップし、"://"を返します。既知のプレフィックスまたはサフィックスを削除するには、代わりにremoveprefix()removesuffix()を使用してください。

検索

python
text = "Hello, world"

text.find("world")         # 7
text.find("Python")        # -1  (見つかりません)
text.count("l")            # 3
text.startswith("Hello")   # True
text.endswith("world")     # True

find()は、テキストの片が文字列内で開始される位置を返します。そこにない場合は、-1を返します。startswith()endswith()は、文字列が何か特定で始まるか終わるかだけを気にする場合に使用してください。

find()は最初の一致の開始インデックスを返すか、-1を返します。-1慣例により、チェックなしでスライスまたは算術で結果を直接使用できます。startswith()endswith()はそれぞれ文字列のタプルを受け入れるため、1つの呼び出しで複数のプレフィックスまたはサフィックスをテストできます。

find()は左から右にスキャンし、一致がない場合は-1を返します。index()は同じ検索を行いますが、-1を返す代わりにValueErrorを発生させます。一致の欠如がコードにバグがあり、そこで停止したい場合はindex()を選択し、欠如が正常な入力で確認するためfind()を選択します。「これで始まるか終わるか」という純粋な質問の場合、startswith()endswith()はあなたが意図したことを言い、最初の不一致で停止するため、その仕事のためのfind()またはinチェックよりも優先します。

置換

python
text = "Hello, world"

text.replace("world", "Python")   # "Hello, Python"
text.replace("l", "L")            # "HeLLo, worLd"  (すべての出現)
text.replace("l", "L", 1)         # "HeLlo, world"  (最初のみ)

replace()はテキストの1つの部分を別のもので交換し、新しい文字列を返します。元は変わりません。最初の出現のみを置換したい場合は、3番目の引数を渡してください。

replace()はデフォルトですべての非重複出現を置換します。count引数は置換される数を制限します。新しい文字列を返すため、呼び出しをチェーンできます。text.replace("a", "A").replace("e", "E")は両方の置換を順番に適用します。

replace()はパターンではなくリテラル部分文字列にマッチするため、正規表現は行わず、引数のすべての文字をそのまま扱います。左から右に非重複一致を置換します。これは驚くことができます。"aaa".replace("aa", "b")は最初の一致が2番目のaaと重なるため、"bb"ではなく"ba"を与えます。count引数は置換される数を制限し、すべての呼び出しは新しい文字列を返すため、チェーンできます。text.replace(",", "").replace(" ", "_")です。

分割と結合

split()は文字列をセパレータで部分に切って、リストとして返します。切断するものを指定します。

split()はセパレータで分割し、セグメントをリストとして返します。引数なしで呼び出された場合、任意の空白実行で分割し、複数の連続するスペースからの空の文字列を破棄します。

split(sep)は左から右にスキャンし、sepのすべての非重複出現で分割します。引数なしの場合、異なるアルゴリズムを使用します。任意の空白実行で分割し、結果から先頭および後続の空白をストリップします。rsplit(sep, n)は右から分割し、ドット付きパスまたは名前付きの識別子の最後のセグメントを分離するのに便利です。

python
csv_row = "Tanaka,28,Tokyo"
parts = csv_row.split(",")     # ["Tanaka", "28", "Tokyo"]

"  hello   world  ".split()   # ["hello", "world"]

split()はリストを返します。値の順序付きシーケンスです。彼らは自分たちのリスト章を取得します。今のところsplit()が生成する部分のシーケンスとして扱い、join()が消費します。

join()は逆を行います。文字列のリストを1つに組み合わせます。.join()の前の文字列は各アイテムの間に配置されます。

python
words = ["Hello", "world"]

" ".join(words)    # "Hello world"
", ".join(words)   # "Hello, world"
"".join(words)     # "Helloworld"

覚えておくパターン:separator.join(list_of_strings)。セパレータは左側に、リストは右側にあります。" ".join(words)は各単語の間にスペースを配置します。"".join(words)はそれらをつなぎます。

join()は複数の部分から単一の文字列を組み立てるときの正しいツールです。各ステップで新しい文字列を作成するのではなく、単一の割り当てを実行します。2つまたは3つの文字列の場合、+は完全に問題ありません。任意の有意なサイズのリストがある場合は、join()に到達してください。

join()は部分を1回歩き、総サイズを計算し、結果を1回割り当て、すべてを書き込みます。ループで繰り返された+で同じ文字列を構築することは、高い形状です。文字列は変わらないため、各+は新しい文字列を割り当て、これまでのすべてをコピーするため、コストはピース数の正方形で増加します。数個の文字列について誰も注意しません。数千個では速い操作を遅くします。それを防ぐルール:部分をリストに集めて、最後に1回join()し、ループで文字列を+=しません。

Juno基本的な文字列メソッド これらはすべて新しい文字列を返すため、結果を割り当てるか、それは消えます。毎日使用するだろうと思います。.lower().upper()のケース、スペースをトリムするための.strip()、テキストを位置する.find()(そこにない場合は-1を返す)、テキストをスワップするための.replace()、および文字列を分割してsep.join()で一緒に戻すための.split()
Juno基本的な文字列メソッド これらはすべて新しい文字列を返し、なし突然変異するため、チェーンまたは割り当てます。罠を成功させてください。.strip("x")はプレフィックスではなく、トリムする文字のセットを取得します。.split()引数なしで空白の実行を折りたたみます。多くの部分を組み立てるため、リストを構築し、`sep.join()`それを実行してください。
Juno基本的な文字列メソッド 実際のコードで噛む2つの罠:.strip(chars)は、プレフィックスではなく、末尾から文字セットをストリップするため、プレフィックスを意図する場合はremoveprefix()を使用し、ループで`+=`で文字列を構築することは遅い形状であるため、ループして1回join()します。比較のため、.lower()よりも.casefold()で正規化し、.title()をディスプレイのみとして扱ってください。

f文字列

f文字列はテキスト内に値を直接埋め込みます。開く引用符の前にfを置き、任意の変数または式を中括弧で囲みます。コードが実行されるとき、Pythonはそれを埋めます。また、値の後にコロンを追加して、表示方法を制御できます。

f文字列は{}内の任意の式をランタイムで評価し、結果を文字列に変換します。中括弧内のコロンはフォーマット仕様を導入します。小数点、配置、および数値フォーマットを制御するためのコンパクト構文です。

f文字列の各{}は値独自の__format__メソッド(Pythonが値をフォーマットするときに舞台裏で呼び出すダンダー、ダブルアンダースコアメソッド)を呼び出し、コロンの後に書いたものに沿って渡します。書く任意のクラスは、__format__を定義して、f文字列内にどのように表示されるかを決定できます。変換フラグ!r!s、および!aは最初に値に対してrepr()str()、またはascii()を実行します。!rは保つべきものです。コード、引用符およびエスケープに入力するのと同じ方法で値を表示するため、実際に下に示します。

python
name = "Tanaka"
score = 94.5

print(f"Hello, {name}!")           # "Hello, Tanaka!"
print(f"Score: {score:.1f}%")      # "Score: 94.5%"
print(f"2 + 2 = {2 + 2}")          # "2 + 2 = 4"
print(f"Name: {name.upper()}")     # "Name: TANAKA"

:の後のフォーマット仕様は値の表示方法を制御します。

仕様意味
.2f小数点以下2桁f"{3.14159:.2f}""3.14"
.0%パーセンテージ、小数点なしf"{0.94:.0%}""94%"
,千の位の区切りf"{1000000:,}""1,000,000"
>1010文字で右配置f"{'hi':>10}"" hi"

最も使用するのは.2fです。小数を表示してきちんとした数字を望む場合は常に、長い実行数字ではなく。テーブルの他のすべては、それが必要な場合がそこにあります。{}の内側に任意の変数、算術、またはメソッド呼び出しを入れることができます。

.2f.0%はほとんどのディスプレイフォーマットをカバーしています。配置指定子(><^)は幅と組み合わされるとき、表形式の出力を生成します。一般的なパターンは{value:[align][width][.precision][type]}です。ピースを認識すると、すべての組み合わせを記憶するすべての仕様を読むことができます。

同じ仕様は異なるタイプに対して異なる意味を持つことができます。各タイプはそれ自体をフォーマットするためです。f"{'hi':5}"はテキストを右側に埋め、f"{42:5}"は数字を左側に埋めます。同じ:5、反対の結果。有効な変換フラグは!rです。書き込んだ引用符を実行した後にフォーマットを実行し、不可視文字(タブ、後続スペース、改行)を表示可能なエスケープシーケンスに変えます。出力が微妙に間違って見える場合、{value}{value!r}にスワップすることは、実際にある場所を見るための最速の方法です。

Junof文字列 開く引用符の前にfを置き、任意の変数、合計、またはメソッド呼び出しを{}で囲み、行が実行されるとPythonは結果をドロップします。中括弧内のコロンは、外観を制御します。:.2fは2つの小数点は、あなたが身を寄せるだろうと思います。`+`でテキストを一緒に接着するよりもはるかにきちんとしています。
Junof文字列f"..." `{}`の任意の式を評価し、結果を直接ドロップし、`str()`は必要ありません。コロンの後は、フォーマット仕様が来ます。:.2f:,:>10およびすべての友人、すべての`{value:[align][width][.precision][type]}`に従います。部分を学ぶと、すべてを記憶せずに仕様を読むことができます。
Junof文字列 各`{}`は値独自の`__format__`を呼び出すため、コロンの後の仕様はそのタイプが決定することを意味し、これは`:5`がテキストと数字を反対方向に埋める理由です。保つべき旗は`!r`です。それはあなたが書くだろう方法で値を示すため、余計な空白とその他の不可視のゴミは、出力が間違って見える瞬間に飛び出します。

複数行文字列

複数行にわたる文字列を書くには、トリプルクォートマークを使用します。開始時に3つの"と終了時に3つです。Pythonは、記入したとおりに正確にすべての改行とスペースを保持します。

トリプル引用符文字列は、すべての空白と改行を文字通りに保持します。電子メールテンプレートとSQLクエリなどの長いテキストブロック、およびドキュメント文字列の標準です。関数またはクラスボディの開始に配置された実装ドキュメント。

トリプル引用符文字列は各行の先頭のスペースを含め、すべての文字を正確に保持します。これがキャッチです。リテラルをコードと一致させるようにインデントし、そのインデントはテキスト内に着地します。関数、クラス、またはモジュールの最初のステートメントの場合、Pythonはそれをそのオブジェクトのドキュメント文字列help()が表示するドキュメント)として保持するため、慣例は短い概要をそこに置くことです。リテラルをそれを囲むものと一致させようとインデント、インデントをリークさせずに、値をランタイムでtextwrap.dedent()で剥がしてください。トリプル'''"""は同じ。"""は慣例です。

python
message = """
Dear Tanaka,

Thank you for your order.

Best regards,
The Team
"""
Juno複数行文字列 各終端で3つの引用符は、文字列が複数行で実行され、Pythonはすべての改行とスペースを入力したとおりに保持します。メッセージやテンプレートのように、1行で快適に収まらないテキストのブロックがある場合は常に到達してください。
Juno複数行文字列 トリプル引用符は行の破れと間隔を対応していないわたしはメールテンプレート、SQL、およびすべての長いブロックに適しています。また、ドキュメント文字列がどのように機能するかです。関数またはクラスの上部のトリプル引用符文字列がインライン記述になります。インデントに注意してください。ラインをラインアップするために追加するスペースはテキスト内で終わるためです。
Juno複数行文字列 トリプル引用符の内側のすべて、先頭の空白を含め、文字通り保持され、罠です。リテラルをコードと一致させるようにインデントし、そのインデントは値に着地します。関数またはクラスの上部に短い方を置き、それは`help()`が表示するドキュメント文字列になります。ソース内でインデントしてから値をクリーンの場合、`textwrap.dedent()`で実行してください。

エスケープシーケンス

いくつかの文字は文字列内で直接入力するのが難しいです。Pythonはエスケープシーケンスを使用します。何かを表すバックスラッシュに続く文字です。あなたが常に使う2つは、新しい行に\n、タブに\tです。

エスケープシーケンスにより、そうでなければ構文を壊すか、直接入力できない文字を埋め込むことができます。あなたが到達する方法。\n(改行)、\t(タブ)、\\(リテラルバックスラッシュ)、\"および\'(一致するデリミタ文字列内の引用符)。Windowsパスはバックスラッシュを必要とし、エスケープ処理と衝突します。rで接頭辞を付けて無効にしてください。

日常の\n\tを超えて、Pythonは、直接入力できない文字のUnicodeエスケープをサポートしています。\uXXXX\UXXXXXXXXは番号でそれを指定し、\N{name}は単語で指定し、\N{GREEK SMALL LETTER ALPHA}のようです。実際のコードで到達するものは生文字列で、r"..."として書かれ、エスケープ処理を完全に無効にし、変わらずすべてのバックスラッシュを渡します。Windowsパスと正規表現パターンに使用してください。バックスラッシュはそのコンシューマーのものであり、Pythonのものではなく、rを忘れると、パターンは静かに間違ったものと一致します。

シーケンス文字
\n改行
\tタブ
\\リテラルバックスラッシュ
\"ダブルクォート
\'シングルクォート
python
print("Line one\nLine two")        # 2行の出力
print("Name:\tTanaka")             # Name:   Tanaka
path = r"C:\Users\Tanaka\Documents" # 生文字列、エスケープ処理なし
Junoエスケープシーケンス 文字列内のバックスラッシュは、「次の文字を特別に読む」を意味します。`\n`は新しい行を開始し、`\t`はタブを挿入し、`\\`は1つの実際のバックスラッシュです。これら2つ、`\n`と`\t`は、あなたが実際に入力するものです。引用符の前に`r`をポップし、バックスラッシュは普通に戻り、Windowsパスに便利です。
Junoエスケープシーケンス `\n`、`\t`、`\\`、および`\"`日常のエスケープをカバーしています。頭痛を保存する方法:生文字列、`r"..."`は、すべてのバックスラッシュを文字通りに保つようエスケープ処理を切り替えます。Windowsパスと正規表現パターンに使用してください。バックスラッシュは別の何かのためのものです。
Junoエスケープシーケンス `\n`と`\t`を過ぎて、`\N{name}`のようなUnicodeエスケープがありますが、労働者は生文字列`r"..."`です。すべてのバックスラッシュを触れられないで渡します。正規表現パターンとWindowsパスに到達してください。`r`を忘れるとパターンが静かに間違ったものと一致するため、エラーが発生しないため、あなたを教えません。

文字列内容を確認

Pythonには、文字列に含まれているものについてのはい/いいえの質問に答えるメソッドがあります。彼らはTrueまたはFalseを返します。最初は有用です。isdigit()を使用すると、変換前に文字列がすべて数字であるかを確認できるため、予期しない入力でクラッシュを避けることができます。

is*メソッドはそれぞれ、文字列全体の特定のプロパティをテストし、すべての文字が条件を満たす場合のみTrueを返します。主な用途は入力検証です。予期しない入力のクラッシュを避けるために変換前に確認してください。int()前にisdigit()は古典的なパターンで、ファイルと例外の章で説明しているValueErrorをキャッチするための代替です。

これらのチェックは、プレーンASCII文字と数字のみではなく、すべてのUnicodeを横断して「この種の文字が確認」を聞きます。つまり、"2".isdigit()は上付き2および通常の"2"に対してTrueです。これにより、予期しない入力が検証チェックをスリップできます。厳密に数字0から9を意味する場合、組み合わせs.isascii() and s.isdigit()です。isnumeric()はより広いで、分数およびその他の数値の値の文字をカウントするため、実際に受け入れるものを一致させるだけでなく、正しく見える最初のチェックよりも狭いチェックに到達してください。

python
"42".isdigit()       # True
"hello".isalpha()    # True
"hello42".isalnum()  # True
"   ".isspace()      # True
"Hello".islower()    # False
"HELLO".isupper()    # True
Juno文字列内容を確認 `is*`メソッドはイエスまたはノーの質問に答え、すべての文字が適合したとき`True`だけを返します。あなたが最初に使用するもの:テキストが実際に数字であることを確認するために`int()`前に`isdigit()`を呼び出し、奇妙な入力はあなたをクラッシュさせません。
Juno文字列内容を確認 各`is*`メソッドは、文字列全体が渡される場合にのみ`True`です。変換前に検証するのに便利です。`int()`前に`isdigit()`は古典的なガードです。それは文字列全体をテストしていることを覚えておいてください。空の文字列はすべてに対して`False`を返します。
Juno文字列内容を確認 これらのチェックはすべてのUnicodeを走査しません。プレーンASCIIなため、`isdigit()`は上付きおよび受け入れることを意図していなかった他の数値文字をパスします。数字`0`から`9`を意味する場合、ペアリング:`s.isascii() and s.isdigit()`です。実際の入力と一致し、最初に正しく見える狭いチェックよりも狭いチェックを選んでください。

実践

空白をストリップし、ケースを正規化し、その後、必要なものを引き出します。このシーケンスはほぼすべてのユーザー提供テキストを処理します。

python
raw_input = "  [email protected]  "
email = raw_input.strip().lower()   # "[email protected]"

at_pos = email.find("@")
username = email[:at_pos]
domain = email[at_pos + 1:]

print(f"User:   {username}")    # "tanaka"
print(f"Domain: {domain}")      # "example.com"

部分からURLを構築し、すぐに検証と解析を行います。

python
BASE_URL = "https://api.example.com"
version = "v2"
resource = "users"
user_id = 42

url = f"{BASE_URL}/{version}/{resource}/{user_id}"
# "https://api.example.com/v2/users/42"

parts = url.split("://")              # ["https", "api.example.com/v2/users/42"]
protocol = parts[0]                   # "https"
secured = url.startswith("https")
domain = parts[1].split("/")[0]       # "api.example.com"

print(f"Protocol : {protocol}")
print(f"Secure   : {secured}")
print(f"Domain   : {domain}")

find()、スライス、およびf文字列配置を使用して、構造化ログラインを解析します。

python
log_entry = "[2024-01-15 09:42:11] ERROR: File not found: report.csv"

timestamp = log_entry[1:20]
rest = log_entry[22:]                # "ERROR: File not found: report.csv"
colon_pos = rest.find(":")
level = rest[:colon_pos]             # "ERROR"
message = rest[colon_pos + 2:]       # "File not found: report.csv"

print(f"[{timestamp}] {level:>8}: {message}")
# [2024-01-15 09:42:11]    ERROR: File not found: report.csv

find()は境界を見つけ、スライスは部分を抽出し、>8形式仕様は重要度ラベルを右配置するため、レベル名の長さが異なるときに列が一貫性を保ちます。

メソッドリファレンス

メソッド何をするか
.lower() / .upper()すべて小文字/大文字に変換
.title() / .capitalize()各単語を大文字化/最初のみ
.strip() / .lstrip() / .rstrip()周辺の空白を削除
.find(sub)最初の一致のインデックス、または-1
.count(sub)subが表示される回数
.startswith(s) / .endswith(s)プレフィックス/サフィックスチェック
.replace(old, new)出現を置換
.split(sep)リストに分割
sep.join(iterable)アイテムを文字列に結合
.isdigit() / .isalpha() / .isalnum()文字型チェック