Herkese selamlar ve sağlıklı günler. 🙂
Julia programlama dili serimizin üçüncü yazısıyla tekrardan bir aradayız. İlk iki bölüm itibariyle Julia’nın kendisini, sunduğu özellikleri ve paket yöneticisini tanıdık. Bu bölümde de, artık Julia’ya başlangıç yapıyoruz. Julia’da değişken tanımlamayı, operatör türlerini/kullanımlarını ve veri türlerini tanıyoruz.
İsterseniz sözü daha fazla uzatmadan hemen başlayalım! 🙂
Bölümler
- Julia: Derinlemesine Bir Bakış & Başlangıç – Bölüm 1
- Julia: Pkg Paket Yöneticisi Yönetimi – Bölüm 2
- Julia: Değişkenler, Operatörler ve Veri Türleri – Bölüm 3
- Julia: Kontrol Akışları – Bölüm 4
- Julia: Fonksiyonlar – Bölüm 5
- Julia: Tipler – Bölüm 6
- Julia: I/O ve Hata Yakalama – Bölüm 7
- Julia: Metodlar – Bölüm 8
Bölüm İçeriği
Aşağıda Julia dersleri Bölüm 3 kapsamındaki başlıklar listelenmiştir.
- Değişkenler
- Operatörler
- Veri Türleri
1. Değişkenler
Değişkenler, veriyi içerisinde depolayan birimlerdir. Geliştirici tarafından tutulmak/saklanmak istenen veri, daha sonra kullanılmak üzere bir değişkene atanır.
Programlama dillerinin en temel özelliklerinden olan değişken tanımlama işlemiyle herhangi bir programlama diliyle başlangıç seviyesinde ilgilenmiş herkes tanışmıştır. Julia programlama dilinde deklare edilen değişkenin ait olduğu veri tipini geliştiricinin belirtmesine gerek yoktur. Otomatik olarak atanılan değere göre hangi veri tipi sınıfına ait olduğu belirlenir. Ancak daha öncesinde C/C++, C#, Java gibi programlama dilleriyle uğraşanlar geliştiriciler, değişkenlerin veri tiplerinin kendileri tarafından belirlemesini gerektiğine aşinalardır.
Her programlama dilinde olduğu gibi Julia için de değişken atamaları aşağıdaki gibi yapılmaktadır:
|
1 2 3 4 5 6 7 8 9 10 11 |
julia> x = 5 5 julia> x + 1 6 julia> x = 5 + 5 10 julia> x = "Merhaba Dünya" Merhaba Dünya |
Julia değişkenleri adlandırmak için son derece esnek bir sistem sağlar. Değişken adları büyük/küçük harfe duyarlıdır. Aynı zamanda Unicode adlarına (UTF-8 kodlamasında) izin verilir.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
julia> x = 5.0 5 .0 julia> y = -6 -6 julia> δ = 0.00001 0.00001 julia> Привет = "Merhaba" "Merhaba" |
Çok güzel bir özellik olarak Julia REPL ve diğer birkaç Julia düzenleme ortamında, ters eğik çizgiden sonra LaTeX sembol formatı adını yazarak birçok Unicode matematik sembolünü pratik olarak yazabilirsiniz.
Desteklenen sembollerin tam listesine buradan göz atabilirsiniz.
Örnek olarak:
Julia, gerektiğinde yerleşik sabitleri ve işlevleri yeniden tanımlamanıza bile izin verecektir (potansiyel karışıklıkları önlemek için bu önerilmez):
|
1 2 3 4 5 6 7 8 |
julia> pi = 3 3 julia> pi 3 julia> sqrt = 4 4 |
Ancak, halihazırda kullanımda olan yerleşik bir sabiti veya işlevi yeniden tanımlamaya çalışırsanız, Julia size bir hata çıktısı üretir:
|
1 2 3 4 5 6 7 8 9 10 11 |
julia> pi π = 3.1415926535897... julia> pi = 3 ERROR: cannot assign a value to variable MathConstants.pi from module Main julia> sqrt(100) 10.0 julia> sqrt = 4 ERROR: cannot assign a value to variable Base.sqrt from module Main |
İzin Verilen Değişken Adları
Değişken adları, bir harf (A-Z veya a-z), alt çizgi veya 00A0’dan büyük Unicode kodlamalarının bir alt kümesiyle başlamalıdır; özellikle, Unicode karakter kategorileri Lu/Ll/ Lt/Lm/Lo/ Nl (harfler), para birimi ve diğer simgeler ve matematik sembollerinin bir alt kümesine izin verilmektedir.
Değişkenler için açıkça izin verilmeyen adlar, dahili ifadelerin adlarıdır:
|
1 2 3 4 5 |
julia> else = false ERROR: syntax: unexpected "else" julia> try = "No" ERROR: syntax: unexpected "=" |
Dilde tanımlı dahili ifadeler değişken adlandırılmasında kullanılamazlar.
Sözcüklerin ayrımı alt çizgilerle (‘_’) belirtilebilir, ancak adın okuması zorlamadığı takdirde alt çizgi kullanımı önerilmez.
Julia’nın müsade ettiği yazım stili hakkında buradan daha detaylı bilgi alabilirsiniz.
Değişken Kapsamları
Bir değişkenin kapsamı, içinde bir değişkenin görülebildiği kod bölgesidir. Değişkenin kapsamını belirleme, değişken adlandırmaları çakışmaların önlenmesine yardımcı olur.
Dildeki bazı yapılar, bazı değişken kümelerin kapsamı olarak uygun kapsam bloklarını sunar.
Julia’da global ve local olmak üzere iki ana kapsam türü bulunmaktadır.
| Yapı | Kapsam Türü | İç içe yerleştirilebilecek kapsam blokları |
|---|---|---|
module, baremodule | global | global |
| etkileşimli istemci (REPL) | global | global |
struct, macro | local | global |
for, while, try-catch-finally, let | local | global ya da local |
| fonksiyonlar (söz dizimi, anonim & do blokları) | local | global ya da local |
| comprehensions, broadcast-fusing | local | global ya da local |
Bu tabloda özellikle eksik olan, blok içermeyen begin blokları ve if bloklarıdır. Ama bu blokların kapsamlarını serimizin ileriki bölümlerinde ele alacağız. Şu an için değişken atamalarında pratik olarak kullanılabilecek temel değişken kapsamlarımızı tanıyacağız.
const Kullanımı
Değişkenlerin yaygın kullanımlarından biri olan const kullanımı, değişmeyen değerler için tanımlanır. Bu kapsamdaki değişkenler yalnızca bir kez atanır. Atama, const anahtar sözcüğü kullanılarak derleyiciye bildirilir:
|
1 2 3 |
julia> const e = 2.718281828459; julia> const pi = 3.14159265358; |
Tek bir const atamasında birden çok değişken de bildirebiliriz:
|
1 2 |
julia> const x, y = 10, 20 (10, 20) |
Öncesinde const ile tanımlanmış bir değişken için yeni atanmak istenen değer ilk sabit değerle aynı değilse hata alınır:
|
1 2 3 4 5 |
julia> const x = 1.0 1.0 julia> x = 1 ERROR: invalid redefinition of constant x |
Aynı veri tipindeyse ise de uyarı yazdırılır. Bu durum için veri tipi ondalıklı yani float veri tipindedir.
|
1 2 3 4 5 6 |
julia> const y = 1.0 1.0 julia> y = 2.0 WARNING: redefining constant y 2.0 |
local Kullanımı
local hem okuma hem de yazma için bir üst yerel kapsamdaki tüm değişkenleri devralır.
Global kapsamların aksine, local kapsamlar ad alanları değildir, bu nedenle iç kapsamdaki değişkenler, bir tür nitelikli erişim yoluyla üst kapsamdan alınamaz.
|
1 2 3 4 5 6 7 8 |
julia> for i = 1:1 x = i + 1 for j = 1:1 local x = 0 end println(x) end 2 |
global Kullanımı
Her modül, diğer tüm modüllerin global kapsamından ayrı olarak yeni bir küresel kapsam sunar; her şeyi kapsayan global kapsam yoktur.
Modüller, değişken tanımlamaları veya using ya da import aracılığıyla veya nokta gösterimini kullanarak nitelikli erişim yoluyla diğer modüllerin değişkenlerini kapsamlarına dahil edebilir.
global kullanımına yönelik basit bir atama ve çağrılma örneği:
|
1 2 3 4 5 6 7 |
julia> for i = 1:10 global z z = i end julia> z 10 |
2. Operatörler
Her programlama dilinde olduğu gibi Julia’da da operatörler, değişkenler ve değerler üzerinde işlem yapmak için kullanılan matematiksel sembollerdir. Bu semboller aritmetik ve mantıksal hesaplamalar yapmak için kullanılır. Operatörlerin işlem gerçekleştirdiği değişkenler Operand olarak adlandırılmaktadır.
Örneğin, aşağıdaki ifadeyi göz önünde bulundurabiliriz:
|
1 |
c = a + b |
Burada “+”, toplama operatörü olarak bilinen en basit operatördür ve “a” ve “b”, işlenenlerdir. Toplama operatörü derleyiciye “a” ve “b” işlenenlerinin ikisini birbiriyle toplamasını söylemektedir.
Operatör Türleri
Julia programlama dilinde 6 tip operatör bulunmaktadır.
- Aritmetik Operatörler (Arithmetic Operators)
- Bitsel Operatörler (Bitwise Operators)
- Mantıksal Operatörler (Logical Operators)
- Atama Operatörleri (Assignment Operators)
- Vektörel Nokta Operatörleri (Vectorized ‘dot’ Operators)
- İlişkisel Operatörler (Relational Operators)
Dilerseniz hep birlikte bu tipleri tanıyalım. 🙂
1. Aritmetik Operatörler
Aritmetik operatörler, değişkenler ve değerler üzerinde aritmetik/matematiksel işlemler gerçekleştirmek için kullanılırlar.
Bu operatörler toplama, çıkarma, çarpma, bölme, vb. işlemleri içerir. Hepimizin aşina olduğu en temel operatörlerdir.
Örnek: (+, – , * , / , % , +x , -x)
Aritmetik operatörler iki türdür:
- Tekli Operatörler: Tek bir değerle çalışan operatörler tekli operatördür. Örneğin: (+x, -x)
- İkili Operatörler: İki değerle çalışan operatörler ikili operatördür. Örneğin: (+ , – , * , /)
| Operatör | Açıklama | Söz dizim |
|---|---|---|
| + (Birli artı) | Birli artı operatörünün sonucu ( + ), işleneninin değeridir. | +x |
| – (Birli eksi) | Birli olumsuzlama operatörü ( – ) işleneninin negatifini üretir. | -x |
| + | İki değeri toplama operatörü | x + y |
| – | İki değerinin farkının alınmasını sağlayan operatör | x – y |
| * | İki değeri çarpımını sağlayan operatör | x * y |
| / | İlk değeri, ikinciye bölen operatör. Ondalıklı (float) olarak değer döndürür. | x / y |
| ÷ | İlk değeri, ikinciye bölen operatör. Tam sayı (integer) olarak değer döndürür. | x ÷ y |
| \ | İkinci değeri, birinciye böler. | x \ y |
| ^ | İlk değerin, ikinci değer karşılığınca üssünü alır. | x ^ y |
| % | İlk değerin, ikinciye bölümünün kalanını döndürür. | x % y |
| ! | Bool değerini değiştirir, yani true’dan false’a veya false’dan true’ya olacak şekilde. | x ! y |
Aşağıdaki örneklerde olduğu gibi kullanılabilirler:
|
1 2 3 4 5 6 7 8 9 10 |
Çıktı: 6 55 2.2 2 0.45454545454545453 161051 1 |
2. Bitsel Operatörler
Bitsel operatörler, bir sayının ayrı bitlerinin manipülasyonunu gerçekleştirmek için kullanılır. Tam sayı türlerinden herhangi biriyle kullanılabilirler.
Örnekler: (~, &, |, >>, <<)
| Operatör | Açıklama | Söz dizim |
|---|---|---|
| ~ | Bitwise NOT | ~x |
| & | Bitwise AND | x & y |
| | | Bitwise OR | x | y |
| ⊻ | Bitwise XOR | x ⊻ y |
| >>> | Logical right | x >>> y |
| >> | Bitwise right shift | x >> y |
| << | Bitwise/Logical left shift | x << y |
Kullanımı yukarıdaki tabloya göre sırasıyla aşağıdaki gibidir:
3. Mantıksal Operatörler
Mantıksal Operatörler, iki veya daha fazla koşulu birleştirmek/kısıtlamak veya orijinal durumun değerlendirmesini dikkate almak için kullanılırlar. Mantıksal bir operatörün çalışmasının sonucu, true veya false olan bir boole değeridir.
Örneğin, Julia’da ‘&&’ operatörü olarak temsil edilen mantıksal operatör AND, göz önünde bulundurulan her iki koşul da sağlandığında doğrudur.
Aksi takdirde, false değeri döndürür. Bu nedenle, a && b, hem a hem de b doğru olduğunda (yani sıfır olmayan) true değerini döndürür.
| Operatör | Açıklama | Söz dizim |
|---|---|---|
| && | Logical AND: Her iki değer doğruysa doğrudur | x && y |
| || | Logical OR: Değerlerden herhangi biri doğruysa doğrudur | x || y |
| ! | Logical NOT: İşlenen değer yanlışsa doğrudur | !x |
|
1 2 3 4 5 |
Çıktı: false true false |
4.Atama Operatörleri
Atama operatörleri, bir değişkene değer atamak için kullanılır. Atama operatörünün sol taraftaki işlenen, bir değişkendir ve atama operatörünün sağ taraftaki işleneni bir değerdir. Sağ taraftaki değer, sol taraftaki değişkenle aynı veri türünde olmalıdır, aksi takdirde derleyici bir hata oluşturur.
| Operatör | Açıklama | Söz dizim |
|---|---|---|
| = | Sol taraftaki işlenene ifadenin sağ tarafının değerini atar. | x = y + z |
| += | Sol taraftaki işleneni sağ taraftaki işlenene ekler ve ardından soldaki işlenene atar. | a += b a = a + b |
| -= | Sağ taraftaki işleneni sol işlenenden çıkarır ve ardından sol işlenene atar. | a -= b a = a – b |
| *= | Sağ taraftaki işleneni sol işlenenle çarpar ve ardından sol işlenene atar. | a *= b a = a * b |
| /= | Sol taraftaki işleneni sağ işlenenle böler ve ardından sol işlenene atar. | a /= b a = a / b |
| \= | Sağ taraftaki işleneni sol işlenenle böler ve ardından sol işlenene atar. | a \= b a = a \ b |
| ÷= | Sol taraftaki işleneni sağ işlenenle böler ve ardından sol işlenene atar. | a ÷= b a = a ÷ b |
| %= | Sol ve sağ işlenenleri kullanarak mod alır ve sonucu sol işlenene atar. | a %= b a = a % b |
| ^= | İşlenenleri kullanarak üs değerini hesaplar ve çıkan değeri sol işlenene atar. | a ^= b a = a ^ b |
| &= | İşlenenlerde bitsel AND gerçekleştirir ve sol işlenene değeri atar. | a &= b a = a & b |
| |= | İşlenenlerde bitsel OR gerçekleştirir ve sol işlenene değeri atar. | a |= b a = a | b |
| ⊻= | İşlenenlerde bitsel xOR gerçekleştirir ve sol işlenene değeri atar. | a ⊻= b a = a ⊻ b |
| >>>= | İşlenenlerde mantıksal sağ kaydırma yapar ve sol işlenene değeri atar. | a>>>=b a=a>>>b |
| >>= | İşlenenlerde bitsel sağa kaydırma yapar ve sol işlenene değer atar. | a >>= b a = a >> b |
| <<= | İşlenenlerde bitsel sola kaydırma gerçekleştirir ve sol işlenene değer atar. | a <<= b a = a << b |
5. Vektörel Nokta Operatörü
Bir “nokta” işleci bir dizinin tamamında, bir ikili işlem gerçekleştirmek için kullanılır.
|
1 2 3 4 5 6 7 8 9 10 |
# Dizi oluşturma A = [4, 5, 6, 7] # Kuvvet alma işlemi gerçekleştirme # Hata üretir A = A ^ 2 # (.) operatörünü kullanarak kuvvet alma gerçekleştirme A = A .^ 2 println(A) |
Yukarıdaki kod (.) operatörü kullanılmadan gerçekleştirildiğinde bir hata oluşturur. Bunun nedeni de, üs işlecinin dizilerde işlem gerçekleştirememesidir.
Aşağıda da görebileceğimiz gibi hata üretmektedir:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
ERROR: LoadError: MethodError: no method matching ^(::Array{Int64,1}, ::Int64) Closest candidates are: ^(!Matched::Float16, ::Integer) at math.jl:885 ^(!Matched::Regex, ::Integer) at regex.jl:712 ^(!Matched::Missing, ::Integer) at missing.jl:155 ... Stacktrace: [1] macro expansion at .\none:0 [inlined] [2] literal_pow(::typeof(^), ::Array{Int64,1}, ::Val{2}) at .\none:0 [3] top-level scope at C:\Users\kullanici\Desktop\main.jl:5 [4] include(::Module, ::String) at .\Base.jl:377 [5] exec_options(::Base.JLOptions) at .\client.jl:288 [6] _start() at .\client.jl:484 in expression starting at C:\Users\kullanici\Desktop\main.jl:5 |
Ancak nokta operatörünü kullanarak dizi üzerinde gerçekleştirdiğimiz işlemde aşağıdaki başarılı çıktıyı elde ederiz:
|
1 |
[16, 25, 36, 49] |
6. İlişkisel Operatörler
Bu operatörler, eşitlik, büyüklük ve küçüklü gibi ilişkileri kontrol etmek için kullanılır. Karşılaştırmadan sonra boole tipinde sonuç döndürürler ve döngüsel ifadelerde, koşullu if-else ifadelerinde yaygın olarak kullanılırlar.
| Operatör | Açıklama | Söz dizim |
|---|---|---|
| > | Büyüktür: Sol taraftaki işlenen sağdan büyükse doğrudur. | x > y |
| < | Küçüktür: Sol taraftaki işlenen sağdan küçükse doğrudur. | x < y |
| == | Eşittir: Her iki işlenen de eşitse doğrudur. | x == y |
| !=, ≠ | Eşit değil: İşlenenler eşit değilse doğrudur. | x != y or x ≠ y |
| >=, ≥ | Büyüktür veya eşittir: Sol taraftaki işlenen sağdan büyük veya ona eşitse doğrudur. | x >= y or x ≥ y |
| <=, ≤ | Küçüktür veya eşittir: Sol taraftaki işlenen sağdan küçük veya ona eşitse doğrudur. | x <= y or x ≤ y |
3. Veri Türleri
Julia’nın türleri temel olarak çeşitli boyutlarda ve işlevlerdeki veri türleridir. Değerleri ve yapıları saklayan kutular gibidirler. Bir değişken deklarasyonundaki her değer (değişken değil) bir türe sahiptir ve olmalıdır da. Bir değerin türünü tanımlamak ya programcı tarafından ya da derleyicinin kendisi tarafından yapılır. Bölümümüzün Değişkenler kısmında da belirttiğimiz gibi bunu Julia otomatik olarak yapmaktadır. Ancak hızlı yürütme sağlamak ve kodumuzu hatalara daha az eğilimli hale getirmek için kaynak kodunu çalıştırmadan önce değerin türünü tanımlamak da mümkündür.
Bunun için veri türlerini tanımak ve neler üzerinde çalıştığımızı bilmemiz gereklidir. 🙂
Aşağıdaki her değer farklı türdedir. Tam sayı değeri, ondalıklı değerden ve rasyonel değerden farklıdır ve benzer şekilde diğer iki değer birbirinden farklıdır.
|
1 2 3 4 5 |
10 -> Tam sayı (Integer) 10.5 -> Ondalıklı (Float) 10/3 -> Rasyonel (Rational) |
Hal böyle olunca bu üç değeri toplamamız veya bu değerler üzerinde başka bir işlem yapmamız gerekiyorsa, değerler aynı tipte olmadığı için işlemi gerçekleştirmek zor olacaktır. Bu değerleri birbirleriyle işlem yaptırabilmek, diğer iki değeri, üçüncü değerle aynı türde olacak şekilde dönüştürmemiz gerekir.
Burada programlama dillerinin tip dönüşüm yapıları karşımıza çıkmaktadır. Ancak tip dönüşümlerinden bahsetmeden önce tip sistemlerimizi tanıyalım:
Tip sistemleri temel olarak iki kategoriye ayrılır:
- Statik Tip Sistemi (Static Type System) : Statik tip sisteminde, çalıştırılabilir her program ifadesi yürütülmeden önce bir türde tanımlanır. Programcı tarafından tanımlanan tipler, performansı olumlu yönde etkilerler.
- Dinamik Tip Sistemi (Dynamic Type System) : Dinamik tip sisteminde, derleyici kod derleme sırasında değerlerin türüne karar vermek zorundadır. Bu, kodun yürütülmesi için ekstra zaman almasına neden olur.
Julia, değişken değerlerini belirlemek dinamik tip sistemini kullanmaktadır. Ancak, belirli değerlerin belirli türlerde olduğunu gösterme avantajı sağlamak için statik olarak yazılmış tanımları da kabul eder. Yani, zaten hızlı olan bu dili daha da performanslı olacak şekilde kullanabilmek geliştiricinin elindedir.
Varsayılan olarak, Julia türü olmayan değerleri gerekli olan herhangi bir türle atar. Böylece programcı herhangi bir Julia fonksiyonunu, türleri açıkça tanımlamaksızın yazabilmektedir. Ancak, değere açık bir tür sağlamak daha iyi kod okunabilirliğini sağlar ve ayrıca koddaki hataları bulmayı kolaylaştırır. Julia’da tip sistemini kullanmak zorunlu olmasada, kullanımı kodu daha net, daha basit, daha hızlı ve sağlam hale getirecektir.
Tip Deklerasyonu
Julia’da türler :: operatörüyle ilan edilir.
Türler, programın iyi çalıştığını doğrulamak ve derleyiciye, daha hızlı ve daha verimli kodla sonuçlanacak ifade ve değerlerin türü hakkında bazı ek bilgiler sağlamak için belirtilirler.
Geliştirici, türden habersizse ve değere veya ifadeye yanlış bir tür atarsa ne olacağı üç aşağı beş yukarı ortadadır.
Bu Julia’da ki bir istisna ile ele alınır. Sol taraftaki değer sağ tarafta bildirilen türde değilse, bir istisna oluşturulur ve kod yürütme burada durur. Derleyici, sol taraftaki hesaplanan değerin sağ tarafta belirtilen türde olmasını bekler. Ortaya çıkan istisna, sol taraftan (tanımlandığı gibi) beklenen türü ve gerçekte ne üretildiğini belirtir.
Yukarıdaki kodda, sol taraftaki ifade bir ondalıklı türle tanımlandığında, soldaki hesaplanan değerin sonucunun bildirildiği gibi Float64 türünde olması derleyici tarafından öngörülür. Ancak durum yukarıdaki örnek için öyle değildir. Dolayısıyla yürütme sırasında bir hata oluştuğu görülebilir. Derleyici de hata çıktısında TypeError durumunu gösterir ve Int yani tam sayı veri tipi kullanılması gerektiğini işaret eder.
Tamam öyleyse, biz de Int olarak deklare edelim ve sonucu görelim. 🙂
|
1 2 3 4 5 6 7 |
julia> (50 + 50)::Int64 100 veya julia> (50 + 50)::Int 100 |
Şimdi derleyicinin dilinden konuşmaya başlıyoruz. 🙂
Atama Operatörü ile Tip Deklarasyonu
Atama işleciyle birlikte kullanıldığında :: işleci, sol taraftaki değişkeni yazılan bir değer yapmak için kullanılırsa, bu değişkeni her zaman aynı türün değerini tutacak şekilde kısıtlar, tıpkı C dilinde statik olarak yazılmış değişkenler gibi.
Değişkene atanan her değer, aynı türde değilse, convert işlevi kullanılarak aynı türe dönüştürülür:
Julia’da fonksiyonlar ile de tip deklarasyonuna izin verilir. Bu, işlevin daima hesaplanan değeri belirtilen tip biçimini dönüştürmesine ve döndürmesine neden olmaktadır.
|
1 2 3 4 5 6 7 8 |
function FonkToplam(x, y)::Float64 return x + y end FonkToplam(1, 2) Çıktı: 3.0 |
Fonksiyonları ve parametreleri ileri bölümlerde tanıyacak olsak da bu kısa işlem fonksiyonların ve end anahtar kelimesinin mantığını kısaca açıklamaktadır. 🙂
Yukarıdaki kodda, fonksiyonun tam sayı (integer) değeri döndürmesi gerekir, ancak işlevin tür bildirimi nedeniyle, hesaplanan değerin çıktısı Float64’e yani istenen türe dönüştürülür.
Julia’nın İlkel Veri Türleri
Aşağıda Julia’nın desteklediği ilkel veri türleri sunulmuştur:
- Tam sayı türler:
| Tip | İmzalanmış | Bit sayısı | En küçük değer | En büyük değer |
|---|---|---|---|---|
Int8 | ✓ | 8 | -2^7 | 2^7 – 1 |
UInt8 | 8 | 0 | 2^8 – 1 | |
Int16 | ✓ | 16 | -2^15 | 2^15 – 1 |
UInt16 | 16 | 0 | 2^16 – 1 | |
Int32 | ✓ | 32 | -2^31 | 2^31 – 1 |
UInt32 | 32 | 0 | 2^32 – 1 | |
Int64 | ✓ | 64 | -2^63 | 2^63 – 1 |
UInt64 | 64 | 0 | 2^64 – 1 | |
Int128 | ✓ | 128 | -2^127 | 2^127 – 1 |
UInt128 | 128 | 0 | 2^128 – 1 | |
Bool | N/A | 8 | false (0) | true (1) |
- Ondalıklı türler
| Tür | Dilim | Bit sayısı |
|---|---|---|
Float16 | half | 16 |
Float32 | single | 32 |
Float64 | double | 64 |
Ayrıca, bu ilkel sayısal türlerinin de ötesinde Karmaşık ve Rasyonel Sayılar için de tam desteğe sahiptir.
Değerin Hangi Sınıfa Dahil Olduğunu Bulma
Aşağıdaki fonksiyonu kullanarak değerin hangi veri tipi sınıfına dahil olduğunu görebilirsiniz.
Somut ve Soyut Tipler
Julia her nesnenin bir türe sahip olmasına izin verir. Somut (concrete) bir sınıf, tüm yöntemleri için bir uygulaması olan bir sınıftır. Uygulanmayan yöntemleri olamaz. Ayrıca soyut (abstract) bir sınıfı genişletebilir veya tüm yöntemlerini uyguladığı sürece bir ara birim uygulayabilir. Tam bir sınıftır ve somutlaştırılabilir.
Somut tiplerin alt tipleri olmasına izin verilmez. Alt türler, bir türün alt ögeleridir. Bir tür daha farklı türlere ayrılabilirse, bu bölümlere alt tür denir. Örneğin: katarlar (string), bool, rasyonel vb.
Soyut tipler ise alt tipleri olan sınıflardır. Örneğin: sayılar soyut bir tiptir. Nesnelerini yaratamasak da,türlerinin yardımıyla, bir programcı belirtilen türün alt türlerinden herhangi biriyle çalışabilecek kodlar yazabilir.
Somut tipler başlıca iki kategoriye ayrılırlar:
- İlkel türler (Primitive types)
- Bileşik türler (Composite types)
İlkel türlere örnek olarak bir üst başlıkta belirttiğimiz Int8, Int16, Int64, Float16, Float32, String vb. veri türlerini gösterebiliriz.
Serimizin 6. Bölümünde tiplere detaylıca değinecek ve kullanımlarını gösterecek olsak da bileşik türlerin; belirli türlerin tek değerleri olarak ayrı ayrı ele alınabilen adlandırılmış alanların bir koleksiyonu olduğunu şimdiden söyleyebiliriz.
Bileşik türler struct anahtar sözcüğü kullanılarak bildirilebilir. Ayriyeten, Julia mutable anahtar kelimesi ile kullanımıyla değişken bileşik türlerin (mutable composite types) tanımlanmasına da izin vermektedir.
Diziler ve Demetler
Veri türleri/tipleri üzerine yoğunlaşmak önem taşımaktadır çünkü değişkenlerimizin değerlerini tutan, yapılarımızın oluşturulmasını sağlayan yapılar veri türleridir. Julia gibi bir hesaplama odaklı dilin bu konuda sağladığı kontrolleri, algoritmalarımıza uygulayabilmek dili tam performanslı ve doğru şekilde kullanabilmek açısından önem taşımaktadır.
Julia’da, diziler (arrays) ve demetler (tuples) sayısal verilerle çalışmak için en önemli veri türüdür.
Diziler
Julia’da diziler öğelerden oluşan bir koleksiyondur. Diziler, satırlara ve sütunlara bölünmüş N-boyutlu saklama kaplarımızdır. Diziler, içeriklerinin değiştirilebileceği, silinebileceği, üzerine yazılabileceği vb. yapılardır. Değişken tanımlamasında olduğu gibi yine aynı şekilde Julia’da öğeleri diziye atamadan önce bir dizinin veri türünü tanımlamak zorunlu değildir.
Söz dizim formatı:
|
1 2 3 4 5 6 |
#1B Dizi Dizi1 = [a, b, c, ...] #2B Dizi Dizi2 = [a b ; c d] #3B Dizi Dizi3 = cat([a b; c d], [e f; g h], dims=3) |
1B Dizi Oluşturma
|
1 |
A = [1, 2, 3, 4] |
2B Dizi Oluşturma
|
1 |
A = [1 2; 3 4] |
3B Dizi Oluşturma
|
1 |
A = cat([1 2; 3 4], [5 6; 7 8], dims=3) |
Dizi Elemanlarına Erişme
|
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 |
#1B Dizi Dizi1 = [1, 2, 3, 4] ÇIKTI: 4-element Array{Int64,1}: 1 2 3 4 # Index Değeri println(Dizi1[2]) ÇIKTI: 2 #2B Dizi Dizi2 = [1 2 "Data Science"; 3 4 "Earth"] # Geçen dizin değeri #Satır - sütun seçimi println(Dizi2[1, 3]) # Son değer erişme println(Dizi2[2, end]) # getindex() fonksiyon kullanımı println(getindex(Dizi2, 2, 3)) # Her satırı belirtmek için iki nokta üst üste kullanma println(Dizi2[:, 3]) # Her sütunu belirtmek için iki nokta üst üste kullanma println(Dizi2[1, :]) 3B dizilerin elemanlarına erişim için de aynı söz dizim formatı index değerleri genişletilerek kullanılmaktadır. |
Demetler
Demetler ise virgülle ayrılmış aynı veya farklı veri tiplerinin farklı değerlerinin değişmez bir koleksiyonudur. Demetler, dizilere oldukça benzerlik göstermektedir. Ancak diziler sadece benzer veri türlerinin değerlerini almaktadırlar.. Bir demet değerleri değiştirilemez çünkü demet yapısı değiştirilmeye müsade etmemektedir. Demetler, heterojen bir değerler topluluğudur.
Bir demet içinde saklanan değerlerin sırası herhangi bir tipte olabilir ve tam sayılarla indekslenir.
Bir grubun değerleri söz dizimsel olarak “virgül” ile ayrılır. Gerekli olmamakla birlikte, parantez içindeki değer sırasını kapatarak bir demet tanımlamak daha yaygındır.
Söz dizim formatı:
|
1 2 |
demet_adi = (deger1, deger2, deger3, ...) |
Örnek Kullanım:
|
1 2 3 4 5 6 7 |
# Benzer değerlere sahip bir demet oluşturma demet = (1, 2, 5, 7) println(demet) # Karışık değerlere sahip bir demet oluşturma karisik_demet = (1, 2, 3, "Data Science Earth") println(karisik_demet) |
Demet Elemanlarına Erişim
Bir demetin elemanlarına, diziler de olduğu gibi köşeli parantez ([]) kullanılarak kolayca erişilebilir.
|
1 2 3 4 5 6 7 8 |
# Demet oluşturma demet = ("Data", "Science", "Earth", 1, 2, 3) # Erişim println(demet[3]) ÇIKTI: Earth |
Julia programlama dilinde dizilere ve demetlere yönelik tüm kullanımları, dizi operasyonlarını buradan keşfedebilirsiniz.
Bir sonraki bölümde görüşmek dileğiyle. 🙂
Pingback: