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

数値と算術演算

docs.scrimba.com

数値はほぼすべてのプログラムに登場します。ショッピングカートの合計、ゲームのスコア更新、何かが起きた回数のカウント。Pythonは紙の計算のような算術演算子を提供し、さらに最初から知る価値のあるものがいくつかあります。

Pythonの算術演算子は標準的なセット、整数除算、剰余、累乗をカバーしています。いくつかの動作は他の言語と異なる方法で重要です。/は常にfloatを返し、床除算は負の無限大に向かって丸め、剰余は真の剰余セマンティクスに従います。

Pythonの整数にはオーバーフロー(固定サイズ整数の言語で発生するラップアラウンドまたはエラー)がありません。メモリが許す限り大きくなります。floatは通常の倍精度小数で、ほとんどの作業に問題ありませんが、金銭には決して正確ではありません。算術演算子は、多くの言語がコピーするC規約ではなく、数学的定義に従います。//は床除算(負の無限大に向かって丸める)で、%は被除数ではなく除数の符号を持ちます。どちらの選択でも、入力が正か負かに関わらず同じ結果が得られ、これが循環とラップの動作に必要な動作です。

演算子

数学の4つの演算子(+-*/)は期待通りに機能します。Pythonは3つ追加し、常に使用するものを追加します。整数除算、剰余、累乗です。

標準的な4つの演算子は期待通りに動作します。注目すべき1つのルール:/は結果が整数でも常にfloatを返します。3つの追加演算子は、追加作業なしに表現できることを拡張します。

各演算子はダンダーメソッド(ダブルアンダースコアで名付けられたメソッドで、Pythonが舞台裏で呼び出す)に接続されます。+__add__に、//__floordiv__に、%__mod__に、**__pow__に接続されます。実用的な見返りは、独自のクラスがこれらのメソッドを定義し、組み込み数値と同じ方法で+または*を直接操作できることです。intfloatを1つの操作で混ぜると常にfloatが得られ、/は何を与えても常にfloatを返します。

python
price = 12.99
quantity = 3

print(price * quantity)   # 38.97
print(price + 2)          # 14.99
print(price - 1.00)       # 11.99
演算子名前結果
+加算5 + 38
-減算5 - 32
*乗算5 * 315
/除算5 / 31.6666...
//整数除算5 // 31
%剰余5 % 32
**累乗5 ** 3125
Juno演算子+-*/は紙の計算のように動作します。3つの追加は早期から学ぶ価値があります。//は整数に除算し、%は剰余を返し、**は累乗します。%の方が期待以上に使うことになります。
Juno演算子 4つの基本は期待通りに動作します。1つのルールを覚えておいてください。/は常にfloatを返します。追加のものは、整数除算の//、剰余の%、累乗の**です。それぞれがヘルパーを書く手間を省きます。
Juno演算子 すべての演算子はダンダーにルートしているため、__add__または__mul__を定義するクラスは+*に直接プラグインできます。intfloatを混ぜると常にfloatに拡張され、`/`は何を与えても常にfloatを返します。

除算:/ vs //

/は答えが整数でも常に正確な小数を返します。//は小数部を切り落とし、負の無限大に向かって床。正の数の場合は小数を切ることを意味しますが、負の数の場合はゼロからさらに1ステップ進みます。

/は常にfloatを返します。入力が整数でも返します。//は結果の床を返します。真の結果以下の最大の整数です。正の数の場合は切り詰めと同じです。負の数の場合は異なります。

/は真の除算で常にfloatを返します。//は床除算です。真の商を0に向かって切るのではなく、負の無限大に向かって丸めます。これは多くの他の言語が行うこととは異なります。実際に重要な理由は、Pythonの//%がすべての整数入力(負を含む)に対してa == (a // b) * b + (a % b)を満たすためです。切り詰める除算は負を壊すため、サイクリングまたはラップロジックなしで符号を特別扱いすることなく正確に保ちます。

python
10 / 2     # 5.0   (常にfloat、均等に割れても)
10 / 3     # 3.3333333333333335

10 // 3    # 3
7 // 2     # 3
-7 // 2    # -4    (ゼロに向かってではなく、負の無限大に向かって床)

ほとんどの場合、正の数で//を使用します。負の動作が現れたときに念頭に置いてください。

Juno除算:/ vs ///は常に小数を返します。均等に割れても4 / 22.0です。//は小数部を切り落としますが、負に注意してください。-7 // 2-3ではなく-4です。これは切り詰めではなく床だからです。最初にやったときに私を引っかかりました。

Pythonはこれを床除算と呼びます。数学的床関数を適用するからです。他の言語は代わりにゼロに向かって切り、負の場合異なる結果を与えます。名前//はヒントです。除算してから床。

Juno除算:/ vs ///は常にfloatを返します。4 / 2でも2.0を返します。//は切り詰めではなく床するため、-7 // 2-4です。正の数では2つは同じに見えます。ギャップは負でのみ開きます。

//floor(a / b)を計算し、切り詰めはしません。floatでも機能します。7.5 // 23.0で、床の商はintではなくfloatとして返されます。

Juno除算:/ vs ////は商を床するため、a == (a // b) * b + (a % b)をすべての入力、負を含めて満たします。これが循環ロジックで頼るプロパティです。floatのオペランドは//をfloatを返すようにします。7.5 // 23.0を与えます。

剰余演算子%

%は整数除算後に残っているものを提供します。10 // 33の場合(3は10に3回入る)、10 % 31です(3×3=9、10-9=1)。最も一般的な使用は数が偶数か奇数かを確認することです。

%は剰余演算子です。偶数/奇数チェックが最も一般的な使用ですが、循環またはラップの問題に一般化されます。カウンターを範囲内に保つ、アイテムをグループに配布する、シーケンスを繰り返す。パターンは常にvalue % limitで、0からlimit - 1の間の値を返します。

Pythonの%は真の剰余です。結果は常に除数の符号を持ちます。多くの他の言語は被除数の符号を代わりに取るため、Pythonが2を与える-7 % 3に対して-1を与えます。Pythonの答えは、//が負の無限大に向かって床することで、剰余をa - (a // b) * bとして定義することから生じます。見返りはvalue % limitが負の無限大に入っても0からlimit - 1の内側に留まることです。ガード句なしでリストの終わりの周りをラップするインデックスが範囲に着陸します。

python
10 % 3    # 1
10 % 2    # 0  (均等に割る)
10 % 7    # 3

6 % 2     # 0  (偶数)
7 % 2     # 1  (奇数)
Juno剰余演算子 %%は整数除算後の余りです。10 % 31です。3が10に3回入り、1が余るからです。ほとんどの場合、偶数/奇数チェックで出会います。n % 2は偶数は0、奇数は1です。
Juno剰余演算子 %%は剰余で、偶数/奇数を超えて進みます。値を範囲内に保つ必要があるときはいつでも、value % limitは0からlimit - 1に巻き付けます。カウンター、グループ割り当て、繰り返しサイクル、すべて同じ形。
Juno剰余演算子 %%は除数の符号に従うため、-7 % 32です。-1ではありません。これによりvalue % limitは負の入力でも範囲内に留まり、ラップするインデックスにはガード句がありません。

累乗**

**は数を累乗します。2つのアスタリスクを使用し、Pythonで別の意味を持つ^シンボルではありません。

**は累乗です。floatでも機能し、別の関数呼び出しではなく分数累乗として根を表現できます。

**は累乗に引き上げ、分数の累乗形式は便利です。n ** 0.5は何もインポートせずに平方根です。2つのintのオペランドがintを与え、floatのオペランドがfloatを与えます。大きなまたは正確な作業に到達する前に知っておく1つのこと。9 ** 0.5はfloat数学を通るため、いくつかの入力に対して2.9999999999999996に着陸できます。正確さが重要な場合、math.isqrt()は整数根およびmath.pow()モジュールの章で説明されているツールです。

