Ebben a cikkben megismerheti a Pythonban használt különböző számokat, az egyik adattípusból a másikba való konvertálást és a Python által támogatott matematikai műveleteket.
Szám Adattípus Pythonban
A Python egész számokat, lebegőpontos és komplex számokat támogat. Ezek a meghatározás szerint int, floatés complexosztályok Python.
Az egész számokat és a lebegő pontokat egymástól tizedespont jelenléte vagy hiánya választja el. Például az 5 egy egész szám, míg az 5,0 egy lebegőpontos szám.
A komplex számokat a következő formában írjuk:, x + yjahol x a valós rész, y pedig a képzeletbeli rész.
A type()függvény segítségével megtudhatjuk, hogy egy változó vagy egy érték melyik osztályba tartozik, és isinstance()ellenőrizhetjük, hogy egy adott osztályhoz tartozik-e.
Nézzünk meg egy példát:
a = 5 print(type(a)) print(type(5.0)) c = 5 + 3j print(c + 3) print(isinstance(c, complex))
A fenti program futtatásakor a következő kimenetet kapjuk:
(8 + 3j) Igaz
Míg az egész számok bármilyen hosszúak lehetnek, a lebegőpontos szám csak 15 tizedesjegyig pontos (a 16. hely pontatlan).
A számok, amelyekkel mindennap foglalkozunk, a tizedes (10. alap) számrendszerből származnak. De a számítógépes programozóknak (általában beágyazott programozóknak) bináris (2. alap), hexadecimális (16. alap) és oktális (8. alap) számrendszerekkel kell dolgozniuk.
A Pythonban ezeket a számokat úgy ábrázolhatjuk, hogy az előtagot megfelelően helyezzük el a szám elé. A következő táblázat felsorolja ezeket az előtagokat.
| Számrendszer | Előtag |
|---|---|
| Bináris | „0b” vagy „0B” |
| Octal | „0o” vagy „0O” |
| Hexadecimális | „0x” vagy „0X” |
Íme néhány példa
# Output: 107 print(0b1101011) # Output: 253 (251 + 2) print(0xFB + 0b10) # Output: 13 print(0o15)
A program futtatásakor a kimenet a következő lesz:
107 253 13
Írja be a konverziót
Átalakíthatjuk az egyik típusú számot egy másikra. Ez más néven kényszer.
Az összeadás, kivonás kényszeríti az egész számot implicit módon (automatikusan) lebegésre, ha az egyik operandus lebeg.
>>> 1 + 2.0 3.0
Fentebb láthatjuk, hogy 1 (egész szám) 1,0-re (float) kényszerül az összeadáshoz, és az eredmény szintén lebegőpontos szám.
Beépített funkciókat is használhatunk, mint például int(), float()és complex()kifejezetten konvertálhatunk a típusok között. Ezek a függvények akár karakterláncokból is konvertálhatók.
>>> int(2.3) 2 >>> int(-2.8) -2 >>> float(5) 5.0 >>> complex('3+5j') (3+5j)
Amikor lebegőből egész számba konvertál, a szám csonka lesz (a tizedes részeket eltávolítjuk).
Python Decimal
A Python beépített osztályú lebegője elvégez néhány számítást, amely meghökkenthet minket. Mindannyian tudjuk, hogy az 1.1 és a 2.2 összege 3,3, de úgy tűnik, hogy a Python nem ért egyet.
>>> (1.1 + 2.2) == 3.3 False
Mi folyik itt?
Kiderült, hogy a lebegőpontos számok a számítógépes hardverben bináris törtekként valósulnak meg, mivel a számítógép csak a bináris (0 és 1) értékeket érti. Emiatt az általunk ismert tizedes törtek nagy része nem tárolható pontosan a számítógépünkben.
Vegyünk egy példát. Az 1/3 törtet nem tudjuk tizedes számként képviselni. Ez 0,33333333-at kap … ami végtelen hosszú, és csak közelíteni tudjuk.
Kiderült, hogy a 0,1 tizedes tört végtelen hosszú bináris törtet eredményez, 0,000110011001100110011 … és számítógépünk csak véges számot tárol belőle.
Ez csak kb. 0,1, de soha nem lesz egyenlő. Ennélfogva ez a számítógépes hardver korlátozása, és nem hiba a Pythonban.
>>> 1.1 + 2.2 3.3000000000000003
A probléma kiküszöbölésére használhatjuk a Pythonhoz mellékelt tizedes modult. Míg a lebegőpontos számok pontossága legfeljebb 15 tizedesjegy lehet, a tizedes modul felhasználó által beállítható pontossággal rendelkezik.
Lássuk a különbséget:
import decimal print(0.1) print(decimal.Decimal(0.1))
Kimenet
0,1 0,1000000000000000055511151231257827021181583404541015625
Ezt a modult akkor használjuk, amikor decimális számításokat akarunk végezni, ahogyan azt az iskolában megtanultuk.
Megőrzi a jelentőséget is. Tudjuk, hogy a 25,50 kg pontosabb, mint a 25,5 kg, mivel az egyikhez képest két jelentős tizedesjegy van.
from decimal import Decimal as D print(D('1.1') + D('2.2')) print(D('1.2') * D('2.50'))
Kimenet
3,3 3 000
Notice the trailing zeroes in the above example.
We might ask, why not implement Decimal every time, instead of float? The main reason is efficiency. Floating point operations are carried out must faster than Decimal operations.
When to use Decimal instead of float?
We generally use Decimal in the following cases.
- When we are making financial applications that need exact decimal representation.
- When we want to control the level of precision required.
- When we want to implement the notion of significant decimal places.
Python Fractions
Python provides operations involving fractional numbers through its fractions module.
A fraction has a numerator and a denominator, both of which are integers. This module has support for rational number arithmetic.
We can create Fraction objects in various ways. Let's have a look at them.
import fractions print(fractions.Fraction(1.5)) print(fractions.Fraction(5)) print(fractions.Fraction(1,3))
Output
3/2 5 1/3
While creating Fraction from float, we might get some unusual results. This is due to the imperfect binary floating point number representation as discussed in the previous section.
Fortunately, Fraction allows us to instantiate with string as well. This is the preferred option when using decimal numbers.
import fractions # As float # Output: 2476979795053773/2251799813685248 print(fractions.Fraction(1.1)) # As string # Output: 11/10 print(fractions.Fraction('1.1'))
Output
2476979795053773/2251799813685248 11/10
This data type supports all basic operations. Here are a few examples.
from fractions import Fraction as F print(F(1, 3) + F(1, 3)) print(1 / F(5, 6)) print(F(-3, 10)> 0) print(F(-3, 10) < 0)
Output
2/3 6/5 False True
Python Mathematics
Python offers modules like math and random to carry out different mathematics like trigonometry, logarithms, probability and statistics, etc.
import math print(math.pi) print(math.cos(math.pi)) print(math.exp(10)) print(math.log10(1000)) print(math.sinh(1)) print(math.factorial(6))
Output
3.141592653589793 -1.0 22026.465794806718 3.0 1.1752011936438014 720
Here is the full list of functions and attributes available in the Python math module.
import random print(random.randrange(10, 20)) x = ('a', 'b', 'c', 'd', 'e') # Get random choice print(random.choice(x)) # Shuffle x random.shuffle(x) # Print the shuffled x print(x) # Print random element print(random.random())
Amikor a fenti programot futtatjuk, a kimenetet a következőképpen kapjuk meg. (Az értékek a véletlenszerű viselkedés miatt eltérőek lehetnek)
18 e („c”, „e”, „d”, „b”, „a”) 0,5682821194654443
Itt található a Python random modulban elérhető funkciók és attribútumok teljes listája.
