In [2]:
%matplotlib inline
from matplotlib import pyplot as plt
import numpy as np
x = np.linspace(0,9,10)
y = x**2
plt.plot(x,y,'r--')
plt.xlabel('x')
plt.ylabel('$y^2$')
plt.title("x'in karesi")
plt.show()
Doç. Dr. Özgür Baştürk
Ankara Üniversitesi, Astronomi ve Uzay Bilimleri Bölümü
obasturk at ankara.edu.tr
http://ozgur.astrotux.org
Bu ders Ankara Üniversitesi Fen Bilimleri, Astronomi ve Uzay Bilimleri Anabilim Dalı'nın bir Yüksek Lisans dersi olup, temel amacı öğrencilere astronomide kullanılan veritabanlarına modern yöntemlerle erişme, veritabanları ve kataloglardan veri çekme, bu veriyi analize hazır hale getirme (işleme), veriyi görselleştirme ve rapor oluşturma, yığın veriye uygulanabilecek yöntemlerle astronomi verisinden istatistiksel çıkarımlarda bulunmaya yönelik olarak bilgi vermeyi amaçlamaktadır. Öğrencilere bu amaçlarla kullanılan numpy, scipy, pandas, astroquery, matplotlib, seaborn, statsmodels gibi Python modülleri ve astronomide sık başvurulan veritabanları tanıtılacaktır.
Astronomide veritabanlarına erişim, veri çekme, veri analizi, görselleştirme ve istatistiksel çıkarım işlemleri için giderek daha popüler hale gelmekte olan Python programlama dilinin ve modüllerinin olanakları dersin amaçları doğrultusunda kullanılacaktır. Dersin temel yöntemi gelişmiş bir programlama dili olan Python'ın temel yapıları ve dış modüllerin fonksiyonları kullanılarak bilgisayar kodlarının geliştirilmesine ve kullanımına dayalıdır. Öğrenci, araştırma ilgisi ve alanı dahilinde kendi geliştireceği kodlarla temel konuları uygulamalı olarak öğrenecek, arasınav yerine geçecek küçük ödevlerle konuları pekiştirecek, final projesiyle de astronomide ilgi duyduğu bir alandaki bir veritabanı uygulaması geliştirecektir.
Ders notları, ödevler ve final projesi için Juypter defterlerinden (notebook) yararlanılacak, ana platform olarak Jupyter Notebooks ve / veya Jupyter Lab platformu kullanılacaktır.
800100715151 Astronomide Veritabanları dersi 8 AKTS kredi ve haftada 3 saatlik (Salı günleri, 13:30-16:30) bir programdan oluşmaktadır. Dersin notlandırması
üzerinden yapılacaktır. Final Projesi her bir öğrenciye özgü ve öncelikle ilgi duyduğu araştırma alanına odaklı olarak öğrenciyle birlikte seçilecek ve sınırları birlikte saptanacaktır.
Jupyter temel olarak metin, görsel, kod (Python, R ve Julia başta olmak üzere çeşitli program dillerinde yazılmış), kod çıktısı ve işaretle dillerinin (html, latex) bir arada kullanılabildiği bir platformdur. Bu ders Jupyter platformu üzerinden işleneek olup, öğrencinin temel fonksiyonları biliyor olmasının yanı sıra bazı kısa yolları ve ileri düzey yapıları kullanabiliyor olması kendi yararına olacaktır. Jupyter hakkında daha geniş bilgiye Jupyter sitesinden ulaşabilirsiniz. Jupyter ve Python'u kurmak için bu derste önerilen yöntem olan Anaconda üzerinden kurmak için AST415 Astronomide Sayısal Çözümleme-I Ders 1. Unix ve Python'a Giriş 'in sonuna doğru görsellerle verilen anlatımdan yararlanabilirsiniz.
Jupyter'la etkileşebileceğiniz iki temel yöntemden birincisi kod çalıştırmaktır. Bu nedenle Jupyter defterlerinin temel birimi olan hücrelerin (cell) varsayılan türü kod çalıştırmaya (Code cell) yöneliktir. Yapmanız gereken tek şey yeni (Insert --> Cell Below) ya da b kısayol tuşuna basarak bir hücre oluşturup, o hücrenin içerisinde kodunuzu yazmanızdır. Yeni oluşturulan bir Jupyter defteri zaten boş bir kod hücresiyle açılır. Bir kod hücresi içine istediğiniz uzunlukta kod yazabilirsiniz. Jupyter hücresinin başında yazdığınızı bir girdi (input) olduğunu gösteren In ifadesi ve yanında köşeli parantez içinde çalıştırıldığı vakit, çalıştırılan kaçıncı kod olduğnu gösteren bir tam sayı yer alır. Kodunuzu kod hücresi içinde yazdıktan sonra çalıştırmak için Run aracını () ve Cell --> Run Cells menü seçeneklerini kullanabileceğiniz gibi Ctrl+Enter seçeneği ile kodunuzu çalıştırıp o hücre içinde kalabilir, Alt+Enter tuş takımı ile kodunuzu çalıştırıp alta yeni bir hücre (kod hücresi açabilir ya da Shift+Enter seçeneği ile kodunuzu çalıştırıp varsa bir sonraki hücreyi seçebilirsiniz. Kodunuzu her çalıştırmanız sonrasında o kodun çalıştırılma sayısı (In [ ] ) bir artacaktır.
Dikey atış problemini çözen bir Python kodu aşağıda örnek olarak verilmiştir.
v0 = 5 # Ilk hiz m/s
t = 0.6 # zaman s
g = 9.81 # yercekimi ivmesi m/s**2
y = v0*t - 0.5*g*t**2
print(y)
1.2342
Kod, kod hücresine yazılırken; çalıştırıldığında çekirdete (Kernel) çalıştırılır. Çekirdeğe ilişkin işlemler Kernel menüsünden ya da araç çubuğundaki , gibi butonlarla çalıştırılabilir, dudurulabilir ya da yeniden tüm çekirdek yeniden başlatılabilir.
Jupyter'da herhangi bir metin yazmak için hücreyi tıklayarak ya da hücrenin içine girilmişse ESC tuşuyla hücre seçilmelidir. Aktif bir hücre yeşil renkte bir çerçeveyle, seçili bir hücre ise mavi renkte bir çerçeveyle çevrilidir. Hücre seçildikten sonra türü istenirse Araç Çubuğu'ndaki drop-down menüden Markdown seçeneği seçilerek, istenirse de kısaca m tuşuna basılarak metin moduna dönüştürülür. Aynı şekilde bir hücreyi kod hücresine dönüştürmek istediğinizde araç çubuğundaki menüyü kullanabileceğiniz gibi y kısayol tuşundan da faydalanabilirsiniz. Bu durumda kod satırlarındaki In [ ] ifadesi hücre başında yer almaz. Şu ana kadar bu Jupyter defterinin tüm metin hücreleri bu şekilde oluşturulmuştur. Örnek olarak inceleyebilirsiniz.
Metin hücrelerinde latex ve html işaretleme dillerini kullanablirsiniz. Dikey atış kodu örneğindeki formül
$$ y = V_0 t - \frac{1}{2} g t^2 $$ifadesi ile verilebilir. $ işareti satır içinde latex ifadesi kulllanmak, $$ ise yazılan latex ifadesini yeni bir satırın ortasına almak için kullanılabilir.
Ayrıca metinlerinizde html etiketlerini (tag) kullanarak bold, italik, altı çizili metinler yazabilir, metinlerinize link verebilir ya da renklendirebilirsiniz!
Çizdiğiniz grafikleri Jupyter defterinizde göstermek ve .py uzantılı dış programları çalıştırmak gibi bu derste sıkça ihtiyaç duyacağınız bazı aksiyonlar için Jupyter'da "sihirli sözcükler" (magic words) adı verilen yapılardan yararlanmanız gerekecektir. Bir örnek aşağıda verilmektedir.
%matplotlib inline
from matplotlib import pyplot as plt
import numpy as np
x = np.linspace(0,9,10)
y = x**2
plt.plot(x,y,'r--')
plt.xlabel('x')
plt.ylabel('$y^2$')
plt.title("x'in karesi")
plt.show()
Jupyter'da kullanılabilecek bazı kullanışlı sihirli sözcükler aşağıda listelenmiştir.
%paste & %cpaste: Başka bir kaynaktan ya da terminalden kod kopyalarken ">>>" prompt sembollerini atarak sizin sadece kodu kopyalamanızı sağlar.
%run: Bu derste sıkça kullanacağınız bir sihirli sözcük olup, py uzantılı kodlarınızı Jupyter içinden çalıştırmanıza olanak sağlar (Örnek: %run deneme.py)
%timeit: Kodunuzu zamanlamanıza olanak sağlar (Örnek: %timeit L = [x ** 2 for x in range(1000)])
%xmode: Hata mesajlarının gösterilme şeklini belirler. Plain, Verbose ve Context olmak üzere üç çeşit hata mesajı alma modu bulunmaktadır.
%debug: Herhangi bir hata mesajı aldığınızda, kodun hata veren noktasına gidip bir hata ayıklama (debug) kutucuğu (prompt) açar ve sizden kodu düzeltmenizi bekler.
%pdb on: Jupyter'ın varsayılan davranışının bir hatayla karşılaşıldığında debug prompt'u açması şeklinde olmasını istiyorsanız bu sihirli sözcükle sağlayabilirsiniz.
%history: : İlgiil Jupyter defterinin tarihçesini listeler.
%lsmagic: Tüm sihirli sözcüklerin bir listesine erişiminizi saplar
%lsmagic
Available line magics: %alias %alias_magic %autoawait %autocall %automagic %autosave %bookmark %cat %cd %clear %colors %conda %config %connect_info %cp %debug %dhist %dirs %doctest_mode %ed %edit %env %gui %hist %history %killbgscripts %ldir %less %lf %lk %ll %load %load_ext %loadpy %logoff %logon %logstart %logstate %logstop %ls %lsmagic %lx %macro %magic %man %matplotlib %mkdir %more %mv %notebook %page %pastebin %pdb %pdef %pdoc %pfile %pinfo %pinfo2 %pip %popd %pprint %precision %prun %psearch %psource %pushd %pwd %pycat %pylab %qtconsole %quickref %recall %rehashx %reload_ext %rep %rerun %reset %reset_selective %rm %rmdir %run %save %sc %set_env %store %sx %system %tb %time %timeit %unalias %unload_ext %who %who_ls %whos %xdel %xmode Available cell magics: %%! %%HTML %%SVG %%bash %%capture %%debug %%file %%html %%javascript %%js %%latex %%markdown %%perl %%prun %%pypy %%python %%python2 %%python3 %%ruby %%script %%sh %%svg %%sx %%system %%time %%timeit %%writefile Automagic is ON, % prefix IS NOT needed for line magics.
Hücre silmek ve eklemek için Insert ve Cell menü seçeneklerinden uygun olanlarını, araç çubuğundaki simgeleri kullanabileceğiniz gibi, işletim sistemlerinin sağladığı Crtl+c, Crtl+x ve Crtl+v seçenekleri de kullanabilirsiniz. Ayrıca araç çubuğunda bu işlerin yanı sıra satır taşımak için kullanabileceğiniz araçlara erişiminizi sağlayan butonlar da bulunmaktadır. Ancak en pratiği kısa yol tuşlarını kullanmaktır. Bu noktada tavisye kısa yol tuşlarını öğrenmek ve verimlilik açısından klavyeden elinizi ayırmadan (ve böylece yazdığınız şeye konsantrasyonunuzu kaybetmeden) bu tuşları kullanmanız olacaktır. a tuşunu bulunulan hücrenin üstüne, b tuşuna altına hücre eklemek,
Jupyter'da herhangi bir konuda yardım almak ve tanımlı kısayol tuşlarını öğrenmek için Help menüsündeki seçeneklerden yararlanabilirsiniz. Bu bölümde Python'la kod yazarken ve bazı önemli paketleri (modülleri) kullanırken sorunlarla karşılaştığınız zaman nasıl yardım alabileceğinize ilişkin bazı ipuçları verilecektir.
help(len)
Help on built-in function len in module builtins:
len(obj, /)
Return the number of items in a container.
Aynı seçeneğe erişmek için daha kısa bir yol ise yardım almak istediğiniz fonksiyonu yazıp sonuna ? koymaktır. İşletim sistemi ve kullanılan tarayıcıya bağlı olarak standard bir çıktı alınabileceği gibi yardım içeriğini taşıyan bir pencere (pop-up window) de açılabilir.
len?
Sadece ön tanımlı fonksiyonlar değil, çeşitlli nesneler üzerine tanımlı metotlara (ing. attribute) ulaşmak için aynı yöntemler kullanılabilir.
L = ['1', 3.14, 2]
help(L.insert)
Help on built-in function insert:
insert(index, object, /) method of builtins.list instance
Insert object before index.
L?
Herhangi bir fonksiyonun (kulllanıcı tanımlı ya da değil) dokümantasyon bloğu (docstring) varsa, ona ulaşarak da fonksiyonun (sınıfın ya da kod parçasının) nasıl kullanılabileceği konusunda da bilgi alınabilir.
def daire(r = 1):
"""
r yaricapina sahip bir dairenin
cevresini ve alanini hesaplayip
programa dondurur.
Kullanilisi:
alan, cevre = daire(R)
Input:
r : Dairenin yaricapi
Output:
alan = pi*r**2
cevre = 2*pi*r
Ornek:
R = 5
print(daire(R))
Cikti:
78.53981633974483 31.41592653589793
"""
from math import pi
return pi*r**2, 2*pi*r
R = 5
alan, cevre = daire(R)
print("Yaricapi {:g} birim olan bir dairenin alani {:g} birimkare, cevresi {:g} birimdir".\
format(R,alan,cevre))
print("-----------------------------------------")
print("Daire fonksiyonu dokumantasyon blogu:")
print("-----------------------------------------")
help(daire)
Yaricapi 5 birim olan bir dairenin alani 78.5398 birimkare, cevresi 31.4159 birimdir
-----------------------------------------
Daire fonksiyonu dokumantasyon blogu:
-----------------------------------------
Help on function daire in module __main__:
daire(r=1)
r yaricapina sahip bir dairenin
cevresini ve alanini hesaplayip
programa dondurur.
Kullanilisi:
alan, cevre = daire(R)
Input:
r : Dairenin yaricapi
Output:
alan = pi*r**2
cevre = 2*pi*r
Ornek:
R = 5
print(daire(R))
Cikti:
78.53981633974483 31.41592653589793
Fonksiyonun kaynak koduna ulaşmak için fonksiyon adını takiben ?? kullanılır.
daire??
Eğer bu opsiyon (??) sadece iç dokümantasyon bloğunu veren ? ile aynı çıktıyı veriyorsa bu durumda bu fonksiyon Python dışında bir programcılık diliyle kodlanıp, Python'a entegre edilmiş olabilir.
len??
Ayrıca tam adını hatırlayamadığınız fonksiyonları hatırlamak ya da bütün fonksiyonun adını yazmamak için fonksiyonun hatırlayabildiğiniz ya da yazmak istediğiniz kadarını yazdıktan sonra TAB tuşuna basarak geri kalanını iPython'ın yazmasını isteyebilirsiniz.
# Daha once tanimladiginiz L listesi uzerinde hangi metotlarin
# tanimli oldugunu gormek icin L yazip nokta koyduktan sonra
# <TAB> tusuna basiniz
Ayrıca nesnenin üzerinde tanımlı gizli metotları da görmek isterseniz; nesne_adi._ yazdıktan sonra TAB tuşuna basabilirsiniz.
# Daha once tanimladiginiz L listesi uzerinde hangi gizli metotlarin
# tanimli oldugunu gormek icin L._ yazdiktan sonra
# <TAB> tusuna basiniz
TAB ile birlikte wildcard (*, ?) kullanmak, adını ve ilk birkaç harfini hatırlayamadığınız ancak bir kısmını hatırlayabildiğiniz fonksiyon, metot ya da modülleri bulmanıza yardımcı olacaktır.
*Warning?
Tıpkı Python fonksiyonları gibi, IPython sihirli sözcükleriyle tanımlanan fonksiyonlarının da aynı şekilde ulaşılabilen iç dokümantasyon blokları bulunmaktadır.
%timeit?
Herhangi bir sihirli sözcükle ilgili dokümantasyona sözcüğü yazıp Enter'a basarak erişebilirsiniz.
#%run
Çekirdek (Kernel) Jupyter'ın interaktif olarak kod çalıştıran bileşenidir. IPython kulllanırken, bu bir Python kodudur. Python'dan başka dillerde çekirdekler olabileceği gibi birden fazla Python versiyonu (2.7, 3.6, 3.8 gibi) sistemde kurulu iseler bulunabilir. Çekirdek Jupyter defterindeki kod parçalarını alır, çalıştırır ve deftere çıktı (output) ya da hata mesajı (error message) yollar.
Çıktı koda bağlı olarak print ifadesi kullanılmamışsa tıpkı input hücreleri gibi Out[ ] ifadesi ile köşeli parantez içinde numarandırılır. print ifadesinin kulllanıldığı durumda çıktı stdout nesnesine yönlendirilr. Kod hatta veriyorsa bu da stderr nesnesi üzerinden gelir.
print("merhaba, stdout")
merhaba, stdout
3 + 5
8
np.array([1,2,3])
array([1, 2, 3])
Jupyter'da çıktılar senkronize değildir. Kod bir taraftan çıktı üretir ve ekrana getirirken, siz diğer tarafta başka bir hücre üzerinde çalışıyor olabilirsiniz. Bir hücre çıktı ürettikçe üretilen çıktı bir önceki çıktıdan sonra ekrana gelir. Tüm kod bloğunun çalışıp, tüm çıktıların ekrana tek bir anda basılması beklenmez.
import time, sys
for i in range(5):
print(i)
time.sleep(0.8)
0 1 2 3 4
Kod bloklarının uzun çıktılar vermesi durumunda çıktının olduğu blok isteğe göre büyütülüp küçültülebilir. Aşağıdaki kod parçasının çalıştırıldıktan sonra verdiği çıktıyı küçültmek için çıktı hücresinin sol tarafında beliren alana tek (sağ tarafta bir kaydırma çubuğu için) ya da çift (çıktı bloğunu tamamen kapatmak için) tıklayınız.
for i in range(60):
print(i)
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
Eğer kodun çıktsı çok uzunsa tarayıcı bunun için bir kaydırma çubuğunu otomatik olarak sağlar.
from math import pi
for r in range(500):
print(2*pi*r)
0.0 6.283185307179586 12.566370614359172 18.84955592153876 25.132741228718345 31.41592653589793 37.69911184307752 43.982297150257104 50.26548245743669 56.548667764616276 62.83185307179586 69.11503837897544 75.39822368615503 81.68140899333463 87.96459430051421 94.24777960769379 100.53096491487338 106.81415022205297 113.09733552923255 119.38052083641213 125.66370614359172 131.94689145077132 138.23007675795088 144.51326206513048 150.79644737231007 157.07963267948966 163.36281798666926 169.64600329384882 175.92918860102841 182.212373908208 188.49555921538757 194.77874452256717 201.06192982974676 207.34511513692635 213.62830044410595 219.9114857512855 226.1946710584651 232.4778563656447 238.76104167282426 245.04422698000386 251.32741228718345 257.610597594363 263.89378290154264 270.1769682087222 276.46015351590177 282.7433388230814 289.02652413026095 295.3097094374406 301.59289474462014 307.8760800517997 314.1592653589793 320.4424506661589 326.7256359733385 333.0088212805181 339.29200658769764 345.57519189487726 351.85837720205683 358.1415625092364 364.424747816416 370.7079331235956 376.99111843077515 383.27430373795477 389.55748904513433 395.84067435231395 402.1238596594935 408.4070449666731 414.6902302738527 420.97341558103227 427.2566008882119 433.53978619539146 439.822971502571 446.10615680975064 452.3893421169302 458.6725274241098 464.9557127312894 471.23889803846896 477.5220833456485 483.80526865282815 490.0884539600077 496.37163926718733 502.6548245743669 508.93800988154646 515.221195188726 521.5043804959057 527.7875658030853 534.0707511102648 540.3539364174444 546.637121724624 552.9203070318035 559.2034923389832 565.4866776461628 571.7698629533423 578.0530482605219 584.3362335677015 590.6194188748811 596.9026041820607 603.1857894892403 609.4689747964198 615.7521601035994 622.0353454107791 628.3185307179587 634.6017160251382 640.8849013323178 647.1680866394973 653.451271946677 659.7344572538566 666.0176425610362 672.3008278682157 678.5840131753953 684.8671984825748 691.1503837897545 697.4335690969341 703.7167544041137 709.9999397112932 716.2831250184728 722.5663103256525 728.849495632832 735.1326809400116 741.4158662471912 747.6990515543707 753.9822368615503 760.26542216873 766.5486074759095 772.8317927830891 779.1149780902687 785.3981633974482 791.6813487046279 797.9645340118075 804.247719318987 810.5309046261666 816.8140899333462 823.0972752405258 829.3804605477054 835.663645854885 841.9468311620645 848.2300164692441 854.5132017764238 860.7963870836033 867.0795723907829 873.3627576979625 879.645943005142 885.9291283123216 892.2123136195013 898.4954989266809 904.7786842338604 911.06186954104 917.3450548482195 923.6282401553992 929.9114254625788 936.1946107697584 942.4777960769379 948.7609813841175 955.044166691297 961.3273519984767 967.6105373056563 973.8937226128359 980.1769079200154 986.460093227195 992.7432785343747 999.0264638415542 1005.3096491487338 1011.5928344559134 1017.8760197630929 1024.1592050702725 1030.442390377452 1036.7255756846316 1043.0087609918114 1049.291946298991 1055.5751316061705 1061.85831691335 1068.1415022205297 1074.4246875277092 1080.7078728348888 1086.9910581420684 1093.274243449248 1099.5574287564275 1105.840614063607 1112.1237993707869 1118.4069846779664 1124.690169985146 1130.9733552923256 1137.2565405995051 1143.5397259066847 1149.8229112138642 1156.1060965210438 1162.3892818282234 1168.672467135403 1174.9556524425827 1181.2388377497623 1187.5220230569419 1193.8052083641214 1200.088393671301 1206.3715789784806 1212.6547642856601 1218.9379495928397 1225.2211349000193 1231.5043202071988 1237.7875055143784 1244.0706908215582 1250.3538761287377 1256.6370614359173 1262.9202467430969 1269.2034320502764 1275.486617357456 1281.7698026646356 1288.0529879718151 1294.3361732789947 1300.6193585861743 1306.902543893354 1313.1857292005336 1319.4689145077132 1325.7520998148927 1332.0352851220723 1338.3184704292519 1344.6016557364314 1350.884841043611 1357.1680263507906 1363.4512116579701 1369.7343969651497 1376.0175822723295 1382.300767579509 1388.5839528866886 1394.8671381938682 1401.1503235010478 1407.4335088082273 1413.7166941154069 1419.9998794225864 1426.283064729766 1432.5662500369456 1438.8494353441251 1445.132620651305 1451.4158059584845 1457.698991265664 1463.9821765728436 1470.2653618800232 1476.5485471872028 1482.8317324943823 1489.114917801562 1495.3981031087415 1501.681288415921 1507.9644737231006 1514.2476590302804 1520.53084433746 1526.8140296446395 1533.097214951819 1539.3804002589986 1545.6635855661782 1551.9467708733578 1558.2299561805373 1564.513141487717 1570.7963267948965 1577.0795121020763 1583.3626974092558 1589.6458827164354 1595.929068023615 1602.2122533307945 1608.495438637974 1614.7786239451536 1621.0618092523332 1627.3449945595128 1633.6281798666923 1639.911365173872 1646.1945504810517 1652.4777357882313 1658.7609210954108 1665.0441064025904 1671.32729170977 1677.6104770169495 1683.893662324129 1690.1768476313086 1696.4600329384882 1702.7432182456678 1709.0264035528476 1715.3095888600271 1721.5927741672067 1727.8759594743863 1734.1591447815658 1740.4423300887454 1746.725515395925 1753.0087007031045 1759.291886010284 1765.5750713174637 1771.8582566246432 1778.141441931823 1784.4246272390026 1790.7078125461821 1796.9909978533617 1803.2741831605413 1809.5573684677208 1815.8405537749004 1822.12373908208 1828.4069243892595 1834.690109696439 1840.9732950036187 1847.2564803107985 1853.539665617978 1859.8228509251576 1866.1060362323371 1872.3892215395167 1878.6724068466963 1884.9555921538758 1891.2387774610554 1897.521962768235 1903.8051480754145 1910.088333382594 1916.371518689774 1922.6547039969535 1928.937889304133 1935.2210746113126 1941.5042599184922 1947.7874452256717 1954.0706305328513 1960.3538158400308 1966.6370011472104 1972.92018645439 1979.2033717615698 1985.4865570687493 1991.769742375929 1998.0529276831085 2004.336112990288 2010.6192982974676 2016.9024836046472 2023.1856689118267 2029.4688542190063 2035.7520395261859 2042.0352248333654 2048.318410140545 2054.601595447725 2060.884780754904 2067.167966062084 2073.4511513692632 2079.734336676443 2086.017521983623 2092.300707290802 2098.583892597982 2104.8670779051613 2111.150263212341 2117.4334485195204 2123.7166338267 2129.9998191338796 2136.2830044410593 2142.5661897482387 2148.8493750554185 2155.1325603625983 2161.4157456697776 2167.6989309769574 2173.9821162841367 2180.2653015913165 2186.548486898496 2192.8316722056757 2199.114857512855 2205.398042820035 2211.681228127214 2217.964413434394 2224.2475987415737 2230.530784048753 2236.813969355933 2243.097154663112 2249.380339970292 2255.6635252774713 2261.946710584651 2268.2298958918304 2274.5130811990102 2280.79626650619 2287.0794518133694 2293.362637120549 2299.6458224277285 2305.9290077349083 2312.2121930420876 2318.4953783492674 2324.7785636564467 2331.0617489636265 2337.344934270806 2343.6281195779857 2349.9113048851655 2356.194490192345 2362.4776754995246 2368.760860806704 2375.0440461138837 2381.327231421063 2387.610416728243 2393.893602035422 2400.176787342602 2406.4599726497813 2412.743157956961 2419.026343264141 2425.3095285713202 2431.5927138785 2437.8758991856794 2444.159084492859 2450.4422698000385 2456.7254551072183 2463.0086404143976 2469.2918257215774 2475.5750110287568 2481.8581963359366 2488.1413816431163 2494.4245669502957 2500.7077522574755 2506.990937564655 2513.2741228718346 2519.557308179014 2525.8404934861937 2532.123678793373 2538.406864100553 2544.690049407732 2550.973234714912 2557.256420022092 2563.539605329271 2569.822790636451 2576.1059759436303 2582.38916125081 2588.6723465579894 2594.955531865169 2601.2387171723485 2607.5219024795283 2613.805087786708 2620.0882730938874 2626.3714584010672 2632.6546437082466 2638.9378290154264 2645.2210143226057 2651.5041996297855 2657.787384936965 2664.0705702441446 2670.353755551324 2676.6369408585037 2682.9201261656835 2689.203311472863 2695.4864967800427 2701.769682087222 2708.052867394402 2714.336052701581 2720.619238008761 2726.9024233159403 2733.18560862312 2739.4687939302994 2745.751979237479 2752.035164544659 2758.3183498518383 2764.601535159018 2770.8847204661975 2777.1679057733772 2783.4510910805566 2789.7342763877364 2796.0174616949157 2802.3006470020955 2808.583832309275 2814.8670176164546 2821.1502029236344 2827.4333882308138 2833.7165735379936 2839.999758845173 2846.2829441523527 2852.566129459532 2858.849314766712 2865.132500073891 2871.415685381071 2877.6988706882503 2883.98205599543 2890.26524130261 2896.548426609789 2902.831611916969 2909.1147972241483 2915.397982531328 2921.6811678385075 2927.9643531456873 2934.2475384528666 2940.5307237600464 2946.8139090672257 2953.0970943744055 2959.3802796815853 2965.6634649887646 2971.9466502959444 2978.229835603124 2984.5130209103036 2990.796206217483 2997.0793915246627 3003.362576831842 3009.645762139022 3015.928947446201 3022.212132753381 3028.4953180605607 3034.77850336774 3041.06168867492 3047.344873982099 3053.628059289279 3059.9112445964583 3066.194429903638 3072.4776152108175 3078.7608005179973 3085.043985825177 3091.3271711323564 3097.610356439536 3103.8935417467155 3110.1767270538953 3116.4599123610747 3122.7430976682544 3129.026282975434 3135.3094682826136
Jupyter defterlerinde In tüm girdilerin (inputs), Out ise çıktıların tutulduğu birer Python listesidir. İstenen girdi ya da çıktı istendiği vakit ekrana getirilebilir ya da üzerinde işlem yapılabilir.
print(In[1])
v0 = 5 # Ilk hiz m/s t = 0.6 # zaman s g = 9.81 # yercekimi ivmesi m/s**2 y = v0*t - 0.5*g*t**2 print(y)
x = 2.0
y = 2*x**2 - 2*x + 4
y
8.0
print(Out[23]) # Sizde 25. output olmayabilir, dogru sayiyla calistiriniz
8.0
Out[23]*3*x**2
96.0
print() son çıktıyı, print() bir öncekini, and print() ondan öncekini ... verir
print(_)
print(__)
96.0 8.0
Out[25] için bir kısa yol _25 yazmaktır.
import math
_25-math.sin(math.pi/2)
95.0
Sonuna ";" işareti koyduğunuz kod bloğu çalışır ama ekrana çıktı vermez. Bu yapıyı sıklıkla kullanmanız gerekebileceğinden öğrenmenizde fayda vardır.
math.sin(2) + math.cos(2);
Bu durumda bu satırın vereceği çıktıya da Out[x] ile (ya da _x ile) erişmek mümkün değildir.
Out[27] # Bir önceki kod satiri hangi sayiya sahipse onu kullaniniz
95.0
%history ilgili Jupyter defterinde çalıştırılmış kod bloklarının numaralarını almak için kullanılabilir.
%history -n 20-23
20:
for i in range(60):
print(i)
21:
from math import pi
for r in range(500):
print(2*pi*r)
22: print(In[1])
23:
x = 2.0
y = 2*x**2 - 2*x + 4
y
Bu derste ihtiyaç duyulacak temel Python programlama bilgisi Ankara Üniversitesi Fen Fakültesi Astronomi ve Uzay Bilimleri Bölümü 4. sınıf seçmeli dersi AST415 Astronomide Sayısal Çözümleme-I dersinde verilmektedir. Bu derse başlamadan önce AST415'in internet sayfasına eriştikten sonra ders notlarını indirmeniz, anlayarak okumanız, kod yazarak çalışmanız, alıştırmalarını ve ödev sorularını yapıp cevaplarıyla karşılaştırmanız önerilir. Bu nedenle 800100715151 Astronomide Veritabanları dersini alacak tüm yüksek lisans / doktora öğrencilerine bu çalışmayı ders başlamadan yapmalarını öneriyoruz. İdealinde bu dersi AST415 almış ya da bir başka şekilde Python diliyle programlamaya aşina öğrencilerin almasıdır. Ancak yüksek lisans derslerine önkoşul koyamadığımız için programlama bilgisi yeterli olmayan öğrencilerimize AST415 notlarına iyi çalışmalarını önermekle yetiniyoruz. Aşağıda seçilmiş 8 soru 1. ödev olarak verilmiştir. Bu ödevi anlayarak yapabiliyor olmanız durumunda bu dersin gerektirdiği Python programlama bilgisinin asgari düzeyine sahip olduğunuz varsayılabilir.
Bu derste sıkça kullanacağımız numpy ve scipy paketleri için ise özel bir girişe ihtiyaç duyduk. Bu paketleri özet olarak anlatırken Python'la ilgili bazı temel yapıları da tekrar görmenizi, hatırlamanızı ve daha iyi öğrenmenizi de amaçladık.
Numpy, Python için temel bilimsel fonksiyonların bulunduğu bir pakettir. Sağladığı N-boyutlu dizi nesnesi yardımıyla matematiksel işlemler ve fonksiyonların uygulanmasını kolaylaştırır ve lineer cebirden Fourier dönüşümlerine kadar pek çok konuda gelişmiş fonksiyonlar sunar.
Bu işlemleri optimize gerçekleştirebilmesi için numpy'ın temel nesnesi olan dizi nesnesi, listelerden farklı olarak aynı tür (float) veri içerir ve sabit uzunlukta tanımlanır. Aritmetik işlemlerin ve vektörel (diziler üzerinde işlem yapmak üzere) tanımlanmış fonksiyonların döngü tanımlanmaksızın tek bir kerede uygulanmasını sağlaması itibarı ile ayrıca pratiktir.
Bir numpy dizisi oluşturmak için sıklıkla kullanılan iki fonksiyon bulunmaktadır; npp.arange ve np.linspace. Öncelikle bu iki fonksiyona bakalım.
# Oncelikle numpy modulunu cagiralim (import edelim)
# numpy modulunun standart lakabi np 'dir.
import numpy as np
a = np.arange(0,15,1) # O'dan 15'e (15 haric) 1er aralikli sayilardan olusan dizi
print("a: ", a)
# baslangic noktasinin varsayilan degeri 0, adim buyuklugununki 1 oldugundan
# ayni dizi asagidaki sekilde de tanimlanabilir.
a = np.arange(15)
print("a: ", a)
a: [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14] a: [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
# Linspace'de ise baslangic, son (son dahil) ve adim buyuklugu yerine
# dizide kac eleman istendigi bilgisi saglanir
b = np.linspace(0,9,10)
print("b: ", b)
b: [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
Bir listeyi ya da diziye dönüştürülebilecek herhangi başka bir seriyi (ing. iterable) bir numpy disizine dönüştürmek üzere ise np.array fonksiyonu kullanılır.
liste = [1, 2, 3, 4, 5]
c = np.array(liste)
print("c: ", c)
seri = range(12)
d = np.array(seri)
print("d: ", d)
c: [1 2 3 4 5] d: [ 0 1 2 3 4 5 6 7 8 9 10 11]
Ayrıca ihtiyaca göre (örneğin toplayarak ilerlemek üzere) sıfırlardan (ya da çarparak ilerlemek üzere) birlerden oluşan diziler oluşturmak üzere de sırasıyla np.zeros ve np.ones fonksiyonları kullanılır.
sifirlar = np.zeros(5)
print("5 tane 0'dan olusan dizi:", sifirlar)
birler = np.ones(8)
print("8 tane 1'den olusan dizi: ", birler)
5 tane 0'dan olusan dizi: [0. 0. 0. 0. 0.] 8 tane 1'den olusan dizi: [1. 1. 1. 1. 1. 1. 1. 1.]
np.linspace'e çok benzeyen ancak eşit aralıkları logaritmik olarak düzenleyen bir de np.logspace fonksiyonu bulunmaktadır.
loga = np.logspace(1,5,5)
print("loga : ", loga)
loga : [1.e+01 1.e+02 1.e+03 1.e+04 1.e+05]
Bir fonksiyona dayalı olarak bir numpy dizisi oluşturmak için np.fromfunction fonksiyonunu kullanabilirsiniz.
dizi = np.fromfunction(lambda i, j: i * j, (4, 4), dtype=int)
print(dizi)
[[0 0 0 0] [0 1 2 3] [0 2 4 6] [0 3 6 9]]
numpy'da nümerik dizilerde indeksleme ve dilimleme çok önemli bir fark dışında listelerdekiyle aynı şekilde yapılır. Bu çok önemli fark dilimlerin orjinal dizinin bir kopyası olmayıp gerçekten bir bölümü olmasıdır. Dolayısı ile dilim üzerinde bir değişiklik yapıldığı vakit orjinal dizide de bu dilimin karşılık geldiği elemanlar değişir!. Bazı
a = np.linspace(10,50,9)
print("a: ", a)
# linspace reel sayilardan (float) mutesekkil bir dizi yaratir
print("a[0]: {:.2f}, a[-1]: {:.2f}, a[5]: {:.2f}".format(a[0],a[-1],a[5]))
print("a[:5]: ", a[:5])
print("a[7:]: ", a[7:])
print("a[3:7]: ", a[3:7])
print("a[0:-1:2]: ", a[0:-1:2])
print("a[::4]: ", a[::4])
print("a[1:-1]: ", a[1:-1])
b = a[1:-1]
print("b: ", b)
b[2] = 0.1
print("Yeni b: ", b)
print("a: ", a)
a: [10. 15. 20. 25. 30. 35. 40. 45. 50.] a[0]: 10.00, a[-1]: 50.00, a[5]: 35.00 a[:5]: [10. 15. 20. 25. 30.] a[7:]: [45. 50.] a[3:7]: [25. 30. 35. 40.] a[0:-1:2]: [10. 20. 30. 40.] a[::4]: [10. 30. 50.] a[1:-1]: [15. 20. 25. 30. 35. 40. 45.] b: [15. 20. 25. 30. 35. 40. 45.] Yeni b: [15. 20. 0.1 30. 35. 40. 45. ] a: [10. 15. 20. 0.1 30. 35. 40. 45. 50. ]
Nümerik dizilerde indeksleme ve dilimleme işlemlerinde getirdiği pratik kullanım faydaları açısından $a[range(f:t:i)]$ yapsını incelemek gerekir. Bu yapı $a[f:t:i]$ yapısyla aynıdır ve $a$ dizisinin $f$ indeksinden başlayıp $t$ indeksine kadar ($t$ hariç), $i$ büyüklüğündeki adımlarla elemanlarının alınması ve istenirse değiştirilmesine yarar.
import numpy as np
a = np.linspace(72,79,8)
print("a = ", a)
a[[1,6,7]] = 100 # 1., 6. ve 7. indekslerin değerini 100 yap
print("a[[1,6,7]] = 10 -->", a)
# range 2 ile 8 indeksler arasinda (8 haric) 3er atlayarak indeks degerlerini uretir
a[range(2,8,3)] = -2
print("a[range(2,8,3)] = -2 -->", a)
a = [72. 73. 74. 75. 76. 77. 78. 79.] a[[1,6,7]] = 10 --> [ 72. 100. 74. 75. 76. 77. 100. 100.] a[range(2,8,3)] = -2 --> [ 72. 100. -2. 75. 76. -2. 100. 100.]
Daha da pratik ve oldukça kullanışlı bir indeksleme ve dilimleme yöntemi de boolean ifadelere dayanandır. Aşağıda verilen örneklerde göreceğiniz gibi boolean ifadeler de indeksleme ve dilimleme için kullanılabilir.
import numpy as np
a = np.linspace(-4,5,10)
print("a[a < 0] -->", a[a < 0])
# negatif elemanlari a dizisinin maksimumu degeri yap
a[a < 0] = a.max()
print("a[a < 0] = a.max() -->", a)
# 1., 6. ve 7. indekslerin değerini 10 yap
a[[1,6,7]] = 10
print("a[[1,6,7]] = 10 -->", a)
# a'daki 10lari verilen baska bir diziden sirayla secilen elemanlarla degistir
a[a == 10] = [10, 20, 30]
print("a[a == 10] = [10, 20, 30] -->", a)
# a > 2 returns True for elements of a larger than 2 and False otherwise
print(a > 2)
a[a < 0] --> [-4. -3. -2. -1.] a[a < 0] = a.max() --> [5. 5. 5. 5. 0. 1. 2. 3. 4. 5.] a[[1,6,7]] = 10 --> [ 5. 10. 5. 5. 0. 1. 10. 10. 4. 5.] a[a == 10] = [10, 20, 30] --> [ 5. 10. 5. 5. 0. 1. 20. 30. 4. 5.] [ True True True True False False True True True True]
numpy'da çok boyutlu diziler satırları öne alan (row major storage) yapıda saklanır. Aşağıdaki örnekte oluşturan a dizisinin her bir satırının $[ ]$ arasında tutulduğuna, sütunların ise ayrılmadığına dikkat ediniz.
a = np.arange(15).reshape(3,5)
print("a: \n", a)
a: [[ 0 1 2 3 4] [ 5 6 7 8 9] [10 11 12 13 14]]
Dizi içinde belli bir elemanın yerini belirlemek (indekslemek) için aşağıdaki yazım kurallarından herhangi biri kullanılabilir.
print("a[1,2]: ", a[1,2])
print("a[1][2]: ", a[1][2])
a[1,2]: 7 a[1][2]: 7
Benzer bir mantığı takip ederek dilimleme de yapabilirsiniz.
# a dizinin 0 ile 2. satir arasi (2 haric)
# 1 ve 4 sütunlar arasi (4 haric)
print("a[0:2,1:4]: \n",a[0:2,1:4])
a[0:2,1:4]: [[1 2 3] [6 7 8]]
# a dizisinin bastan sona birer atlayarak tum satirlari
# ve son satir haric tum sutunlari
print("a[::2,:-1] \n", a[::2,:-1])
a[::2,:-1] [[ 0 1 2 3] [10 11 12 13]]
Herhangi bir sütuna ulaşmaya çalışırken numpy'ın satırı öncelediği akılda tutulmalıdır.
print("a[:,2]: ", a[:,2])
a[:,2]: [ 2 7 12]
Satırları tek tek yazdırmak için bir for döngüsü kullanmak isteyebilirsiniz ancak önerilen Python dizilerini eleman eleman ya da satır satır taramak için döngüleri kullanmanız yerine dilimleri kullanmanızdır, çünkü bu yol çok daha hızlıdır.
# Satir uzerinden ilerleme
i = 1
for satir in a:
print("{:d}.satir: {:s}".format(i, str(satir)))
i += 1
# Sutun uzerinden ilerleme
for j in range(a.shape[1]):
print("{:d}.sutun: {:s}".format(j, str(a[:,j])))
j += 1
1.satir: [0 1 2 3 4] 2.satir: [5 6 7 8 9] 3.satir: [10 11 12 13 14] 0.sutun: [ 0 5 10] 1.sutun: [ 1 6 11] 2.sutun: [ 2 7 12] 3.sutun: [ 3 8 13] 4.sutun: [ 4 9 14]
Bir numpy dizisi üzerine tanılanmış pek çok metot bulunmakla birlikte sıklıkla kullanılanları aşağıda örneklenmiştir.
a = np.arange(15)
print("a dizisinin boyutu: ", a.ndim)
print("a dizisinin sekli: ",a.shape)
print("a dizisinin eleman sayisi: ",a.size)
print("a dizisinin elemanlarinin turu: ",a.dtype)
print("a dizisinin eleman buyuklugu:b ",a.itemsize)
print("a dizisinin turu: ", type(a))
a dizisinin boyutu: 1 a dizisinin sekli: (15,) a dizisinin eleman sayisi: 15 a dizisinin elemanlarinin turu: int64 a dizisinin eleman buyuklugu:b 8 a dizisinin turu: <class 'numpy.ndarray'>
Ayrıca diziler ve üzerinde yapabileceğiniz işlemler ve tanımlı metotlar hakkında daha fazla bilgi almak için help fonksiyonundan faydalanabilirsiniz.
help(a)
Help on ndarray object:
class ndarray(builtins.object)
| ndarray(shape, dtype=float, buffer=None, offset=0,
| strides=None, order=None)
|
| An array object represents a multidimensional, homogeneous array
| of fixed-size items. An associated data-type object describes the
| format of each element in the array (its byte-order, how many bytes it
| occupies in memory, whether it is an integer, a floating point number,
| or something else, etc.)
|
| Arrays should be constructed using `array`, `zeros` or `empty` (refer
| to the See Also section below). The parameters given here refer to
| a low-level method (`ndarray(...)`) for instantiating an array.
|
| For more information, refer to the `numpy` module and examine the
| methods and attributes of an array.
|
| Parameters
| ----------
| (for the __new__ method; see Notes below)
|
| shape : tuple of ints
| Shape of created array.
| dtype : data-type, optional
| Any object that can be interpreted as a numpy data type.
| buffer : object exposing buffer interface, optional
| Used to fill the array with data.
| offset : int, optional
| Offset of array data in buffer.
| strides : tuple of ints, optional
| Strides of data in memory.
| order : {'C', 'F'}, optional
| Row-major (C-style) or column-major (Fortran-style) order.
|
| Attributes
| ----------
| T : ndarray
| Transpose of the array.
| data : buffer
| The array's elements, in memory.
| dtype : dtype object
| Describes the format of the elements in the array.
| flags : dict
| Dictionary containing information related to memory use, e.g.,
| 'C_CONTIGUOUS', 'OWNDATA', 'WRITEABLE', etc.
| flat : numpy.flatiter object
| Flattened version of the array as an iterator. The iterator
| allows assignments, e.g., ``x.flat = 3`` (See `ndarray.flat` for
| assignment examples; TODO).
| imag : ndarray
| Imaginary part of the array.
| real : ndarray
| Real part of the array.
| size : int
| Number of elements in the array.
| itemsize : int
| The memory use of each array element in bytes.
| nbytes : int
| The total number of bytes required to store the array data,
| i.e., ``itemsize * size``.
| ndim : int
| The array's number of dimensions.
| shape : tuple of ints
| Shape of the array.
| strides : tuple of ints
| The step-size required to move from one element to the next in
| memory. For example, a contiguous ``(3, 4)`` array of type
| ``int16`` in C-order has strides ``(8, 2)``. This implies that
| to move from element to element in memory requires jumps of 2 bytes.
| To move from row-to-row, one needs to jump 8 bytes at a time
| (``2 * 4``).
| ctypes : ctypes object
| Class containing properties of the array needed for interaction
| with ctypes.
| base : ndarray
| If the array is a view into another array, that array is its `base`
| (unless that array is also a view). The `base` array is where the
| array data is actually stored.
|
| See Also
| --------
| array : Construct an array.
| zeros : Create an array, each element of which is zero.
| empty : Create an array, but leave its allocated memory unchanged (i.e.,
| it contains "garbage").
| dtype : Create a data-type.
|
| Notes
| -----
| There are two modes of creating an array using ``__new__``:
|
| 1. If `buffer` is None, then only `shape`, `dtype`, and `order`
| are used.
| 2. If `buffer` is an object exposing the buffer interface, then
| all keywords are interpreted.
|
| No ``__init__`` method is needed because the array is fully initialized
| after the ``__new__`` method.
|
| Examples
| --------
| These examples illustrate the low-level `ndarray` constructor. Refer
| to the `See Also` section above for easier ways of constructing an
| ndarray.
|
| First mode, `buffer` is None:
|
| >>> np.ndarray(shape=(2,2), dtype=float, order='F')
| array([[0.0e+000, 0.0e+000], # random
| [ nan, 2.5e-323]])
|
| Second mode:
|
| >>> np.ndarray((2,), buffer=np.array([1,2,3]),
| ... offset=np.int_().itemsize,
| ... dtype=int) # offset = 1*itemsize, i.e. skip first element
| array([2, 3])
|
| Methods defined here:
|
| __abs__(self, /)
| abs(self)
|
| __add__(self, value, /)
| Return self+value.
|
| __and__(self, value, /)
| Return self&value.
|
| __array__(...)
| a.__array__([dtype], /) -> reference if type unchanged, copy otherwise.
|
| Returns either a new reference to self if dtype is not given or a new array
| of provided data type if dtype is different from the current dtype of the
| array.
|
| __array_function__(...)
|
| __array_prepare__(...)
| a.__array_prepare__(obj) -> Object of same type as ndarray object obj.
|
| __array_ufunc__(...)
|
| __array_wrap__(...)
| a.__array_wrap__(obj) -> Object of same type as ndarray object a.
|
| __bool__(self, /)
| self != 0
|
| __complex__(...)
|
| __contains__(self, key, /)
| Return key in self.
|
| __copy__(...)
| a.__copy__()
|
| Used if :func:`copy.copy` is called on an array. Returns a copy of the array.
|
| Equivalent to ``a.copy(order='K')``.
|
| __deepcopy__(...)
| a.__deepcopy__(memo, /) -> Deep copy of array.
|
| Used if :func:`copy.deepcopy` is called on an array.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __divmod__(self, value, /)
| Return divmod(self, value).
|
| __eq__(self, value, /)
| Return self==value.
|
| __float__(self, /)
| float(self)
|
| __floordiv__(self, value, /)
| Return self//value.
|
| __format__(...)
| Default object formatter.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __iadd__(self, value, /)
| Return self+=value.
|
| __iand__(self, value, /)
| Return self&=value.
|
| __ifloordiv__(self, value, /)
| Return self//=value.
|
| __ilshift__(self, value, /)
| Return self<<=value.
|
| __imatmul__(self, value, /)
| Return self@=value.
|
| __imod__(self, value, /)
| Return self%=value.
|
| __imul__(self, value, /)
| Return self*=value.
|
| __index__(self, /)
| Return self converted to an integer, if self is suitable for use as an index into a list.
|
| __int__(self, /)
| int(self)
|
| __invert__(self, /)
| ~self
|
| __ior__(self, value, /)
| Return self|=value.
|
| __ipow__(self, value, /)
| Return self**=value.
|
| __irshift__(self, value, /)
| Return self>>=value.
|
| __isub__(self, value, /)
| Return self-=value.
|
| __iter__(self, /)
| Implement iter(self).
|
| __itruediv__(self, value, /)
| Return self/=value.
|
| __ixor__(self, value, /)
| Return self^=value.
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lshift__(self, value, /)
| Return self<<value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __matmul__(self, value, /)
| Return self@value.
|
| __mod__(self, value, /)
| Return self%value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __neg__(self, /)
| -self
|
| __or__(self, value, /)
| Return self|value.
|
| __pos__(self, /)
| +self
|
| __pow__(self, value, mod=None, /)
| Return pow(self, value, mod).
|
| __radd__(self, value, /)
| Return value+self.
|
| __rand__(self, value, /)
| Return value&self.
|
| __rdivmod__(self, value, /)
| Return divmod(value, self).
|
| __reduce__(...)
| a.__reduce__()
|
| For pickling.
|
| __reduce_ex__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __rfloordiv__(self, value, /)
| Return value//self.
|
| __rlshift__(self, value, /)
| Return value<<self.
|
| __rmatmul__(self, value, /)
| Return value@self.
|
| __rmod__(self, value, /)
| Return value%self.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __ror__(self, value, /)
| Return value|self.
|
| __rpow__(self, value, mod=None, /)
| Return pow(value, self, mod).
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| __rsub__(self, value, /)
| Return value-self.
|
| __rtruediv__(self, value, /)
| Return value/self.
|
| __rxor__(self, value, /)
| Return value^self.
|
| __setitem__(self, key, value, /)
| Set self[key] to value.
|
| __setstate__(...)
| a.__setstate__(state, /)
|
| For unpickling.
|
| The `state` argument must be a sequence that contains the following
| elements:
|
| Parameters
| ----------
| version : int
| optional pickle version. If omitted defaults to 0.
| shape : tuple
| dtype : data-type
| isFortran : bool
| rawdata : string or list
| a binary string with the data (or a list if 'a' is an object array)
|
| __sizeof__(...)
| Size of object in memory, in bytes.
|
| __str__(self, /)
| Return str(self).
|
| __sub__(self, value, /)
| Return self-value.
|
| __truediv__(self, value, /)
| Return self/value.
|
| __xor__(self, value, /)
| Return self^value.
|
| all(...)
| a.all(axis=None, out=None, keepdims=False, *, where=True)
|
| Returns True if all elements evaluate to True.
|
| Refer to `numpy.all` for full documentation.
|
| See Also
| --------
| numpy.all : equivalent function
|
| any(...)
| a.any(axis=None, out=None, keepdims=False, *, where=True)
|
| Returns True if any of the elements of `a` evaluate to True.
|
| Refer to `numpy.any` for full documentation.
|
| See Also
| --------
| numpy.any : equivalent function
|
| argmax(...)
| a.argmax(axis=None, out=None)
|
| Return indices of the maximum values along the given axis.
|
| Refer to `numpy.argmax` for full documentation.
|
| See Also
| --------
| numpy.argmax : equivalent function
|
| argmin(...)
| a.argmin(axis=None, out=None)
|
| Return indices of the minimum values along the given axis.
|
| Refer to `numpy.argmin` for detailed documentation.
|
| See Also
| --------
| numpy.argmin : equivalent function
|
| argpartition(...)
| a.argpartition(kth, axis=-1, kind='introselect', order=None)
|
| Returns the indices that would partition this array.
|
| Refer to `numpy.argpartition` for full documentation.
|
| .. versionadded:: 1.8.0
|
| See Also
| --------
| numpy.argpartition : equivalent function
|
| argsort(...)
| a.argsort(axis=-1, kind=None, order=None)
|
| Returns the indices that would sort this array.
|
| Refer to `numpy.argsort` for full documentation.
|
| See Also
| --------
| numpy.argsort : equivalent function
|
| astype(...)
| a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)
|
| Copy of the array, cast to a specified type.
|
| Parameters
| ----------
| dtype : str or dtype
| Typecode or data-type to which the array is cast.
| order : {'C', 'F', 'A', 'K'}, optional
| Controls the memory layout order of the result.
| 'C' means C order, 'F' means Fortran order, 'A'
| means 'F' order if all the arrays are Fortran contiguous,
| 'C' order otherwise, and 'K' means as close to the
| order the array elements appear in memory as possible.
| Default is 'K'.
| casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
| Controls what kind of data casting may occur. Defaults to 'unsafe'
| for backwards compatibility.
|
| * 'no' means the data types should not be cast at all.
| * 'equiv' means only byte-order changes are allowed.
| * 'safe' means only casts which can preserve values are allowed.
| * 'same_kind' means only safe casts or casts within a kind,
| like float64 to float32, are allowed.
| * 'unsafe' means any data conversions may be done.
| subok : bool, optional
| If True, then sub-classes will be passed-through (default), otherwise
| the returned array will be forced to be a base-class array.
| copy : bool, optional
| By default, astype always returns a newly allocated array. If this
| is set to false, and the `dtype`, `order`, and `subok`
| requirements are satisfied, the input array is returned instead
| of a copy.
|
| Returns
| -------
| arr_t : ndarray
| Unless `copy` is False and the other conditions for returning the input
| array are satisfied (see description for `copy` input parameter), `arr_t`
| is a new array of the same shape as the input array, with dtype, order
| given by `dtype`, `order`.
|
| Notes
| -----
| .. versionchanged:: 1.17.0
| Casting between a simple data type and a structured one is possible only
| for "unsafe" casting. Casting to multiple fields is allowed, but
| casting from multiple fields is not.
|
| .. versionchanged:: 1.9.0
| Casting from numeric to string types in 'safe' casting mode requires
| that the string dtype length is long enough to store the max
| integer/float value converted.
|
| Raises
| ------
| ComplexWarning
| When casting from complex to float or int. To avoid this,
| one should use ``a.real.astype(t)``.
|
| Examples
| --------
| >>> x = np.array([1, 2, 2.5])
| >>> x
| array([1. , 2. , 2.5])
|
| >>> x.astype(int)
| array([1, 2, 2])
|
| byteswap(...)
| a.byteswap(inplace=False)
|
| Swap the bytes of the array elements
|
| Toggle between low-endian and big-endian data representation by
| returning a byteswapped array, optionally swapped in-place.
| Arrays of byte-strings are not swapped. The real and imaginary
| parts of a complex number are swapped individually.
|
| Parameters
| ----------
| inplace : bool, optional
| If ``True``, swap bytes in-place, default is ``False``.
|
| Returns
| -------
| out : ndarray
| The byteswapped array. If `inplace` is ``True``, this is
| a view to self.
|
| Examples
| --------
| >>> A = np.array([1, 256, 8755], dtype=np.int16)
| >>> list(map(hex, A))
| ['0x1', '0x100', '0x2233']
| >>> A.byteswap(inplace=True)
| array([ 256, 1, 13090], dtype=int16)
| >>> list(map(hex, A))
| ['0x100', '0x1', '0x3322']
|
| Arrays of byte-strings are not swapped
|
| >>> A = np.array([b'ceg', b'fac'])
| >>> A.byteswap()
| array([b'ceg', b'fac'], dtype='|S3')
|
| ``A.newbyteorder().byteswap()`` produces an array with the same values
| but different representation in memory
|
| >>> A = np.array([1, 2, 3])
| >>> A.view(np.uint8)
| array([1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0,
| 0, 0], dtype=uint8)
| >>> A.newbyteorder().byteswap(inplace=True)
| array([1, 2, 3])
| >>> A.view(np.uint8)
| array([0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0,
| 0, 3], dtype=uint8)
|
| choose(...)
| a.choose(choices, out=None, mode='raise')
|
| Use an index array to construct a new array from a set of choices.
|
| Refer to `numpy.choose` for full documentation.
|
| See Also
| --------
| numpy.choose : equivalent function
|
| clip(...)
| a.clip(min=None, max=None, out=None, **kwargs)
|
| Return an array whose values are limited to ``[min, max]``.
| One of max or min must be given.
|
| Refer to `numpy.clip` for full documentation.
|
| See Also
| --------
| numpy.clip : equivalent function
|
| compress(...)
| a.compress(condition, axis=None, out=None)
|
| Return selected slices of this array along given axis.
|
| Refer to `numpy.compress` for full documentation.
|
| See Also
| --------
| numpy.compress : equivalent function
|
| conj(...)
| a.conj()
|
| Complex-conjugate all elements.
|
| Refer to `numpy.conjugate` for full documentation.
|
| See Also
| --------
| numpy.conjugate : equivalent function
|
| conjugate(...)
| a.conjugate()
|
| Return the complex conjugate, element-wise.
|
| Refer to `numpy.conjugate` for full documentation.
|
| See Also
| --------
| numpy.conjugate : equivalent function
|
| copy(...)
| a.copy(order='C')
|
| Return a copy of the array.
|
| Parameters
| ----------
| order : {'C', 'F', 'A', 'K'}, optional
| Controls the memory layout of the copy. 'C' means C-order,
| 'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
| 'C' otherwise. 'K' means match the layout of `a` as closely
| as possible. (Note that this function and :func:`numpy.copy` are very
| similar, but have different default values for their order=
| arguments.)
|
| See also
| --------
| numpy.copy
| numpy.copyto
|
| Examples
| --------
| >>> x = np.array([[1,2,3],[4,5,6]], order='F')
|
| >>> y = x.copy()
|
| >>> x.fill(0)
|
| >>> x
| array([[0, 0, 0],
| [0, 0, 0]])
|
| >>> y
| array([[1, 2, 3],
| [4, 5, 6]])
|
| >>> y.flags['C_CONTIGUOUS']
| True
|
| cumprod(...)
| a.cumprod(axis=None, dtype=None, out=None)
|
| Return the cumulative product of the elements along the given axis.
|
| Refer to `numpy.cumprod` for full documentation.
|
| See Also
| --------
| numpy.cumprod : equivalent function
|
| cumsum(...)
| a.cumsum(axis=None, dtype=None, out=None)
|
| Return the cumulative sum of the elements along the given axis.
|
| Refer to `numpy.cumsum` for full documentation.
|
| See Also
| --------
| numpy.cumsum : equivalent function
|
| diagonal(...)
| a.diagonal(offset=0, axis1=0, axis2=1)
|
| Return specified diagonals. In NumPy 1.9 the returned array is a
| read-only view instead of a copy as in previous NumPy versions. In
| a future version the read-only restriction will be removed.
|
| Refer to :func:`numpy.diagonal` for full documentation.
|
| See Also
| --------
| numpy.diagonal : equivalent function
|
| dot(...)
| a.dot(b, out=None)
|
| Dot product of two arrays.
|
| Refer to `numpy.dot` for full documentation.
|
| See Also
| --------
| numpy.dot : equivalent function
|
| Examples
| --------
| >>> a = np.eye(2)
| >>> b = np.ones((2, 2)) * 2
| >>> a.dot(b)
| array([[2., 2.],
| [2., 2.]])
|
| This array method can be conveniently chained:
|
| >>> a.dot(b).dot(b)
| array([[8., 8.],
| [8., 8.]])
|
| dump(...)
| a.dump(file)
|
| Dump a pickle of the array to the specified file.
| The array can be read back with pickle.load or numpy.load.
|
| Parameters
| ----------
| file : str or Path
| A string naming the dump file.
|
| .. versionchanged:: 1.17.0
| `pathlib.Path` objects are now accepted.
|
| dumps(...)
| a.dumps()
|
| Returns the pickle of the array as a string.
| pickle.loads or numpy.loads will convert the string back to an array.
|
| Parameters
| ----------
| None
|
| fill(...)
| a.fill(value)
|
| Fill the array with a scalar value.
|
| Parameters
| ----------
| value : scalar
| All elements of `a` will be assigned this value.
|
| Examples
| --------
| >>> a = np.array([1, 2])
| >>> a.fill(0)
| >>> a
| array([0, 0])
| >>> a = np.empty(2)
| >>> a.fill(1)
| >>> a
| array([1., 1.])
|
| flatten(...)
| a.flatten(order='C')
|
| Return a copy of the array collapsed into one dimension.
|
| Parameters
| ----------
| order : {'C', 'F', 'A', 'K'}, optional
| 'C' means to flatten in row-major (C-style) order.
| 'F' means to flatten in column-major (Fortran-
| style) order. 'A' means to flatten in column-major
| order if `a` is Fortran *contiguous* in memory,
| row-major order otherwise. 'K' means to flatten
| `a` in the order the elements occur in memory.
| The default is 'C'.
|
| Returns
| -------
| y : ndarray
| A copy of the input array, flattened to one dimension.
|
| See Also
| --------
| ravel : Return a flattened array.
| flat : A 1-D flat iterator over the array.
|
| Examples
| --------
| >>> a = np.array([[1,2], [3,4]])
| >>> a.flatten()
| array([1, 2, 3, 4])
| >>> a.flatten('F')
| array([1, 3, 2, 4])
|
| getfield(...)
| a.getfield(dtype, offset=0)
|
| Returns a field of the given array as a certain type.
|
| A field is a view of the array data with a given data-type. The values in
| the view are determined by the given type and the offset into the current
| array in bytes. The offset needs to be such that the view dtype fits in the
| array dtype; for example an array of dtype complex128 has 16-byte elements.
| If taking a view with a 32-bit integer (4 bytes), the offset needs to be
| between 0 and 12 bytes.
|
| Parameters
| ----------
| dtype : str or dtype
| The data type of the view. The dtype size of the view can not be larger
| than that of the array itself.
| offset : int
| Number of bytes to skip before beginning the element view.
|
| Examples
| --------
| >>> x = np.diag([1.+1.j]*2)
| >>> x[1, 1] = 2 + 4.j
| >>> x
| array([[1.+1.j, 0.+0.j],
| [0.+0.j, 2.+4.j]])
| >>> x.getfield(np.float64)
| array([[1., 0.],
| [0., 2.]])
|
| By choosing an offset of 8 bytes we can select the complex part of the
| array for our view:
|
| >>> x.getfield(np.float64, offset=8)
| array([[1., 0.],
| [0., 4.]])
|
| item(...)
| a.item(*args)
|
| Copy an element of an array to a standard Python scalar and return it.
|
| Parameters
| ----------
| \*args : Arguments (variable number and type)
|
| * none: in this case, the method only works for arrays
| with one element (`a.size == 1`), which element is
| copied into a standard Python scalar object and returned.
|
| * int_type: this argument is interpreted as a flat index into
| the array, specifying which element to copy and return.
|
| * tuple of int_types: functions as does a single int_type argument,
| except that the argument is interpreted as an nd-index into the
| array.
|
| Returns
| -------
| z : Standard Python scalar object
| A copy of the specified element of the array as a suitable
| Python scalar
|
| Notes
| -----
| When the data type of `a` is longdouble or clongdouble, item() returns
| a scalar array object because there is no available Python scalar that
| would not lose information. Void arrays return a buffer object for item(),
| unless fields are defined, in which case a tuple is returned.
|
| `item` is very similar to a[args], except, instead of an array scalar,
| a standard Python scalar is returned. This can be useful for speeding up
| access to elements of the array and doing arithmetic on elements of the
| array using Python's optimized math.
|
| Examples
| --------
| >>> np.random.seed(123)
| >>> x = np.random.randint(9, size=(3, 3))
| >>> x
| array([[2, 2, 6],
| [1, 3, 6],
| [1, 0, 1]])
| >>> x.item(3)
| 1
| >>> x.item(7)
| 0
| >>> x.item((0, 1))
| 2
| >>> x.item((2, 2))
| 1
|
| itemset(...)
| a.itemset(*args)
|
| Insert scalar into an array (scalar is cast to array's dtype, if possible)
|
| There must be at least 1 argument, and define the last argument
| as *item*. Then, ``a.itemset(*args)`` is equivalent to but faster
| than ``a[args] = item``. The item should be a scalar value and `args`
| must select a single item in the array `a`.
|
| Parameters
| ----------
| \*args : Arguments
| If one argument: a scalar, only used in case `a` is of size 1.
| If two arguments: the last argument is the value to be set
| and must be a scalar, the first argument specifies a single array
| element location. It is either an int or a tuple.
|
| Notes
| -----
| Compared to indexing syntax, `itemset` provides some speed increase
| for placing a scalar into a particular location in an `ndarray`,
| if you must do this. However, generally this is discouraged:
| among other problems, it complicates the appearance of the code.
| Also, when using `itemset` (and `item`) inside a loop, be sure
| to assign the methods to a local variable to avoid the attribute
| look-up at each loop iteration.
|
| Examples
| --------
| >>> np.random.seed(123)
| >>> x = np.random.randint(9, size=(3, 3))
| >>> x
| array([[2, 2, 6],
| [1, 3, 6],
| [1, 0, 1]])
| >>> x.itemset(4, 0)
| >>> x.itemset((2, 2), 9)
| >>> x
| array([[2, 2, 6],
| [1, 0, 6],
| [1, 0, 9]])
|
| max(...)
| a.max(axis=None, out=None, keepdims=False, initial=<no value>, where=True)
|
| Return the maximum along a given axis.
|
| Refer to `numpy.amax` for full documentation.
|
| See Also
| --------
| numpy.amax : equivalent function
|
| mean(...)
| a.mean(axis=None, dtype=None, out=None, keepdims=False, *, where=True)
|
| Returns the average of the array elements along given axis.
|
| Refer to `numpy.mean` for full documentation.
|
| See Also
| --------
| numpy.mean : equivalent function
|
| min(...)
| a.min(axis=None, out=None, keepdims=False, initial=<no value>, where=True)
|
| Return the minimum along a given axis.
|
| Refer to `numpy.amin` for full documentation.
|
| See Also
| --------
| numpy.amin : equivalent function
|
| newbyteorder(...)
| arr.newbyteorder(new_order='S', /)
|
| Return the array with the same data viewed with a different byte order.
|
| Equivalent to::
|
| arr.view(arr.dtype.newbytorder(new_order))
|
| Changes are also made in all fields and sub-arrays of the array data
| type.
|
|
|
| Parameters
| ----------
| new_order : string, optional
| Byte order to force; a value from the byte order specifications
| below. `new_order` codes can be any of:
|
| * 'S' - swap dtype from current to opposite endian
| * {'<', 'little'} - little endian
| * {'>', 'big'} - big endian
| * '=' - native order, equivalent to `sys.byteorder`
| * {'|', 'I'} - ignore (no change to byte order)
|
| The default value ('S') results in swapping the current
| byte order.
|
|
| Returns
| -------
| new_arr : array
| New array object with the dtype reflecting given change to the
| byte order.
|
| nonzero(...)
| a.nonzero()
|
| Return the indices of the elements that are non-zero.
|
| Refer to `numpy.nonzero` for full documentation.
|
| See Also
| --------
| numpy.nonzero : equivalent function
|
| partition(...)
| a.partition(kth, axis=-1, kind='introselect', order=None)
|
| Rearranges the elements in the array in such a way that the value of the
| element in kth position is in the position it would be in a sorted array.
| All elements smaller than the kth element are moved before this element and
| all equal or greater are moved behind it. The ordering of the elements in
| the two partitions is undefined.
|
| .. versionadded:: 1.8.0
|
| Parameters
| ----------
| kth : int or sequence of ints
| Element index to partition by. The kth element value will be in its
| final sorted position and all smaller elements will be moved before it
| and all equal or greater elements behind it.
| The order of all elements in the partitions is undefined.
| If provided with a sequence of kth it will partition all elements
| indexed by kth of them into their sorted position at once.
| axis : int, optional
| Axis along which to sort. Default is -1, which means sort along the
| last axis.
| kind : {'introselect'}, optional
| Selection algorithm. Default is 'introselect'.
| order : str or list of str, optional
| When `a` is an array with fields defined, this argument specifies
| which fields to compare first, second, etc. A single field can
| be specified as a string, and not all fields need to be specified,
| but unspecified fields will still be used, in the order in which
| they come up in the dtype, to break ties.
|
| See Also
| --------
| numpy.partition : Return a parititioned copy of an array.
| argpartition : Indirect partition.
| sort : Full sort.
|
| Notes
| -----
| See ``np.partition`` for notes on the different algorithms.
|
| Examples
| --------
| >>> a = np.array([3, 4, 2, 1])
| >>> a.partition(3)
| >>> a
| array([2, 1, 3, 4])
|
| >>> a.partition((1, 3))
| >>> a
| array([1, 2, 3, 4])
|
| prod(...)
| a.prod(axis=None, dtype=None, out=None, keepdims=False, initial=1, where=True)
|
| Return the product of the array elements over the given axis
|
| Refer to `numpy.prod` for full documentation.
|
| See Also
| --------
| numpy.prod : equivalent function
|
| ptp(...)
| a.ptp(axis=None, out=None, keepdims=False)
|
| Peak to peak (maximum - minimum) value along a given axis.
|
| Refer to `numpy.ptp` for full documentation.
|
| See Also
| --------
| numpy.ptp : equivalent function
|
| put(...)
| a.put(indices, values, mode='raise')
|
| Set ``a.flat[n] = values[n]`` for all `n` in indices.
|
| Refer to `numpy.put` for full documentation.
|
| See Also
| --------
| numpy.put : equivalent function
|
| ravel(...)
| a.ravel([order])
|
| Return a flattened array.
|
| Refer to `numpy.ravel` for full documentation.
|
| See Also
| --------
| numpy.ravel : equivalent function
|
| ndarray.flat : a flat iterator on the array.
|
| repeat(...)
| a.repeat(repeats, axis=None)
|
| Repeat elements of an array.
|
| Refer to `numpy.repeat` for full documentation.
|
| See Also
| --------
| numpy.repeat : equivalent function
|
| reshape(...)
| a.reshape(shape, order='C')
|
| Returns an array containing the same data with a new shape.
|
| Refer to `numpy.reshape` for full documentation.
|
| See Also
| --------
| numpy.reshape : equivalent function
|
| Notes
| -----
| Unlike the free function `numpy.reshape`, this method on `ndarray` allows
| the elements of the shape parameter to be passed in as separate arguments.
| For example, ``a.reshape(10, 11)`` is equivalent to
| ``a.reshape((10, 11))``.
|
| resize(...)
| a.resize(new_shape, refcheck=True)
|
| Change shape and size of array in-place.
|
| Parameters
| ----------
| new_shape : tuple of ints, or `n` ints
| Shape of resized array.
| refcheck : bool, optional
| If False, reference count will not be checked. Default is True.
|
| Returns
| -------
| None
|
| Raises
| ------
| ValueError
| If `a` does not own its own data or references or views to it exist,
| and the data memory must be changed.
| PyPy only: will always raise if the data memory must be changed, since
| there is no reliable way to determine if references or views to it
| exist.
|
| SystemError
| If the `order` keyword argument is specified. This behaviour is a
| bug in NumPy.
|
| See Also
| --------
| resize : Return a new array with the specified shape.
|
| Notes
| -----
| This reallocates space for the data area if necessary.
|
| Only contiguous arrays (data elements consecutive in memory) can be
| resized.
|
| The purpose of the reference count check is to make sure you
| do not use this array as a buffer for another Python object and then
| reallocate the memory. However, reference counts can increase in
| other ways so if you are sure that you have not shared the memory
| for this array with another Python object, then you may safely set
| `refcheck` to False.
|
| Examples
| --------
| Shrinking an array: array is flattened (in the order that the data are
| stored in memory), resized, and reshaped:
|
| >>> a = np.array([[0, 1], [2, 3]], order='C')
| >>> a.resize((2, 1))
| >>> a
| array([[0],
| [1]])
|
| >>> a = np.array([[0, 1], [2, 3]], order='F')
| >>> a.resize((2, 1))
| >>> a
| array([[0],
| [2]])
|
| Enlarging an array: as above, but missing entries are filled with zeros:
|
| >>> b = np.array([[0, 1], [2, 3]])
| >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
| >>> b
| array([[0, 1, 2],
| [3, 0, 0]])
|
| Referencing an array prevents resizing...
|
| >>> c = a
| >>> a.resize((1, 1))
| Traceback (most recent call last):
| ...
| ValueError: cannot resize an array that references or is referenced ...
|
| Unless `refcheck` is False:
|
| >>> a.resize((1, 1), refcheck=False)
| >>> a
| array([[0]])
| >>> c
| array([[0]])
|
| round(...)
| a.round(decimals=0, out=None)
|
| Return `a` with each element rounded to the given number of decimals.
|
| Refer to `numpy.around` for full documentation.
|
| See Also
| --------
| numpy.around : equivalent function
|
| searchsorted(...)
| a.searchsorted(v, side='left', sorter=None)
|
| Find indices where elements of v should be inserted in a to maintain order.
|
| For full documentation, see `numpy.searchsorted`
|
| See Also
| --------
| numpy.searchsorted : equivalent function
|
| setfield(...)
| a.setfield(val, dtype, offset=0)
|
| Put a value into a specified place in a field defined by a data-type.
|
| Place `val` into `a`'s field defined by `dtype` and beginning `offset`
| bytes into the field.
|
| Parameters
| ----------
| val : object
| Value to be placed in field.
| dtype : dtype object
| Data-type of the field in which to place `val`.
| offset : int, optional
| The number of bytes into the field at which to place `val`.
|
| Returns
| -------
| None
|
| See Also
| --------
| getfield
|
| Examples
| --------
| >>> x = np.eye(3)
| >>> x.getfield(np.float64)
| array([[1., 0., 0.],
| [0., 1., 0.],
| [0., 0., 1.]])
| >>> x.setfield(3, np.int32)
| >>> x.getfield(np.int32)
| array([[3, 3, 3],
| [3, 3, 3],
| [3, 3, 3]], dtype=int32)
| >>> x
| array([[1.0e+000, 1.5e-323, 1.5e-323],
| [1.5e-323, 1.0e+000, 1.5e-323],
| [1.5e-323, 1.5e-323, 1.0e+000]])
| >>> x.setfield(np.eye(3), np.int32)
| >>> x
| array([[1., 0., 0.],
| [0., 1., 0.],
| [0., 0., 1.]])
|
| setflags(...)
| a.setflags(write=None, align=None, uic=None)
|
| Set array flags WRITEABLE, ALIGNED, (WRITEBACKIFCOPY and UPDATEIFCOPY),
| respectively.
|
| These Boolean-valued flags affect how numpy interprets the memory
| area used by `a` (see Notes below). The ALIGNED flag can only
| be set to True if the data is actually aligned according to the type.
| The WRITEBACKIFCOPY and (deprecated) UPDATEIFCOPY flags can never be set
| to True. The flag WRITEABLE can only be set to True if the array owns its
| own memory, or the ultimate owner of the memory exposes a writeable buffer
| interface, or is a string. (The exception for string is made so that
| unpickling can be done without copying memory.)
|
| Parameters
| ----------
| write : bool, optional
| Describes whether or not `a` can be written to.
| align : bool, optional
| Describes whether or not `a` is aligned properly for its type.
| uic : bool, optional
| Describes whether or not `a` is a copy of another "base" array.
|
| Notes
| -----
| Array flags provide information about how the memory area used
| for the array is to be interpreted. There are 7 Boolean flags
| in use, only four of which can be changed by the user:
| WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED.
|
| WRITEABLE (W) the data area can be written to;
|
| ALIGNED (A) the data and strides are aligned appropriately for the hardware
| (as determined by the compiler);
|
| UPDATEIFCOPY (U) (deprecated), replaced by WRITEBACKIFCOPY;
|
| WRITEBACKIFCOPY (X) this array is a copy of some other array (referenced
| by .base). When the C-API function PyArray_ResolveWritebackIfCopy is
| called, the base array will be updated with the contents of this array.
|
| All flags can be accessed using the single (upper case) letter as well
| as the full name.
|
| Examples
| --------
| >>> y = np.array([[3, 1, 7],
| ... [2, 0, 0],
| ... [8, 5, 9]])
| >>> y
| array([[3, 1, 7],
| [2, 0, 0],
| [8, 5, 9]])
| >>> y.flags
| C_CONTIGUOUS : True
| F_CONTIGUOUS : False
| OWNDATA : True
| WRITEABLE : True
| ALIGNED : True
| WRITEBACKIFCOPY : False
| UPDATEIFCOPY : False
| >>> y.setflags(write=0, align=0)
| >>> y.flags
| C_CONTIGUOUS : True
| F_CONTIGUOUS : False
| OWNDATA : True
| WRITEABLE : False
| ALIGNED : False
| WRITEBACKIFCOPY : False
| UPDATEIFCOPY : False
| >>> y.setflags(uic=1)
| Traceback (most recent call last):
| File "<stdin>", line 1, in <module>
| ValueError: cannot set WRITEBACKIFCOPY flag to True
|
| sort(...)
| a.sort(axis=-1, kind=None, order=None)
|
| Sort an array in-place. Refer to `numpy.sort` for full documentation.
|
| Parameters
| ----------
| axis : int, optional
| Axis along which to sort. Default is -1, which means sort along the
| last axis.
| kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
| Sorting algorithm. The default is 'quicksort'. Note that both 'stable'
| and 'mergesort' use timsort under the covers and, in general, the
| actual implementation will vary with datatype. The 'mergesort' option
| is retained for backwards compatibility.
|
| .. versionchanged:: 1.15.0.
| The 'stable' option was added.
|
| order : str or list of str, optional
| When `a` is an array with fields defined, this argument specifies
| which fields to compare first, second, etc. A single field can
| be specified as a string, and not all fields need be specified,
| but unspecified fields will still be used, in the order in which
| they come up in the dtype, to break ties.
|
| See Also
| --------
| numpy.sort : Return a sorted copy of an array.
| numpy.argsort : Indirect sort.
| numpy.lexsort : Indirect stable sort on multiple keys.
| numpy.searchsorted : Find elements in sorted array.
| numpy.partition: Partial sort.
|
| Notes
| -----
| See `numpy.sort` for notes on the different sorting algorithms.
|
| Examples
| --------
| >>> a = np.array([[1,4], [3,1]])
| >>> a.sort(axis=1)
| >>> a
| array([[1, 4],
| [1, 3]])
| >>> a.sort(axis=0)
| >>> a
| array([[1, 3],
| [1, 4]])
|
| Use the `order` keyword to specify a field to use when sorting a
| structured array:
|
| >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
| >>> a.sort(order='y')
| >>> a
| array([(b'c', 1), (b'a', 2)],
| dtype=[('x', 'S1'), ('y', '<i8')])
|
| squeeze(...)
| a.squeeze(axis=None)
|
| Remove axes of length one from `a`.
|
| Refer to `numpy.squeeze` for full documentation.
|
| See Also
| --------
| numpy.squeeze : equivalent function
|
| std(...)
| a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)
|
| Returns the standard deviation of the array elements along given axis.
|
| Refer to `numpy.std` for full documentation.
|
| See Also
| --------
| numpy.std : equivalent function
|
| sum(...)
| a.sum(axis=None, dtype=None, out=None, keepdims=False, initial=0, where=True)
|
| Return the sum of the array elements over the given axis.
|
| Refer to `numpy.sum` for full documentation.
|
| See Also
| --------
| numpy.sum : equivalent function
|
| swapaxes(...)
| a.swapaxes(axis1, axis2)
|
| Return a view of the array with `axis1` and `axis2` interchanged.
|
| Refer to `numpy.swapaxes` for full documentation.
|
| See Also
| --------
| numpy.swapaxes : equivalent function
|
| take(...)
| a.take(indices, axis=None, out=None, mode='raise')
|
| Return an array formed from the elements of `a` at the given indices.
|
| Refer to `numpy.take` for full documentation.
|
| See Also
| --------
| numpy.take : equivalent function
|
| tobytes(...)
| a.tobytes(order='C')
|
| Construct Python bytes containing the raw data bytes in the array.
|
| Constructs Python bytes showing a copy of the raw contents of
| data memory. The bytes object is produced in C-order by default.
| This behavior is controlled by the ``order`` parameter.
|
| .. versionadded:: 1.9.0
|
| Parameters
| ----------
| order : {'C', 'F', 'A'}, optional
| Controls the memory layout of the bytes object. 'C' means C-order,
| 'F' means F-order, 'A' (short for *Any*) means 'F' if `a` is
| Fortran contiguous, 'C' otherwise. Default is 'C'.
|
| Returns
| -------
| s : bytes
| Python bytes exhibiting a copy of `a`'s raw data.
|
| Examples
| --------
| >>> x = np.array([[0, 1], [2, 3]], dtype='<u2')
| >>> x.tobytes()
| b'\x00\x00\x01\x00\x02\x00\x03\x00'
| >>> x.tobytes('C') == x.tobytes()
| True
| >>> x.tobytes('F')
| b'\x00\x00\x02\x00\x01\x00\x03\x00'
|
| tofile(...)
| a.tofile(fid, sep="", format="%s")
|
| Write array to a file as text or binary (default).
|
| Data is always written in 'C' order, independent of the order of `a`.
| The data produced by this method can be recovered using the function
| fromfile().
|
| Parameters
| ----------
| fid : file or str or Path
| An open file object, or a string containing a filename.
|
| .. versionchanged:: 1.17.0
| `pathlib.Path` objects are now accepted.
|
| sep : str
| Separator between array items for text output.
| If "" (empty), a binary file is written, equivalent to
| ``file.write(a.tobytes())``.
| format : str
| Format string for text file output.
| Each entry in the array is formatted to text by first converting
| it to the closest Python type, and then using "format" % item.
|
| Notes
| -----
| This is a convenience function for quick storage of array data.
| Information on endianness and precision is lost, so this method is not a
| good choice for files intended to archive data or transport data between
| machines with different endianness. Some of these problems can be overcome
| by outputting the data as text files, at the expense of speed and file
| size.
|
| When fid is a file object, array contents are directly written to the
| file, bypassing the file object's ``write`` method. As a result, tofile
| cannot be used with files objects supporting compression (e.g., GzipFile)
| or file-like objects that do not support ``fileno()`` (e.g., BytesIO).
|
| tolist(...)
| a.tolist()
|
| Return the array as an ``a.ndim``-levels deep nested list of Python scalars.
|
| Return a copy of the array data as a (nested) Python list.
| Data items are converted to the nearest compatible builtin Python type, via
| the `~numpy.ndarray.item` function.
|
| If ``a.ndim`` is 0, then since the depth of the nested list is 0, it will
| not be a list at all, but a simple Python scalar.
|
| Parameters
| ----------
| none
|
| Returns
| -------
| y : object, or list of object, or list of list of object, or ...
| The possibly nested list of array elements.
|
| Notes
| -----
| The array may be recreated via ``a = np.array(a.tolist())``, although this
| may sometimes lose precision.
|
| Examples
| --------
| For a 1D array, ``a.tolist()`` is almost the same as ``list(a)``,
| except that ``tolist`` changes numpy scalars to Python scalars:
|
| >>> a = np.uint32([1, 2])
| >>> a_list = list(a)
| >>> a_list
| [1, 2]
| >>> type(a_list[0])
| <class 'numpy.uint32'>
| >>> a_tolist = a.tolist()
| >>> a_tolist
| [1, 2]
| >>> type(a_tolist[0])
| <class 'int'>
|
| Additionally, for a 2D array, ``tolist`` applies recursively:
|
| >>> a = np.array([[1, 2], [3, 4]])
| >>> list(a)
| [array([1, 2]), array([3, 4])]
| >>> a.tolist()
| [[1, 2], [3, 4]]
|
| The base case for this recursion is a 0D array:
|
| >>> a = np.array(1)
| >>> list(a)
| Traceback (most recent call last):
| ...
| TypeError: iteration over a 0-d array
| >>> a.tolist()
| 1
|
| tostring(...)
| a.tostring(order='C')
|
| A compatibility alias for `tobytes`, with exactly the same behavior.
|
| Despite its name, it returns `bytes` not `str`\ s.
|
| .. deprecated:: 1.19.0
|
| trace(...)
| a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
|
| Return the sum along diagonals of the array.
|
| Refer to `numpy.trace` for full documentation.
|
| See Also
| --------
| numpy.trace : equivalent function
|
| transpose(...)
| a.transpose(*axes)
|
| Returns a view of the array with axes transposed.
|
| For a 1-D array this has no effect, as a transposed vector is simply the
| same vector. To convert a 1-D array into a 2D column vector, an additional
| dimension must be added. `np.atleast2d(a).T` achieves this, as does
| `a[:, np.newaxis]`.
| For a 2-D array, this is a standard matrix transpose.
| For an n-D array, if axes are given, their order indicates how the
| axes are permuted (see Examples). If axes are not provided and
| ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then
| ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.
|
| Parameters
| ----------
| axes : None, tuple of ints, or `n` ints
|
| * None or no argument: reverses the order of the axes.
|
| * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s
| `i`-th axis becomes `a.transpose()`'s `j`-th axis.
|
| * `n` ints: same as an n-tuple of the same ints (this form is
| intended simply as a "convenience" alternative to the tuple form)
|
| Returns
| -------
| out : ndarray
| View of `a`, with axes suitably permuted.
|
| See Also
| --------
| ndarray.T : Array property returning the array transposed.
| ndarray.reshape : Give a new shape to an array without changing its data.
|
| Examples
| --------
| >>> a = np.array([[1, 2], [3, 4]])
| >>> a
| array([[1, 2],
| [3, 4]])
| >>> a.transpose()
| array([[1, 3],
| [2, 4]])
| >>> a.transpose((1, 0))
| array([[1, 3],
| [2, 4]])
| >>> a.transpose(1, 0)
| array([[1, 3],
| [2, 4]])
|
| var(...)
| a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=True)
|
| Returns the variance of the array elements, along given axis.
|
| Refer to `numpy.var` for full documentation.
|
| See Also
| --------
| numpy.var : equivalent function
|
| view(...)
| a.view([dtype][, type])
|
| New view of array with the same data.
|
| .. note::
| Passing None for ``dtype`` is different from omitting the parameter,
| since the former invokes ``dtype(None)`` which is an alias for
| ``dtype('float_')``.
|
| Parameters
| ----------
| dtype : data-type or ndarray sub-class, optional
| Data-type descriptor of the returned view, e.g., float32 or int16.
| Omitting it results in the view having the same data-type as `a`.
| This argument can also be specified as an ndarray sub-class, which
| then specifies the type of the returned object (this is equivalent to
| setting the ``type`` parameter).
| type : Python type, optional
| Type of the returned view, e.g., ndarray or matrix. Again, omission
| of the parameter results in type preservation.
|
| Notes
| -----
| ``a.view()`` is used two different ways:
|
| ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
| of the array's memory with a different data-type. This can cause a
| reinterpretation of the bytes of memory.
|
| ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
| returns an instance of `ndarray_subclass` that looks at the same array
| (same shape, dtype, etc.) This does not cause a reinterpretation of the
| memory.
|
| For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
| bytes per entry than the previous dtype (for example, converting a
| regular array to a structured array), then the behavior of the view
| cannot be predicted just from the superficial appearance of ``a`` (shown
| by ``print(a)``). It also depends on exactly how ``a`` is stored in
| memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus
| defined as a slice or transpose, etc., the view may give different
| results.
|
|
| Examples
| --------
| >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
|
| Viewing array data using a different type and dtype:
|
| >>> y = x.view(dtype=np.int16, type=np.matrix)
| >>> y
| matrix([[513]], dtype=int16)
| >>> print(type(y))
| <class 'numpy.matrix'>
|
| Creating a view on a structured array so it can be used in calculations
|
| >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
| >>> xv = x.view(dtype=np.int8).reshape(-1,2)
| >>> xv
| array([[1, 2],
| [3, 4]], dtype=int8)
| >>> xv.mean(0)
| array([2., 3.])
|
| Making changes to the view changes the underlying array
|
| >>> xv[0,1] = 20
| >>> x
| array([(1, 20), (3, 4)], dtype=[('a', 'i1'), ('b', 'i1')])
|
| Using a view to convert an array to a recarray:
|
| >>> z = x.view(np.recarray)
| >>> z.a
| array([1, 3], dtype=int8)
|
| Views share data:
|
| >>> x[0] = (9, 10)
| >>> z[0]
| (9, 10)
|
| Views that change the dtype size (bytes per entry) should normally be
| avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
|
| >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)
| >>> y = x[:, 0:2]
| >>> y
| array([[1, 2],
| [4, 5]], dtype=int16)
| >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
| Traceback (most recent call last):
| ...
| ValueError: To change to a dtype of a different size, the array must be C-contiguous
| >>> z = y.copy()
| >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
| array([[(1, 2)],
| [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')])
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| T
| The transposed array.
|
| Same as ``self.transpose()``.
|
| Examples
| --------
| >>> x = np.array([[1.,2.],[3.,4.]])
| >>> x
| array([[ 1., 2.],
| [ 3., 4.]])
| >>> x.T
| array([[ 1., 3.],
| [ 2., 4.]])
| >>> x = np.array([1.,2.,3.,4.])
| >>> x
| array([ 1., 2., 3., 4.])
| >>> x.T
| array([ 1., 2., 3., 4.])
|
| See Also
| --------
| transpose
|
| __array_finalize__
| None.
|
| __array_interface__
| Array protocol: Python side.
|
| __array_priority__
| Array priority.
|
| __array_struct__
| Array protocol: C-struct side.
|
| base
| Base object if memory is from some other object.
|
| Examples
| --------
| The base of an array that owns its memory is None:
|
| >>> x = np.array([1,2,3,4])
| >>> x.base is None
| True
|
| Slicing creates a view, whose memory is shared with x:
|
| >>> y = x[2:]
| >>> y.base is x
| True
|
| ctypes
| An object to simplify the interaction of the array with the ctypes
| module.
|
| This attribute creates an object that makes it easier to use arrays
| when calling shared libraries with the ctypes module. The returned
| object has, among others, data, shape, and strides attributes (see
| Notes below) which themselves return ctypes objects that can be used
| as arguments to a shared library.
|
| Parameters
| ----------
| None
|
| Returns
| -------
| c : Python object
| Possessing attributes data, shape, strides, etc.
|
| See Also
| --------
| numpy.ctypeslib
|
| Notes
| -----
| Below are the public attributes of this object which were documented
| in "Guide to NumPy" (we have omitted undocumented public attributes,
| as well as documented private attributes):
|
| .. autoattribute:: numpy.core._internal._ctypes.data
| :noindex:
|
| .. autoattribute:: numpy.core._internal._ctypes.shape
| :noindex:
|
| .. autoattribute:: numpy.core._internal._ctypes.strides
| :noindex:
|
| .. automethod:: numpy.core._internal._ctypes.data_as
| :noindex:
|
| .. automethod:: numpy.core._internal._ctypes.shape_as
| :noindex:
|
| .. automethod:: numpy.core._internal._ctypes.strides_as
| :noindex:
|
| If the ctypes module is not available, then the ctypes attribute
| of array objects still returns something useful, but ctypes objects
| are not returned and errors may be raised instead. In particular,
| the object will still have the ``as_parameter`` attribute which will
| return an integer equal to the data attribute.
|
| Examples
| --------
| >>> import ctypes
| >>> x = np.array([[0, 1], [2, 3]], dtype=np.int32)
| >>> x
| array([[0, 1],
| [2, 3]], dtype=int32)
| >>> x.ctypes.data
| 31962608 # may vary
| >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32))
| <__main__.LP_c_uint object at 0x7ff2fc1fc200> # may vary
| >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint32)).contents
| c_uint(0)
| >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_uint64)).contents
| c_ulong(4294967296)
| >>> x.ctypes.shape
| <numpy.core._internal.c_long_Array_2 object at 0x7ff2fc1fce60> # may vary
| >>> x.ctypes.strides
| <numpy.core._internal.c_long_Array_2 object at 0x7ff2fc1ff320> # may vary
|
| data
| Python buffer object pointing to the start of the array's data.
|
| dtype
| Data-type of the array's elements.
|
| Parameters
| ----------
| None
|
| Returns
| -------
| d : numpy dtype object
|
| See Also
| --------
| numpy.dtype
|
| Examples
| --------
| >>> x
| array([[0, 1],
| [2, 3]])
| >>> x.dtype
| dtype('int32')
| >>> type(x.dtype)
| <type 'numpy.dtype'>
|
| flags
| Information about the memory layout of the array.
|
| Attributes
| ----------
| C_CONTIGUOUS (C)
| The data is in a single, C-style contiguous segment.
| F_CONTIGUOUS (F)
| The data is in a single, Fortran-style contiguous segment.
| OWNDATA (O)
| The array owns the memory it uses or borrows it from another object.
| WRITEABLE (W)
| The data area can be written to. Setting this to False locks
| the data, making it read-only. A view (slice, etc.) inherits WRITEABLE
| from its base array at creation time, but a view of a writeable
| array may be subsequently locked while the base array remains writeable.
| (The opposite is not true, in that a view of a locked array may not
| be made writeable. However, currently, locking a base object does not
| lock any views that already reference it, so under that circumstance it
| is possible to alter the contents of a locked array via a previously
| created writeable view onto it.) Attempting to change a non-writeable
| array raises a RuntimeError exception.
| ALIGNED (A)
| The data and all elements are aligned appropriately for the hardware.
| WRITEBACKIFCOPY (X)
| This array is a copy of some other array. The C-API function
| PyArray_ResolveWritebackIfCopy must be called before deallocating
| to the base array will be updated with the contents of this array.
| UPDATEIFCOPY (U)
| (Deprecated, use WRITEBACKIFCOPY) This array is a copy of some other array.
| When this array is
| deallocated, the base array will be updated with the contents of
| this array.
| FNC
| F_CONTIGUOUS and not C_CONTIGUOUS.
| FORC
| F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
| BEHAVED (B)
| ALIGNED and WRITEABLE.
| CARRAY (CA)
| BEHAVED and C_CONTIGUOUS.
| FARRAY (FA)
| BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
|
| Notes
| -----
| The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),
| or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag
| names are only supported in dictionary access.
|
| Only the WRITEBACKIFCOPY, UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be
| changed by the user, via direct assignment to the attribute or dictionary
| entry, or by calling `ndarray.setflags`.
|
| The array flags cannot be set arbitrarily:
|
| - UPDATEIFCOPY can only be set ``False``.
| - WRITEBACKIFCOPY can only be set ``False``.
| - ALIGNED can only be set ``True`` if the data is truly aligned.
| - WRITEABLE can only be set ``True`` if the array owns its own memory
| or the ultimate owner of the memory exposes a writeable buffer
| interface or is a string.
|
| Arrays can be both C-style and Fortran-style contiguous simultaneously.
| This is clear for 1-dimensional arrays, but can also be true for higher
| dimensional arrays.
|
| Even for contiguous arrays a stride for a given dimension
| ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``
| or the array has no elements.
| It does *not* generally hold that ``self.strides[-1] == self.itemsize``
| for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for
| Fortran-style contiguous arrays is true.
|
| flat
| A 1-D iterator over the array.
|
| This is a `numpy.flatiter` instance, which acts similarly to, but is not
| a subclass of, Python's built-in iterator object.
|
| See Also
| --------
| flatten : Return a copy of the array collapsed into one dimension.
|
| flatiter
|
| Examples
| --------
| >>> x = np.arange(1, 7).reshape(2, 3)
| >>> x
| array([[1, 2, 3],
| [4, 5, 6]])
| >>> x.flat[3]
| 4
| >>> x.T
| array([[1, 4],
| [2, 5],
| [3, 6]])
| >>> x.T.flat[3]
| 5
| >>> type(x.flat)
| <class 'numpy.flatiter'>
|
| An assignment example:
|
| >>> x.flat = 3; x
| array([[3, 3, 3],
| [3, 3, 3]])
| >>> x.flat[[1,4]] = 1; x
| array([[3, 1, 3],
| [3, 1, 3]])
|
| imag
| The imaginary part of the array.
|
| Examples
| --------
| >>> x = np.sqrt([1+0j, 0+1j])
| >>> x.imag
| array([ 0. , 0.70710678])
| >>> x.imag.dtype
| dtype('float64')
|
| itemsize
| Length of one array element in bytes.
|
| Examples
| --------
| >>> x = np.array([1,2,3], dtype=np.float64)
| >>> x.itemsize
| 8
| >>> x = np.array([1,2,3], dtype=np.complex128)
| >>> x.itemsize
| 16
|
| nbytes
| Total bytes consumed by the elements of the array.
|
| Notes
| -----
| Does not include memory consumed by non-element attributes of the
| array object.
|
| Examples
| --------
| >>> x = np.zeros((3,5,2), dtype=np.complex128)
| >>> x.nbytes
| 480
| >>> np.prod(x.shape) * x.itemsize
| 480
|
| ndim
| Number of array dimensions.
|
| Examples
| --------
| >>> x = np.array([1, 2, 3])
| >>> x.ndim
| 1
| >>> y = np.zeros((2, 3, 4))
| >>> y.ndim
| 3
|
| real
| The real part of the array.
|
| Examples
| --------
| >>> x = np.sqrt([1+0j, 0+1j])
| >>> x.real
| array([ 1. , 0.70710678])
| >>> x.real.dtype
| dtype('float64')
|
| See Also
| --------
| numpy.real : equivalent function
|
| shape
| Tuple of array dimensions.
|
| The shape property is usually used to get the current shape of an array,
| but may also be used to reshape the array in-place by assigning a tuple of
| array dimensions to it. As with `numpy.reshape`, one of the new shape
| dimensions can be -1, in which case its value is inferred from the size of
| the array and the remaining dimensions. Reshaping an array in-place will
| fail if a copy is required.
|
| Examples
| --------
| >>> x = np.array([1, 2, 3, 4])
| >>> x.shape
| (4,)
| >>> y = np.zeros((2, 3, 4))
| >>> y.shape
| (2, 3, 4)
| >>> y.shape = (3, 8)
| >>> y
| array([[ 0., 0., 0., 0., 0., 0., 0., 0.],
| [ 0., 0., 0., 0., 0., 0., 0., 0.],
| [ 0., 0., 0., 0., 0., 0., 0., 0.]])
| >>> y.shape = (3, 6)
| Traceback (most recent call last):
| File "<stdin>", line 1, in <module>
| ValueError: total size of new array must be unchanged
| >>> np.zeros((4,2))[::2].shape = (-1,)
| Traceback (most recent call last):
| File "<stdin>", line 1, in <module>
| AttributeError: Incompatible shape for in-place modification. Use
| `.reshape()` to make a copy with the desired shape.
|
| See Also
| --------
| numpy.reshape : similar function
| ndarray.reshape : similar method
|
| size
| Number of elements in the array.
|
| Equal to ``np.prod(a.shape)``, i.e., the product of the array's
| dimensions.
|
| Notes
| -----
| `a.size` returns a standard arbitrary precision Python integer. This
| may not be the case with other methods of obtaining the same value
| (like the suggested ``np.prod(a.shape)``, which returns an instance
| of ``np.int_``), and may be relevant if the value is used further in
| calculations that may overflow a fixed size integer type.
|
| Examples
| --------
| >>> x = np.zeros((3, 5, 2), dtype=np.complex128)
| >>> x.size
| 30
| >>> np.prod(x.shape)
| 30
|
| strides
| Tuple of bytes to step in each dimension when traversing an array.
|
| The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
| is::
|
| offset = sum(np.array(i) * a.strides)
|
| A more detailed explanation of strides can be found in the
| "ndarray.rst" file in the NumPy reference guide.
|
| Notes
| -----
| Imagine an array of 32-bit integers (each 4 bytes)::
|
| x = np.array([[0, 1, 2, 3, 4],
| [5, 6, 7, 8, 9]], dtype=np.int32)
|
| This array is stored in memory as 40 bytes, one after the other
| (known as a contiguous block of memory). The strides of an array tell
| us how many bytes we have to skip in memory to move to the next position
| along a certain axis. For example, we have to skip 4 bytes (1 value) to
| move to the next column, but 20 bytes (5 values) to get to the same
| position in the next row. As such, the strides for the array `x` will be
| ``(20, 4)``.
|
| See Also
| --------
| numpy.lib.stride_tricks.as_strided
|
| Examples
| --------
| >>> y = np.reshape(np.arange(2*3*4), (2,3,4))
| >>> y
| array([[[ 0, 1, 2, 3],
| [ 4, 5, 6, 7],
| [ 8, 9, 10, 11]],
| [[12, 13, 14, 15],
| [16, 17, 18, 19],
| [20, 21, 22, 23]]])
| >>> y.strides
| (48, 16, 4)
| >>> y[1,1,1]
| 17
| >>> offset=sum(y.strides * np.array((1,1,1)))
| >>> offset/y.itemsize
| 17
|
| >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
| >>> x.strides
| (32, 4, 224, 1344)
| >>> i = np.array([3,5,2,2])
| >>> offset = sum(i * x.strides)
| >>> x[3,5,2,2]
| 813
| >>> offset / x.itemsize
| 813
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
Dizilerin eleman sayısına uygun şekilde şeklini (satır x sütun 'dan oluşan bir matris şeklinde düşünebilirsiniz) değiştirebilmek için np.reshape fonksiyonundan aşağıdaki örnekte olduğu gibi yararlanabilirsiniz.
a = np.arange(15)
print("Degisiklik oncesi a dizisi: \n", a)
print("Degisiklik oncesi a dizisinin boyutu: ", a.ndim)
print("a dizisinin eleman sayisi: ", a.size)
a = a.reshape(3,5)
print("Degisiklik sonrasi a dizisi: \n", a)
print("Degisiklik sonrasi a dizisinin boyutu: ", a.ndim)
print("a dizisinin eleman sayisi: ", a.size)
Degisiklik oncesi a dizisi: [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14] Degisiklik oncesi a dizisinin boyutu: 1 a dizisinin eleman sayisi: 15 Degisiklik sonrasi a dizisi: [[ 0 1 2 3 4] [ 5 6 7 8 9] [10 11 12 13 14]] Degisiklik sonrasi a dizisinin boyutu: 2 a dizisinin eleman sayisi: 15
nxn bir birim matris formunda bir numpy dizisi oluşturmak için np.eye fonksiyonunu kullanabilirsiniz. Uyarı: numpy 'da matrix nesnesi dizi (array) nesnesinden farklıdıır.
i4 = np.eye(4)
print("4x4 birim matris formunda dizi: \n", i4)
4x4 birim matris formunda dizi: [[1. 0. 0. 0.] [0. 1. 0. 0.] [0. 0. 1. 0.] [0. 0. 0. 1.]]
numpy dizileri ile çalışırken atama operatörü ("=") bir kopyalama işlemi yapmak yerine aynı diziye yeni bir isim verilmesini sağlar. Bu nedenle dizilerden herhangi birinde bir değişiklik yapıldığında diğeri de değişir.
a = np.arange(0,4.25,0.25)
print("a: ", a)
b = a
print("b: ", b)
a[2] = 100.0
print("Degisiklik sonrasi a: ", a)
print("Degisiklik sonrasi b: ", b)
a: [0. 0.25 0.5 0.75 1. 1.25 1.5 1.75 2. 2.25 2.5 2.75 3. 3.25 3.5 3.75 4. ] b: [0. 0.25 0.5 0.75 1. 1.25 1.5 1.75 2. 2.25 2.5 2.75 3. 3.25 3.5 3.75 4. ] Degisiklik sonrasi a: [ 0. 0.25 100. 0.75 1. 1.25 1.5 1.75 2. 2.25 2.5 2.75 3. 3.25 3.5 3.75 4. ] Degisiklik sonrasi b: [ 0. 0.25 100. 0.75 1. 1.25 1.5 1.75 2. 2.25 2.5 2.75 3. 3.25 3.5 3.75 4. ]
Sonuç olarak :
b = a
ifadesiyle herhangi bir kopyalama işlemi yapılmaz. a ve b hafızanın aynı adresinde bulunan bir dizi için iki farklı isimldir.
b = a[:]
ifadesi a'nın bir görüntüsünü (view) b'ye alır (_shallow copy_). a ve b aynı hafıza adresindeki dizinin iki farklı adıyken, şekilleri bağımsız olarak tutulur.
b = a.copy()
ifadesiyle a'nın içeriği b'ye kopyalanır ( _deep_ copy). Hafızanın başka bir adresinde a'yla aynı içeriğe sahip ancak ondan farklı isimde bir b dizisi yaratılır. Dolayısyla a'da yapılacak bir değişiklik b'yi; b'de yapılacak bir değişiklik ise a'yı etkilemez.
dizi1 = np.arange(18)
dizi2 = dizi1[:]
dizi1.shape = (3,6)
print("1. dizi: \n", dizi1)
print("2. dizi: \n", dizi2)
dizi2[1] = -1
print("2. dizideki degisiklik sonrasi 1. dizi: \n", dizi1)
print("2. dizideki degisiklik sonrasi 2. dizi: \n", dizi2)
1. dizi: [[ 0 1 2 3 4 5] [ 6 7 8 9 10 11] [12 13 14 15 16 17]] 2. dizi: [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17] 2. dizideki degisiklik sonrasi 1. dizi: [[ 0 -1 2 3 4 5] [ 6 7 8 9 10 11] [12 13 14 15 16 17]] 2. dizideki degisiklik sonrasi 2. dizi: [ 0 -1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17]
a = np.arange(0,2.1,0.5)
b = a.copy()
print("a: ", a)
print("b: ", b)
b[1:3] = np.array([-100,-1000])
print("a: ", a)
print("b: ", b)
a: [0. 0.5 1. 1.5 2. ] b: [0. 0.5 1. 1.5 2. ] a: [0. 0.5 1. 1.5 2. ] b: [ 0. -100. -1000. 1.5 2. ]
İki diziyi karşılaştırmak ve aynı olup olmadıklarını ve ne düzeyde benzer olduklarını anlamak için çeşitli fonksiyonlar ya da yapılar kullanılabilir.
a = np.arange(1,4.1,0.6)
c = a[:]
print("a: ", a)
print("c: ", c)
print("c = a?:", c is a)
c = c.reshape(2,3)
print("c: ", c)
print(c.base is a)
print(c.flags.owndata)
print(a.flags.owndata)
a: [1. 1.6 2.2 2.8 3.4 4. ] c: [1. 1.6 2.2 2.8 3.4 4. ] c = a?: False c: [[1. 1.6 2.2] [2.8 3.4 4. ]] True False True
Python'da, toplama, bir sabitle çarpma gibi bazı işlemler numpy dizileri üzerinde doğrudan uygulanabilir.
a = np.arange(20).reshape(5,4)
print("a: \n", a)
print("3a: \n", a*3)
print("a + a: \n", a + a)
a: [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11] [12 13 14 15] [16 17 18 19]] 3a: [[ 0 3 6 9] [12 15 18 21] [24 27 30 33] [36 39 42 45] [48 51 54 57]] a + a: [[ 0 2 4 6] [ 8 10 12 14] [16 18 20 22] [24 26 28 30] [32 34 36 38]]
Ancak çarpma ve bölmenin sadece karşılıklı elemanların çarpılması ya da bölünmesinden ibaret olduğu (matris çarpması olmadığı) bilinmelidir. Dolayısı ile çarpma ve bölme sadece aynı şekildeki diziler arasında uygulanabilen işlemlerdir.
print("a^2: \n", a**2)
a^2: [[ 0 1 4 9] [ 16 25 36 49] [ 64 81 100 121] [144 169 196 225] [256 289 324 361]]
Ancak matris çarpması da numpy üzerinde yapılabilir ve bunun için @ operatörü kullanılır.
b = np.linspace(10,29,20)
print("a: \n", a)
b = b.reshape(4,5)
print("b: \n", b)
print("a . b: \n", a @ b)
a: [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11] [12 13 14 15] [16 17 18 19]] b: [[10. 11. 12. 13. 14.] [15. 16. 17. 18. 19.] [20. 21. 22. 23. 24.] [25. 26. 27. 28. 29.]] a . b: [[ 130. 136. 142. 148. 154.] [ 410. 432. 454. 476. 498.] [ 690. 728. 766. 804. 842.] [ 970. 1024. 1078. 1132. 1186.] [1250. 1320. 1390. 1460. 1530.]]
Pek çok fonksiyon diziler üzerinde de kullanılabildiği gibi bazı fonksiyonların diziler için özel olarak tanımlanmış halleri de numpy paketinde bulunabilir.
print("a dizisi elemanlarinin toplami: ", sum(a))
theta = np.arange(0, 2*np.pi+np.pi/32, np.pi/16)
print("cos(a): \n", np.cos(a))
from matplotlib import pyplot as plt
%matplotlib inline
plt.plot(theta, np.cos(theta), "r-")
plt.xlabel("theta")
plt.ylabel("cos(theta)")
plt.hlines(y = 0, xmin=min(theta), xmax=max(theta), lw=1)
plt.show()
a dizisi elemanlarinin toplami: [40 45 50 55] cos(a): [[ 1. 0.54030231 -0.41614684 -0.9899925 ] [-0.65364362 0.28366219 0.96017029 0.75390225] [-0.14550003 -0.91113026 -0.83907153 0.0044257 ] [ 0.84385396 0.90744678 0.13673722 -0.75968791] [-0.95765948 -0.27516334 0.66031671 0.98870462]]
np.random.random_sample() fonksiyonu [0.0, 1.0) aralığıda rastgele değerlerden oluşan diziler yaratmak için kullanılır. Bu fonksiyonu ve sabitle çarpmayı kullanarak 10x10 bir numpy dizisi oluşturunuz. Dizinin ortalamasını ve standart sapmasını uygun numpy fonksiyonlarını kullanarak yazdırınız.
Aşağdaki diziyi manuel olarak (elinizle) yazmadan pratik bir yöntemle oluşturunuz. Bu dizinin sadece 1, 3 ve 5. satırları ile 2. sütunundan oluşan bir dizi (vektör) oluşturup, ekrana yazdırınız.
[[1, 6, 11],
[2, 7, 12],
[3, 8, 13],
[4, 9, 14],
[5, 10, 15]]Kenarlarındaki tüm rakamları 1, ortasındaki tüm rakamları 0 olan nxn bir dizi oluşturmak üzere bir fonksiyon yazınız. Fonksiyonunuz kare dizinin bir kenarını (n) argüman olarak alsın ve bu kurala uygun olarak oluşturduğu nxn diziyi programa döndürsün. Aşağıda 4x4 bir dizi örnek olarak verilmiştir.
1 1 1 1
1 0 0 1
1 0 0 1
1 1 1 10 ile 90 derece (0 dahil 90 hariç) arasında beşer derecelik eşit uzaklıklarla birbirinden ayrılan zenit açılarından oluşan, zenit isminde bir numpy dizisi oluşturunuz. z zenit açısını, X hava kütlesini göstermek üzere bu dizinin 60 dereceden küçük tüm elemanlarına $ X = sec(z) $; 60 derece ve ondan büyük bütün elemanlarına; $ X = sec(z) - 0.0018167 (sec(z) - 1) - 0.002875 (sec(z) - 1)^2 - 0.0008083 (sec(z) - 1)^3 $ (Hardie, 1962) formülünü uygulayarak hava kütlesini hesaplayınız ve X isimli bir dizide toplayarak, bu diziyi ekrana yazdırınız.
yildizlar.dat salt metin dosyasını np.loadtxt() fonksiyonu ile okuyarak sütunlarını uygun olarak isimlendirdiğiniz dizilerde toplayınız. Yörünge döneminin histogramını bulunduğu diziyi np.histogram() fonksiyonunu kullanarak oluşturunuz. Fonksiyon çıktı olarak her bir gruptaki (bin) gezegen sayısını ve grubun limitlerini döndürür. Her bir grubun ortalamasını hesaplayarak ekrana yazdırınız.
Standart sapma aşağıdaki ifade ile hesaplanır.
Verilen bir a dizisi için
a dizisinin ortalmasını ($\bar{a}$),a dizisinin eleman sayısını bölümünü,hesaplayan standart_sapma isimli bir fonksiyon yazınız. Fonksiyonunuz sadece a dizisini alsın ve dizinin standart sapmasını döndürsün.