Forstå gulvdivisjonen
Syntaksen er enkel, dvs. 'a // b', der 'a' er telleren og 'b' er nevneren. Utfallet er et heltall som representerer kvotienten som rundes ned til nærmeste hele tall, og eliminerer eventuelle brøkrester.
Eksempel 1: Mestring av gulvdivisjonen i Python for presisjonsavrunding nedover
La oss starte med et grunnleggende eksempel for å forstå det grunnleggende konseptet med etasjeinndeling:
teller = 10
nevner = 3
resultat = teller // nevner
skrive ut ( f 'Resultatet av {teller} // {nevner} er {resultat}' )
I dette eksemplet setter vi telleren til 10 og nevneren til 3. Etasjeinndelingen utføres ved å bruke “//” som gir resultatet 3. Dette er fordi 10 delt på 3 er 3 med resten av 1, og etasje divisjon runder ned til nærmeste hele tall.
Eksempel 2: Håndtering av negative tall
I dette eksemplet skal vi utforske hvordan etasjeinndeling i Python klarer de negative tallene. Scenariet involverer en teller på '-7' og en nevner på '2'. Når vi utfører etasjedelingsoperasjonen ved å bruke ' // ”, runder Python intelligent ned resultatet til nærmeste hele tall.
teller = - 7
nevner = 2
resultat = teller // nevner
skrive ut ( f 'Resultatet av {teller} // {nevner} er {resultat}' )
Selv om å dele -7 med 2 gir en kvotient på -3,5, sørger etasjedeling for at vi får det største heltallet som er mindre enn eller lik resultatet. Dermed er resultatet avrundet ned -4. Denne oppførselen ligner på vår naturlige forventning om at negative tall skal rundes ned i den mer negative retningen i sammenheng med etasjedeling.
Eksempel 3: Etasjeinndeling med flytere
I dette eksemplet skal vi se nærmere på bruken av etasjeinndeling med flyttall. Eksemplene involverer en teller (15.8) og en nevner (4). Til tross for tilstedeværelsen av desimaltegn, opererer etasjedeling uten problemer på disse flyttallsverdiene, og demonstrerer dens allsidighet mer enn bare heltall.
teller = 15.8nevner = 4
resultat = teller // nevner
skrive ut ( f 'Resultatet av {teller} // {nevner} er {resultat}' )
Vi kjører 15.8 // 4 i Python resulterer i en kvotient på 3.0. Her må vi observere at utfallet automatisk konverteres til et flyttall for å bevare presisjonen. Selv om resultatet kan virke motsatt av forventningene våre for de som er kjent med tradisjonell heltallsdivisjon, gjenspeiler det regelen for Pythons etasjedeling til prinsippet om å returnere det største heltallet som er mindre enn eller lik resultatet.
Eksempel 4: Etasjeinndeling med store tall
Pythons etasjeinndeling håndterer sømløst store antall. Tenk på følgende eksempel:
teller = 987654321nevner = 123456789
resultat = teller // nevner
skrive ut ( f 'Resultatet av {teller} // {nevner} er {resultat}' )
Resultatet av denne etasjeinndelingen er 8 når den runder ned kvotienten på 987654321 delt på 123456789.
Eksempel 5: Etasjeinndeling i uttrykk
Etasjeinndeling kan integreres i mer komplekse uttrykk. La oss utforske et scenario der etasjeinndeling er en del av en større ligning:
verdi = 27øke = 4
resultat = ( verdi + 3 ) // øke
skrive ut ( f 'Resultatet av ({value} + 3) // {increment} er {result}' )
I dette eksemplet evalueres uttrykket '(verdi + 3) // inkrement' som resulterer i 7. Etasjeinndelingen brukes etter å ha lagt til 3 til verdien av 27 og dividert med 4.
Eksempel 6: Flere etasjeinndelinger
Det er mulig å utføre flere etasjeinndelinger etter hverandre. La oss se på følgende eksempel:
teller = 100nevner 1 = 3
nevner 2 = 4
resultat = teller // nevner1 // nevner2
skrive ut ( f 'Resultatet av {teller} // {nevner1} // {nevner2} er {resultat}' )
I dette tilfellet er resultatet 8. Først deles 100 på 3 som resulterer i 33. Den påfølgende etasjeinndelingen deler 33 med 4, og gir sluttresultatet 8.
Eksempel 7: Etasjeinndeling i løkker
I dette eksemplet har vi et scenario der et visst antall «total_items»-varer må behandles i batcher av en bestemt størrelse («items_per_batch»). Vi bruker etasjeinndelingen '//' for å bestemme det totale antallet partier. Resultatet lagres i 'batches'-variabelen. Deretter påføres en løkke for å iterere over hver batch som viser en melding som indikerer gjeldende batch som behandles.
totalt_varer = 17items_per_batch = 5
partier = total_items // items_per_batch
til parti i område ( partier ) :
skrive ut ( f 'Behandler batch {batch + 1}' )
Dette eksemplet illustrerer hvordan etasjeinndelingen er spesielt nyttig i situasjoner der dataene må deles inn i like store deler for behandling, slik at alle varer er inkludert i et helt antall batcher.
Eksempel 8: Etasjeinndeling med brukerinngang
Dette eksemplet involverer brukerinndata for å vise den dynamiske karakteren til etasjeinndeling. Programmet ber brukeren legge inn verdiene for telleren og nevneren. Den utfører deretter etasjeinndelingen på disse brukerangitte verdiene, og viser resultatet avrundet nedover.
teller = int ( input ( 'Skriv inn telleren: ' ) )nevner = int ( input ( 'Skriv inn nevneren: ' ) )
resultat = teller // nevner
skrive ut ( f 'Resultatet av {teller} // {nevner} er {resultat}' )
Dette demonstrerer hvordan etasjeinndelingen enkelt kan kombineres til scenarier der brukerinndata eller eksterne kilder er variable, noe som gjør den anvendelig i interaktive og dynamiske programmeringsmiljøer.
Eksempel 9: Finansiell søknad
La oss utforske et annet eksempel der denne finansielle applikasjonen har som mål å bestemme det nødvendige antallet måneder for å nå et sparemål.
sparemål = 10 000månedlig_sparing = 850
måneder_påkrevd = sparemål // månedlig_sparing
skrive ut ( f «Det vil ta {months_required} måneder å nå et sparemål på {savings_goal}» )
Det totale sparemålet «sparemål» og det månedlige sparebeløpet «månedlig_sparing» er gitt i koden. Etasjeinndeling brukes deretter for å beregne hele antall måneder som trengs for å nå sparemålet. Dette eksemplet viser hvordan etasjeinndelingen kan brukes i praktiske økonomiske beregninger der et presist, avrundet resultat er avgjørende.
Eksempel 10: Temperaturkonvertering
Dette eksemplet involverer temperaturkonvertering fra Celsius til Fahrenheit.
celsius_temperatur = 28konverteringsfaktor = 9 / 5
Fahrenheit_temperatur = ( celsius_temperatur * konverteringsfaktor ) + 32
rounded_fahrenheit = Fahrenheit_temperatur // 1 # Bruke etasjeinndeling for å runde ned
skrive ut ( f '{celsius_temperature} grader Celsius er omtrent {rounded_fahrenheit} grader Fahrenheit' )
Vi brukte konverteringsformelen som resulterer i en flytende kommaverdi for Fahrenheit-temperaturen. For å få et avrundet heltall for Fahrenheit, brukes etasjedeling med en divisor på 1. Dette eliminerer desimaldelen av temperaturen, og gir et helt tall i Fahrenheit. Dette viser en praktisk anvendelse av gulvinndeling i virkelige scenarier der presis avrunding er nødvendig, for eksempel i temperaturrepresentasjoner.
Konklusjon
I denne artikkelen undersøkte vi variasjonen av gulvinndeling i Python, og understreket dens betydning for presisjonsavrunding nedover. Fra grunnleggende eksempler til mer komplekse scenarier, viste vi hvordan etasjeinndeling håndterer ulike situasjoner, inkludert negative tall, flyter og store heltall. Hvert av disse eksemplene ble forklart i detalj for å gi en grundig forståelse av bruken og betydningen av etasjedeling i ulike programmeringssammenhenger. Å forstå hvert trinn i eksempelkoden er viktig for å utnytte kraften til etasjedeling i Python for å gi et solid grunnlag for matematiske operasjoner som krever avrundede heltallsresultater.