`numpy` — numpy uyumlu dizi işlemleri#

ulab modülünün numpy alt modülü, ndarray n-boyutlu dizi türü etrafında kurulmuş numpy uyumlu bir API sağlar. CPython numpy kütüphanesinin özenle seçilmiş bir alt kümesini uygular: dizi oluşturma, eleman bazlı matematik, indirgemeler ve istatistikler, doğrusal cebir, FFT’ler, rastgele sayı üretimi, polinom uydurma ve temel G/Ç.

Alt modül geleneksel olarak np adıyla içe aktarılır:

from ulab import numpy as np

a = np.array([1, 2, 3, 4], dtype=np.float)
b = np.linspace(0, 1, num=5)
c = np.dot(a.reshape((2, 2)), a.reshape((2, 2)))

Her dtype bağımsız değişkeni, modül düzeyinde sunulan tam sayı sabitlerinden biridir: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16 ve numpy.float (varsayılan). Sonuç türü ndarray, numpy.ndarray’e atıfta bulunur.

Alt modüller#

`ndarray` sınıfı — n-boyutlu dizi#

ndarray, numpy / ulab kütüphanesinin merkezinde yer alan, n-boyutlu ve dtype farkındalıklı kaptır. Veriler, yorumlanması küçük bir başlık (dtype, shape, strides, ndim, itemsize) tarafından tanımlanan bitişik bir blokta saklanır. Birçok işlem – reshape, transpose, dilimleme – yalnızca bu başlığı ayarlar ve bu nedenle çok ucuzdur; yeni depolama ayıran metotlar (copy, flatten, çoğu aritmetik) yeni yoğun bir dizi döndürür.

Aynı tür ulab.ndarray, numpy.ndarray ve (bu sayfa içinde) yalnızca ndarray olarak erişilebilir.

class numpy.ndarray(values: ndarray | bytes | list | tuple, *, dtype: int = numpy.float)#

Yeni bir ndarray oluşturur.

Parametreler:

values – Kaynak veri. Ya başka bir ndarray (derin kopyalanır, dtype farklıysa tür dönüşümüyle) ya da herhangi bir MicroPython yinelenebilir nesnesidir. İç içe geçmiş yinelenebilir nesneler çok boyutlu diziler üretir; iç yinelenebilir nesnelerin tümü aynı uzunlukta olmalıdır, aksi halde bir ValueError yükseltilir.
dtype – Yeni dizi için öğe türü. numpy tarafından sunulan tür kodu tam sayılarından biri (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16 ve numpy.float) veya bir dtype örneği. Varsayılan numpy.float’tır.

numpy.array fabrika işlevi, bir ndarray oluşturmanın geleneksel yoludur; bu yapıcıya yönlendirir.

byteswap(*, inplace: bool = False) → ndarray#

Her öğenin bayt sırasını değiştirir. uint16, int16 ve float dizileri için bu, her öğenin bayt sırasını tersine çevirir; bu, mikrodenetleyicinin bayt sırası ile uyuşmayan çevre birimlerinden gelen verileri işlerken kullanışlıdır. Tek baytlık türler (bool, uint8, int8) için bu, bir görünüm veya kopya döndüren boş bir işlemdir.

inplace False ise (varsayılan) yeni bir ndarray döndürülür ve özgün dizi değiştirilmeden bırakılır. inplace True ise self‘in baytları yerinde takas edilir ve self‘in bir görünümü döndürülür.

copy() → ndarray#: Dizinin yeni, yoğun bir derin kopyasını döndürür. Kopya kendi verisine sahiptir; üzerinde yapılan değişiklikler özgün diziyi etkilemez.

flatten(*, order: str = 'C') → ndarray#

Dizinin yeni, tek boyutlu bir kopyasını döndürür.

Parametreler:: order – 'C' (varsayılan) verileri C sırasında dolaşır (son eksen en hızlı değişir); 'F' verileri Fortran sırasında dolaşır (ilk eksen en hızlı değişir).

reshape(shape: int | tuple[int, ...]) → ndarray#: Dizinin yeni bir şekle sahip bir görünümünü döndürür. Toplam eleman sayısı değişmemelidir, aksi halde bir ValueError yükseltilir. Yalnızca ULAB_MAX_DIMS > 1 olduğunda kullanılabilir. shape özniteliğine atama yapmaya eşdeğerdir.

