I den här artikeln lär du dig om de olika siffrorna som används i Python, hur man konverterar från en datatyp till en annan och de matematiska operationer som stöds i Python.
Nummerdatatyp i Python
Python stöder heltal, flytande nummer och komplexa nummer. De definieras som int, floatoch complexklasser i Python.
Heltals och flytpunkter separeras av närvaron eller frånvaron av en decimal. Till exempel är 5 ett heltal medan 5,0 är ett flytpunktsnummer.
Komplexa siffror skrivs i form, x + yjdär x är den verkliga delen och y är den imaginära delen.
Vi kan använda type()funktionen för att veta vilken klass en variabel eller ett värde tillhör och isinstance()funktion för att kontrollera om den tillhör en viss klass.
Låt oss titta på ett exempel:
a = 5 print(type(a)) print(type(5.0)) c = 5 + 3j print(c + 3) print(isinstance(c, complex))
När vi kör programmet ovan får vi följande resultat:
(8 + 3j) Sant
Medan heltal kan ha vilken längd som helst, är ett flytpunkt endast korrekt upp till 15 decimaler (den 16: e platsen är felaktig).
Siffrorna vi hanterar varje dag är av decimalsystemet (bas 10). Men datorprogrammerare (vanligtvis inbäddade programmerare) behöver arbeta med binära (bas 2), hexadecimala (bas 16) och oktala (bas 8) nummersystem.
I Python kan vi representera dessa siffror genom att lämpligt placera ett prefix före det numret. Följande tabell listar dessa prefix.
| Nummersystem | Prefix |
|---|---|
| Binär | '0b' eller '0B' |
| Octal | '0o' eller '0O' |
| Hexadecimal | '0x' eller '0X' |
Här är några exempel
# Output: 107 print(0b1101011) # Output: 253 (251 + 2) print(0xFB + 0b10) # Output: 13 print(0o15)
När du kör programmet blir resultatet:
107 253 13
Skriv konvertering
Vi kan konvertera en typ av nummer till en annan. Detta är också känt som tvång.
Operationer som addition, subtraktion tvingar heltal att flyta implicit (automatiskt), om en av operanderna är float.
>>> 1 + 2.0 3.0
Vi kan se ovan att 1 (heltal) tvingas till 1.0 (float) för addition och resultatet är också ett flytpunktsnummer.
Vi kan också använda inbyggda funktioner som int(), float()och complex()att konvertera mellan typer uttryckligen. Dessa funktioner kan till och med konverteras från strängar.
>>> int(2.3) 2 >>> int(-2.8) -2 >>> float(5) 5.0 >>> complex('3+5j') (3+5j)
Vid konvertering från flottör till heltal trunkeras numret (decimaldelar tas bort).
Python decimal
Pythons inbyggda klassfloat utför några beräkningar som kan förvåna oss. Vi vet alla att summan av 1.1 och 2.2 är 3.3, men Python verkar vara oense.
>>> (1.1 + 2.2) == 3.3 False
Vad händer?
Det visar sig att flytande siffror implementeras i datorhårdvara som binära fraktioner eftersom datorn bara förstår binär (0 och 1). Av denna anledning kan de flesta decimalfraktionerna vi känner inte lagras exakt i vår dator.
Låt oss ta ett exempel. Vi kan inte representera bråk 1/3 som ett decimaltal. Detta ger 0.33333333 … vilket är oändligt långt, och vi kan bara approximera det.
Det visar sig att decimalfraktionen 0,1 kommer att resultera i en oändligt lång binär bråkdel på 0,000110011001100110011 … och vår dator lagrar bara ett begränsat antal av den.
Detta kommer bara att vara ungefär 0,1 men aldrig lika. Därför är det begränsningen av vår datorhårdvara och inte ett fel i Python.
>>> 1.1 + 2.2 3.3000000000000003
För att övervinna detta problem kan vi använda decimalmodulen som medföljer Python. Medan siffror med flytande punkter har precision upp till 15 decimaler har decimalmodulen precision som användaren kan ställa in.
Låt oss se skillnaden:
import decimal print(0.1) print(decimal.Decimal(0.1))
Produktion
0,1 0,1000000000000000055511151231257827021181583404541015625
Denna modul används när vi vill göra decimalberäkningar som vi lärde oss i skolan.
Det bevarar också betydelse. Vi vet att 25,50 kg är mer exakt än 25,5 kg eftersom det har två betydande decimaler jämfört med en.
from decimal import Decimal as D print(D('1.1') + D('2.2')) print(D('1.2') * D('2.50'))
Produktion
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())
När vi kör programmet ovan får vi utmatningen enligt följande (värdena kan vara olika på grund av det slumpmässiga beteendet)
18 e ('c', 'e', 'd', 'b', 'a') 0.5682821194654443
Här är en fullständig lista över funktioner och attribut som är tillgängliga i Python slumpmässiga modul.
