Universelle Funktionen in Numpy sind einfache mathematische Funktionen. Es ist nur ein Begriff, den wir mathematischen Funktionen in der Numpy-Bibliothek gegeben haben. Numpy bietet verschiedene universelle Funktionen, die eine Vielzahl von Vorgängen abdecken.

Diese Funktionen umfassen trigonometrische Standardfunktionen, Funktionen für arithmetische Operationen, die Behandlung komplexer Zahlen, statistische Funktionen usw. Universelle Funktionen haben verschiedene Eigenschaften, die wie folgt sind:

  • Diese Funktionen arbeiten mit ndarray (N-dimensionales Array), dh der Array-Klasse von Numpy.
  • Es führt schnelle elementweise Array-Operationen aus.
  • Es unterstützt verschiedene Funktionen wie Array-Broadcasting, Type Casting usw.
  • Numpy, universelle Funktionen sind Objekte, die zur Klasse numpy.ufunc gehören.
  • Python-Funktionen können auch als universelle Funktion mithilfe der frompyfunc- Bibliotheksfunktion erstellt werden.
  • Einige Ufuncs werden automatisch aufgerufen, wenn der entsprechende arithmetische Operator für Arrays verwendet wird. Wenn beispielsweise das Hinzufügen von zwei Arrays elementweise mit dem Operator '+' durchgeführt wird, wird np.add() intern aufgerufen.

Einige der grundlegenden universellen Funktionen in Numpy sind:

Trigonometrische Funktionen:

Diese Funktionen funktionieren im Bogenmaß, daher müssen Winkel durch Multiplikation mit pi / 180 in Bogenmaß umgewandelt werden. Nur dann können wir trigonometrische Funktionen aufrufen. Sie nehmen ein Array als Eingabeargumente. Es enthält Funktionen wie-

Funktion Beschreibung
Sünde, cos, tan Berechnen Sie Sinus, Cosinus und Tangens von Winkeln
Arcsin, Arccos, Arctan Berechnen Sie inversen Sinus, Cosinus und Tangens
Hypot Berechnen Sie die Hypotenuse des gegebenen rechtwinkligen Dreiecks
sinh, cosh, tanh Berechnen Sie hyperbolischen Sinus, Cosinus und Tangens
arcsinh, arccosh, arctanh Berechnen Sie den inversen hyperbolischen Sinus, Cosinus und Tangens
deg2rad Grad in Bogenmaß umrechnen
rad2deg Bogenmaß in Grad umrechnen 
import numpy as np 
  
angles = np.array([0, 30, 45, 60, 90, 180])  
  
radians = np.deg2rad(angles) 
  
print('Sine of angles in the array:') 
sine_value = np.sin(radians) 
print(np.sin(radians)) 
  
print('Inverse Sine of sine values:') 
print(np.rad2deg(np.arcsin(sine_value))) 
  
print('Sine hyperbolic of angles in the array:') 
sineh_value = np.sinh(radians) 
print(np.sinh(radians)) 
  
print('Inverse Sine hyperbolic:') 
print(np.sin(sineh_value))  
  
base = 4
height = 3
print('hypotenuse of right triangle is:') 
print(np.hypot(base, height))
Ausgabe: 
Sinus der Winkel im Array:
[0.00000000e + 00 5.00000000e-01 7.07106781e-01 8.66025404e-01
   1.00000000e + 00 1.22464680e-16]
Inverser Sinus der Sinuswerte:
[0.00000000e + 00 3.00000000e + 01 4.50000000e + 01 6.00000000e + 01
   9.00000000e + 01 7.01670930e-15]
Sinus hyperbolisch von Winkeln im Array:
[0. 0.54785347 0.86867096 1.24936705 2.3012989
  11.54873936]
Inverser Sinus hyperbolisch:
[0. 0.52085606 0.76347126 0.94878485 0.74483916 -0.85086591]
Hypotenuse des rechtwinkligen Dreiecks ist:
5.0

Statistische Funktionen:

Diese Funktionen werden verwendet, um Mittelwert, Median, Varianz und Minimum der Array-Elemente zu berechnen. Es enthält Funktionen wie-

