Pythongetallen, typeconversie en wiskunde

In dit artikel leer je over de verschillende getallen die in Python worden gebruikt, hoe je van het ene gegevenstype naar het andere converteert en de wiskundige bewerkingen die in Python worden ondersteund.

Getalgegevenstype in Python

Python ondersteunt gehele getallen, getallen met drijvende komma en complexe getallen. Ze zijn gedefinieerd als int , float , en complex klassen in Python.

Gehele getallen en drijvende punten worden gescheiden door de aan- of afwezigheid van een decimaalteken. 5 is bijvoorbeeld een geheel getal, terwijl 5.0 een getal met drijvende komma is.

Complexe getallen worden geschreven in de vorm x + yj , waarbij x is het echte deel en y is het denkbeeldige deel.

We kunnen de type() . gebruiken functie om te weten tot welke klasse een variabele of waarde behoort en isinstance() functie om te controleren of het tot een bepaalde klasse behoort.

Laten we een voorbeeld bekijken:

a = 5

print(type(a))

print(type(5.0))

c = 5 + 3j
print(c + 3)

print(isinstance(c, complex))

Wanneer we het bovenstaande programma uitvoeren, krijgen we de volgende uitvoer:

<class 'int'>
<class 'float'>
(8+3j)
True

Hoewel gehele getallen elke lengte kunnen hebben, is een getal met drijvende komma slechts nauwkeurig tot 15 decimalen (de 16e plaats is onnauwkeurig).

De getallen waarmee we elke dag te maken hebben, zijn van het decimale (grondtal 10) getallenstelsel. Maar computerprogrammeurs (meestal embedded programmeurs) moeten werken met binaire (grondtal 2), hexadecimale (grondtal 16) en octale (grondtal 8) getalsystemen.

In Python kunnen we deze getallen weergeven door op de juiste manier een voorvoegsel voor dat getal te plaatsen. In de volgende tabel staan ​​deze voorvoegsels.

Hier zijn enkele voorbeelden

# Output: 107
print(0b1101011)

# Output: 253 (251 + 2)
print(0xFB + 0b10)

# Output: 13
print(0o15)

Wanneer u het programma uitvoert, is de uitvoer:

107
253
13

Type conversie

We kunnen het ene type nummer in het andere omzetten. Dit wordt ook wel dwang genoemd.

Bewerkingen zoals optellen, aftrekken dwingen integer om impliciet (automatisch) te zweven als een van de operanden zwevend is.

>>> 1 + 2.0
3.0

We kunnen hierboven zien dat 1 (geheel getal) wordt gedwongen tot 1.0 (float) om op te tellen en het resultaat is ook een getal met drijvende komma.

We kunnen ook ingebouwde functies gebruiken zoals int() , float() en complex() om expliciet tussen typen te converteren. Deze functies kunnen zelfs converteren van strings.

>>> int(2.3)
2
>>> int(-2.8)
-2
>>> float(5)
5.0
>>> complex('3+5j')
(3+5j)

Bij het converteren van float naar integer, wordt het getal afgekapt (decimale delen worden verwijderd).

Python-decimaal

De ingebouwde klasse float van Python voert enkele berekeningen uit die ons misschien zullen verbazen. We weten allemaal dat de som van 1.1 en 2.2 3,3 is, maar Python lijkt het daar niet mee eens te zijn.

>>> (1.1 + 2.2) == 3.3
False

Wat is er aan de hand?

Het blijkt dat getallen met drijvende komma in computerhardware zijn geïmplementeerd als binaire breuken, aangezien de computer alleen binair (0 en 1) begrijpt. Om deze reden kunnen de meeste decimale breuken die we kennen, niet nauwkeurig worden opgeslagen in onze computer.

Laten we een voorbeeld nemen. We kunnen de breuk 1/3 niet weergeven als een decimaal getal. Dit geeft 0.33333333... wat oneindig lang is, en we kunnen het alleen benaderen.