python
2 ** 10    # 1024
3 ** 3     # 27
9 ** 0.5   # 3.0  (平方根:0.5の累乗に引き上げる)
Juno累乗 ****は数を累乗に引き上げるため、2 ** 101024です。分数の累乗はルートを与えます。9 ** 0.53.0です。1つの罠はシンボルです。**を使用し、^ではなく、Pythonで関連のないことをします。
Juno累乗 ****は累乗で、floatを取るため、9 ** 0.5は個別の関数呼び出しなしで平方根を与えます。インラインで迅速に根を求めたいときは、分数の累乗形式に到達してください。
Juno累乗 ** 2つのintはintを与え、任意のfloatはfloatを与えます。** 0.5ルートトリックの落とし穴は、float数学を通って実行され、ドリフトする可能性があることです。正確さが重要な場合はmath.isqrt()またはmath.pow()に到達してください。

演算子の優先順位

Pythonは標準的な数学の順序に従います。累乗最初、乗算と除算、加算と減算。確実でない場合は括弧を使用してください。意図を明確にし、何も費用がかかりません。

Pythonは標準的なPEMDAS/BODMAS順序に従います。人々を引っかかる部分。///%はすべて同じ優先順位レベルを共有し、混合されたときに左から右に評価します。括弧は無料です。順序が一見では明確でない場合はいつでもそれらを使用してください。

算術演算子の中で最高から最低への優先順位。**、単項-(単一の値の前のマイナス記号)、* / // %(共有レベルのときは左から右)、+ -。実際のコードで悩むようになる1つの罠。-2 ** 2-(2 ** 2)で、-4です。**は先導マイナスより厳しくバインドするからです。負である可能性がある値を平方する場合は、(-2) ** 2として括弧を付けるか、符号は警告なしに間違っています。

python
2 + 3 * 4      # 14、20ではない
2 ** 3 + 1     # 9、512ではない
10 - 4 / 2     # 8.0、3.0ではない

(2 + 3) * 4    # 20
10 / (2 + 3)   # 2.0
Juno演算子の優先順位 紙の計算と同じ順序。累乗最初、乗算と除算、加算と減算。順序が一見では明確でない場合は、括弧を追加してください。何も費用がかかりませんし、まさに意図したことを示唆しています。
Juno演算子の優先順位 標準的なPEMDAS順序。1つの引っかかり。///%はすべて同じレベルにあり、混合されたときに左から右に実行します。その左から右のルールは人々が誤読する部分です。グループ化が明確でないときはいつでも括弧を付けます。
Juno演算子の優先順位 罠は単項マイナスが**より緩くバインドすることです。-2 ** 2-4です。負の可能性があるものを(-2) ** 2として平方するか、符号は警告なしに反転します。

intとfloatがどのように相互作用するか

Pythonは一貫したルールを持っています。/は常に小数を返し、4 / 2でも2.0を与えます。整数と小数を混ぜる任意の操作もfloatを与えます。整数が必要な場合は、//を使用するか、int()で変換してください。

タイプルールは予測可能です。/は常にfloatを返します。//%は2つの整数でintを返します。intfloatを混ぜる任意の操作はfloatを返します。これは4 / 22ではなく2.0であることを意味し、整数が必要な場合(例えば、インデックスとして使用する)に重要です。

ルールは固定であり、内在する価値があります。intはいつでもfloatとのミックス時にfloatに拡張され、/は常にfloatを返し、//はオペランドが両方ともintのときのみintを返します。このバグが防ぐことは、floatが何かの必要があるかもしれないものにこっそり入ることです。リストインデックスまたは辞書キー。2.02は交換可能ではありません。計算がfloatを生成し、intが必要な場合は、除算が整数に出てきたことを期待するのではなく、その時点でint()で変換してください。

