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 argümanı, modül düzeyinde sunulan tamsayı sabitlerinden biridir: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float (varsayılan) ve (karmaşık sayı desteği derlendiğinde) numpy.complex. Sonuç türü ndarray, numpy.ndarray türüne karşılık gelir.

Alt modüller

• numpy.fft — Hızlı Fourier Dönüşümü rutinleri
• numpy.linalg — Lineer cebir rutinleri
• numpy.random — Rastgele sayı üretimi

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 dizinin eleman türü. numpy tarafından sunulan tür kodu tamsayılarından biri (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float ve – desteklendiğinde – numpy.complex) veya bir dtype örneği. Varsayılan değer 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 elemanın bayt sırasını ters çevirir. uint16, int16, float ve complex dizileri için bu, eleman başına bayt sırasını tersine çevirir; bu, bayt sıralaması mikrodenetleyicininkiyle eşleşmeyen çevre birimlerinden veri tüketirken yararlıdır. Tek baytlık dtype’lar (bool, uint8, int8) için bu, bir görünüm ya da kopya döndüren bir işlem-yok (no-op) durumudur.

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.

real: ndarray

Karmaşık bir dizinin gerçek kısmı, bir float ndarray olarak döndürülür. Gerçek diziler için bu, self‘in aynı dtype ile bir kopyasıdır. Yalnızca aygıt yazılımı karmaşık sayı desteğiyle derlendiğinde kullanılabilir.

imag: ndarray

Karmaşık bir dizinin sanal kısmı, bir float ndarray olarak döndürülür. Gerçek diziler için bu, self ile aynı dtype türünde sıfırlardan oluşan bir dizidir. Yalnızca aygıt yazılımı karmaşık sayı desteğiyle derlendiğinde kullanılabilir.

Desteklenen operatörler

ndarray örnekleri aşağıdaki operatörleri destekler. İkili operatörler, işlenenlerini standart numpy yayınlama (broadcasting) kurallarına göre yayar ve numpy’nin yukarı dönüştürme (upcasting) kurallarını izler (örneğin uint8 + int8 => int16, uint16 + int16 => float); karmaşık bir işlenen içeren işlemler karmaşık bir sonuç üretir.

Aritmetik (ikili): +, -, *, /, //, %, **. Yansıtılmış (sağ taraflı) işlenenler ve yerinde varyantlar +=, -=, *=, /=, %=, **= de desteklenir. Hem ndarray-ile-ndarray hem de ndarray-ile-skaler biçimleri kabul edilir. Taban bölme (//) ve modülo operatörü (%) complex diziler için uygulanmamıştır.

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

Bit düzeyinde (yalnızca tamsayı dizileri): &, |, ^. Bunları bir float veya complex diziye uygulamak TypeError yükseltir.

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]

[start, stop] kapalı aralığında (veya endpoint False ise yarı açık aralıkta) num adet eşit aralıklı örnek döndürür. retstep True olduğunda, bir (samples, step) demeti döndürür. Karmaşık start/stop değerleri karmaşık bir dizi üretir (karmaşık sayı desteği etkinleştirildiğinde).

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.

Karmaşık sayı yardımcıları

Bu işlevler yalnızca ulab karmaşık sayı desteğiyle derlendiğinde (ULAB_SUPPORTS_COMPLEX) kullanılabilir.

numpy.real(val: ndarray) → ndarray

val‘in gerçek kısmını döndürür. Gerçek dtype’lı bir girdi için, dtype’ı koruyan bir kopya döndürür; karmaşık bir girdi için, bir float ndarray döndürür.

numpy.imag(val: ndarray) → ndarray

val‘in sanal kısmını döndürür. Gerçek dtype’lı bir girdi için, aynı dtype türünde sıfırlardan oluşan bir dizi döndürür; karmaşık bir girdi için, bir float ndarray döndürür.

numpy.conjugate(val: ndarray | complex | int | float) → ndarray | complex | int | float

val‘in karmaşık eşleniğini döndürür. Gerçek değerli girdiler değişmeden döndürülür.

numpy.sort_complex(a: ndarray) → ndarray

1 boyutlu a dizisini önce gerçek kısma, ardından sanal kısma göre sıralar. Sonuç, a gerçek değerli olsa bile her zaman karmaşık dtype’ındadı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 elemanının üstel e**x değerini hesaplar; karmaşık girdi verildiğinde karmaşık bir ndarray döndürebilir (karmaşık sayı desteği etkinleştirilmişse).

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 elemanının karekökünü hesaplar; negatif gerçek girdiler için karmaşık sonuçlar elde etmek üzere dtype=numpy.complex geçin (karmaşık sayı desteği etkinleştirilmişse).

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.