Python, plaši izmantotā programmēšanas valoda, ir izcila skaitliskās skaitļošanas uzdevumos, tomēr tā nav imūna pret izaicinājumiem, ko rada peldošā komata aritmētika. Peldošā komata skaitļi Python ir reālu skaitļu tuvinājumi, kas noved pie noapaļošanas kļūdas, precizitātes zudums un atcelšana kas var izjaukt aprēķinus. Mēs varam pamaniet šīs kļūdas, meklējot dīvainus rezultātus un izmantojot instrumentusnumpy.finfo>uz monitora precizitāte . Ar zināmu piesardzību un gudriem trikiem mēs varam pārbaudiet šīs kļūdas un nodrošināt, ka mūsu Python aprēķini ir uzticami. Šajā rakstā mēs izpētīsim peldošā komata kļūdu sarežģītības Python .
Kas ir peldošā komata skaitļi?
Peldošā komata skaitļi ir efektīvs veids, kā attēlot reālos skaitļus datoros. Tie sastāv no trim daļām:
- Nozīmīgi: Faktiskie cipari, kas apzīmē numuru (piemēram, 3,14159)
- Eksponents: Norāda, cik vietās ir jāpārvieto nozīmīgs pa kreisi vai pa labi (piem., -2 in 3,14159 x 10^-2)
- Bāze: Datoriem parasti ir 2, kas nosaka, kā iekšēji tiek attēloti skaitļi
Kāpēc rodas peldošā komata kļūdas?
Peldošā komata kļūdas rodas tāpēc, ka datori saglabā reālus skaitļus, izmantojot ierobežotu bitu skaitu, kā rezultātā rodas tuvinājumi un iespējamas neprecizitātes. Peldošā komata skaitļiem ir būtiski ierobežojumi:
- Ierobežota precizitāte: Nozīmē var saglabāt tikai ierobežotu skaitu ciparu, kas noved pie noapaļošanas kļūdas attēlojot precīzas decimāldaļas.
- Precizitātes zudums: Tādas darbības kā saskaitīšana vai atņemšana var vēl vairāk samazināt precizitāti, pastiprinot noapaļošanas efektu.
- Nepiepildīšana/pārpilde: Ļoti mazi vai lieli skaitļi var izkrist ārpus reprezentējamā diapazona, izraisot zemplūsma (kļūst par nulli) vai pārplūde (kļūst par bezgalību).
Peldošā komata kļūdu veidi
a) Noapaļošanas kļūdas: Visizplatītākais, kas rodas, ja ir jātuvina precīzs decimālskaitlis, lai tas atbilstu pludiņa ierobežotajai precizitātei.
b) Precizitātes zudums: Turpmākajās darbībās var pakāpeniski uzkrāties noapaļošanas kļūdas, izraisot būtiskas neprecizitātes gala rezultātā.
c) Katastrofāla atcelšana: Atņemot gandrīz vienādus skaitļus ar pretējām zīmēm, to nozīmīgie cipari tiek atcelti, atstājot nelielu un neprecīzu rezultātu.
d) pārpilde/nepieplūde: Tās rodas, ja aprēķini pārsniedz attēlojamo peldošo vērtību diapazonu, kā rezultātā tiek iegūti neprecīzi vai bezjēdzīgi rezultāti.
Peldošā komata kļūdu noteikšana
- Negaidītu rezultātu novērošana: Salīdzinot aprēķinātās vērtības ar sagaidāmajiem rezultātiem vai vizualizējot datus, var atklāties pretrunas, ko bieži izraisa kļūdas.
- Izmantojot tādas bibliotēkas kā
numpy.finfo>: Bibliotēkām patīknumpy>nodrošināt tādus rīkus kāfinfo>lai pārbaudītu dažādu peldošo datu tipu precizitāti un ierobežojumus.
Python peldošā komata kļūda
Šeit mēs apspriedīsim dažāda veida piemērus, kas ilustrē Python peldošā komata kļūdas:
Precizitātes zudums decimāldaļās binārajā konvertācijā
Šajā piemērā decimālskaitlis 0,1 tiek pārveidots par bināro skaitli. Sakarā ar bezgalīgo bināro izplešanos 0,1 tiek izmantots tikai ierobežots skaits bitu, kā rezultātā tiek zaudēta precizitāte.
Python3
decimal_number>=> 0.1> binary_representation>=> format>(decimal_number,>'.30f'>)># 30 decimal places> print>(f>'Decimal: {decimal_number}
Binary: {binary_representation}'>)> |
>
>
Izvade:
Decimal: 0.1 Binary: 0.100000000000000005551115123126>
Noapaļošanas kļūdas
Šeit sagaidāms, ka rezultāts, pievienojot 1/3 trīs reizes, būs 1,0. Tomēr noapaļošanas kļūdu dēļ, attēlojot 1/3, summa var nebūt precīzi 1,0.
Python3
result>=> 1.0> /> 3.0> sum_result>=> result>+> result>+> result> print>(f>'Expected Result: 1.0
Actual Result: {sum_result}'>)> |
java skeneris
>
>
Izvade:
Expected Result: 1.0 Actual Result: 1.0>
Akumulatīvas kļūdas iteratīvajos aprēķinos
Šis piemērs parāda, kā iteratīvajos aprēķinos var rasties akumulatīvas kļūdas. Desmit reižu pievienošana 0,1 var nedot precīzu rezultātu 1,0 peldošā komata precizitātes ierobežojumu dēļ.
Python3
total>=> 0.0> for> i>in> range>(>10>):> >total>+>=> 0.1> print>(f>'Expected Result: 1.0
Actual Result: {total}'>)> |
>
>
Izvade:
Expected Result: 1.0 Actual Result: 0.9999999999999999>
Salīdzināšanas problēmas
Šajā gadījumā, salīdzinot summu 0,1 un 0,2 ar 0,3, var nenākt gaidītaisTrue>rezultāts peldošā komata skaitļu raksturīgās neprecizitātes dēļ.
Python3
a>=> 0.1> +> 0.2> b>=> 0.3> print>(f>'a: {a}
b: {b}
Equal: {a == b}'>)> |
>
>
Izvade:
a: 0.30000000000000004 b: 0.3 Equal: False>
Negaidīti aprēķinu rezultāti
Lūk, atņemšana no1e16>no summas(1e16 + 1)>paredzams, ka rezultāts būs 1, taču peldošā komata kļūdu dēļ rezultāts var nebūt tieši 1.
Python3
a>=> 0.1> +> 0.2> b>=> 0.3> print>(f>'a: {a}
b: {b}
Equal: {a == b}'>)> |
>
>
Izvade:
Expected Result: 1 Actual Result: 0.0>
Peldošā komata precizitātes izpratne
Šeit mēs sapratīsim peldošā komata precizitāti: 1.2–1.0 anomālija Python-
Pārstāvības izaicinājumi
Kā zināms, 1,2 – 1,0 = 0,2. Bet, mēģinot darīt to pašu Python, jūs būsiet pārsteigti par rezultātiem:
>>> 1,2 - 1,0>
Izvade:
0.199999999999999996>
To var uzskatīt par Python kļūdu, taču tā nav. Tam ir maz sakara ar Python un daudz vairāk ar to, kā pamatā esošā platforma apstrādā peldošā komata skaitļus. Tas ir parasts gadījums, kad sistēmā apstrādājat peldošā komata skaitļus. Tā ir problēma, ko rada peldošā komata skaitļu iekšējais attēlojums, kas izmanto fiksētu bināro ciparu skaitu, lai attēlotu decimālo skaitli. Dažus decimālskaitļus ir grūti attēlot bināros skaitļos, tāpēc daudzos gadījumos tas rada nelielas noapaļošanas kļūdas. Mēs zinām līdzīgus gadījumus decimālmatemātikā, jo daudzus rezultātus nevar attēlot ar noteiktu decimālciparu skaitu, jo Piemērs
10 / 3 = 3.33333333.......>
Šajā gadījumā, ņemot par piemēru 1.2, 0.2 attēlojums binārajā formātā ir 0.00110011001100110011001100…… un tā tālāk. Šo bezgalīgo decimālo skaitli ir grūti saglabāt iekšēji. Parasti peldošā objekta vērtība tiek saglabāta binārā peldošā komata formā ar fiksētu precizitāti ( parasti 53 biti ). Tātad mēs pārstāvam 1.2 iekšēji kā,
1.0011001100110011001100110011001100110011001100110011>
Kas ir tieši vienāds ar:
1.1999999999999999555910790149937383830547332763671875>
Peldošā komata kļūdas apstrāde
Šeit mēs apspriedīsim dažādus piemērus, kā rīkoties ar peldošā komata kļūdām Python:
Noapaļošana līdz noteiktai decimālzīmei
Noapaļojot rezultātu līdz noteiktai zīmei aiz komata (piemēram, 2), varat mazināt nelielu peldošā komata kļūdu ietekmi.
Python3
result>=> 1.2> -> 1.0> rounded_result>=> round>(result,>2>)> print>(f>'Original Result: {result}
Rounded Result: {rounded_result}'>)> |
>
>
Izvade:
Original Result: 0.19999999999999996 Rounded Result: 0.2>
Decimālās klases izmantošana augstai precizitātei
Thedecimal>modulis nodrošinaDecimal>klase, ļaujot veikt augstākas precizitātes aritmētiku. Precizitātes iestatīšana argetcontext().prec>var palīdzēt pārvaldīt konkrētu aprēķinu precizitāti
Python3
from> decimal>import> Decimal, getcontext> getcontext().prec>=> 4> # Set precision to 4 decimal places> result>=> Decimal(>'1.2'>)>-> Decimal(>'1.0'>)> print>(f>'High Precision Result: {result}'>)> |
>
>
Izvade:
High Precision Result: 0.2>
Daļskaitļu izmantošana precīziem attēlojumiem
Thefractions>modulis ļauj strādāt ar precīziem daļskaitļiem, izvairoties no peldošā komata kļūdām.
Python3
from> fractions>import> Fraction> result>=> Fraction(>'1.2'>)>-> Fraction(>'1.0'>)> print>(f>'Exact Fractional Result: {result}'>)> |
>
abstraktajai klasei var būt konstruktors
>
Izvade:
Exact Fractional Result: 1/5>
Starprezultātu apstrāde ar decimāldaļu
IzmantojietDecimal>klase starpposma aprēķiniem, lai samazinātu kumulatīvās kļūdas pirms konvertēšanas atpakaļ uz peldošo.
Python3
from> decimal>import> Decimal, getcontext> getcontext().prec>=> 6> # Set precision to 6 decimal places> intermediate_result>=> Decimal(>'1.2'>)>-> Decimal(>'1.0'>)> final_result>=> float>(intermediate_result)># Convert back to float if needed> print>(f>'Intermediate Result: {intermediate_result}
Final Result: {final_result}'>)> |
>
>
Izvade:
Intermediate Result: 0.2 Final Result: 0.2>
Secinājums
Tomēr jūs domājat, kāpēc python neatrisina šo problēmu , patiesībā tam nav nekāda sakara ar python. Tas notiek tāpēc, ka pamatā esošā platforma c apstrādā peldošā komata skaitļus, un galu galā ar neprecizitāti mēs vienmēr esam pierakstījuši skaitļus kā fiksētu ciparu virkni. Ņemiet vērā, ka tas ir binārā peldošā komata būtībā: tā arī nav kļūda Python vai C , un tā nav arī kļūda jūsu kodā. Jūs redzēsit vienādas darbības visās valodās, kas atbalsta mūsu aparatūras peldošā komata aritmētiku, lai gan dažās valodās atšķirības var netikt parādītas pēc noklusējuma vai visos izvades režīmos. Mums ir jāņem vērā šī uzvedība, ja mums ir svarīgas matemātikas problēmas, kurām nepieciešama precīza precizitāte, vai izmantojot to nosacījumu priekšrakstos. Pārbaudiet peldošais punkts sadaļu python dokumentācijā, lai uzzinātu vairāk par šādām darbībām.
Bieži uzdotie jautājumi (FAQ)
1. Kas ir peldošā komata kļūda Python?
Peldošā komata kļūda programmā Python attiecas uz neatbilstībām starp paredzamajiem un faktiskajiem rezultātiem, strādājot ar peldošā komata skaitļiem, kas izriet no ierobežojumiem reālu skaitļu attēlošanai binārā sistēmā.
2. Kāpēc 1.2 - 1.0> nav vienāds 0.2> Pythonā?
Neatbilstība ir saistīta ar problēmām, kas saistītas ar decimālskaitļu attēlošanu bināros skaitļos. Iekšējās binārās attēlošanas laikā rodas noapaļošanas kļūdas, kas rada negaidītus rezultātus.
3. Vai peldošā komata kļūda ir Python kļūda?
Nē, tā nav Python kļūda. Tā ir izplatīta problēma skaitļošanā, kas saistīta ar to, kā peldošā komata skaitļi tiek iekšēji attēloti. Python atbilst IEEE 754 standartam peldošā komata aritmētikai.
4. Kā es varu noapaļot peldošā komata rezultātu līdz noteiktai zīmei aiz komata?
Jūs varat izmantot
round()>funkcija, lai noapaļotu peldošā komata rezultātu līdz noteiktai zīmei aiz komata. Piemēram,rounded_result = round(result, 2)>.
5. Kas ir decimal> moduli, un kā tas palīdz apstrādāt peldošā komata kļūdas?
The
decimal>modulis nodrošinaDecimal>klase augstākas precizitātes aritmētikai. Precizitātes iestatīšana un lietošanaDecimal>var palīdzēt mazināt peldošā komata kļūdas.