python
4 / 2      # 2.0   (常にfloat)
4 // 2     # 2     (int)
4 + 2      # 6     (int)
4 + 2.0    # 6.0   (float)
4 * 0.5    # 2.0   (float)
Junointとfloatがどのように相互作用するか/は常に小数を与えるため、4 / 22ではなく2.0です。整数を小数で任意の場所で混ぜると、小数が出てきます。整数が必要な場合は、//に到達するか、int()でラップしてください。
Junointとfloatがどのように相互作用するか/は常にfloatです。`//`と`%`は2つのintで`int`に留まり、任意の`int`は`float`と混ぜられてfloatに出てきます。人々を引っかかるのは、インデックスを求めるとき、4 / 22.0の場合です。
Junointとfloatがどのように相互作用するか 迷路のfloatは、正確な`int`が必要なものを壊します。インデックスまたは辞書キーのように、`2.0`は`2`ではありません。除算が整数に出てきたことを信頼するのではなく、その境界でint()で変換してください。

Float精度

ある時点で、ほぼすべての人を驚かせる落とし穴があります。

python
0.1 + 0.2   # 0.30000000000000004

その小さなエラーはPythonのバグではありません。コンピューターはバイナリで小数を格納し、0.1などのいくつかの値を正確に表現することはできません。10進数で1/3を正確に書くことができない方法に似ています。ほとんどの日常的な計算ではそれは重要ではありません。金銭を表示するために、round()または:.2f形式指定子は出力をきれいに保ちます。

floatは約15から16の有効な10進数字の精度を提供します。いくつかの分数をバイナリで正確に格納できないため、不正確さが生じるため、0.1 + 0.20.30000000000000004を生成します。ドリフトはどの値を検査する場合のみ表示されます。:.2fまたはround()でフォーマットすることで、出力でそれを非表示にします。

金銭作業でセントの分数が蓄積される場合、Pythonは標準ライブラリのdecimal.Decimalを正確な基数10算術で提供します。これはモジュールの章で説明されています。

floatはバイナリ(基数2)で数を格納し、分母が2の累乗ではない分数(1/10のような)バイナリ形式がありません。1/3が10進数形式がない方法と同じです。これは0.1 + 0.20.30000000000000004に着陸する全体の理由です。操作ごとのエラーは小さいですが、長い算術の連鎖にわたって蓄積するため、同じ合計を計算する2つの方法が最後の数字で同意しないことができます。

バグを防ぐルール。floatは絶対に金銭に使用しないでください。floatを==で正確な等価性に対してテストしないでください。正確な基数10算術が必要な場合(請求、会計)decimal.Decimalに到達するか、正確な比率が必要な場合fractions.Fractionに到達してください。どちらもPythonの標準ライブラリに付属し、モジュールの章で説明されています。

JunoFloat精度 コンピューターはバイナリで小数を格納し、`0.1`などのいくつかの値には正確なバイナリ形式がないため、`0.1 + 0.2`は`0.30000000000000004`に出てきます。それはPythonのバグではなく、すべての言語がこれをします。日常的な出力の場合、round()または:.2fがそれをきれいに保ちます。
JunoFloat精度 バイナリはすべての小数を正確に保持できないため、`0.1 + 0.2`は`0.30000000000000004`にドリフトします。ほとんどの数学に問題なく、`:.2f`または`round()`が表示をきれいにします。セントを追加する必要がある場合は、decimal.Decimalに切り替えます。
JunoFloat精度 あなたを救うルール。金銭にはfloatはなく、floatに`==`は決してありません。エラーは操作の長いチェーンにわたって蓄積するため。正確な基数10にはdecimal.Decimalを、正確な比率にはfractions.Fractionを使用してください。

読みやすい数値リテラル

Pythonは大きな数をより読みやすくするために、数値リテラルにアンダースコアを入れることを許可します。Pythonはそれらを完全に無視します。これはあなたのためです。

アンダースコアは数値リテラルの任意の場所で有効で、解析中に値に影響を与えることなく取り除かれます。定数の数千の区切り文字と、バイナリまたは16進数リテラルで数字をグループ化するのに便利です。

アンダースコアはPythonが値を見る前に取り除かれるため、その値に対して0の効果があります。それらは整数、floats、基づくリテラル(0xFF_FF0b1010_00011_234.567_890)で機能し、16進数定数でバイトをグループ化するのに便利で、10進数で数千のみではありません。唯一の制限。アンダースコアは開始、終了の横に、小数点またはエクスポーネントマーカーの横にはいません。