Het blijkt dat de decimale breuk 0.1 zal resulteren in een oneindig lange binaire breuk van 0.000110011001100110011... en onze computer slaat er slechts een eindig getal van op.

Dit zal slechts 0,1 benaderen, maar nooit gelijk zijn. Daarom is het de beperking van onze computerhardware en geen fout in Python.

>>> 1.1 + 2.2
3.3000000000000003

Om dit probleem op te lossen, kunnen we de decimale module gebruiken die bij Python wordt geleverd. Terwijl getallen met drijvende komma een precisie hebben tot 15 decimalen, heeft de decimale module een door de gebruiker instelbare precisie.

Laten we eens kijken wat het verschil is:

import decimal

print(0.1)

print(decimal.Decimal(0.1))

Uitvoer

0.1
0.1000000000000000055511151231257827021181583404541015625

Deze module wordt gebruikt wanneer we decimale berekeningen willen uitvoeren zoals we op school hebben geleerd.

Het behoudt ook betekenis. We weten dat 25,50 kg nauwkeuriger is dan 25,5 kg, omdat er twee significante decimalen zijn in vergelijking met één.

from decimal import Decimal as D

print(D('1.1') + D('2.2'))

print(D('1.2') * D('2.50'))

Uitvoer

3.3
3.000

Let op de volgende nullen in het bovenstaande voorbeeld.

We kunnen ons afvragen waarom we Decimal niet implementeren? elke keer, in plaats van zweven? De belangrijkste reden is efficiëntie. Bewerkingen met drijvende komma moeten sneller worden uitgevoerd dan Decimal operaties.

Wanneer decimaal gebruiken in plaats van zwevend?

Over het algemeen gebruiken we decimaal in de volgende gevallen.

• Als we financiële toepassingen maken die een exacte decimale weergave nodig hebben.
• Als we het vereiste precisieniveau willen regelen.
• Als we het begrip significante decimalen willen implementeren.

Python-breuken

Python biedt bewerkingen met fractionele getallen via zijn fractions module.

Een breuk heeft een teller en een noemer, beide gehele getallen. Deze module heeft ondersteuning voor rekenen met rationale getallen.

We kunnen Fraction-objecten op verschillende manieren maken. Laten we ze eens bekijken.

import fractions

print(fractions.Fraction(1.5))

print(fractions.Fraction(5))

print(fractions.Fraction(1,3))

Uitvoer

3/2
5
1/3

Tijdens het maken van Fraction vanaf float , kunnen we enkele ongebruikelijke resultaten krijgen. Dit komt door de imperfecte weergave van binaire getallen met drijvende komma, zoals besproken in de vorige sectie.

Gelukkig, Fraction stelt ons in staat om ook met string te instantiëren. Dit is de voorkeursoptie bij het gebruik van decimale getallen.

import fractions

# As float
# Output: 2476979795053773/2251799813685248
print(fractions.Fraction(1.1))

# As string
# Output: 11/10
print(fractions.Fraction('1.1'))

Uitvoer

2476979795053773/2251799813685248
11/10

Dit gegevenstype ondersteunt alle basisbewerkingen. Hier zijn een paar voorbeelden.

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)

Uitvoer

2/3
6/5
False
True

Python-wiskunde

Python biedt modules zoals math en random om verschillende wiskunde uit te voeren, zoals trigonometrie, logaritmen, waarschijnlijkheid en statistiek, enz.

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))

Uitvoer

3.141592653589793
-1.0
22026.465794806718
3.0
1.1752011936438014
720

Hier is de volledige lijst met functies en attributen die beschikbaar zijn in de Python-wiskundemodule.

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())

Wanneer we het bovenstaande programma uitvoeren, krijgen we de uitvoer als volgt. (Waarden kunnen verschillen vanwege het willekeurige gedrag)

18
e
['c', 'e', 'd', 'b', 'a']
0.5682821194654443

Hier is de volledige lijst met functies en attributen die beschikbaar zijn in de willekeurige module van Python.