sort(*, axis: int | None = -1) → None#

Diziyi yerinde sıralar.

Parametreler:: axis – Sıralamanın yapılacağı eksen. -1 (varsayılan) son eksen boyunca sıralar; None önce diziyi düzleştirir, ardından sıralar.

tobytes() → bytearray#: Dizinin temel veri arabelleğine takma ad veren (alias) bir bytearray döndürür. Döndürülen bytearray üzerinden yapılan yazmalar diziyi yerinde değiştirir. Dizi yoğun değilse (örneğin dilimlenmiş bir görünüm) ValueError yükseltir.

tolist() → list#: Dizinin içeriğini (muhtemelen iç içe geçmiş) bir Python list olarak döndürür. İç içe geçme derinliği ndim değerine eşittir.

transpose() → ndarray#: Dizinin transpozunu (eksenleri tersine çevrilmiş) döndürür. Tek boyutlu diziler için bu self döndürür. Yalnızca ULAB_MAX_DIMS > 1 olduğunda kullanılabilir. T özniteliği bu metot için bir kısayoldur.

dtype: dtype | int#: Dizi elemanlarının veri türü. Aygıt yazılımı ULAB_HAS_DTYPE_OBJECT etkinleştirilmiş olarak derlendiğinde bir dtype örneği döndürür; aksi halde temel tek karakterlik tür kodunu bir tamsayı olarak döndürür.

flat: flatiter#: Dizinin her elemanını C sırasında üreten düz (flat) bir yineleyici. flatten() metodunun aksine, flat üzerinde yineleme yapmak yeni bir dizi ayırmaz.

itemsize: int#: dtype değerinden türetilen, tek bir dizi elemanının bayt cinsinden boyutu.

ndim: int#: Dizi boyutlarının sayısı (shape uzunluğu).

shape: tuple[int, ...]#: Dizinin her eksen boyunca uzunlukları. shape‘e bir demet atamak diziyi yerinde yeniden şekillendirir (reshape() ile eşdeğer).

size: int#: Dizideki toplam eleman sayısı (shape‘in çarpımı).

strides: tuple[int, ...]#: O eksen boyunca bir sonraki elemana ulaşmak için bellekte her eksen boyunca atlanacak bayt sayısı.

T: ndarray#: Dizinin transpozu; transpose() ile eşdeğerdir.

Desteklenen operatörler#

ndarray örnekleri aşağıdaki operatörleri destekler. İkili operatörler, operandlarını standart numpy yayın kurallarına göre yayar ve numpy’ın yükseltme kurallarını izler (örn. uint8 + int8 => int16, uint16 + int16 => float).

Aritmetik (ikili): +, -, *, /, //, %, **. Yansıtılmış (sağ taraf) operandlar ve yerinde varyantlar +=, -=, *=, /=, %=, **= de desteklenir. Hem ndarray-ile-ndarray hem de ndarray-ile-skaler biçimleri kabul edilir.

Karşılaştırma: ==, !=, <, <=, >, >=. Her biri, yayınlanmış şekle sahip bir boolean ndarray döndürür.

Bit düzeyi (yalnızca tam sayı dizileri): &, |, ^. Bunları bir float dizisine uygulamak TypeError hatası verir.

Tekli: + (bir kopya döndürür), - (negasyon; işaretsiz dtype’larda değerler modulo \(2^N\) sarmalanır), abs() (eleman bazlı mutlak değer; işaretsiz dtype’larda hesaplama yapmadan bir kopya döndürür), ~ (bit düzeyinde tersine çevirme, yalnızca tamsayı dtype’ları), len() (ilk eksenin uzunluğunu döndürür).

İndeksleme ve dilimleme: a[i], a[i, j, ...], a[start:stop:step], boolean-maske indeksleme (a[mask]) ve tamsayı-dizisi (fancy) indeksleme, hem okumalarda hem yazmalarda desteklenir.