python
population = 8_100_000_000
distance_km = 384_400
pi_approx = 3.141_592_653
Juno読みやすい数値リテラル 長い数字にアンダースコアをドロップしてそれを読みやすくしてください。`8_100_000_000`は`8100000000`と同じ値です。Pythonはそれらを完全に無視し、インタープリターではなくあなたの目のためです。
Juno読みやすい数値リテラル アンダースコアは数値リテラル内の任意の場所で有効で、解析時に消えます。値は変わりません。定数の数千区切りに良く、バイナリまたは16進数で数字をグループ化するのと同様に有用です。
Juno読みやすい数値リテラル アンダースコアは整数、floats、および基づくリテラル全体で化粧品であるため、0xFF_FF0b1010_0001がより明確に読むことができます。唯一のルール。開始、終了、または小数点またはエクスポーネントマーカーの横にはありません。

便利な組み込み関数

abs()

abs()は絶対値を返します。常に正で、入力の符号に関わらず。数字がゼロからどのくらい離れているかを気にするときに使用し、どちらの方向ではなく。

abs()は数の大きさを返します。整数とfloatで動作します。距離計算、エラーマージン、方向が不関係で値のサイズだけが必要な状況に有用です。

abs()は数の大きさを返し、戻り型は入力と一致します。intでintが出て、floatがfloatを与えます。日常的な使用は、2つの値がターゲットからどのくらい離れているかを比較し、どちらの側に落ちるかを気にしません。例えばabs(measured - expected) < toleranceは許容範囲チェックとして、符号付き範囲に対して2つの比較よりも明確に読みます。

python
abs(-5)     # 5
abs(3.7)    # 3.7
abs(-0.5)   # 0.5
Junoabs()abs()は符号を取り除き、肯定的なサイズを返します。abs(-5)5で、abs(3.7)3.7です。数がゼロからどのくらい離れているかを気にするときに到達してください。どちらの方向ではなく。
Junoabs()abs()は`int`または`float`の大きさを与え、方向は破棄されます。距離とエラーマージンチェックの清潔な方法です。符号が質問の一部ではない場所。
Junoabs()abs()は入力タイプを保ちます。`int`は`int`に留まります。保つ価値のあるパターンはabs(measured - expected) < toleranceです。符号付き範囲の周りの2つの比較ではなく、1つの許容チェック。

round()

round()はデフォルトで最も近い整数に丸めます。2番目の引数を渡して、特定の小数位数を保つ。

python
round(3.7)          # 4
round(3.2)          # 3
round(3.14159, 2)   # 3.14

知る価値がある1つのこと。round(2.5)2を与え、3ではありません。値が2つのオプション間の正確に途中の場合、Pythonは最も近い偶数に丸めます。

round()銀行家の丸めを使用します。値が正確に途中の場合、常に上に丸めるのではなく、最も近い偶数に丸めます。これは統計作業での累積エラーを最小化しますが、0.5が常に上に丸められることを期待する場合は驚くことができます。

python
round(2.5)   # 2  (最も近い偶数に丸める)
round(3.5)   # 4
round(4.5)   # 4  (5ではなく)
round(3.14159, 2)   # 3.14

round()は半分を偶数に丸める(銀行家の丸め)を使用します。正確なタイを最も近い偶数の整数に、常に上ではなく行きます。これは数字の長い列での丸めエラーが1つの方向にバイアスされるのを保ちます。これは統計作業のデフォルトです。2つの実用的な注意。最初に、floatのタイがバイナリにある場合は正確なタイではないことがよくあるため、round(2.675, 2)2.68ではなく2.67を与えます。2.675を正確に格納することはできません。2番目に、通貨の丸めが数セントを追加する必要がある場合、floatに対してround()に頼るのではなく、decimal.Decimalと明示的な丸めモードでそれを実行してください。

