Numeric Python: Mga Uri, Module at Praktikal na Paggamit

Home » Sawa » Numeric Python: Mga Uri, Module at Praktikal na Paggamit

Ang pagtatrabaho gamit ang mga numero ay nasa puso ng karamihan sa mga programang Python, bumubuo ka man ng isang simpleng script, nag-aaral ng siyentipikong datos, o gumagawa ng prototype ng isang algorithm. Ang pag-unawa kung paano kinakatawan at minamanipula ng Python ang mga numeric value ang unang hakbang sa pagsulat ng maaasahan at mahusay na code na kumikilos ayon sa iyong inaasahan.

Kapag pinag-uusapan ng mga tao ang "numeric Python" madalas nilang tinutukoy ang dalawang bagay: sa isang gilid, ang mga built-in na uri ng numero at mga karaniwang tool sa library tulad ng math, cmath, decimal, random at numbers; sa kabilang banda, ang mas malawak na ecosystem sa paligid ng numerical computing, na may mga library tulad ng NumPy na nagpapalawak sa wika gamit ang mga karagdagang numeric type at vectorized operation. Ipapakita sa iyo ng gabay na ito ang pundasyong iyon nang detalyado, mula sa mga basic type hanggang sa mga advanced na abstraksyon.

Mga pangunahing uri ng numero sa Python

Tinutukoy ng Python ang ilang built-in na numeric na kategorya na sumasaklaw sa karamihan ng pang-araw-araw na pangangailangan: mga integer para sa mga buong numero, mga floating-point na numero para sa mga totoong halaga na may mga decimal, mga complex number para sa mga halaga na may mga totoong at kathang-isip na bahagi, at ang espesyal na uri ng Boolean na kumikilos na parang isang napakaliit na miyembro ng pamilya ng integer. Lahat ng mga ito ay maayos na nai-integrate sa mga arithmetic operator ng Python.

Mga integer (int) kumakatawan sa mga buong numero, positibo o negatibo, nang walang decimal pointWalang takdang itaas na hangganan sa kanilang laki sa karaniwang Python; hangga't mayroon kang memorya, maaaring lumaki ang iyong integer. Mga halagang tulad ng 1, -5 or 20234567890123456789 lahat ay balido int mga pagkakataon, at maaari mong kumpirmahin iyon gamit ang type(1) or type(-5), na babalik <class 'int'>.

Mga numerong lumulutang-punto (float) ay ginagamit para sa mga totoong numero na may fractional component. Ang mga ito ay isinusulat na may decimal point, tulad ng 2.0, -7.823457 or 0.5, o may siyentipikong notasyon tulad ng 1e8 (na nangangahulugang 100,000,000). Kapag gumagawa ka ng mga operasyon tulad ng paghahati, kahit sa pagitan ng mga integer, madalas na pino-promote ng Python ang resulta sa isang float; Halimbawa, 9 / 2 magbubunga 4.5, at type(4.5) is <class 'float'>.

Mga kumplikadong numero (complex) pagsamahin ang isang tunay na bahagi at isang kathang-isip na bahagi, isinulat na may kasunod na j para sa haka-haka na yunit. Isang halaga tulad ng 2 + 3j ay may tunay na bahagi 2 at isang kathang-isip na bahagi 3. Maaari mo itong buuin nang direkta (hal. 3.14j) at siyasatin ang mga ito gamit ang mga katangian tulad ng .real at .imag, o tawagan .conjugate() upang makuha ang complex conjugate. Ang mga ito ay partikular na popular sa engineering, signal processing at scientific computing.

Mga Boolean (bool) ay teknikal na numerikal din, Dahil True at False kumilos na parang mga integer na 1 at 0 sa mga ekspresyong aritmetika. Halimbawa, True + 2 sinusuri sa 3Sa loob, bool ay isang subklase ng int, kaya naman ang mga boolean value ay maayos na isinasama sa mga kalkulasyon at paghahambing.

