Syntaks
Syntaksen for at skabe et array, der indeholder komplekse tal, er som følger:
Metode 1:
1j * np. arrangere ( størrelse )Syntaksen givet ovenfor 1j er den imaginære del, hvilket betyder, at vi opretter en matrix af komplekse tal, hvor np.arrang er den funktion, der leveres af NumPy til at skabe en matrix til et specificeret interval. Størrelse, som angiver matrixstørrelsen, overføres til funktionen.
Metode 2:
for eksempel. array ( [ Re+Re*Im , Re+Re*Im , … ] )I denne syntaks er np.arrray den funktion, der gør os i stand til at skabe et array, men vi kan ikke videregive området til det. Vi sender simpelthen værdier til det 'n' gange. I funktionen passerede vi 'Re', som angiver reelle tal, der tilføjer dem til 'Im' et imaginært tal i multiplum af et reelt tal. Vi kan overføre imaginære værdier til n gange.
Eksempel #01:
Som vi ved, understøtter NumPy også komplekse tal og giver flere forskellige metoder til at implementere og manipulere komplekse tal. I eksemplet nedenfor vil vi implementere to måder at skabe arrays, der indeholder komplekse tal. For at implementere NumPy-funktioner, lad os først importere NumPy-biblioteket som np. Derefter vil vi initialisere et array med navnet 'array_a', som vi tildeler funktionen np.arange(), som vil indeholde de komplekse tal. Og rækkevidden af arrayet vil være '8'. I den næste linje oprettede vi en anden matrix ved navn 'array_b', hvortil vi sendte en matrix af komplekse tal ved at sende de komplekse værdier direkte til den. Til sidst udskrev vi det komplekse array, som vi oprettede ved hjælp af begge metoder.
importere nusset som for eksempel.
array_a = 1j * np. arrangere ( 8 )
matrix_b = for eksempel. array ( [ to +1d , 3 +4j , 5 +2j , 1 +6j ] )
Print ( 'kompleks matrix ved hjælp af funktion arange()' , array_a )
Print ( 'kompleks array ved hjælp af np.array() funktion' , matrix_b )
Som vist i uddraget nedenfor er resultatet af den kode, vi har udført. Vi kan se, at vi har skabt to arrays, der har en række komplekse tal fra 0j til 7j. I den anden har vi passeret det tilfældige område af komplekse tal af størrelse 4.
Metode 3:
for eksempel. kompleks ( Re+Re*Im )I ovenstående syntaks er np.complex() den indbyggede klasse, der leveres af Python-pakken NumPy, der gør det muligt for os at gemme komplekse værdier.
Eksempel #02:
En anden måde at skabe et NumPy kompleks array på er at bruge NumPy's complex() klasse. Complex class() bruges til at gemme komplekse tal og returnerer det komplekse objekt, som vi kan bruge flere gange i den enkelte kode. Når vi nu implementerer klassen complex() importerer vi først vores Numpy-pakke. Derefter vil vi initialisere et array, hvortil vi har sendt en kompleks klasse, der bruger en stjerne '*' til at sende et objekt af kompleks() klasse, som vi har sendt '3+1j' til. Ved at bruge funktionen arrange() oprettede vi et array med størrelse 5. Til sidst viste vi bare outputtet af koden, hvori vi oprettede et komplekst array ved hjælp af klassen complex().
importere nusset som for eksempel.array = for eksempel. kompleks ( 3 +1d ) *for eksempel. arrangere ( 5 )
Print ( 'kompleks array ved hjælp af np.complex() klasse' , array )
Som vist i figuren nedenfor har vi lavet en række komplekse tal. Men en ting mere, vi kan bemærke i figuren, er, at konstantværdien ikke udføres fortløbende, fordi vi har sendt '3+1j' til en kompleks()-klasse, hvilket betyder, at et nummer tre vil blive tilføjet til hver næste konstantværdi.
Metode 4:
for eksempel. dem ( form , dtype = Ingen , bestille = 'C' , * , synes godt om = Ingen )I denne metode np.ones() specificerer vi et array af komplekse tal ved at bruge parameteren dtype i NumPy arrayet. Np.ones() bruges til at returnere et nyt array, der indeholder 1'ere. Til funktionen np.ones() sendte vi fire parametre 'shape', som bruges til at definere formen på arrayet, uanset om det er '2', '3' eller andet. 'dtype' er datatypen. I vores tilfælde vil vi bruge en kompleks datatype. 'Rækkefølgen' definerer, om arrayet er endimensionelt, to- eller flerdimensionelt.
Eksempel #03:
Lad os implementere metoden ones() for at få en bedre ide om, hvordan den fungerer, mens du bruger komplekse tal. For at implementere denne metode, lad os først importere vores pakker med NumPy, der leveres af Python. Dernæst vil vi oprette et array, som vi sender funktionen np.ones() til, som vi sendte to parametre til. Den første er '4', hvilket betyder, at matrixstørrelsen vil være 4, og den anden er 'dtype', som er kompleks. Det betyder, at vi skal skabe en række komplekse tal af datatype. At gange funktionen ones() med værdien '2' betyder, at vores reelle tal vil være '2'. Til sidst udskrev vi det array, som vi oprettede ved hjælp af print-erklæringen.
importere nusset som for eksempel.array = for eksempel. dem ( 4 , dtype = kompleks ) * to
Print ( 'kompleks array ved hjælp af np.ones() funktion' , array )
Som vist nedenfor udføres outputtet af vores kode med succes, hvor vi har et endimensionelt array, der indeholder 4 komplekse værdier med et reelt tal 2.
Eksempel #04:
Lad os nu implementere et andet eksempel, hvor vi vil skabe en række komplekse tal og udskrive de imaginære og reelle dele af de komplekse tal. Vi vil først importere NumPy-biblioteket og derefter oprette et array, hvortil vi sendte '6' komplekse værdier til et array ved navn 'array', som er '56+0j, 27+0j, 68+0j, 49+0j, 120+0j , 4+0j”. I den næste linje udskrev vi simpelthen arrayet. Nu udskriver vi imaginære og reelle værdier af det komplekse array.
Numpy har en indbygget funktion til begge de operationer, der er vist nedenfor. Den første til at få den imaginære del er 'array_name.imag', hvor værdien før prikken er den matrix, hvorfra vi skal hente den imaginære del. Og den anden til at få den rigtige del er 'array_name.real'. I vores tilfælde er navnet på et array 'array', så vi bestod print-erklæringen, array-navnet og nøgleordet for at få begge elementer.
importere nusset som for eksempel.array = for eksempel. array ( [ 56 .+ 0 . j , 27 .+ 0 . j , 68 .+ 0 . j , 49 .+ 0 . j , 120 .+ 0 . j , 3 + 4 . j ] )
Print ( 'Original array:x' , array )
Print ( 'Virkelig del af arrayet:' )
Print ( array . ægte )
Print ( 'Imaginær del af arrayet:' )
Print ( array . imag )
Som vist i uddraget nedenfor, outputtet, hvor den imaginære og den virkelige del af det komplekse array udføres med succes. Hvor de rigtige dele er '56', '27', '68', '120' og '3'. Og de imaginære dele er '0'er'.
Konklusion
I denne artikel har vi kort diskuteret komplekse tal, og hvordan vi kan skabe komplekse arrays ved hjælp af NumPys indbyggede funktioner. Vi beskrev flere funktioner, der gør os i stand til at skabe komplekse arrays ved at implementere flere eksempler for at forstå bedre.