python
round(2.5)   # 2
round(3.5)   # 4
round(4.5)   # 4
Junoround()round(x)は最も近い整数に移動し、round(x, n)は`n`小数位を保ちます。驚き。正確に途中に座っている値は最も近い偶数に丸めるため、round(2.5)2で、3ではありません。
Junoround()round()は銀行家の丸めを使用するため、正確な半分は最も近い偶数に移動します。round(2.5)2で、round(4.5)4です。集約作業でバイアスを削減しますが、半分が常に上に丸められることを期待するときに期待してください。
Junoround() 銀行家の丸めとバイナリは`round(2.675, 2)`が`2.67`であることを意味します。`2.675`が正確なタイではないので。通貨の場合は、floatに対して`round()`に頼るのではなく、選択した方法でdecimal.Decimalで丸めます。

divmod()

divmod()は商と剰余を単一の呼び出しで与えます。タプルタプルとセットの章で説明)である値のペアを返し、2つの名前に一度に割り当てることができます。

divmod(a, b)(a // b, a % b)と同等ですが、単一のステップで計算されます。とにかく両方の値が必要な場合、ページ分割、時間変換、またはアイテムをグループに配布する場合に使用します。

divmod(a, b)は除算を1回行い、床の商と剰余の剰余の両方をペアとして返すため、//%で同じ除算を再計算することを回避します。時間変換(divmod(seconds, 60))、ページ分割、またはアイテムを固定サイズの行に配置しているとき、とにかく両方の部分が必要な場所で最もきれいに読みます。

python
divmod(10, 3)   # (3, 1): 商3、剰余1
divmod(7, 2)    # (3, 1)
divmod(9, 3)    # (3, 0)

quotient, remainder = divmod(10, 3)
print(quotient)    # 3
print(remainder)   # 1
Junodivmod()divmod(a, b)は商と剰余を一緒に返します。divmod(10, 3)(3, 1)です。quotient, remainder = divmod(10, 3)で両方を一度にアンパックできます。
Junodivmod()divmod(a, b)は1つのステップで(a // b, a % b)です。時間変換またはページ分割などの両方のピースが必要な場合に、除算を2回計算するのではなく到達してください。
Junodivmod() 1つの除算、両方の結果。`divmod()`は分離した`//`と`%`の冗長作業をスキップします。`divmod(seconds, 60)`またはロー配置のような両方の部分が必要な場合は最もよく読みます。

実際に

チップ計算機。

python
bill = 45.50
tip_rate = 0.18
tip = round(bill * tip_rate, 2)
total = round(bill + tip, 2)

print(f"Bill:  ${bill}")
print(f"Tip:   ${tip}")
print(f"Total: ${total}")

round()は出力を金銭のように見せ、小数点のあるのではなく。

ページング用のカウントページと進捗トラックを。

python
total_items = 153
items_per_page = 10

full_pages, leftover = divmod(total_items, items_per_page)
total_pages = (total_items + items_per_page - 1) // items_per_page

print(f"Full pages: {full_pages}, leftover: {leftover}")
print(f"Total pages needed: {total_pages}")   # 16
python
total_files = 847
processed_files = 312

percent = round(processed_files / total_files * 100, 1)
print(f"Progress: {processed_files}/{total_files} ({percent}%)")

天井除算公式(n + d - 1) // dは、floatに変換せずに丸めアップするための標準的な整数トリックです。

最小最大正規化と変化の割合。2つのパターン、データ作業で絶えず表示されます。

python
# 最小最大正規化。値を0.0から1.0の範囲にスケーリング
value = 75
minimum = 0
maximum = 100

normalised = (value - minimum) / (maximum - minimum)
print(f"Normalised: {normalised:.2f}")   # 0.75

# 2つの測定値間の変化率
before = 1_200
after = 1_380

change = (after - before) / before * 100
print(f"Change: {change:.1f}%")          # 15.0%

両方のパターンは比率に減少します。参照範囲または参照の大きさに相対的な値。floatの精度はほとんどの分析作業に十分です。累積されたエラーは、計算が数十の操作を連鎖させるか、多くの大きさの順序で異なる値に関わる場合にのみ重要です。