Binibigyang-daan ka ng Python na malayang paghaluin ang mga uri ng numerong ito sa mga ekspresyon, na nagpo-promote sa mas pangkalahatang uri kung kinakailangan. Pagdaragdag ng int sa isang float nagbubunga ng a float, at ang pagsasama-sama ng mga float na may mga complex number ay nagbubunga ng isang complex na resulta: mga expression tulad ng 1 + 1.0, 2.0 + (3 + 5j) or 6 / (5 + 8j) lahat ng trabaho nang walang karagdagang seremonya.

Mga operator ng aritmetika at pag-uugali ng paghahati

Kapag mayroon ka nang mga numeric value, gagamitin mo ang mga karaniwang arithmetic operator para gamitin ang mga ito.: karagdagan (+), pagbabawas (-), pagpaparami (*), dibisyon (/), paghahati ng sahig (//), eksponensyasyon (**) at modulo (%Inilalapat ng Python ang mga ito sa mga integer, float at complex number, na nagsasagawa ng type promotion kung kinakailangan.

Ang paghahati ay isang lugar kung saan ang disenyo ng Python ay sadyang ginawa.. Paggamit / palaging nagbubunga ng floating-point na resulta kapag ang parehong argumento ay numeric, kahit na pareho silang integer. Kaya 9 / 2 mga resulta 4.5, Hindi 4Hinihikayat ka nitong mag-isip sa mga tuntunin ng paghahati ng real-number bilang default, na karaniwang siyang gusto mo sa mga kalkulasyon na siyentipiko o pinansyal.

Kung kailangan mo ng integer division na nagtatapon ng fractional na bahagi, gagamitin mo ang floor division operator //. Halimbawa, 9 // 2 naglalabas 4, at -9 // 2 magbubunga -5, dahil ang resulta ay naka-floor (na-round down patungo sa negatibong infinity). Bukod pa rito, divmod(a, b) binibigyan ka ng parehong quotient at ang remainder nang sabay-sabay, na nagbabalik ng isang pares na sumasalamin (a // b, a % b).

Sa likod ng mga eksena, maingat na kinokontrol ng Python kung paano nakikipag-ugnayan ang iba't ibang numeric flavorsAng isang panloob na padron na makikita mo sa karaniwang library ay ang ideya ng "mga operator fallback": mga function na unang sumusubok sa isang implementasyon na partikular sa uri, halimbawa para sa mga rational number, pagkatapos ay babalik sa mga built-in na operator kapag ang isang operand ay isang regular int, float or complexIto ang nagbibigay-daan sa mga pasadyang uri ng numero na makipag-ugnayan sa sistemang aritmetika ng Python gamit ang mga espesyal na pamamaraan tulad ng __add__ at __radd__.

Kodigo ng aklatan para sa rasyonal na aritmetika, tulad ng Fraction uri, malinaw na inilalarawan ang estratehiyang itoKapag nagdadagdag ng dalawa Fraction mga pagkakataon, kinukuwenta nito ang isang bagong praksyon sa pamamagitan ng pag-cross-multiply ng mga numerator at denominator. Kung magdadagdag ka ng Fraction sa isang simpleng integer o halimbawa ng numbers.Rational, ginagamit nito ang tumpak na rasyonal na algorithm. Kung ang isa pang operand ay isang float or complex, ito ay magko-convert sa mas malawak na uri na iyon at magde-delegate sa mga regular na operator, pinapanatiling pare-pareho at madaling maunawaan ang pag-uugali.

Mga built-in na numerical function

Higit pa sa mga raw operator, ang Python ay may kasamang hanay ng mga built-in na function na nakakaalam kung paano pangasiwaan ang mga numero.Ang mga function na ito ay laging available nang hindi nag-i-import ng kahit ano at gumagana sa mga karaniwang numeric type, kasama ang anumang custom na object na nagpapatupad ng mga tamang special method.

abs(x) ibinabalik ang ganap na halaga ng argumento nito, na ginagawang positibo ang mga negatibong numero at iniiwan ang mga positibong halaga na hindi nagbabago. Kung magpapasa ka ng isang bagay na tumutukoy sa __abs__(), ilalaan ng Python ang pamamaraang iyon. Para sa mga kumplikadong numero, abs() ibinabalik ang magnitude (ang distansya mula sa pinagmulan sa complex plane).

round(x, ndigits) nagbibigay sa iyo ng halagang nira-round off sa isang takdang bilang ng mga decimal place. Kung ndigits ay tinanggal o None, ibinabalik nito ang pinakamalapit na integer. Hindi tulad ng panuntunang "round half up" sa paaralan, ang built-in na Python round gumagamit ng estratehiyang “round half to even” para sa mga tabla upang mabawasan ang statistical bias sa mga paulit-ulit na kalkulasyon.

Mga tungkulin ng conversion tulad ng int() at float() bumuo ng mga numero mula sa iba pang mga bagay. Tumatawag int(x) sa isang float ay itinatapon ang fractional na bahagi (halimbawa, int(1.9) is 1), At float(x) Gumagawa ng representasyon ng floating-point mula sa mga integer, string, o mga katugmang bagay. Kapag nag-convert ka mula float patungong int, walang rounding na nangyayari; ang decimal na bahagi ay pinutol lamang.

Ang iba pang built-in ay nagsisilbing mga tungkulin ng representasyon at pagsasama-sama. Mga function tulad ng hex() at oct() ibalik ang mga representasyon ng string ng mga integer sa hexadecimal o octal na may naaangkop na mga prefix (0x at 0o). Mga katulong sa pagsasama-sama tulad ng max() at min() i-scan ang isang iterable o isang serye ng mga argumento upang mahanap ang pinakamalaki o pinakamaliit na halaga, habang pow() at ang ** Kinukuha ng operator ang mga kapangyarihan ng pagkalkula at opsyonal na tanggapin ang ikatlong argumento para sa modular exponentiation.

Mga advanced na tool sa numero: matematika, cmath at decimal

Para sa mas sopistikadong mga kalkulasyon, ang Python ay nagbibigay ng mga nakalaang karaniwang mga module ng library sa halip na palakihin ang pangunahing wika. Ang pinakamahalaga para sa gawaing pangnumero ay math, cmath at decimal, bawat isa ay nagta-target sa isang partikular na subset ng mga problema.

Ang math Ang modyul ay nakatuon sa real-valued floating-point mathematicsPagkatapos itong i-import gamit ang import math, makakakuha ka ng access sa mga function at constant na karaniwang kailangan sa engineering, physics at pang-araw-araw na analytics, lahat ay ipinapatupad sa mahusay na C code at gumagana sa float halaga.

math kinabibilangan ng mga kagamitan sa teorya ng numero at representasyon tulad ng math.ceil() para sa pag-round up sa pinakamalapit na integer, math.floor() para sa pag-round down, math.modf() upang hatiin ang isang float sa mga bahaging fractional at integer, at math.frexp() / math.ldexp() para gumana gamit ang internal binary representation. Nagbibigay din ito ng power at logarithmic routine tulad ng math.exp(), math.log(), math.log10(), math.pow() at math.sqrt(), pati na rin ang mga trigonometriko at hayperboliko na tungkulin tulad ng math.sin(), math.cos(), math.tan(), math.asin(), math.acos(), math.atan(), math.atan2(), math.sinh(), math.cosh() at math.tanh().

Para sa kaginhawahan, math nag-e-export ng mga pangunahing constant tulad ng math.pi at math.eMagagamit ang mga ito tuwing kinukuwenta mo ang mga lawak, anggulo, o exponential growth at gusto mo ng mga pare-parehong halaga na may mahusay na katumpakan sa kabuuan ng iyong code base.

Kapag kailangan mong magtrabaho gamit ang mga kumplikadong numero, ang cmath Ang modyul ay gumaganap ng parehong papel para sa kumplikadong eroplanoAng mga API mirror nito math ngunit gumagamit ng mga kumplikadong argumento at nagbabalik ng mga kumplikadong resulta, kaya maaari mong kalkulahin ang mga kumplikadong exponential, logarithms at trigonometric function nang hindi manu-manong binabago ang mga numero sa mga tunay at kathang-isip na bahagi.

Ang decimal Ang modyul ay nagta-target ng ibang punto ng paghihirap: eksaktong base-10 na aritmetikaAng karaniwang binary floating-point ay hindi maaaring kumatawan nang tumpak sa maraming decimal fractions, kaya ang mga kalkulasyon tulad ng 0.1 + 0.2 magbubunga ng medyo kakaibang resulta. decimal.Decimal Iniiwasan ito sa pamamagitan ng paggamit ng arbitrary precision base‑10 arithmetic, na ginagawa itong mainam para sa mga aplikasyon sa pananalapi at kahit saan kailangan mong mahigpit na kontrolin ang pag-ikot.

Bilang default, ang mga operasyon ng floating-point ng Python ay sumusunod sa gawi ng IEEE-754 at gumagamit ng representasyon ng base-2.Kapag ang isang halaga ay eksaktong nasa kalagitnaan sa pagitan ng dalawang numerong maaaring representahin, ang "round half to even" ay inilalapat, ibig sabihin kalahati ng mga tali ay nira-round down at kalahati ay nira-round up. Naiiwasan nito ang sistematikong paglihis sa malalaking kalkulasyon. Kung gusto mo ng komersyal na semantika ng "round half up", maaari mong i-configure ang isang decimal kontekstong gagamitin ROUND_HALF_UP, na palaging nagtutulak ng .5 na halaga palayo sa zero.

Paggawa gamit ang mga uri ng numero sa pagsasagawa

Ang paggalugad kung paano gumagana nang interaktibo ang mga numero ay isang mahusay na paraan upang mabuo ang intuwisyonPaandarin ang Python interpreter at lumikha ng pinaghalong integer, float, at kumplikadong value, pagkatapos ay subukan ang mga pangunahing operasyon sa mga ito. Diretso lang ang pagdaragdag at pagpaparami, ngunit lalong nakakatulong ang pag-eksperimento sa paghahati, paghahati sa sahig, pag-round up, at mga conversion, habang pinapanood kung paano nagbabago ang uri ng resulta.

Ang pag-convert sa pagitan ng mga uri ng numero ay minsan kinakailangan upang tumugma sa mga inaasahan ng isang API o upang gawing simple ang lohika.Kung mayroon kang float at gusto mo lang ang buong bahagi nito, italaga ito sa isang variable tulad ng my_float = 1.9 at pagkatapos ay tumawag my_int = int(my_float)Pag-iimprenta my_int Binibigyan 1, at type(my_int) kinukumpirma na ito ay isang intTandaan na ang praksyonal na bahagi ay itinatapon sa halip na bilugan.

Ang kabaligtaran na direksyon—tumutulong sa mas pangkalahatang uri—ay kadalasang nangyayari nang hindi sinasadyaKapag nagdagdag ka ng integer at float, nagbabalik ang Python ng float nang hindi humihingi, dahil ang real number system ay naglalaman ng mga integer. Nangyayari ang parehong promosyon kapag pinagsama mo ang isang float at isang complex number: ang floating‑point value ay itinuturing na mayroong isang haka-haka na bahagi ng zero, at ang resulta ay complex.

Kasama sa mga kumplikadong numero ang ilang built-in na kaginhawahan na nagpaparamdam sa mga ito na naturalMaaari mong direktang siyasatin a.real at a.imag para makuha ang mga bahagi, tumawag a.conjugate() para i-flip ang tanda ng haka-haka na bahagi, at ipasa ang mga ito sa mga function sa cmath nang walang manu-manong conversion. Kahit na bihira mo silang gamitin, ang pagkaalam na umiiral ang mga ito at kung paano sila kumikilos ay makakatulong kapag nakatagpo ka ng scientific code.

Ang katumpakan at katumpakan ay laging mahalaga kapag nakikitungo sa floating-point dataAng epektibong katumpakan ng isang karaniwang Python float ay humigit-kumulang 15 decimal na digit; lampas doon, ang ika-16 na digit ay maaaring hindi maaasahan. Para sa maraming gawain, ito ay ganap na katanggap-tanggap, ngunit kung kailangan mo ng eksaktong decimal na aritmetika o mas mahuhulaang pag-round, ang decimal Binibigyan ka ng modyul ng kontrol na kailangan mo kapalit ng kaunting performance.

Mga random na numero at mga espesyal na numerical value

Ang pagbuo ng mga random na numero ay isa pang madalas na gawain sa mga numeric na daloy ng trabaho sa Python., bumubuo ka man ng mga simpleng laro, nagpapatakbo ng mga simulation ng Monte Carlo o nagsusulat ng mga test case na gumagamit ng mga kondisyon ng gilid. Ang karaniwang library random Ang modyul ay nagbibigay ng mga pangunahing kaalaman para sa mga ganitong sitwasyon.

random.randint(a, b) lumilikha ng isang pseudo-random integer sa pagitan ng a at b, kasamaGinagawa nitong madali ang paggaya ng mga dice roll o pagpili ng mga random na indeks sa isang listahan. Para sa mga floating-point value, ang mga function tulad ng random.random() at ang mga kaugnay na helper ay bumubuo ng mga pare-parehong random na numero sa mga saklaw tulad ng [0.0, 1.0), na handa nang i-scale o i-transform para sa iyong partikular na distribusyon.

Inilalantad din ng Python ang ilang mga numeric na halaga na kumakatawan sa mga hindi pangkaraniwan o "edge case" na dami.Ang isa ay NaN (“Hindi Isang Numero”), na nakukuha halimbawa sa pamamagitan ng pagtawag float('nan')Ang NaN ay nagpapahiwatig ng mga resultang hindi natukoy o hindi maipapakita, tulad ng resulta ng paghahati ng zero sa zero o pag-parse ng isang sirang numeric field mula sa input data.

Bukod sa NaN, sinusuportahan ng Python ang positibo at negatibong kawalang-hanggan, binuo gamit ang float('inf') at float('-inf')Ang mga ito ay kapaki-pakinabang bilang mga sentinel value kapag sinisimulan ang mga baryabol para sa mga algorithm na naghahanap ng minimum o maximum na mga halaga, o kapag nagmomodelo ng mga unbounded range sa mga numerical method.

Ang paggamit ng mga NaN ay nangangailangan ng partikular na pag-iingat dahil hindi sila kumikilos tulad ng mga regular na numero.Ang mga paghahambing na kinasasangkutan ng NaN ay palaging mali (kahit na nan == nan), at ang aritmetika gamit ang NaN ay may posibilidad na mapalaganap ang NaN sa pamamagitan ng resulta. Bagama't hindi malalim na tinatalakay ng gabay na ito ang semantika ng NaN, ang pagkaalam sa kanilang mga kakaibang katangian ay makakatulong sa iyong mas epektibong i-debug ang mga pipeline ng data at mga numerical algorithm.

Mga abstraktong hirarkiya ng numero gamit ang modyul ng mga numero

Habang nagiging mas sopistikado ang iyong code, maaaring kailanganin mo ng isang nababaluktot na paraan upang makilala ang mga "numeric" na halaga. nang hindi manu-manong sinusuri ang bawat uri ng kongkreto (tulad ng int, float, complex at mga scalar ng NumPy). Dito matatagpuan ang numbers Dumating ang module, na nagbibigay ng isang abstract hierarchy ng mga numeric type.

Ang numbers Tinutukoy ng modyul ang mga abstract base class (ABC) na naglalarawan ng numerical behavior., Gaya ng Number, Complex, Real, Rational at IntegralAng mga klaseng ito ay hindi nilayong direktang i-instantiate. Sa halip, ang mga konkretong numeric type ay nagmamana mula sa kanila upang magpahiwatig na ipinapatupad nila ang mga kinakailangang operasyon at katangian.

Ang pinakapangkalahatang ABC ay numbers.Number, na kumakatawan sa "anumang uri ng numero"Kung gusto mong subukan kung ang isang variable ay dapat ituring bilang numeric—marahil habang nagde-debug o kapag nagsusulat ng maliliit na utility script—maaari mong pagsamahin isinstance gamit ang ABC na ito. Halimbawa, isinstance(x, Number) Babalik True para sa mga built-in na numeric type at maraming external numeric type, tulad ng iba't ibang NumPy scalar.

Isang praktikal na ilustrasyon ang gumagamit ng mga uri ng NumPy kasama ng mga built-in na PythonKung i-import mo ang NumPy bilang np at pagkatapos ay i-loop ang mga halaga tulad ng 1, 1., -0.2, 1e8, np.int64(1), np.int0(10), np.int16(2), np.float64(10), np.complex64(10) at np.int32(89), tumatawag isinstance(value, Number) Para sa bawat isa, makikita mo na lahat sila ay binibilang bilang numerik. Makakatipid ka nito mula sa pagsulat ng mahabang hanay ng mga pagsusuri ng uri para sa bawat partikular na klase.

Ito ay nagkakahalaga ng noting na isinstance ang sarili nito ay itinuturing na isang kodigo na "amoy" kapag ginamit nang labisAng labis na pag-asa sa tahasang pagsusuri ng uri ay maaaring magpahiwatig ng mas malalalim na isyu sa disenyo sa isang object-oriented na programa. Gayunpaman, para sa mabilis na pag-debug, mga exploratory script o maliliit na utility, ang pagsusuri laban sa numbers.Number ay isang makapangyarihan at praktikal na kasangkapan upang mapatunayan na ang iyong mga baryabol ay tunay na kumikilos na parang mga numero.

Mga pinalawak na numeric ecosystem: NumPy at mga custom na uri

Bagama't maliit na hanay lamang ng mga pangkalahatang-gamit na uri ng numero ang inilalantad ng core Python, ang mas malawak na ecosystem ay lubos na nagpapalawak ng iyong mga opsyon.Ang NumPy, sa partikular, ay nagpapakilala ng mas maraming numeric flavor na idinisenyo para sa mahusay na pagkalkula sa malalaking array at matrices.

Tinutukoy ng NumPy ang mga uri ng integer na may takdang lapad tulad ng numpy.int64, numpy.int32, numpy.int16 at mga espesyalisadong alyas tulad ng numpy.int0Ang mga ito ay kahawig ng mga uri ng uri na matatagpuan sa mga low-level, numerically oriented na wika tulad ng Fortran at C, kung saan ang pag-alam sa eksaktong laki ng imbakan at pag-uugali ng iyong mga numero ay mahalaga para sa pagganap at interoperability.

Bukod sa mga integer, nag-aalok ang NumPy ng mga uri tulad ng numpy.float64 at numpy.complex64, kasama ang marami pang iba, na maayos na isinasama sa mga array at ufunc (mga pangkalahatang function). Ang mga uri na ito ay karaniwang nakarehistro bilang mga pagkakataon ng naaangkop na mga ABC mula sa numbers modyul, kaya naman sinusuri laban sa numbers.Number gawain gaya ng ipinakita kanina.

Sinadya ng disenyo ng Python na panatilihing simple at madaling ma-access ang pangunahing modelo ng numeroSa halip na pilitin ang bawat user na pamahalaan ang dose-dosenang magkakaibang numeric flavor, nakatuon ito sa tatlong base numeric type (kasama ang mga boolean), habang ginagawang madali para sa mga espesyalisadong library na palawakin ang repertoire na ito kung kinakailangan. Ang isang environment na nakatuon sa engineering, tulad ng isa na binuo ng isang simulation software company, ay natural na lubos na sasandal sa mga extended type at library na ito.

Kung gagawa ka ng sarili mong mga numeric class, na sinusundan ang mga pattern mula sa numbers at fractions tumutulong sa iyo na umangkop sa ecosystemSa pamamagitan ng pag-subclass sa naaangkop na ABC at pagpapatupad ng mga kinakailangang espesyal na pamamaraan (__add__, __radd__, __mul__, at iba pa), ang iyong mga custom na uri ay maaaring natural na makipag-ugnayan sa mga operator ng Python, mga built-in na numerical function, at iba pang numeric library.

Sa kabuuan, pinagsasama ng numeric Python ang isang malinis na sistema ng core type, makapangyarihang karaniwang mga module ng library at isang mayamang ecosystem ng mga library. tulad ng NumPy, na lumilikha ng isang kapaligiran kung saan maaari kang lumipat nang kumportable mula sa simpleng aritmetika patungo sa mga advanced na kalkulasyon sa inhinyeriya. Kapag naunawaan mo na kung paano magkakaugnay ang mga integer, float, complex number, special value, rounding rules at abstract numeric class, mas may kumpiyansa kang makakapagpaliwanag tungkol sa iyong code, maiiwasan ang mga banayad na bug at mapipili ang mga tamang tool para sa bawat numerical task na iyong makakaharap.