De vloerverdeling begrijpen
De syntaxis is eenvoudig, d.w.z. “a // b”, waarbij “a” de teller is en “b” de noemer. De uitkomst is een geheel getal dat het quotiënt vertegenwoordigt dat naar beneden is afgerond op het dichtstbijzijnde gehele getal, waardoor eventuele fractionele resten worden geëlimineerd.
Voorbeeld 1: Beheersing van de vloerverdeling in Python voor nauwkeurig naar beneden afronden
Laten we beginnen met een basisvoorbeeld om het fundamentele concept van vloerverdeling te begrijpen:
teller = 10
noemer = 3
resultaat = teller noemer
afdrukken ( F 'Het resultaat van {teller} // {noemer} is {resultaat}' )
In dit voorbeeld stellen we de teller in op 10 en de noemer op 3. De vloerdeling wordt uitgevoerd met behulp van “//”, wat het resultaat 3 oplevert. Dit komt omdat 10 gedeeld door 3 3 is met een rest van 1, en vloer deling wordt naar beneden afgerond op het dichtstbijzijnde gehele getal.
Voorbeeld 2: Omgaan met negatieve getallen
In dit voorbeeld zullen we onderzoeken hoe vloerverdeling in Python de negatieve getallen mooi beheert. Het scenario omvat een teller van “-7” en een noemer van “2”. Wanneer we de vloerverdelingsbewerking uitvoeren met behulp van “ // ”, rondt Python het resultaat op intelligente wijze af naar het dichtstbijzijnde gehele getal.
teller = - 7
noemer = 2
resultaat = teller noemer
afdrukken ( F 'Het resultaat van {teller} // {noemer} is {resultaat}' )
Hoewel het delen van -7 door 2 resulteert in een quotiënt van -3,5, zorgt de vloerdeling ervoor dat we het grootste gehele getal verkrijgen dat kleiner is dan of gelijk is aan het resultaat. Het afgeronde resultaat is dus -4. Dit gedrag komt overeen met onze natuurlijke verwachting dat negatieve getallen naar beneden moeten worden afgerond in de meer negatieve richting in de context van vloerverdeling.
Voorbeeld 3: Vloerverdeling met drijvers
In dit voorbeeld bekijken we de toepassing van vloerindeling met drijvende-kommagetallen. In de voorbeelden is sprake van een teller (15,8) en een noemer (4). Ondanks de aanwezigheid van decimalen werkt vloerverdeling moeiteloos op deze waarden met drijvende komma, wat de veelzijdigheid ervan meer aantoont dan alleen gehele getallen.
teller = 15.8noemer = 4
resultaat = teller noemer
afdrukken ( F 'Het resultaat van {teller} // {noemer} is {resultaat}' )
We voeren 15.8 // 4 uit in Python, wat resulteert in een quotiënt van 3,0. Hier moeten we opmerken dat de uitkomst automatisch wordt omgezet in een getal met drijvende komma om de precisie te behouden. Hoewel het resultaat misschien tegengesteld lijkt aan onze verwachting voor degenen die bekend zijn met de traditionele deling van gehele getallen, weerspiegelt het de regel van de Python-vloerdeling en het principe van het retourneren van het grootste gehele getal dat kleiner is dan of gelijk is aan het resultaat.
Voorbeeld 4: Vloerindeling met grote cijfers
De vloerindeling van Python kan grote aantallen naadloos verwerken. Beschouw het volgende voorbeeld:
teller = 987654321noemer = 123456789
resultaat = teller noemer
afdrukken ( F 'Het resultaat van {teller} // {noemer} is {resultaat}' )
Het resultaat van deze vloerverdeling is 8, aangezien het quotiënt van 987654321 gedeeld door 123456789 naar beneden wordt afgerond.
Voorbeeld 5: Vloerverdeling in expressies
Vloerindeling kan worden geïntegreerd in complexere uitingen. Laten we een scenario onderzoeken waarin vloerverdeling deel uitmaakt van een grotere vergelijking:
waarde = 27verhogen = 4
resultaat = ( waarde + 3 ) // verhogen
afdrukken ( F 'Het resultaat van ({waarde} + 3) // {increment} is {resultaat}' )
In dit voorbeeld wordt de uitdrukking “(waarde + 3) // verhoging” geëvalueerd, wat resulteert in 7. De vloerverdeling wordt toegepast nadat 3 bij de waarde van 27 is opgeteld en door 4 is gedeeld.
Voorbeeld 6: Meerdere verdiepingsindelingen
Het is mogelijk om meerdere verdiepingsindelingen achter elkaar uit te voeren. Laten we eens kijken naar het volgende voorbeeld:
teller = 100noemer1 = 3
noemer2 = 4
resultaat = teller // noemer1 // noemer2
afdrukken ( F 'Het resultaat van {teller} // {noemer1} // {noemer2} is {resultaat}' )
In dit geval is het resultaat 8. Eerst wordt 100 gedeeld door 3, wat resulteert in 33. De daaropvolgende vloerverdeling deelt 33 door 4, wat het eindresultaat van 8 oplevert.
Voorbeeld 7: Vloerverdeling in lussen
In dit voorbeeld hebben we een scenario waarin een bepaald aantal “total_items” artikelen moeten worden verwerkt in batches van een specifieke grootte (“items_per_batch”). Voor het bepalen van het totaal aantal batches gebruiken wij de verdiepingsindeling “//”. Het resultaat wordt opgeslagen in de variabele “batches”. Vervolgens wordt een lus toegepast om elke batch te doorlopen, waardoor een bericht wordt weergegeven dat de huidige batch aangeeft die wordt verwerkt.
totaal artikelen = 17artikelen_per_batch = 5
batches = totaal_items // items_per_batch
voor partij in bereik ( batches ) :
afdrukken ( F 'Batch verwerken {batch + 1}' )
Dit voorbeeld illustreert hoe de vloerindeling vooral nuttig is in situaties waarin de gegevens voor verwerking in gelijke delen moeten worden verdeeld, zodat alle artikelen in een geheel aantal batches worden opgenomen.
Voorbeeld 8: Verdiepingsindeling met gebruikersinvoer
Dit voorbeeld omvat de gebruikersinvoer om de dynamische aard van de verdiepingsindeling weer te geven. Het programma vraagt de gebruiker om de waarden voor de teller en de noemer in te voeren. Vervolgens wordt de verdiepingsverdeling uitgevoerd op basis van deze door de gebruiker opgegeven waarden, waarbij het resultaat naar beneden wordt afgerond.
teller = int ( invoer ( 'Voer de teller in: ' ) )noemer = int ( invoer ( 'Voer de noemer in: ' ) )
resultaat = teller noemer
afdrukken ( F 'Het resultaat van {teller} // {noemer} is {resultaat}' )
Dit demonstreert hoe de verdiepingsindeling moeiteloos kan worden gecombineerd tot scenario's waarbij de gebruikersinvoer of externe bronnen variabel zijn, waardoor deze toepasbaar is in interactieve en dynamische programmeeromgevingen.
Voorbeeld 9: Financiële toepassing
Laten we een ander voorbeeld bekijken waarbij deze financiële toepassing tot doel heeft het vereiste aantal maanden te bepalen om een besparingsdoel te bereiken.
besparingsdoel = 10000maandelijkse_besparingen = 850
maanden_vereist = saving_goal // maandelijkse_besparingen
afdrukken ( F 'Het duurt {months_required} maanden om een besparingsdoel van { savings_goal} te bereiken' )
Het totale spaardoel “spaardoel” en het maandelijkse spaarbedrag “maandelijkse_besparing” staan in de code. Vervolgens wordt een vloerverdeling toegepast om het gehele aantal maanden te berekenen dat nodig is om het besparingsdoel te bereiken. Dit voorbeeld laat zien hoe de vloerindeling kan worden gebruikt in praktische financiële berekeningen waarbij een nauwkeurig, afgerond resultaat essentieel is.
Voorbeeld 10: Temperatuurconversie
Dit voorbeeld omvat de temperatuurconversie van Celsius naar Fahrenheit.
Celsius_temperatuur = 28conversiefactor = 9 / 5
Fahrenheit_temperatuur = ( Celsius_temperatuur * conversiefactor ) + 32
afgeronde_fahrenheit = Fahrenheit_temperatuur // 1 # Gebruik van vloerverdeling voor afronding naar beneden
afdrukken ( F '{celsius_temperature} graden Celsius is ongeveer {rounded_fahrenheit} graden Fahrenheit' )
We hebben de conversieformule toegepast die resulteert in een drijvende-kommawaarde voor de Fahrenheit-temperatuur. Om een afgerond geheel getal voor Fahrenheit te verkrijgen, wordt vloerdeling gebruikt met een deler van 1. Hierdoor wordt het decimale deel van de temperatuur geëlimineerd, waardoor een geheel getal in Fahrenheit ontstaat. Dit toont een praktische toepassing van vloerverdeling in realistische scenario's waarbij nauwkeurige afronding naar beneden noodzakelijk is, zoals bij temperatuurweergaven.
Conclusie
In dit artikel hebben we de variatie van de vloerverdeling in Python onderzocht, waarbij we de betekenis ervan bij het nauwkeurig naar beneden afronden hebben benadrukt. Van basisvoorbeelden tot complexere scenario's: we hebben laten zien hoe vloerverdeling met verschillende situaties omgaat, waaronder negatieve getallen, floats en grote gehele getallen. Elk van deze voorbeelden werd in detail uitgelegd om een grondig inzicht te verschaffen in de toepassing en betekenis van vloerindeling in verschillende programmeercontexten. Het begrijpen van elke stap van de voorbeeldcode is belangrijk om de kracht van vloerverdeling in Python te kunnen gebruiken om een solide basis te bieden voor wiskundige bewerkingen waarvoor afgeronde gehele getallen nodig zijn.