Yineleme: Bir ndarray üzerinde yineleme yapmak, ilk eksen boyunca alt diziler üretir (1 boyutlu diziler için her seferinde bir eleman). Boyutluluktan bağımsız olarak her skaler eleman üzerinde yineleme yapmak için flat özniteliğini kullanın.

Matris çarpımı operatörü @ uygulanmamıştır; bunun yerine numpy.dot (np.dot(a, b)) kullanın.

Kaydırma (<<, >>) operatörleri operatör düzeyinde uygulanmamıştır. Eleman bazlı tamsayı kaydırmaları için numpy.left_shift ve numpy.right_shift kullanın.

Dizi oluşturma#

numpy.array(values: ndarray | list | tuple, *, dtype: int = float) → ndarray#: Sayılardan oluşan iç içe geçmiş bir yinelenebilir nesneden yeni bir ndarray oluşturur. numpy.ndarray için eşdeğer alternatif yapıcıdır.

numpy.arange(start: int | float, stop: int | float | None = None, step: int | float = 1, *, dtype: int | None = None) → ndarray#: [start, stop) yarı açık aralığında eşit aralıklı değerler döndürür. Yalnızca bir konumsal argüman verilirse, start = 0 olmak üzere stop olarak ele alınır. dtype atlanırsa, girdilerden çıkarsanır (start, stop, step değerlerinin tümü tamsayıysa ve aralık dahilindeyse tamsayı).

numpy.asarray(a: ndarray | list | tuple, *, dtype: int | None = None) → ndarray#: a zaten dtype’ı dtype ile eşleşen bir ndarray ise (veya dtype None ise), a değişmeden döndürülür; aksi halde yeni bir dizi oluşturulur (verildiğinde istenen dtype dönüşümüyle). Yinelenebilir nesneler numpy.array‘deki gibi dönüştürülür.

numpy.concatenate(arrays: tuple, *, axis: int = 0) → ndarray#: Bir ndarray dizisini mevcut bir axis boyunca birleştirir. Tüm girdi dizileri aynı dtype, ndim’e ve axis dışındaki her eksende aynı şekle sahip olmalıdır.

numpy.diag(a: ndarray, *, k: int = 0) → ndarray#: 2 boyutlu bir a için, k-inci köşegeni içeren bir 1 boyutlu dizi döndürür. 1 boyutlu bir a için, a‘nın k-inci köşegene yerleştirildiği 2 boyutlu kare bir dizi döndürür. k pozitif (ana köşegenin üstünde) veya negatif (altında) olabilir.