Funktion Beschreibung
Amin, Amax Gibt das Minimum oder Maximum eines Arrays oder entlang einer Achse zurück
ptp Gibt den Wertebereich (Maximum-Minimum) eines Arrays oder entlang einer Achse zurück
Perzentil (a, p, Achse) Berechnen Sie das p-te Perzentil des Arrays oder entlang der angegebenen Achse
Median Berechnen Sie den Median der Daten entlang der angegebenen Achse
bedeuten Berechnen Sie den Mittelwert der Daten entlang der angegebenen Achse
std Berechnen Sie die Standardabweichung der Daten entlang der angegebenen Achse
var Berechnen Sie die Varianz von Daten entlang der angegebenen Achse
durchschnittlich Berechnen Sie den Durchschnitt der Daten entlang der angegebenen Achse 
import numpy as np 
  
weight = np.array([50.7, 52.5, 50, 58, 55.63, 73.25, 49.5, 45]) 
  
print('Minimum and maximum weight of the students: ') 
print(np.amin(weight), np.amax(weight)) 
  
print('Range of the weight of the students: ') 
print(np.ptp(weight)) 
  
print('Weight below which 70 % student fall: ') 
print(np.percentile(weight, 70)) 
   
print('Mean weight of the students: ') 
print(np.mean(weight)) 
  
print('Median weight of the students: ') 
print(np.median(weight)) 
  
print('Standard deviation of weight of the students: ') 
print(np.std(weight)) 
  
print('Variance of weight of the students: ') 
print(np.var(weight)) 
  
print('Average weight of the students: ') 
print(np.average(weight))
Ausgabe: 
Minimales und maximales Gewicht der Schüler:
45,0 73,25
Gewichtsbereich der Schüler:
28.25
Gewicht, unter das 70% der Schüler fallen:
55.317
Durchschnittsgewicht der Schüler:
54,3225
Durchschnittsgewicht der Schüler:
51.6
Standardgewichtsabweichung der Schüler:
8.05277397857
Gewichtsabweichung der Schüler:
64.84716875
Durchschnittsgewicht der Schüler:
54,3225

Bit-Twiddling-Funktionen:

Diese Funktionen akzeptieren ganzzahlige Werte als Eingabeargumente und führen bitweise Operationen für binäre Darstellungen dieser ganzen Zahlen durch. Es enthält Funktionen wie-

Funktion Beschreibung
bitweise_und führt bitweise und Operationen an zwei Array-Elementen durch
bitwies_or führt bitweise oder Operationen an zwei Array-Elementen durch
bitwise_xor führt eine bitweise xor-Operation an zwei Array-Elementen durch
umkehren führt eine bitweise Inversion eines Array-Elements durch
Linksverschiebung Verschieben Sie die Elemente nach links
rechte Shifttaste Verschieben Sie die Elemente nach links 
import numpy as np 
  
even = np.array([0, 2, 4, 6, 8, 16, 32]) 
odd = np.array([1, 3, 5, 7, 9, 17, 33]) 
  
print('bitwise_and of two arrays: ') 
print(np.bitwise_and(even, odd)) 
  
print('bitwise_or of two arrays: ') 
print(np.bitwise_or(even, odd)) 
  
print('bitwise_xor of two arrays: ') 
print(np.bitwise_xor(even, odd)) 
   
print('inversion of even no. array: ') 
print(np.invert(even)) 
  
print('left_shift of even no. array: ') 
print(np.left_shift(even, 1)) 
  
print('right_shift of even no. array: ') 
print(np.right_shift(even, 1))
Ausgabe: 
bitweise_und von zwei Arrays:
[0 2 4 6 8 16 32]
bitweise_oder von zwei Arrays:
[1 3 5 7 9 17 33]
bitwise_xor von zwei Arrays:
[1 1 1 1 1 1 1]
Inversion von sogar nein. Array:
[-1 -3 -5 -7 -9 -17 -33]
Linksverschiebung von sogar nein. Array:
[0 4 8 12 16 32 64]
Rechtsverschiebung von sogar nein. Array:
[0 1 2 3 4 8 16]