numpy.empty(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray#: zeros için takma ad; shape ve dtype türünde sıfırla doldurulmuş bir dizi döndürür. (ulab arabelleği başlatılmamış olarak bırakmaz.)

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray#: k-inci köşegende birler ve başka yerlerde sıfırlar olacak şekilde 2 boyutlu bir N x M dizisi (M None ise kare N x N) döndürür.

numpy.frombuffer(buffer: bytes, *, dtype: int = float, count: int = -1, offset: int = 0) → ndarray#: Arabellek protokolüne sahip bir nesneyi dtype türünde bir 1 boyutlu ndarray olarak yorumlar. count, okunacak öğe sayısıdır (-1 mevcut tüm öğeleri okur); offset, arabelleğin başında o kadar baytı atlar.

numpy.full(shape: int | tuple[int, ...], fill_value: int | float | bool, *, dtype: int = float) → ndarray#: Her elemanı fill_value olarak ayarlanmış, shape ve dtype türünde yeni bir dizi döndürür.

numpy.linspace(start: float, stop: float, num: int = 50, *, endpoint: bool = True, retstep: bool = False, dtype: int = float) → ndarray | tuple[ndarray, float]#: Kapalı aralık [start, stop] üzerinde (endpoint False ise yarı açık) num adet eşit aralıklı örnek döndürür. retstep True olduğunda (samples, step) demetini döndürür.

numpy.logspace(start: float, stop: float, num: int = 50, *, base: float = 10.0, endpoint: bool = True, dtype: int = float) → ndarray#: Logaritmik bir ölçekte eşit aralıklı num örnek döndürür: sonuç base ** start değerinde başlar ve base ** stop değerinde biter.

numpy.meshgrid(*xi: ndarray, indexing: str = 'xy') → tuple[ndarray, ...]#: Tek boyutlu koordinat dizilerinden oluşan bir diziden koordinat matrisleri demeti döndürür. indexing 'xy' ile (varsayılan), ilk iki girdi Kartezyen koordinatlar olarak ele alınır ve çıktı eksenleri takas edilir; 'ij' ile matris tarzı indeksleme kullanılır. Uygulama, copy=True ve sparse=False olan NumPy eşdeğerine karşılık gelir.

numpy.ones(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray#: shape ve dtype türünde, birlerle doldurulmuş yeni bir dizi döndürür.

numpy.zeros(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray#: shape ve dtype türünde, sıfırlarla doldurulmuş yeni bir dizi döndürür.

İnceleme / yazdırma#

numpy.get_printoptions() → dict#: Mevcut dizi yazdırma seçeneklerini threshold ve edgeitems anahtarlarına sahip bir sözlük olarak döndürür.

numpy.set_printoptions(*, threshold: int | None = None, edgeitems: int | None = None) → None#: Dizi yazdırma seçeneklerini ayarlar. threshold, tam olarak yazdırılan maksimum dizi eleman sayısıdır; edgeitems, dizi özetlendiğinde bir eksenin her ucunda gösterilen öğe sayısıdır.

numpy.ndinfo(array: ndarray) → None#: array hakkında tanılama bilgisi (şekil, strides, dtype, itemsize, …) yazdırır.

numpy.size(a: ndarray, *, axis: int | None = None) → int#: axis boyunca a‘nın eleman sayısını döndürür; axis None ise, toplam eleman sayısını (ndarray.shape‘in çarpımı) döndürür.

Karşılaştırma#

numpy.clip(a: ndarray | int | float, a_min: ndarray | int | float, a_max: ndarray | int | float) → ndarray | int | float#: a değerlerini a_min <= result <= a_max olacak şekilde kırpar. maximum(a_min, minimum(a, a_max)) ile eşdeğerdir; yayınlama, minimum ile aynı kuralları izler.

numpy.equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool#: Eleman bazlı x1 == x2; bir boolean ndarray (her iki girdi de skalerse bir bool skaler) döndürür. Taşınabilirlik için sağlanmıştır – diziler üzerindeki == operatörü aynı sonucu verir.

numpy.not_equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool#: Eleman bazlı x1 != x2; equal‘in boolean karşılığı.

numpy.isfinite(x: ndarray | int | float) → ndarray | bool#: Girdinin sonlu olduğu yerlerde True olan bir boolean dizi (veya skaler) döndürür. Tamsayı girdileri her zaman sonludur.

numpy.isinf(x: ndarray | int | float) → ndarray | bool#: Girdinin sonsuz olduğu yerlerde True olan bir boolean dizi (veya skaler) döndürür. Tamsayı girdileri asla sonsuz değildir.

numpy.maximum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float#: İki dizinin / skalerin eleman bazlı maksimumu. Argümanlar birlikte yayınlanır; dtype’lar farklıysa, çıktı yukarı dönüştürülür.

numpy.minimum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float#: İki dizinin / skalerin eleman bazlı minimumu; maximum‘un karşılığı.

numpy.nonzero(a: ndarray) → tuple[ndarray, ...]#: a‘nın sıfırdan farklı elemanlarının indekslerini içeren, a‘nın her boyutu için bir tane olmak üzere bir ndarray demeti döndürür.

numpy.where(condition: ndarray | int | float, x: ndarray | int | float, y: ndarray | int | float) → ndarray#: Elemanları condition doğru (truthy) olduğunda x‘ten, aksi halde y‘den gelen bir ndarray döndürür. Üç girdi birlikte yayınlanır; çıktı dtype’ı x ve y‘nin yukarı dönüştürmesidir.

Sayısal indirgemeler#

numpy.all(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool#: axis boyunca tüm elemanların True olarak değerlenip değerlenmediğini test eder. axis=None ile (varsayılan) düzleştirilmiş dizi test edilir ve tek bir bool döndürülür.

numpy.any(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool#: axis boyunca herhangi bir elemanın True olarak değerlenip değerlenmediğini test eder. axis=None ile düzleştirilmiş dizi test edilir.

numpy.argmax(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int#: axis boyunca maksimum elemanın indeksini döndürür. axis=None ile dizi düzleştirilir ve tek bir tamsayı döndürülür.

numpy.argmin(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int#: axis boyunca minimum elemanın indeksini döndürür. axis=None ile dizi düzleştirilir ve tek bir tamsayı döndürülür.

numpy.argsort(a: ndarray, *, axis: int = -1) → ndarray#: Girdileri a‘yı axis boyunca artan sırada sıralayan işaretsiz tamsayı indeksli bir ndarray döndürür. Çıktı dtype’ı uint16‘dır, bu nedenle hiçbir eksen 65535 elemanı aşamaz. axis=None desteklenmez.

numpy.cross(a: ndarray, b: ndarray) → ndarray#: 3 uzunluğundaki iki 1 boyutlu dizinin çapraz çarpımını döndürür.

numpy.diff(a: ndarray, *, n: int = 1, axis: int = -1) → ndarray#: a‘nın axis boyunca n-inci ayrık ileri farkını döndürür. n, 0..9 aralığında olmalıdır (türev alma çekirdeği bir int8 içinde saklanır); axis uzunluğu n kadar küçülür. numpy’nin prepend ve append anahtar sözcükleri uygulanmamıştır.

numpy.flip(a: ndarray, *, axis: int | None = None) → ndarray#: Elemanların sırası axis boyunca tersine çevrilmiş yeni bir dizi döndürür; axis=None ile dizi her eksen boyunca tersine çevrilir.

numpy.max(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float#: axis boyunca maksimum elemanı döndürür. axis=None ile (varsayılan) düzleştirilmiş dizi bir skalere indirgenir. numpy’nin out anahtar sözcüğü uygulanmamıştır.

numpy.min(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float#: axis boyunca minimum elemanı döndürür; max‘in karşılığı.

numpy.mean(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | float#: axis boyunca aritmetik ortalamayı döndürür. axis=None ile (varsayılan) düzleştirilmiş dizinin ortalaması bir float olarak döndürülür.

numpy.median(a: ndarray, *, axis: int | None = None) → ndarray | float#: axis boyunca medyanı döndürür. axis=None ile dizi önce düzleştirilir. Çıktı dtype’ı her zaman float’tır.

numpy.roll(a: ndarray, shift: int, *, axis: int | None = None) → ndarray#: a‘yı elemanları shift konum kadar yuvarlanmış (döngüsel olarak kaydırılmış) olarak döndürür. axis=None ile (varsayılan) dizi önce düzleştirilir. Negatif kaydırmalar ters yönde yuvarlanır.

numpy.sort(a: ndarray, *, axis: int = -1) → ndarray#: Yığın sıralaması (heap sort) kullanarak a‘nın axis boyunca sıralanmış bir kopyasını döndürür. axis=None ile dizi önce düzleştirilir. numpy’nin kind ve order anahtar sözcükleri uygulanmamıştır.

numpy.std(a: ndarray | list | tuple, *, axis: int | None = None, ddof: int = 0, keepdims: bool = False) → ndarray | float#: axis boyunca standart sapmayı döndürür. ddof, delta serbestlik derecesidir – kullanılan bölen N - ddof‘tur.

numpy.sum(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float#: axis boyunca toplamı döndürür. axis=None ile düzleştirilmiş dizinin toplamı bir skaler olarak döndürülür.

İstatistikler#

numpy.bincount(x: ndarray, *, weights: ndarray | None = None, minlength: int | None = None) → ndarray#: Tek boyutlu, negatif olmayan tamsayı dizisi x‘teki her değerin kaç kez geçtiğini sayar. x dtype’ı uint8 veya uint16 olmalıdır. weights verilirse, x‘in her girdisi 1 yerine eşleşen ağırlığını katkıda bulunur ve çıktı float dtype’ındadır; aksi halde çıktı uint16 dtype’ındadır. minlength verilirse, çıktı dizisi en az o kadar elemana sahip olur (fazladan girdiler sıfırdır).

numpy.trace(m: ndarray) → int | float#: Kare matris m‘in köşegen elemanlarının toplamını döndürür. Dönüş türü m‘in dtype’ını izler (tamsayı dizileri bir int, float dizileri bir float üretir).

Dönüşüm#

numpy.compress(condition: ndarray | list | tuple, a: ndarray, *, axis: int | None = None) → ndarray#: a‘nın axis boyunca boolean condition tarafından seçilen dilimlerini döndürür. axis=None ile düzleştirilmiş dizi kullanılır.

numpy.delete(a: ndarray, indices: int | ndarray | list | tuple | range, *, axis: int | None = None) → ndarray#: a‘nın indices konumlarındaki girdileri axis boyunca kaldırılmış bir kopyasını döndürür. axis=None ile dizi önce düzleştirilir. Negatif indeksler axis‘in sonundan sayılır; indices silme işleminden önce dahili olarak sıralanır.

numpy.dot(m1: ndarray, m2: ndarray) → ndarray | float#: İki dizinin nokta çarpımını döndürür. İki 1 boyutlu dizi için bu, iç çarpımdır (bir float skaler). 2 boyutlu diziler için bu, matris çarpımıdır; iç boyutlar eşleşmelidir. Sonuç her zaman float dtype’ındadır.

Yaklaşım#

numpy.interp(x: ndarray, xp: ndarray, fp: ndarray, *, left: float | None = None, right: float | None = None) → ndarray#: Tek boyutlu doğrusal interpolasyon. xp, bağımsız değerlerin tekdüze artan bir 1 boyutlu dizisi olmalıdır; fp, karşılık gelen bağımlı değerleri içerir; x, interpolantın değerlendirildiği noktalardır. left ve right, sırasıyla x < xp[0] ve x > xp[-1] için döndürülen değeri geçersiz kılar (varsayılanlar: fp[0] ve fp[-1]).

numpy.trapz(y: ndarray, x: ndarray | None = None, dx: float = 1.0) → float#: Bileşik yamuk kuralı kullanarak y‘yi integrer. x verilirse, y‘ye karşılık gelen örnek konumlarını sağlar; aksi halde dx aralığı kullanılır. y (ve x) 1 boyutlu olmalıdır.

Seçim#

numpy.take(a: ndarray, indices: ndarray | list | tuple, *, axis: int | None = None, out: ndarray | None = None, mode: str | None = None) → ndarray#: a‘dan verilen indices konumlarındaki elemanları axis boyunca alır. axis=None ile düzleştirilmiş dizi kullanılır. mode, sınır dışı davranışı seçer: "raise" (varsayılan – ValueError yükseltir), "wrap" (eksen uzunluğuna göre modülo) veya "clip" (geçerli aralığa kırpar; negatif indekslere izin verilmez). out verilirse sonuç içine yazılır.

Bit düzeyinde#

numpy.bitwise_and(x1: ndarray, x2: ndarray) → ndarray#: İki tamsayı dizisinin eleman bazlı bit düzeyinde VE işlemi; yayınlama desteklenir. Tamsayı olmayan bir dtype bir istisna yükseltir.

numpy.bitwise_or(x1: ndarray, x2: ndarray) → ndarray#: İki tamsayı dizisinin eleman bazlı bit düzeyinde VEYA işlemi.

numpy.bitwise_xor(x1: ndarray, x2: ndarray) → ndarray#: İki tamsayı dizisinin eleman bazlı bit düzeyinde XOR (özel VEYA) işlemi.

numpy.left_shift(x1: ndarray, x2: ndarray) → ndarray#: x1‘in x2 bit kadar eleman bazlı bit düzeyinde sola kaydırılması; her iki dizi de tamsayı dtype’ına sahip olmalıdır.

numpy.right_shift(x1: ndarray, x2: ndarray) → ndarray#: x1‘in x2 bit kadar eleman bazlı bit düzeyinde sağa kaydırılması; her iki dizi de tamsayı dtype’ına sahip olmalıdır.

Filtreleme#

numpy.convolve(a: ndarray, v: ndarray) → ndarray#: İki 1 boyutlu dizinin ayrık doğrusal evrişimini döndürür. Yalnızca "full" modu desteklenir; numpy’nin mode anahtar sözcüğü kabul edilmez (diğer modlar tam sonucu dilimleyerek elde edilebilir). Çıktı uzunluğu len(a) + len(v) - 1‘dir.

Polinom#

numpy.polyfit(x: ndarray | list | tuple, y: ndarray | list | tuple, deg: int) → ndarray#

numpy.polyfit(y: ndarray | list | tuple, deg: int) → ndarray: (x, y) veri noktalarına en küçük kareler yöntemiyle deg derecesinde bir polinom uydurur ve polinom katsayılarını (en yüksek derece önce) döndürür. x atlanırsa, range(len(y)) kullanılır. x ve y‘nin uzunlukları farklıysa ValueError yükseltir.

numpy.polyval(p: ndarray | list | tuple, x: ndarray | list | tuple | int | float) → ndarray | float#: Katsayıları p olan (en yüksek derece önce) polinomu x‘te değerlendirir. x bir skalerse bir float döndürülür, aksi halde bir ndarray.

G/Ç#

numpy.load(file: str) → ndarray#: Daha önce save ile yazılmış bir diziyi file‘dan okur (numpy’nin platformdan bağımsız .npy biçimi). Dosyanın bayt sıralaması ana makineninkinden farklıysa bayt sıralaması anında dönüştürülür.

numpy.loadtxt(file: str, *, delimiter: str | None = None, comments: str = '#', max_rows: int = -1, usecols: int | ndarray | list | tuple | None = None, dtype: int = float, skiprows: int = 0) → ndarray#: Bir metin file‘ından sayısal verileri okur ve bunu bir ndarray olarak döndürür. delimiter varsayılan olarak boşluktur; comments, satır yorumu işaretleyicisidir; max_rows, okunan veri satırı sayısını sınırlar (tümü için -1); usecols, sütunları indeksle seçer; skiprows, o kadar baştaki satırı atlar. dtype float değilse, değerler yuvarlanarak dönüştürülür.

numpy.save(file: str, a: ndarray) → None#: a‘yı numpy’nin platformdan bağımsız .npy biçiminde file‘a kaydeder.

numpy.savetxt(file: str, a: ndarray, *, delimiter: str = ' ', header: str | None = None, footer: str | None = None, comments: str = '# ') → None#: a‘yı metin olarak file‘a yazar. delimiter, bir satırdaki değerleri ayırır; sağlanırsa header ve footer, verilerden önce/sonra yazılır ve her biri comments ile ön eklenir. Değerler kayan nokta olarak yazılır.

Evrensel işlevler#

Eleman bazlı matematik işlevleri. Her biri bir skaler veya bir ndarray kabul eder ve eşleşen şekle sahip bir sonuç döndürür (skaler girdi için bir float skaler, dizi girdisi için bir ndarray). Bir ndarray ile çağrıldığında, sonuç yeni bir kayan nokta ndarray‘idir; sonucu aynı boyutta önceden ayrılmış bir float ndarray içine yazmak için isteğe bağlı bir out anahtar sözcüğü geçilebilir.

numpy.acos(x: ndarray | float, /) → ndarray | float#: x‘in her elemanının ters kosinüsünü (arc kosinüs) hesaplar; sonuç radyan cinsindendir.

numpy.acosh(x: ndarray | float, /) → ndarray | float#: x‘in her elemanının ters hiperbolik kosinüsünü hesaplar.

numpy.arctan2(y: ndarray | float, x: ndarray | float, /) → ndarray | float#: Eleman bazlı iki argümanlı ters tanjant atan2(y, x) hesaplar; iki girdi arasında yayınlamayı destekler.

numpy.around(x: ndarray, /, decimals: int = 0) → ndarray#: ndarray x‘in elemanlarını verilen decimals sayısına yuvarlar; ilk argüman bir ndarray olmalıdır.

numpy.asin(x: ndarray | float, /) → ndarray | float#: x‘in her elemanının ters sinüsünü (arc sinüs) hesaplar; sonuç radyan cinsindendir.

numpy.asinh(x: ndarray | float, /) → ndarray | float#: x‘in her elemanının ters hiperbolik sinüsünü hesaplar.

numpy.atan(x: ndarray | float, /) → ndarray | float#: x‘in her elemanının ters tanjantını (arc tanjant) hesaplar; sonuç radyan cinsindendir.

numpy.atanh(x: ndarray | float, /) → ndarray | float#: x‘in her elemanının ters hiperbolik tanjantını hesaplar.

numpy.ceil(x: ndarray | float, /) → ndarray | float#: x‘in her elemanının tavanını (değerden küçük olmayan en küçük tamsayı) hesaplar.

numpy.cos(x: ndarray | float, /) → ndarray | float#: x‘in her elemanının kosinüsünü (radyan cinsinden) hesaplar.

numpy.cosh(x: ndarray | float, /) → ndarray | float#: x‘in her elemanının hiperbolik kosinüsünü hesaplar.

numpy.degrees(x: ndarray | float, /) → ndarray | float#: x‘in her elemanını radyandan dereceye dönüştürür.

numpy.exp(x: ndarray | float, /) → ndarray | float#: x’in her öğesinin üstel e**x değerini hesaplar.

numpy.expm1(x: ndarray | float, /) → ndarray | float#: x‘in her elemanının sıfıra yakın iyileştirilmiş hassasiyetle exp(x) - 1 değerini hesaplar.

numpy.floor(x: ndarray | float, /) → ndarray | float#: x‘in her elemanının tabanını (değerden büyük olmayan en büyük tamsayı) hesaplar.

numpy.log(x: ndarray | float, /) → ndarray | float#: x‘in her elemanının doğal logaritmasını hesaplar.

numpy.log10(x: ndarray | float, /) → ndarray | float#: x‘in her elemanının 10 tabanında logaritmasını hesaplar.

numpy.log2(x: ndarray | float, /) → ndarray | float#: x‘in her elemanının 2 tabanında logaritmasını hesaplar.

numpy.radians(x: ndarray | float, /) → ndarray | float#: x‘in her elemanını dereceden radyana dönüştürür.

numpy.sin(x: ndarray | float, /) → ndarray | float#: x‘in her elemanının sinüsünü (radyan cinsinden) hesaplar.

numpy.sinc(x: ndarray | float, /) → ndarray | float#: x‘in her elemanının normalize edilmiş sinc işlevini sin(pi*x) / (pi*x) hesaplar.

numpy.sinh(x: ndarray | float, /) → ndarray | float#: x‘in her elemanının hiperbolik sinüsünü hesaplar.

numpy.sqrt(x: ndarray | float, /, *, dtype: int = float) → ndarray | float#: x’in her öğesinin karekökünü hesaplar.

numpy.tan(x: ndarray | float, /) → ndarray | float#: x‘in her elemanının tanjantını (radyan cinsinden) hesaplar.

numpy.tanh(x: ndarray | float, /) → ndarray | float#: x‘in her elemanının hiperbolik tanjantını hesaplar.

numpy.vectorize(f: Callable[[float], float], /, *, otypes: int | None = None) → Callable#: Python işlevi f‘i bir skalere, yinelenebilir nesneye veya ndarray‘e eleman bazlı uygulayan çağrılabilir bir nesne döndürür; otypes, çıktı dtype’ını seçer (varsayılan float).

Sabitler#

numpy.e: float#: Euler sayısı \(e \approx 2.71828\).

numpy.pi: float#: \(\pi \approx 3.14159\).

numpy.inf: float#: IEEE-754 kayan nokta pozitif sonsuzluk.

numpy.nan: float#: IEEE-754 kayan nokta “sayı değil” (not a number).

numpy.bool: int#: Boolean diziler için dtype kodu (uint8 olarak saklanır).

numpy.uint8: int#: İşaretsiz 8 bitlik tamsayı dizileri için dtype kodu.

numpy.int8: int#: İşaretli 8 bitlik tamsayı dizileri için dtype kodu.

numpy.uint16: int#: İşaretsiz 16 bitlik tamsayı dizileri için dtype kodu.

numpy.int16: int#: İşaretli 16 bitlik tamsayı dizileri için dtype kodu.

numpy.float: int#: 32 bitlik kayan nokta dizileri için dtype kodu.

numpy — numpy uyumlu dizi işlemleri#