From dbf05283fc39c9c0f192bb0bd63d9945a6d140d2 Mon Sep 17 00:00:00 2001
From: Haydar Kulekci <haydarkulekci@gmail.com>
Date: Mon, 19 Aug 2013 14:14:05 +0300
Subject: turkish translation for c language

---
 tr-tr/c-tr.html.markdown | 417 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 417 insertions(+)
 create mode 100644 tr-tr/c-tr.html.markdown

(limited to 'tr-tr')

diff --git a/tr-tr/c-tr.html.markdown b/tr-tr/c-tr.html.markdown
new file mode 100644
index 00000000..1f9db274
--- /dev/null
+++ b/tr-tr/c-tr.html.markdown
@@ -0,0 +1,417 @@
+---
+name: c
+category: language
+language: c
+filename: learnc-tr.c
+contributors:
+    - ["Adam Bard", "http://adambard.com/"]
+translators:
+    - ["Haydar KULEKCI", "http://scanf.info/"]
+lang: tr-tr
+
+---
+/*
+C halen modern yüksek performans bilgisayarların dili.
+
+C bir çok programcının kullandığı en düşük seviye dillerdendir, ama
+salt hız ile daha fazlasını karşılar. C'nin bellek yönetiminden iyi
+anlarsanız sizi isteğiniz yere götürecektir.
+
+```c
+// Tek satır yorum // karakterleri ile başlar
+
+/*
+Çoklu satırlı yorumlar bu şekilde görünür.
+*/
+
+// #include ile header dosyalarınız dahil edin.
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+// Fonksiyonlarınızı bir .h dosyasında ya da c dosyanızın üst tarafta 
+// tanımlayın.
+
+void function_1();
+void function_2();
+
+// Programınızın giriş noktası main isimli bir fonksiyondur ve 
+// integer değer döner
+int main() {
+
+// çıktıları yazdırmak için printf kullanılır, "print formatted"
+// %d bir sayı tipidir, \n yeni satır karakteridir
+printf("%d\n", 0); // => 0 karakteri yazdırılır.
+// Tüm ifadeler noktalı virgül ile bitmelidir.
+
+///////////////////////////////////////
+// Tipler
+///////////////////////////////////////
+
+// Değişkenleri kullanmadan önce tanımlamalısınız. Bir değişken tanımlarken
+// tipini belirtmelisiniz; bu tip onun byte olarak boyutunu belirler.
+
+// int değişken tipi 4 byte boyutundadır.
+int x_int = 0;
+
+// short değişken tipi genellikle 2 byte boyutundadır.
+short x_short = 0;
+
+// char tipi 1 byte boyutunu garanti eder. 
+char x_char = 0;
+char y_char = 'y'; // Karakterler '' işaretleri arasına yazılır.
+
+// long tipi 4-8 byte olur; long long tipi en azından 64 bit garantiler.
+long x_long = 0;
+long long x_long_long = 0; 
+
+// float tipi 32-bit kayan noktalı sayı boyutundadır.
+float x_float = 0.0;
+
+// double değişken tipi 64-bit kayan noktalı yazı tipindedir. 
+double x_double = 0.0;
+
+// Integral türleri işaretsiz olabilir. Bunun anlamı, onlar eksi değer 
+// olamaz demektir, ama aynı boyuttaki işaretsiz bir sayının maksimum 
+// değeri işaretli bir sayının maksimum değeriden büyük olur.
+unsigned char ux_char;
+unsigned short ux_short;
+unsigned int ux_int;
+unsigned long long ux_long_long;
+
+// Diğer taraftan char, ki her zaman bir byte boyutundadır, bu tipler 
+// makinenize göre boyut değiştirir. sizeof(T) size bir değişkenin byte 
+// cinsinden boyutunu verir öyle ki bu tipin boyutunu taşınabilir bir 
+// şekilde ifade edilebilir
+// Örneğin,
+printf("%lu\n", sizeof(int)); // => 4 (on machines with 4-byte words)
+
+// Diziler somut bir boyut ile oluşturulmalıdır.
+char my_char_array[20]; // Bu dizi 1 * 20 = 20 byte alan kaplar
+int my_int_array[20]; // Bu dizi 4 * 20 = 80 byte alan kaplar
+                      // (4-byte bir word varsayılır)
+
+// Şu şekilde bir diziyi 0 ile oluşturabilirsiniz:
+char my_array[20] = {0};
+
+// Dizinin elemanlarını indexlemek diğer diller gibidir, veya 
+// diğer diller C gibi.
+my_array[0]; // => 0
+
+// Diziler değişebilirdir (mutable); O sadece memory!
+my_array[1] = 2;
+printf("%d\n", my_array[1]); // => 2
+
+// String'ler bir NUL (0x00) byte ile sonlandırılmış karakter dizileridir,
+// bu string içerisinde özel bir karakter olan '\0' ile gösterilir.
+// (Biz Nul byte'i string karakterleri arasında bulundurmamıza gerek 
+// yoktur; derleyici onu bizim için dizinin sonuna ekler.)
+char a_string[20] = "This is a string";
+printf("%s\n", a_string); // %s bir string formatıdır.
+
+/*
+a_string 16 karakter uzunluğundadır. 
+17. karakter NUL karakteridir.
+18., 19. ve 20. karakterler tanımsızdır.(undefined)
+*/
+
+printf("%d\n", a_string[16]); // => 0
+
+///////////////////////////////////////
+// Operatörler
+///////////////////////////////////////
+
+int i1 = 1, i2 = 2; // Çoklu tanımlama için kısayol.
+float f1 = 1.0, f2 = 2.0;
+
+// Aritmatik basittir.
+i1 + i2; // => 3
+i2 - i1; // => 1
+i2 * i1; // => 2
+i1 / i2; // => 0 (0.5'dir ama 0 a yuvarlanmıştır.)
+
+f1 / f2; // => 0.5, artı veya eksi epsilon
+
+// Modüler aritmetikte vardır.
+11 % 3; // => 2
+
+// Karşılaştırma operatörleri muhtemelen tanıdıktır, ama
+// C'de boolean tipi yoktur. Bunun yerine sayı(int) kullanırız.
+// 0 false yerine ve diğer herşey true yerine geçmektedir. 
+// (Karşılaştırma operatörleri her zaman 0 veya 1 dönmektedir.)
+3 == 2; // => 0 (false)
+3 != 2; // => 1 (true)
+3 > 2; // => 1
+3 < 2; // => 0
+2 <= 2; // => 1
+2 >= 2; // => 1
+
+// Sayılar üzerinde mantık işlemleri
+!3; // => 0 (Logical not)
+!0; // => 1
+1 && 1; // => 1 (Logical and)
+0 && 1; // => 0
+0 || 1; // => 1 (Logical or)
+0 || 0; // => 0
+
+// Bit boyutunda işlem yapmak için operatörler
+~0x0F; // => 0xF0 (bitwise negation)
+0x0F & 0xF0; // => 0x00 (bitwise AND)
+0x0F | 0xF0; // => 0xFF (bitwise OR)
+0x04 ^ 0x0F; // => 0x0B (bitwise XOR)
+0x01 << 1; // => 0x02 (bitwise left shift (by 1))
+0x02 >> 1; // => 0x01 (bitwise right shift (by 1))
+
+///////////////////////////////////////
+// Kontrol Yapıları
+///////////////////////////////////////
+
+if (0) {
+  printf("I am never run\n");
+} else if (0) {
+  printf("I am also never run\n");
+} else {
+  printf("I print\n");
+}
+
+// While Döngüsü
+int ii = 0;
+while (ii < 10) {
+    printf("%d, ", ii++); // ii++, ii değişkenini değerini kullandıktan sonra artırır.
+} // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+printf("\n");
+
+int kk = 0;
+do {
+    printf("%d, ", kk);
+} while (++kk < 10); // ++kk, kk değişkeninin değerini kullanmadan önce artırır.
+// => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+printf("\n");
+
+// For Döngüsü
+int jj;
+for (jj=0; jj < 10; jj++) {
+    printf("%d, ", jj);
+} // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+printf("\n");
+
+///////////////////////////////////////
+// Tip Dönüşümleri
+///////////////////////////////////////
+
+// C'de her değer bir tipe sahiptir, ama siz bir değeri bir başka tipe 
+// dönüştürebilirsiniz.
+
+int x_hex = 0x01; // Hex literatüründe değer atayabilirsiniz.
+
+// Türler arasındaki dönüşümde kendi değerini korumak için çalışacaktır.
+printf("%d\n", x_hex); // => Prints 1
+printf("%d\n", (short) x_hex); // => Prints 1
+printf("%d\n", (char) x_hex); // => Prints 1
+
+// Tip hiçbir hata vermeden taşacaktır(overflow).
+printf("%d\n", (char) 257); // => 1 (Max char = 255)
+
+// Integral tipi kayan noktalı yazı tipine dönüştürülecektir ve tam tersi. 
+printf("%f\n", (float)100); // %f formats a float
+printf("%lf\n", (double)100); // %lf formats a double
+printf("%d\n", (char)100.0);
+
+///////////////////////////////////////
+// İşaretçiler (Pointers)
+///////////////////////////////////////
+
+// Bir işaretci bellek adresini barındıran bir değişkendir. Tanımlaması ile işaret 
+// edeceği verinin tipi de belirtilecektir. Değişkenlerininzi bellek adreslerini 
+// getirerek bellek ile ilgili karışıklığı ortadan kaldırabilirsiniz. 
+
+int x = 0;
+printf("%p\n", &x); // & işareti bir değişkenin bellek adresini getirmek için kullanılır. 
+// (%p işaretçilerin formatıdır)
+// => Bazı bellek adresleri yazdırılacaktır.
+
+
+// İşaretçiler tanımlanırken * ile başlar
+int *px, not_a_pointer; // px sayı tipinde bir işaretçidir. 
+px = &x; // X değişkeninin bellek adresi px değişkeninde tutulmaktadır.
+printf("%p\n", px); // => x değişkeninin bellek adresi yazdırılacaktır. 
+printf("%d, %d\n", (int)sizeof(px), (int)sizeof(not_a_pointer));
+// => 64-bit sistemde "8, 4" yazdırılacaktır.
+
+// İşaretçinin adres olarak gösterdiği yerdeki değeri almak için 
+// değişkenin önüne * işareti ekleyiniz.
+printf("%d\n", *px); // => 0 bastıracaktır, x in değeridir, 
+                     // çünkü px değişkeni x in adresini göstermektedir.
+
+// Ayrıca siz işaretçinin gösterdiği yerin değerini 
+// değiştirebilirsiniz. Burada referansı parantez içerisinde göstereceğiz 
+// çünkü ++ işleminin önceliği * işleminden yüksektir.
+(*px)++; // px'in işaret ettiği değeri 1 artır. 
+printf("%d\n", *px); // => 1 yazdırılır.
+printf("%d\n", x); // => 1 yazdırılır.
+
+int x_array[20]; // Diziler(arrays) bellekten yan yana bellek bloklarını 
+                 // tahsis etmek için iyi bir yöntemdir.
+int xx;
+for (xx=0; xx<20; xx++) {
+    x_array[xx] = 20 - xx;
+} // x_array dizisi 20, 19, 18,... 2, 1 değerleri ile oluşturuluyor.
+
+// Bir sayı tipinde işaretçi tanımlanıyor ve x_array'i işaret ediyor.
+int* x_ptr = x_array;
+// x_ptr artık dizinin ilk elemanını işaret etmektedir (the integer 20).
+// Bu çalışacaktır çünkü diziler(arrays) aslında sadece onların ilk 
+// elemanlarını gösteren birer işaretçidir.
+
+// Diziler ilk elemanlarını gösteren birer işaretçidirler.
+printf("%d\n", *(x_ptr)); // => 20 yazılacaktır.
+printf("%d\n", x_array[0]); // => 20 yazılacaktır.
+
+// İşaretçiler kendi tiplerinde artırılır ve azaltılır. 
+printf("%d\n", *(x_ptr + 1)); // => 19 yazılacaktır.
+printf("%d\n", x_array[1]); // => 19 yazılacaktır.
+
+// Ayrıca dinamik olarak bir bellek bloğunu standart kütüphanede bulunan 
+// malloc fonksiyonu ile uygulamanız için ayırabilirsiniz. Bu fonksiyon 
+// byte türünden ayırmak istediğiniz bloğun boyutunu parametre olarak alır. 
+int* my_ptr = (int*) malloc(sizeof(int) * 20);
+for (xx=0; xx<20; xx++) {
+    *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx 'de aynı zamanda çalışabilir
+} // Bellekte 20, 19, 18, 17... 2, 1 (as ints) şeklinde oluşturulmuş olacaktır.
+
+// Eğer ayrımadığınız bir bellek adresini çağırırsanız
+// öngörülmeyen bir değer dönecektir. 
+printf("%d\n", *(my_ptr + 21)); // => kim-bilir-ne-yazacak?
+
+// Malloc fonksiyonu ile ayrıdığınız bellek kısmı ile işiniz bittiğinde 
+// onu free fonksiyonu ile boşaltmalısınız, aksi durumda uygulamanız 
+// kapatılana kadar belleğin o kısmını kimse kullanamaz. 
+free(my_ptr);
+
+// Metin Dizileri(String) birer karakter dizisidir(char array), ama
+// genelde karakter işaretçisi olarak kullanılır.
+char* my_str = "This is my very own string";
+
+printf("%c\n", *my_str); // => 'T'
+
+function_1();
+} // main fonksiyon sonu
+
+///////////////////////////////////////
+// Fonksiyonlar
+///////////////////////////////////////
+
+// Fonksiyon tanımlama sözdizimi:
+// <return type> <fonksiyon adi>(<args>)
+
+int add_two_ints(int x1, int x2){
+    return x1 + x2; // bir değer geri döndürmek için return kullanılır.
+}
+
+/*
+Fonksiyonlar pass-by-value'dür, ama isterseniz işaretçi referanslarını 
+kullanarak fonksiyona gönderilen parametrenin değerini değiştirebilirsiniz. 
+
+Example: Bir metni tersine çevirme
+*/
+
+// Bir void konksiyonu hiç bir değer dönmez
+void str_reverse(char* str_in){
+    char tmp;
+    int ii=0, len = strlen(str_in); // Strlen C'nin standart kütüphanesinin bir fonksiyonu
+    for(ii=0; ii<len/2; ii++){
+        tmp = str_in[ii];
+        str_in[ii] = str_in[len - ii - 1]; // sondan ii'inci elemanı
+        str_in[len - ii - 1] = tmp;
+    }
+}
+
+/*
+char c[] = "This is a test.";
+str_reverse(c);
+printf("%s\n", c); // => ".tset a si sihT"
+*/
+
+///////////////////////////////////////
+// Kullanıcı Tanımlı Tipler ve Yapılar
+///////////////////////////////////////
+
+// Typedef'ler bir tip takma adı oluşturur.
+typedef int my_type;
+my_type my_type_var = 0;
+
+// Struct'lar bir veri koleksiyonudur. 
+struct rectangle {
+    int width;
+    int height;
+};
+
+
+void function_1(){
+
+    struct rectangle my_rec;
+
+    // "." ile yapı üyelerine ulaşılabilir.
+    my_rec.width = 10;
+    my_rec.height = 20;
+
+    // Bir yapının adresini işaretçiye atayabilirsiniz.
+    struct rectangle* my_rec_ptr = &my_rec;
+
+    // İşaretçi üzerinden bir yapıya ulaşabilirsiniz. 
+    (*my_rec_ptr).width = 30;
+
+    // ya da -> işareti ile yapının elemanlarına ulaşabilirsiniz. 
+    my_rec_ptr->height = 10; // (*my_rec_ptr).height = 10; ile aynıdır.
+}
+
+// Kolaylık sağlamak için bir yapıya typedef tanımlayabilirsiniz. 
+typedef struct rectangle rect;
+
+int area(rect r){
+    return r.width * r.height;
+}
+
+///////////////////////////////////////
+// Fonksiyon İşaretçiler
+///////////////////////////////////////
+
+/*
+Çalışma zamanında, fonksiyonların bilinen bir bellek adresleri vardır. Fonksiyon
+işaretçileri fonksiyonları direk olarak çağırmayı sağlayan veya geri bildirim(callback)
+için parametre gönderirken kullanılan başka birer işaretçidirler. Ama, syntax tanımı 
+başlangıçta biraz karışık gelebilir. 
+
+Örnek: bir işaretçiden str_reverse kullanımı
+*/
+void str_reverse_through_pointer(char * str_in) {
+    // f adında bir fonksiyon işaretçisi tanımlanır.
+    void (*f)(char *); // Signature should exactly match the target function.
+    f = &str_reverse; // Assign the address for the actual function (determined at runtime)
+    (*f)(str_in); // Just calling the function through the pointer
+    // f(str_in); // That's an alternative but equally valid syntax for calling it.
+}
+
+/*
+As long as function signatures match, you can assign any function to the same pointer.
+Function pointers are usually typedef'd for simplicity and readability, as follows:
+*/
+
+typedef void (*my_fnp_type)(char *);
+
+// Gerçek bir işaretçi tanımlandığı zaman ki kullanımı:
+// ...
+// my_fnp_type f; 
+
+```
+
+## Daha Fazla Okuma Listesi
+
+[K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language)'in bir kopyasını bulundurmak mükemmel olabilir
+
+Diğer bir iyi kaynak ise [Learn C the hard way](http://c.learncodethehardway.org/book/)
+
+Diğer taraftan google sizin için bir arkadaş olabilir.
-- 
cgit v1.2.3


From f6b7d0b2c02de143df5992fa10e5284bf72132d3 Mon Sep 17 00:00:00 2001
From: Haydar Kulekci <haydarkulekci@gmail.com>
Date: Mon, 19 Aug 2013 14:41:44 +0300
Subject: some updates turkish translation for latest updates of forked repo

---
 tr-tr/c-tr.html.markdown | 585 ++++++++++++++++++++++++++---------------------
 1 file changed, 326 insertions(+), 259 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/c-tr.html.markdown b/tr-tr/c-tr.html.markdown
index 1f9db274..50bca246 100644
--- a/tr-tr/c-tr.html.markdown
+++ b/tr-tr/c-tr.html.markdown
@@ -24,11 +24,16 @@ anlarsanız sizi isteğiniz yere götürecektir.
 Çoklu satırlı yorumlar bu şekilde görünür.
 */
 
-// #include ile header dosyalarınız dahil edin.
+// C Standart kütüphanelerini uygulamanıza #include<ornek.h> ile 
+// dahil edebilirsiniz.
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 
+// Kendi başlık(header) dosyalarınız dahil etmek için "çift tırnak" 
+// kullanmalısınız.
+#include "my_header.h"
+
 // Fonksiyonlarınızı bir .h dosyasında ya da c dosyanızın üst tarafta 
 // tanımlayın.
 
@@ -39,265 +44,317 @@ void function_2();
 // integer değer döner
 int main() {
 
-// çıktıları yazdırmak için printf kullanılır, "print formatted"
-// %d bir sayı tipidir, \n yeni satır karakteridir
-printf("%d\n", 0); // => 0 karakteri yazdırılır.
-// Tüm ifadeler noktalı virgül ile bitmelidir.
-
-///////////////////////////////////////
-// Tipler
-///////////////////////////////////////
-
-// Değişkenleri kullanmadan önce tanımlamalısınız. Bir değişken tanımlarken
-// tipini belirtmelisiniz; bu tip onun byte olarak boyutunu belirler.
-
-// int değişken tipi 4 byte boyutundadır.
-int x_int = 0;
-
-// short değişken tipi genellikle 2 byte boyutundadır.
-short x_short = 0;
-
-// char tipi 1 byte boyutunu garanti eder. 
-char x_char = 0;
-char y_char = 'y'; // Karakterler '' işaretleri arasına yazılır.
-
-// long tipi 4-8 byte olur; long long tipi en azından 64 bit garantiler.
-long x_long = 0;
-long long x_long_long = 0; 
-
-// float tipi 32-bit kayan noktalı sayı boyutundadır.
-float x_float = 0.0;
-
-// double değişken tipi 64-bit kayan noktalı yazı tipindedir. 
-double x_double = 0.0;
-
-// Integral türleri işaretsiz olabilir. Bunun anlamı, onlar eksi değer 
-// olamaz demektir, ama aynı boyuttaki işaretsiz bir sayının maksimum 
-// değeri işaretli bir sayının maksimum değeriden büyük olur.
-unsigned char ux_char;
-unsigned short ux_short;
-unsigned int ux_int;
-unsigned long long ux_long_long;
-
-// Diğer taraftan char, ki her zaman bir byte boyutundadır, bu tipler 
-// makinenize göre boyut değiştirir. sizeof(T) size bir değişkenin byte 
-// cinsinden boyutunu verir öyle ki bu tipin boyutunu taşınabilir bir 
-// şekilde ifade edilebilir
-// Örneğin,
-printf("%lu\n", sizeof(int)); // => 4 (on machines with 4-byte words)
-
-// Diziler somut bir boyut ile oluşturulmalıdır.
-char my_char_array[20]; // Bu dizi 1 * 20 = 20 byte alan kaplar
-int my_int_array[20]; // Bu dizi 4 * 20 = 80 byte alan kaplar
-                      // (4-byte bir word varsayılır)
-
-// Şu şekilde bir diziyi 0 ile oluşturabilirsiniz:
-char my_array[20] = {0};
-
-// Dizinin elemanlarını indexlemek diğer diller gibidir, veya 
-// diğer diller C gibi.
-my_array[0]; // => 0
-
-// Diziler değişebilirdir (mutable); O sadece memory!
-my_array[1] = 2;
-printf("%d\n", my_array[1]); // => 2
-
-// String'ler bir NUL (0x00) byte ile sonlandırılmış karakter dizileridir,
-// bu string içerisinde özel bir karakter olan '\0' ile gösterilir.
-// (Biz Nul byte'i string karakterleri arasında bulundurmamıza gerek 
-// yoktur; derleyici onu bizim için dizinin sonuna ekler.)
-char a_string[20] = "This is a string";
-printf("%s\n", a_string); // %s bir string formatıdır.
-
-/*
-a_string 16 karakter uzunluğundadır. 
-17. karakter NUL karakteridir.
-18., 19. ve 20. karakterler tanımsızdır.(undefined)
-*/
-
-printf("%d\n", a_string[16]); // => 0
-
-///////////////////////////////////////
-// Operatörler
-///////////////////////////////////////
-
-int i1 = 1, i2 = 2; // Çoklu tanımlama için kısayol.
-float f1 = 1.0, f2 = 2.0;
-
-// Aritmatik basittir.
-i1 + i2; // => 3
-i2 - i1; // => 1
-i2 * i1; // => 2
-i1 / i2; // => 0 (0.5'dir ama 0 a yuvarlanmıştır.)
-
-f1 / f2; // => 0.5, artı veya eksi epsilon
-
-// Modüler aritmetikte vardır.
-11 % 3; // => 2
-
-// Karşılaştırma operatörleri muhtemelen tanıdıktır, ama
-// C'de boolean tipi yoktur. Bunun yerine sayı(int) kullanırız.
-// 0 false yerine ve diğer herşey true yerine geçmektedir. 
-// (Karşılaştırma operatörleri her zaman 0 veya 1 dönmektedir.)
-3 == 2; // => 0 (false)
-3 != 2; // => 1 (true)
-3 > 2; // => 1
-3 < 2; // => 0
-2 <= 2; // => 1
-2 >= 2; // => 1
-
-// Sayılar üzerinde mantık işlemleri
-!3; // => 0 (Logical not)
-!0; // => 1
-1 && 1; // => 1 (Logical and)
-0 && 1; // => 0
-0 || 1; // => 1 (Logical or)
-0 || 0; // => 0
-
-// Bit boyutunda işlem yapmak için operatörler
-~0x0F; // => 0xF0 (bitwise negation)
-0x0F & 0xF0; // => 0x00 (bitwise AND)
-0x0F | 0xF0; // => 0xFF (bitwise OR)
-0x04 ^ 0x0F; // => 0x0B (bitwise XOR)
-0x01 << 1; // => 0x02 (bitwise left shift (by 1))
-0x02 >> 1; // => 0x01 (bitwise right shift (by 1))
-
-///////////////////////////////////////
-// Kontrol Yapıları
-///////////////////////////////////////
-
-if (0) {
-  printf("I am never run\n");
-} else if (0) {
-  printf("I am also never run\n");
-} else {
-  printf("I print\n");
-}
-
-// While Döngüsü
-int ii = 0;
-while (ii < 10) {
-    printf("%d, ", ii++); // ii++, ii değişkenini değerini kullandıktan sonra artırır.
-} // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
-
-printf("\n");
-
-int kk = 0;
-do {
-    printf("%d, ", kk);
-} while (++kk < 10); // ++kk, kk değişkeninin değerini kullanmadan önce artırır.
-// => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
-
-printf("\n");
-
-// For Döngüsü
-int jj;
-for (jj=0; jj < 10; jj++) {
-    printf("%d, ", jj);
-} // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
-
-printf("\n");
-
-///////////////////////////////////////
-// Tip Dönüşümleri
-///////////////////////////////////////
-
-// C'de her değer bir tipe sahiptir, ama siz bir değeri bir başka tipe 
-// dönüştürebilirsiniz.
-
-int x_hex = 0x01; // Hex literatüründe değer atayabilirsiniz.
-
-// Türler arasındaki dönüşümde kendi değerini korumak için çalışacaktır.
-printf("%d\n", x_hex); // => Prints 1
-printf("%d\n", (short) x_hex); // => Prints 1
-printf("%d\n", (char) x_hex); // => Prints 1
-
-// Tip hiçbir hata vermeden taşacaktır(overflow).
-printf("%d\n", (char) 257); // => 1 (Max char = 255)
-
-// Integral tipi kayan noktalı yazı tipine dönüştürülecektir ve tam tersi. 
-printf("%f\n", (float)100); // %f formats a float
-printf("%lf\n", (double)100); // %lf formats a double
-printf("%d\n", (char)100.0);
-
-///////////////////////////////////////
-// İşaretçiler (Pointers)
-///////////////////////////////////////
+    // çıktıları yazdırmak için printf kullanılır, "print formatted"
+    // %d bir sayı tipidir, \n yeni satır karakteridir
+    printf("%d\n", 0); // => 0 karakteri yazdırılır.
+    // Tüm ifadeler noktalı virgül ile bitmelidir.
+
+    ///////////////////////////////////////
+    // Tipler
+    ///////////////////////////////////////
+
+    // Değişkenleri kullanmadan önce tanımlamalısınız. Bir değişken tanımlarken
+    // tipini belirtmelisiniz; bu tip onun byte olarak boyutunu belirler.
+
+    // int değişken tipi 4 byte boyutundadır.
+    int x_int = 0;
+
+    // short değişken tipi genellikle 2 byte boyutundadır.
+    short x_short = 0;
+
+    // char tipi 1 byte boyutunu garanti eder. 
+    char x_char = 0;
+    char y_char = 'y'; // Karakterler '' işaretleri arasına yazılır.
+
+    // long tipi 4-8 byte olur; long long tipi en azından 64 bit garantiler.
+    long x_long = 0;
+    long long x_long_long = 0; 
+
+    // float tipi 32-bit kayan noktalı sayı boyutundadır.
+    float x_float = 0.0;
+
+    // double değişken tipi 64-bit kayan noktalı yazı tipindedir. 
+    double x_double = 0.0;
+
+    // Integral türleri işaretsiz olabilir. Bunun anlamı, onlar eksi değer 
+    // olamaz demektir, ama aynı boyuttaki işaretsiz bir sayının maksimum 
+    // değeri işaretli bir sayının maksimum değeriden büyük olur.
+    unsigned char ux_char;
+    unsigned short ux_short;
+    unsigned int ux_int;
+    unsigned long long ux_long_long;
+
+    // Diğer taraftan char, ki her zaman bir byte boyutundadır, bu tipler 
+    // makinenize göre boyut değiştirir. sizeof(T) size bir değişkenin byte 
+    // cinsinden boyutunu verir öyle ki bu tipin boyutunu taşınabilir bir 
+    // şekilde ifade edilebilir
+    // Örneğin,
+    printf("%lu\n", sizeof(int)); // => 4 (bir çok makinede 4-byte words)
+
+    // If the argument of the `sizeof` operator an expression, then its argument
+    // is not evaluated (except VLAs (see below)).
+    // The value it yields in this case is a compile-time constant.
+    int a = 1;
+    size_t size = sizeof(a++); // a++ is not evaluated
+    printf("sizeof(a++) = %zu where a = %d\n", size, a);
+    // prints "sizeof(a++) = 4 where a = 1" (on a 32-bit architecture)
+
+    // Diziler somut bir boyut ile oluşturulmalıdır.
+    char my_char_array[20]; // Bu dizi 1 * 20 = 20 byte alan kaplar
+    int my_int_array[20]; // Bu dizi 4 * 20 = 80 byte alan kaplar
+                          // (4-byte bir word varsayılır)
+
+    // Şu şekilde bir diziyi 0 ile oluşturabilirsiniz:
+    char my_array[20] = {0};
+
+    // Dizinin elemanlarını indexlemek diğer diller gibidir, veya 
+    // diğer diller C gibi.
+    my_array[0]; // => 0
+
+    // Diziler değişebilirdir (mutable); O sadece memory!
+    my_array[1] = 2;
+    printf("%d\n", my_array[1]); // => 2
+
+    // In C99 (and as an optional feature in C11), variable-length arrays (VLAs)
+    // can be declared as well. The size of such an array need not be a compile
+    // time constant:
+    printf("Enter the array size: "); // ask the user for an array size
+    char buf[0x100];
+    fgets(buf, sizeof buf, stdin);
+
+    // strtoul parses a string to an unsigned integer
+    size_t size = strtoul(buf, NULL, 10);
+    int var_length_array[size]; // declare the VLA
+    printf("sizeof array = %zu\n", sizeof var_length_array);
+
+    // A possible outcome of this program may be:
+    // > Enter the array size: 10
+    // > sizeof array = 40
+
+    // String'ler bir NUL (0x00) byte ile sonlandırılmış karakter dizileridir,
+    // bu string içerisinde özel bir karakter olan '\0' ile gösterilir.
+    // (Biz Nul byte'i string karakterleri arasında bulundurmamıza gerek 
+    // yoktur; derleyici onu bizim için dizinin sonuna ekler.)
+    char a_string[20] = "This is a string";
+    printf("%s\n", a_string); // %s bir string formatıdır.
+
+    /*
+    a_string 16 karakter uzunluğundadır. 
+    17. karakter NUL karakteridir.
+    18., 19. ve 20. karakterler tanımsızdır.(undefined)
+    */
+
+    printf("%d\n", a_string[16]); // => 0
+    // i.e., byte #17 is 0 (as are 18, 19, and 20)
+
+    // If we have characters between single quotes, that's a character literal.
+    // It's of type `int`, and *not* `char` (for historical reasons).
+    int cha = 'a'; // fine
+    char chb = 'a'; // fine too (implicit conversion from int to char)
+
+    ///////////////////////////////////////
+    // Operatörler
+    ///////////////////////////////////////
+
+    int i1 = 1, i2 = 2; // Çoklu tanımlama için kısayol.
+    float f1 = 1.0, f2 = 2.0;
+
+    // Aritmatik basittir.
+    i1 + i2; // => 3
+    i2 - i1; // => 1
+    i2 * i1; // => 2
+    i1 / i2; // => 0 (0.5'dir ama 0 a yuvarlanmıştır.)
+
+    f1 / f2; // => 0.5, artı veya eksi epsilon
+
+    // Modüler aritmetikte vardır.
+    11 % 3; // => 2
+
+    // Karşılaştırma operatörleri muhtemelen tanıdıktır, ama
+    // C'de boolean tipi yoktur. Bunun yerine sayı(int) kullanırız.
+    // 0 false yerine ve diğer herşey true yerine geçmektedir. 
+    // (Karşılaştırma operatörleri her zaman 0 veya 1 dönmektedir.)
+    3 == 2; // => 0 (false)
+    3 != 2; // => 1 (true)
+    3 > 2; // => 1
+    3 < 2; // => 0
+    2 <= 2; // => 1
+    2 >= 2; // => 1
+
+    // Sayılar üzerinde mantık işlemleri
+    !3; // => 0 (Logical not)
+    !0; // => 1
+    1 && 1; // => 1 (Logical and)
+    0 && 1; // => 0
+    0 || 1; // => 1 (Logical or)
+    0 || 0; // => 0
+
+    // Bit boyutunda işlem yapmak için operatörler
+    ~0x0F; // => 0xF0 (bitwise negation)
+    0x0F & 0xF0; // => 0x00 (bitwise AND)
+    0x0F | 0xF0; // => 0xFF (bitwise OR)
+    0x04 ^ 0x0F; // => 0x0B (bitwise XOR)
+    0x01 << 1; // => 0x02 (bitwise left shift (by 1))
+    0x02 >> 1; // => 0x01 (bitwise right shift (by 1))
+
+    // Be careful when shifting signed integers - the following are undefined:
+    // - shifting into the sign bit of a signed integer (int a = 1 << 32)
+    // - left-shifting a negative number (int a = -1 << 2)
+    // - shifting by an offset which is >= the width of the type of the LHS:
+    //   int a = 1 << 32; // UB if int is 32 bits wide
+
+    ///////////////////////////////////////
+    // Kontrol Yapıları
+    ///////////////////////////////////////
+
+    if (0) {
+      printf("I am never run\n");
+    } else if (0) {
+      printf("I am also never run\n");
+    } else {
+      printf("I print\n");
+    }
 
-// Bir işaretci bellek adresini barındıran bir değişkendir. Tanımlaması ile işaret 
-// edeceği verinin tipi de belirtilecektir. Değişkenlerininzi bellek adreslerini 
-// getirerek bellek ile ilgili karışıklığı ortadan kaldırabilirsiniz. 
-
-int x = 0;
-printf("%p\n", &x); // & işareti bir değişkenin bellek adresini getirmek için kullanılır. 
-// (%p işaretçilerin formatıdır)
-// => Bazı bellek adresleri yazdırılacaktır.
-
-
-// İşaretçiler tanımlanırken * ile başlar
-int *px, not_a_pointer; // px sayı tipinde bir işaretçidir. 
-px = &x; // X değişkeninin bellek adresi px değişkeninde tutulmaktadır.
-printf("%p\n", px); // => x değişkeninin bellek adresi yazdırılacaktır. 
-printf("%d, %d\n", (int)sizeof(px), (int)sizeof(not_a_pointer));
-// => 64-bit sistemde "8, 4" yazdırılacaktır.
-
-// İşaretçinin adres olarak gösterdiği yerdeki değeri almak için 
-// değişkenin önüne * işareti ekleyiniz.
-printf("%d\n", *px); // => 0 bastıracaktır, x in değeridir, 
-                     // çünkü px değişkeni x in adresini göstermektedir.
-
-// Ayrıca siz işaretçinin gösterdiği yerin değerini 
-// değiştirebilirsiniz. Burada referansı parantez içerisinde göstereceğiz 
-// çünkü ++ işleminin önceliği * işleminden yüksektir.
-(*px)++; // px'in işaret ettiği değeri 1 artır. 
-printf("%d\n", *px); // => 1 yazdırılır.
-printf("%d\n", x); // => 1 yazdırılır.
-
-int x_array[20]; // Diziler(arrays) bellekten yan yana bellek bloklarını 
-                 // tahsis etmek için iyi bir yöntemdir.
-int xx;
-for (xx=0; xx<20; xx++) {
-    x_array[xx] = 20 - xx;
-} // x_array dizisi 20, 19, 18,... 2, 1 değerleri ile oluşturuluyor.
-
-// Bir sayı tipinde işaretçi tanımlanıyor ve x_array'i işaret ediyor.
-int* x_ptr = x_array;
-// x_ptr artık dizinin ilk elemanını işaret etmektedir (the integer 20).
-// Bu çalışacaktır çünkü diziler(arrays) aslında sadece onların ilk 
-// elemanlarını gösteren birer işaretçidir.
-
-// Diziler ilk elemanlarını gösteren birer işaretçidirler.
-printf("%d\n", *(x_ptr)); // => 20 yazılacaktır.
-printf("%d\n", x_array[0]); // => 20 yazılacaktır.
-
-// İşaretçiler kendi tiplerinde artırılır ve azaltılır. 
-printf("%d\n", *(x_ptr + 1)); // => 19 yazılacaktır.
-printf("%d\n", x_array[1]); // => 19 yazılacaktır.
-
-// Ayrıca dinamik olarak bir bellek bloğunu standart kütüphanede bulunan 
-// malloc fonksiyonu ile uygulamanız için ayırabilirsiniz. Bu fonksiyon 
-// byte türünden ayırmak istediğiniz bloğun boyutunu parametre olarak alır. 
-int* my_ptr = (int*) malloc(sizeof(int) * 20);
-for (xx=0; xx<20; xx++) {
-    *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx 'de aynı zamanda çalışabilir
-} // Bellekte 20, 19, 18, 17... 2, 1 (as ints) şeklinde oluşturulmuş olacaktır.
-
-// Eğer ayrımadığınız bir bellek adresini çağırırsanız
-// öngörülmeyen bir değer dönecektir. 
-printf("%d\n", *(my_ptr + 21)); // => kim-bilir-ne-yazacak?
-
-// Malloc fonksiyonu ile ayrıdığınız bellek kısmı ile işiniz bittiğinde 
-// onu free fonksiyonu ile boşaltmalısınız, aksi durumda uygulamanız 
-// kapatılana kadar belleğin o kısmını kimse kullanamaz. 
-free(my_ptr);
-
-// Metin Dizileri(String) birer karakter dizisidir(char array), ama
-// genelde karakter işaretçisi olarak kullanılır.
-char* my_str = "This is my very own string";
-
-printf("%c\n", *my_str); // => 'T'
-
-function_1();
+    // While Döngüsü
+    int ii = 0;
+    while (ii < 10) {
+        printf("%d, ", ii++); // ii++, ii değişkenini değerini kullandıktan sonra artırır.
+    } // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+    printf("\n");
+
+    int kk = 0;
+    do {
+        printf("%d, ", kk);
+    } while (++kk < 10); // ++kk, kk değişkeninin değerini kullanmadan önce artırır.
+    // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+    printf("\n");
+
+    // For Döngüsü
+    int jj;
+    for (jj=0; jj < 10; jj++) {
+        printf("%d, ", jj);
+    } // => prints "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+    printf("\n");
+
+    ///////////////////////////////////////
+    // Tip Dönüşümleri
+    ///////////////////////////////////////
+
+    // C'de her değer bir tipe sahiptir, ama siz bir değeri bir başka tipe 
+    // dönüştürebilirsiniz.
+
+    int x_hex = 0x01; // Hex literatüründe değer atayabilirsiniz.
+
+    // Türler arasındaki dönüşümde kendi değerini korumak için çalışacaktır.
+    printf("%d\n", x_hex); // => Prints 1
+    printf("%d\n", (short) x_hex); // => Prints 1
+    printf("%d\n", (char) x_hex); // => Prints 1
+
+    // Tip hiçbir hata vermeden taşacaktır(overflow).
+    printf("%d\n", (unsigned char) 257); // => 1 (Max char = 255 eğer karakter 8 bit uzunluğunda ise)
+
+    // `char`, `signed char` ve `unsigned char` karakter tiplerinin maksimum uzunluğunu 
+    // belirlemek için <limits.h> kütüphanesindeki CHAR_MAX, SCHAR_MAX ve UCHAR_MAX 
+    // macrolarını kullanınız.
+
+    // Integral tipi kayan noktalı yazı tipine dönüştürülecektir ve tam tersi. 
+    printf("%f\n", (float)100); // %f formats a float
+    printf("%lf\n", (double)100); // %lf formats a double
+    printf("%d\n", (char)100.0);
+
+    ///////////////////////////////////////
+    // İşaretçiler (Pointers)
+    ///////////////////////////////////////
+
+    // Bir işaretci bellek adresini barındıran bir değişkendir. Tanımlaması ile işaret 
+    // edeceği verinin tipi de belirtilecektir. Değişkenlerininzi bellek adreslerini 
+    // getirerek bellek ile ilgili karışıklığı ortadan kaldırabilirsiniz. 
+
+    int x = 0;
+    printf("%p\n", &x); // & işareti bir değişkenin bellek adresini getirmek için kullanılır. 
+    // (%p işaretçilerin formatıdır)
+    // => Bazı bellek adresleri yazdırılacaktır.
+
+
+    // İşaretçiler tanımlanırken * ile başlar
+    int *px, not_a_pointer; // px sayı tipinde bir işaretçidir. 
+    px = &x; // X değişkeninin bellek adresi px değişkeninde tutulmaktadır.
+    printf("%p\n", px); // => x değişkeninin bellek adresi yazdırılacaktır. 
+    printf("%d, %d\n", (int)sizeof(px), (int)sizeof(not_a_pointer));
+    // => 64-bit sistemde "8, 4" yazdırılacaktır.
+
+    // İşaretçinin adres olarak gösterdiği yerdeki değeri almak için 
+    // değişkenin önüne * işareti ekleyiniz.
+    printf("%d\n", *px); // => 0 bastıracaktır, x in değeridir, 
+                         // çünkü px değişkeni x in adresini göstermektedir.
+
+    // Ayrıca siz işaretçinin gösterdiği yerin değerini 
+    // değiştirebilirsiniz. Burada referansı parantez içerisinde göstereceğiz 
+    // çünkü ++ işleminin önceliği * işleminden yüksektir.
+    (*px)++; // px'in işaret ettiği değeri 1 artır. 
+    printf("%d\n", *px); // => 1 yazdırılır.
+    printf("%d\n", x); // => 1 yazdırılır.
+
+    int x_array[20]; // Diziler(arrays) bellekten yan yana bellek bloklarını 
+                     // tahsis etmek için iyi bir yöntemdir.
+    int xx;
+    for (xx=0; xx<20; xx++) {
+        x_array[xx] = 20 - xx;
+    } // x_array dizisi 20, 19, 18,... 2, 1 değerleri ile oluşturuluyor.
+
+    // Bir sayı tipinde işaretçi tanımlanıyor ve x_array'i işaret ediyor.
+    int* x_ptr = x_array;
+    // x_ptr artık dizinin ilk elemanını işaret etmektedir (the integer 20).
+    // Bu çalışacaktır çünkü diziler(arrays) aslında sadece onların ilk 
+    // elemanlarını gösteren birer işaretçidir.
+    // For example, when an array is passed to a function or is assigned to a pointer,
+    // it decays into (implicitly converted to) a pointer.
+    // Exceptions: when the array is the argument of the `&` (address-od) operator:
+    int arr[10];
+    int (*ptr_to_arr)[10] = &arr; // &arr is NOT of type `int *`!
+                                  // It's of type "pointer to array" (of ten `int`s).
+    // or when the array is a string literal used for initializing a char array:
+    char arr[] = "foobarbazquirk";
+    // or when it's the argument of the `sizeof` or `alignof` operator:
+    int arr[10];
+    int *ptr = arr; // equivalent with int *ptr = &arr[0];
+    printf("%zu %zu\n", sizeof arr, sizeof ptr); // probably prints "40, 4" or "40, 8"
+
+    // Diziler ilk elemanlarını gösteren birer işaretçidirler.
+    printf("%d\n", *(x_ptr)); // => 20 yazılacaktır.
+    printf("%d\n", x_array[0]); // => 20 yazılacaktır.
+
+    // İşaretçiler kendi tiplerinde artırılır ve azaltılır. 
+    printf("%d\n", *(x_ptr + 1)); // => 19 yazılacaktır.
+    printf("%d\n", x_array[1]); // => 19 yazılacaktır.
+
+    // Ayrıca dinamik olarak bir bellek bloğunu standart kütüphanede bulunan 
+    // malloc fonksiyonu ile uygulamanız için ayırabilirsiniz. Bu fonksiyon 
+    // byte türünden ayırmak istediğiniz bloğun boyutunu parametre olarak alır. 
+    int* my_ptr = (int*) malloc(sizeof(int) * 20);
+    for (xx=0; xx<20; xx++) {
+        *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx 'de aynı zamanda çalışabilir
+    } // Bellekte 20, 19, 18, 17... 2, 1 (as ints) şeklinde oluşturulmuş olacaktır.
+
+    // Eğer ayrımadığınız bir bellek adresini çağırırsanız
+    // öngörülmeyen bir değer dönecektir. 
+    printf("%d\n", *(my_ptr + 21)); // => kim-bilir-ne-yazacak?
+
+    // Malloc fonksiyonu ile ayrıdığınız bellek kısmı ile işiniz bittiğinde 
+    // onu free fonksiyonu ile boşaltmalısınız, aksi durumda uygulamanız 
+    // kapatılana kadar belleğin o kısmını kimse kullanamaz. 
+    free(my_ptr);
+
+    // Metin Dizileri(String) birer karakter dizisidir(char array), ama
+    // genelde karakter işaretçisi olarak kullanılır.
+    char* my_str = "This is my very own string";
+
+    printf("%c\n", *my_str); // => 'T'
+
+    function_1();
 } // main fonksiyon sonu
 
 ///////////////////////////////////////
@@ -349,6 +406,10 @@ struct rectangle {
     int height;
 };
 
+// It's not generally true that
+// sizeof(struct rectangle) == sizeof(int) + sizeof(int)
+// due to potential padding between the structure members (this is for alignment
+// reasons). [1]
 
 void function_1(){
 
@@ -414,4 +475,10 @@ typedef void (*my_fnp_type)(char *);
 
 Diğer bir iyi kaynak ise [Learn C the hard way](http://c.learncodethehardway.org/book/)
 
+It's very important to use proper spacing, indentation and to be consistent with your coding style in general.
+Readable code is better than clever code and fast code. For a good, sane coding style to adopt, see the
+[Linux kernel coding stlye](https://www.kernel.org/doc/Documentation/CodingStyle).
+
 Diğer taraftan google sizin için bir arkadaş olabilir.
+
+[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member
\ No newline at end of file
-- 
cgit v1.2.3


From e70c6a7155992b2a649790245db360d9584349e6 Mon Sep 17 00:00:00 2001
From: Haydar Kulekci <haydarkulekci@gmail.com>
Date: Tue, 20 Aug 2013 09:59:49 +0300
Subject: turkish translation for php language

---
 tr-tr/php-tr.html.markdown | 682 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 682 insertions(+)
 create mode 100644 tr-tr/php-tr.html.markdown

(limited to 'tr-tr')

diff --git a/tr-tr/php-tr.html.markdown b/tr-tr/php-tr.html.markdown
new file mode 100644
index 00000000..94bc31ff
--- /dev/null
+++ b/tr-tr/php-tr.html.markdown
@@ -0,0 +1,682 @@
+---
+language: php
+filename: learnphp-tr.php
+contributors:
+    - ["Malcolm Fell", "http://emarref.net/"]
+    - ["Trismegiste", "https://github.com/Trismegiste"]
+translators:
+    - ["Haydar KULEKCI", "http://scanf.info/"]
+lang: tr-tr
+---
+
+PHP 5+ versiyonu için geçerlidir.
+
+```php
+<?php // PHP kodları <?php etiketleri içerisinde bulunmalıdır.
+
+// Eğer php dosyanız sadece PHP kodu içeriyorsa, php'nin kapatma 
+// etiketini kapatmayabilirsiniz. 
+
+// // işareti ile tek satırlık yorum satırı başlar.
+
+# # işareti de aynı görevi görür ancak // daha genel kullanımdadır.
+
+
+
+/*
+    Çoklu satır kodu bu şekilde yazıyoruz. slash yıldız ile başlar 
+    ve yıldız slash ile biter.
+*/
+
+// "echo" ya da "print" metodları çıktı almak için kullanılır.
+print('Hello '); // Ekrana Yeni satır karakteri olmadan "Hello " 
+                 // yazdırılır.
+
+// () parantezler "echo" ve "print" metodları için isteğe bağlıdır. 
+echo "World\n"; // Ekrana yeni satır karakteri olmadan "World"
+                // yazdırılır.
+// (Bütün ifadeler noktalı virgül ile bitmelidir.)
+
+// <?php tagı dışarısındaki herşey otomatik olarak yazdırılacaktır.
+?>
+Hello World Again!
+<?php
+
+
+/************************************
+*   Tipler ve Değişkenler
+*************************************/
+
+// Değişkenler $ sembolü ile başlar.
+// Geçerli bir değişken bir harf veya alt çizgi ile başlar,
+// devamında da bir sayı, harf veya alt çizgi ile devam eder. 
+
+// Mantıksal değerler 
+// Boolean values are harf büyüklüğüne duyarsızdır.
+$boolean = true;  // veya TRUE veya True
+$boolean = false; // veya FALSE veya False
+
+// Tam Sayılar
+$int1 = 12;   // => 12
+$int2 = -12;  // => -12
+$int3 = 012;  // => 10 (öneki 0 olan sekizlik(octal) bir sayıyı gösterir)
+$int4 = 0x0F; // => 15 (öneki 0x olanlar hex sayıları gösterir.)
+
+// Kayan Noktalı Sayılar
+$float = 1.234;
+$float = 1.2e3;
+$float = 7E-10;
+
+// Aritmetik
+$sum        = 1 + 1; // 2
+$difference = 2 - 1; // 1
+$product    = 2 * 2; // 4
+$quotient   = 2 / 1; // 2
+
+// Aritmetik Kısayolları
+$number = 0;
+$number += 1;      // $number değişkeninin değerini 1 artırır.
+echo $number++;    // 1 yazdırılır. (Yazdırıldıktan sonra artırılır.)
+echo ++$number;    // 3 yazdırılır. (yazdırılmadan önce artırılır.)
+$number /= $float; // Bölünür ve bölüm $number değerine eşitlenir.
+
+// Karakter dizileri(strings) tek tırnak ile kullanılmalıdır.
+$sgl_quotes = '$String'; // => '$String'
+
+// Bir değişken içermediği sürece çift tırnak kullanmaktan kaçının
+$dbl_quotes = "This is a $sgl_quotes."; // => 'This is a $String.'
+
+// Özel karakterler sadece çift tırnak ile kullanılabilir.
+$escaped   = "This contains a \t tab character.";
+$unescaped = 'This just contains a slash and a t: \t';
+
+// Gerekirse bir değişkeni küme ayracı içine alın.
+$money = "I have $${number} in the bank.";
+
+// Since PHP 5.3, nowdocs can be used for uninterpolated multi-liners
+$nowdoc = <<<'END'
+Multi line
+string
+END;
+
+// Heredocs will do string interpolation
+$heredoc = <<<END
+Multi line
+$sgl_quotes
+END;
+
+// . işareti ile karakter dizileri birbirine birleştirilebilir.
+echo 'This string ' . 'is concatenated';
+
+
+/********************************
+ * Sabitler
+ */
+
+// Bir sabit define() metodu kullanılarak tanımlanır.
+// ve çalışma zamanından hiçbir zaman değişmez!
+
+// geçerli bir sabit bir harf veya altçizgi ile başlar,
+// ve bir sayı, harf ya da altçizgi ile devam eder.
+define("FOO",     "something");
+
+// sabite ulaşmak için direk olarak seçilen ismi kullanabilirsiniz. 
+echo 'This outputs '.FOO;
+
+
+/********************************
+ * Diziler
+ */
+
+// PHP'de bütün diziler ilişikilendirilebilirdir. (hashmaps),
+// İlişkilendirilebilir(associative) diziler, hashmap olarak bilinir. 
+
+// PHP'nin bütün versiyonları için çalışır
+$associative = array('One' => 1, 'Two' => 2, 'Three' => 3);
+
+// PHP 5.4 ile yeni bir söz dizimi kullanılmaya başlandı
+$associative = ['One' => 1, 'Two' => 2, 'Three' => 3];
+
+echo $associative['One']; // 1 yazdıracaktır.
+
+// Liste kullanımında index'ler tam sayıdır.
+$array = ['One', 'Two', 'Three'];
+echo $array[0]; // => "One"
+
+
+/********************************
+ * Çıktı
+ */
+
+echo('Hello World!');
+// Hello World! çıktısı stdout'a yazdırılır.
+// Eğer bir web browser ile çalışıyorsanır Stdout bir web sayfasıdır.
+
+print('Hello World!'); // echo ile aynıdır.
+
+// Aslında echo bir dil sabitidir, parantezleri kullanmayabilirsiniz. 
+echo 'Hello World!';
+print 'Hello World!'; // Bu yazdırılacaktır. 
+
+$paragraph = 'paragraph';
+
+echo 100;        // Echo ile doğrudan sayısal değer kullanımı
+echo $paragraph; // veya değişken
+
+// PHP 5.4.0 veya daha üstü sürümlerde kısa açılış etiketi 
+// konfigürasyonları yapıldı ise, kısa açılış etiketini kullanabilirsiniz.
+?>
+<p><?= $paragraph ?></p>
+<?php
+
+$x = 1;
+$y = 2;
+$x = $y; // Şu anda $x değişkeni $y ile aynı değere sahiptir.
+$z = &$y;
+// $z, $y'nin referansını içermektedir. 
+// $z'nin değerinin değişmesi $y'nin değerinide değiştireceltir veya
+// tam tersi. Ancak $x özgün değeri olarak kalacaktır.
+
+echo $x; // => 2
+echo $z; // => 2
+$y = 0;
+echo $x; // => 2
+echo $z; // => 0
+
+/********************************
+ * Mantık
+ */
+$a = 0;
+$b = '0';
+$c = '1';
+$d = '1';
+
+// Argüman doğru değilse bir hata fırlatılacaktır.
+
+// Bu karşılaştırmalar tipler aynı olmasa bile her zaman true olacaktır.
+assert($a == $b); // equality
+assert($c != $a); // inequality
+assert($c <> $a); // alternative inequality
+assert($a < $c);
+assert($c > $b);
+assert($a <= $b);
+assert($c >= $d);
+
+// Aşağıdakiler yanlızca değer ve tip aynı olduğunda true olacaktır.
+assert($c === $d);
+assert($a !== $d);
+assert(1 == '1');
+assert(1 !== '1');
+
+// Değişkenler kullanıma bağlı olarak farklı tiplere çevrilebilir.
+
+$integer = 1;
+echo $integer + $integer; // => 2
+
+$string = '1';
+echo $string + $string; // => 2 (Karakter dizisi tam sayıya çevrilmeye zorlanır)
+
+$string = 'one';
+echo $string + $string; // => 0
+// Çıktı 0 olacaktır, çünkü + operatörü karakter dizisi olan 'one' değerini
+// bir sayıya çeviremez.
+
+// Veri tipi çevirileri bir değişkeni farklı bir türde 
+// düzenlemek için kullanılabilir.
+
+$boolean = (boolean) 1; // => true
+
+$zero = 0;
+$boolean = (boolean) $zero; // => false
+
+// Veri tiplerini çevirmek için bazı fonksiyonlar vardır.
+$integer = 5;
+$string = strval($integer);
+
+$var = null; // Null değeri.
+
+
+/********************************
+ * Kontrol Yapıları
+ */
+
+if (true) {
+    print 'I get printed';
+}
+
+if (false) {
+    print 'I don\'t';
+} else {
+    print 'I get printed';
+}
+
+if (false) {
+    print 'Does not get printed';
+} elseif(true) {
+    print 'Does';
+}
+
+// Üçlü operatör
+print (false ? 'Does not get printed' : 'Does');
+
+$x = 0;
+if ($x === '0') {
+    print 'Does not print';
+} elseif($x == '1') {
+    print 'Does not print';
+} else {
+    print 'Does print';
+}
+
+
+
+// Bu alternatif sözdizimi template'ler için kullanışlıdır.
+?>
+
+<?php if ($x): ?>
+This is displayed if the test is truthy.
+<?php else: ?>
+This is displayed otherwise.
+<?php endif; ?>
+
+<?php
+
+// Use switch to save some logic.
+switch ($x) {
+    case '0':
+        print 'Switch does type coercion';
+        break; // Bir breake yazmalısınız ya da 'two' ve 'three'
+               // durumunuda kapsarsınız.
+    case 'two':
+    case 'three':
+        // $variable değişkeni 'two' ya da 'three' ise 
+        break;
+    default:
+        // Varsayılan olarak bir şey yap
+}
+
+// While, do...while ve for döngüleri tanıdıktır.
+$i = 0;
+while ($i < 5) {
+    echo $i++;
+}; // "01234" yazdırılacaktır
+
+echo "\n";
+
+$i = 0;
+do {
+    echo $i++;
+} while ($i < 5); // "01234" yazdırılacaktır.
+
+echo "\n";
+
+for ($x = 0; $x < 10; $x++) {
+    echo $x;
+} // "0123456789" yazdırılacaktır.
+
+echo "\n";
+
+$wheels = ['bicycle' => 2, 'car' => 4];
+
+// Foreach döngüsü diziler üzerinde çalışır
+foreach ($wheels as $wheel_count) {
+    echo $wheel_count;
+} // "24" yazdırılacaktır.
+
+echo "\n";
+
+// Key-Value değerlere ulaşabilirsiniz.
+foreach ($wheels as $vehicle => $wheel_count) {
+    echo "A $vehicle has $wheel_count wheels";
+}
+
+echo "\n";
+
+$i = 0;
+while ($i < 5) {
+    if ($i === 3) {
+        break; // while döngüsünden çıkar
+    }
+    echo $i++;
+} // Prints "012"
+
+for ($i = 0; $i < 5; $i++) {
+    if ($i === 3) {
+        continue; // Aktif döngüyü atlar 
+    }
+    echo $i;
+} // "0124" yazdırılacaktır.
+
+
+
+/********************************
+ * Fonksiyonlar
+ */
+
+// Bir fonksiyon tanımlamak için "function" kullanılır:
+function my_function () {
+  return 'Hello';
+}
+
+echo my_function(); // => "Hello"
+
+// Geçerli bir fonksiyon ismi bir harf veya altçizgi ile başlar ve
+// bir sayı, harf ya da alt çizgi ile devam eder.
+
+function add ($x, $y = 1) { // $y değeri isteğe bağlıdır ve 
+                            // varsayılan değeri 1'dir
+  $result = $x + $y;
+  return $result;
+}
+
+echo add(4); // => 5
+echo add(4, 2); // => 6
+
+// $result fonksiyon dışında ulaşılabilir değildir. 
+// print $result; // Bir uyarı verecektir.
+
+// PHP 5.3'den beri bir anonymous fonksiyon tanımlayabilirsiniz;
+$inc = function ($x) {
+  return $x + 1;
+};
+
+echo $inc(2); // => 3
+
+function foo ($x, $y, $z) {
+  echo "$x - $y - $z";
+}
+
+// Fonksiyonlar bir fonksiyon dönebilir.
+function bar ($x, $y) {
+  // Fonksiyona dışardan değişken gönderebilmek için 'use' komutunu kullanın.
+  return function ($z) use ($x, $y) {
+    foo($x, $y, $z);
+  };
+}
+
+$bar = bar('A', 'B');
+$bar('C'); // "A - B - C" yazdırılacaktır.
+
+// Fonksiyonun ismini karakter dizinden çağırabilirsiniz. 
+$function_name = 'add';
+echo $function_name(1, 2); // => 3
+// Programatik olarak fonksiyonları çalıştırmak için yararlı olabilir
+// veya, call_user_func(callable $callback [, $parameter [, ... ]]); kulanın.
+
+
+/********************************
+ * Includes
+ */
+
+<?php
+// PHP'de include edilecek dosyalar PHP açma etiketi ile başlamalı. (!)
+
+include 'my-file.php';
+// my-file.php dosyasındaki kodlar artık mevcut scope'da kullanılabilir.
+// Eğer dosya include edilemezse bir uyarı (örneğin: file not found) 
+// fırlatılacaktır.
+
+include_once 'my-file.php';
+// Eğer bir dosya include edildi ise tekrar include edilmeyecektir.
+// Bu çoklu class tanımlama hatalarını önler.
+
+require 'my-file.php';
+require_once 'my-file.php';
+// Dosya include edilemediğinde fatal error veren require() bu konu 
+// dışında include() ile aynıdır.
+
+// my-include.php dosyasının içeriği:
+<?php
+
+return 'Anything you like.';
+// Dosya sonu
+
+// Include'lar ver require'lar aynı zamanda bir return dönebilir.
+$value = include 'my-include.php';
+
+// Dosyalar verilen dosya yoluna göre include edilir veya, hiçbirşey 
+// verilmezse include_path konfigürasyonuna göre include edecektir. 
+// Eğer dosya include_path'da da bulunamazsa include hata vermeden 
+// önce içinde bulunulan dizini kontrol ecektir.
+/* */
+
+
+/********************************
+ * Sınıflar
+ */
+
+// Sınıflar class kelimesi ile tanımlanır
+
+class MyClass
+{
+    const MY_CONST      = 'value'; // Bir sabit
+
+    static $staticVar   = 'static';
+
+    // Static değişkenler ve onların görünürlüğü
+    public static $publicStaticVar = 'publicStatic';
+    private static $privateStaticVar = 'privateStatic'; 
+        // Sadece bu sınıf içerisinde erişilebilir
+    protected static $protectedStaticVar = 'protectedStatic'; 
+        // Bu sınıf ve alt sınıflarından erişilebilir
+
+    // Özellikler görünürlüğü ile birlikte tanımlanmalıdır.
+    public $property    = 'public';
+    public $instanceProp;
+    protected $prot = 'protected'; // Sınıf ve alt sınıflardan erişilebilir
+    private $priv   = 'private';   // Sadece bu sınıftan erişilebilir
+
+    // __construct ile bir constructor oluşturulabilir.
+    public function __construct($instanceProp) {
+        // $this ile instance değişkenine erişilir.
+        $this->instanceProp = $instanceProp;
+    }
+
+    // Sınıfın içerisinde metodlar fonksiyonlar gibi tanımlanır.
+    public function myMethod()
+    {
+        print 'MyClass';
+    }
+
+    final function youCannotOverrideMe()
+    {
+    }
+
+    public static function myStaticMethod()
+    {
+        print 'I am static';
+    }
+}
+
+echo MyClass::MY_CONST;    // 'value' şeklinde çıktı verir;
+echo MyClass::$staticVar;  // 'static' şeklinde çıktı verir;
+MyClass::myStaticMethod(); // 'I am static' şeklinde çıktı verir;
+
+// Sınıfların new ile kullanımı
+$my_class = new MyClass('An instance property');
+// Eğer argüman göndermeyeceksek parantezler isteğe bağlıdır.
+
+// Sınıfın üyelerine erişim ->
+echo $my_class->property;     // => "public"
+echo $my_class->instanceProp; // => "An instance property"
+$my_class->myMethod();        // => "MyClass"
+
+
+// "extends" ile sınıfı extend etmek
+class MyOtherClass extends MyClass
+{
+    function printProtectedProperty()
+    {
+        echo $this->prot;
+    }
+
+    // Bir methodu ezmek
+    function myMethod()
+    {
+        parent::myMethod();
+        print ' > MyOtherClass';
+    }
+}
+
+$my_other_class = new MyOtherClass('Instance prop');
+$my_other_class->printProtectedProperty(); // "protected" şeklinde çıktı verir.
+$my_other_class->myMethod();    // "MyClass > MyOtherClass" şeklinde çıktı verir
+
+final class YouCannotExtendMe
+{
+}
+
+// getter ve setter'ları oluşturmak için "magic method"ları kullanabilirsiniz.
+class MyMapClass
+{
+    private $property;
+
+    public function __get($key)
+    {
+        return $this->$key;
+    }
+
+    public function __set($key, $value)
+    {
+        $this->$key = $value;
+    }
+}
+
+$x = new MyMapClass();
+echo $x->property; // __get() metodunu kullanacaktır.
+$x->property = 'Something'; // __set() metodunu kullanacaktır. 
+
+// Sınıflar abstract olabilir(abstract kelimesini kullanarak) veya
+// interface'ler uygulanabilir (implements kelimesi kullanılarak).
+// Bir interface "interface" kelimesi kullanılarak oluşturulur.
+
+interface InterfaceOne
+{
+    public function doSomething();
+}
+
+interface InterfaceTwo
+{
+    public function doSomethingElse();
+}
+
+// interfaces can be extended
+interface InterfaceThree extends InterfaceTwo
+{
+    public function doAnotherContract();
+}
+
+abstract class MyAbstractClass implements InterfaceOne
+{
+    public $x = 'doSomething';
+}
+
+class MyConcreteClass extends MyAbstractClass implements InterfaceTwo
+{
+    public function doSomething()
+    {
+        echo $x;
+    }
+
+    public function doSomethingElse()
+    {
+        echo 'doSomethingElse';
+    }
+}
+
+
+// Sınıflar birden fazla interface kullanabilir.
+class SomeOtherClass implements InterfaceOne, InterfaceTwo
+{
+    public function doSomething()
+    {
+        echo 'doSomething';
+    }
+
+    public function doSomethingElse()
+    {
+        echo 'doSomethingElse';
+    }
+}
+
+
+
+/********************************
+ * Traits
+ */
+// Trait'ler PHP 5.4.0'dan beri kullanılabilir ve "trait" kullanılarak 
+// tanımlanır.
+
+trait MyTrait
+{
+    public function myTraitMethod()
+    {
+        print 'I have MyTrait';
+    }
+}
+
+class MyTraitfulClass
+{
+    use MyTrait;
+}
+
+$cls = new MyTraitfulClass();
+$cls->myTraitMethod(); // "I have MyTrait" çıktısını verir.
+
+
+
+/********************************
+ * İsim Uzayları
+ */
+
+// Bu alan ayrılmıştır, çünkü isim uzayı tanımı bir dosyada en başta 
+// yapılmalıdır. Bu örnekte böyle olmadığını varsayalım.
+
+<?php
+
+// Varsayılan olarak, sınıflar global isim uzayındadır, ve açıkça bir 
+// ters slash ile çağrılabilir.
+
+$cls = new \MyClass();
+
+
+
+// Bir dosya için isim uzayı atama
+namespace My\Namespace;
+
+class MyClass
+{
+}
+
+// (diğer bir dosya)
+$cls = new My\Namespace\MyClass;
+
+//veya diğer bir isim uzayında.
+namespace My\Other\Namespace;
+
+use My\Namespace\MyClass;
+
+$cls = new MyClass();
+
+// veya isim uzayına bir takma isim koyabilirsiniz.
+
+namespace My\Other\Namespace;
+
+use My\Namespace as SomeOtherNamespace;
+
+$cls = new SomeOtherNamespace\MyClass();
+
+*/
+
+```
+
+## Daha fazla bilgi
+
+Referans ve topluluk yazıları için [official PHP documentation](http://www.php.net/manual/) adresini ziyaret edin.
+
+Gncel en yi örnekler için [PHP Usulüne Uygun](http://kulekci.net/php-the-right-way/) adresini ziyaret edin.
+
+Eğer bir paket yöneticisi olan dil kullandıysanız, [Composer](http://getcomposer.org/)'a bir göz atın.
+
+Genel standartlar için PHP Framework Interoperability Group'unun [PSR standards](https://github.com/php-fig/fig-standards) ziyaret edebilirsiniz. 
+
-- 
cgit v1.2.3


From 3f51d6b516b8543dc8d7f6d7a55f3e0210ccd817 Mon Sep 17 00:00:00 2001
From: Haydar Kulekci <haydarkulekci@gmail.com>
Date: Fri, 23 Aug 2013 00:00:54 +0300
Subject: turkish translation for python language

---
 tr-tr/python-tr.html.markdown | 528 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 528 insertions(+)
 create mode 100644 tr-tr/python-tr.html.markdown

(limited to 'tr-tr')

diff --git a/tr-tr/python-tr.html.markdown b/tr-tr/python-tr.html.markdown
new file mode 100644
index 00000000..410339dd
--- /dev/null
+++ b/tr-tr/python-tr.html.markdown
@@ -0,0 +1,528 @@
+---
+language: python
+filename: learnpython-tr.py
+contributors:
+    - ["Louie Dinh", "http://ldinh.ca"]
+translators:
+    - ["Haydar KULEKCI", "http://scanf.info/"]
+lang: tr-tr
+---
+Python Guido Van Rossum tarafından 90'ların başında yaratılmıştır. Şu anda 
+varolanlar arasında en iyi dillerden birisidir. Ben (Louie Dinh) Python
+dilinin syntax'ının belirginliğine aşığım. O basit olarak çalıştırılabilir 
+pseudocode'dur.
+
+Geri bildirimlerden son derece mutluluk duyarım! Bana [@louiedinh](http://twitter.com/louiedinh)
+adresinden ya da louiedinh [at] [google's email service] adresinden ulaşabilirsiniz.
+
+Çeviri için geri bildirimleri de [@kulekci](http://twitter.com/kulekci) 
+adresine yapabilirsiniz. 
+
+Not: Bu yazıdaki özellikler Python 2.7 için geçerlidir, ama Python 2.x için de 
+uygulanabilir. Python 3 için başka bir zaman tekrar bakınız. 
+
+
+```python
+# Tek satır yorum hash işareti ile başlar.
+""" Çoklu satır diziler üç tane çift tırnak 
+    arasında yazılır. Ve yorum olarak da 
+    kullanılabilir
+"""
+
+
+####################################################
+## 1. İlkel Veri Tipleri ve Operatörler
+####################################################
+
+# Sayılar
+3 #=> 3
+
+# Matematik beklediğiniz gibi
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+
+# Bölünme biraz ilginç. EĞer tam sayılar üzerinde bölünme işlemi yapıyorsanız
+# sonuç otomatik olarak kırpılır. 
+5 / 2 #=> 2
+
+# Bölünme işlemini düzenlemek için kayan noktalı sayıları bilmeniz gerekir.
+2.0     # Bu bir kayan noktalı sayı
+11.0 / 4.0 #=> 2.75 ahhh...daha iyi
+
+# İşlem önceliğini parantezler ile sağlayabilirsiniz.
+(1 + 3) * 2 #=> 8
+
+# Boolean değerleri bilindiği gibi
+True
+False
+
+# not ile nagatif(mantıksal) değerini alma
+not True #=> False
+not False #=> True
+
+# Eşitlik ==
+1 == 1 #=> True
+2 == 1 #=> False
+
+# Eşitsizlik !=
+1 != 1 #=> False
+2 != 1 #=> True
+
+# Daha fazla karşılaştırma
+1 < 10 #=> True
+1 > 10 #=> False
+2 <= 2 #=> True
+2 >= 2 #=> True
+
+# Karşılaştırma zincirleme yapılabilir!
+1 < 2 < 3 #=> True
+2 < 3 < 2 #=> False
+
+# Karakter dizisi " veya ' ile oluşturulabilir
+"This is a string."
+'This is also a string.'
+
+# Karakter dizileri birbirleri ile eklenebilir
+"Hello " + "world!" #=> "Hello world!"
+
+# A string can be treated like a list of characters
+# Bir string'e karakter listesi gibi davranabilirsiniz. 
+"This is a string"[0] #=> 'T'
+
+# % karakter dizisini(string) formatlamak için kullanılır, bunun gibi:
+"%s can be %s" % ("strings", "interpolated")
+
+# String'leri formatlamanın yeni bir yöntem ise format metodudur. 
+# Bu metod tercih edilen yöntemdir.
+"{0} can be {1}".format("strings", "formatted")
+# Eğer saymak istemiyorsanız anahtar kelime kullanabilirsiniz.
+"{name} wants to eat {food}".format(name="Bob", food="lasagna")
+
+# None bir objedir
+None #=> None
+
+# `==` eşitliğini non objesi ile karşılaştırmak için kullanmayın.
+# Onun yerine `is` kullanın.
+"etc" is None #=> False
+None is None  #=> True
+
+# 'is' operatörü obje kimliği için test etmektedir. Bu ilkel değerler
+# için kullanışlı değildir, ama objeleri karşılaştırmak için kullanışlıdır.
+
+# None, 0 ve boş string/list'ler False olarak değerlendirilir.
+# Tüm eşitlikler True döner
+0 == False  #=> True
+"" == False #=> True
+
+
+####################################################
+## 2. Değişkenler ve Kolleksiyonlar
+####################################################
+
+# Ekrana yazdırma oldukça kolaydır.
+print "I'm Python. Nice to meet you!"
+
+
+# Değişkenlere bir değer atamadan önce tanımlamaya gerek yoktur.
+some_var = 5    # Değişken isimlerinde gelenek küçük karakter ve alt çizgi 
+                # kullanmaktır.
+some_var #=> 5
+
+# Daha önceden tanımlanmamış ya da assign edilmemeiş bir değişkene erişmeye 
+# çalıştığınızda bir hata fırlatılacaktır. Hata ayıklama hakkında daha fazla 
+# bilgi için kontrol akışı kısmına göz atınız.
+some_other_var  # isim hatası fırlatılır
+
+# isterseniz `if`i bir ifade gibi kullanabilirsiniz.
+"yahoo!" if 3 > 2 else 2 #=> "yahoo!"
+
+# Listeler
+li = []
+# Önceden değerleri tanımlanmış listeler
+other_li = [4, 5, 6]
+
+# Bir listenin sonuna birşeyler eklemek
+li.append(1)    #li şu anda [1]
+li.append(2)    #li şu anda [1, 2]
+li.append(4)    #li şu anda [1, 2, 4]
+li.append(3)    #li şu anda [1, 2, 4, 3]
+# pop ile sondan birşeyler silmek
+li.pop()        #=> 3 and li is now [1, 2, 4]
+# Tekrar sonuna eklemek
+li.append(3)    # li is now [1, 2, 4, 3] again.
+
+# Dizi gibi listenin elemanlarına erişmek
+li[0] #=> 1
+# Son elemanın değerine ulaşmak
+li[-1] #=> 3
+
+# Listede bulunmayan bir index'teki elemana erişirken `IndexError` hatası 
+# fırlatılır 
+li[4] # IndexError fırlatılır
+
+# slice syntax'ı ile belli aralıktakı değerlere bakabilirsiniz.
+# (Açık ve kapalı aralıklıdır.)
+li[1:3] #=> [2, 4]
+# Başlangıcı ihmal etme
+li[2:] #=> [4, 3]
+# Sonu ihmal etme
+li[:3] #=> [1, 2, 4]
+
+# `del` ile istenilen bir elemanı listeden silmek
+del li[2] # li is now [1, 2, 3]
+
+# Listeleri birbiri ile birleştirebilirsiniz.
+li + other_li #=> [1, 2, 3, 4, 5, 6] - Not: li ve other_li yanlız bırakılır
+
+# extend ile listeleri birleştirmek
+li.extend(other_li) # Now li is [1, 2, 3, 4, 5, 6]
+
+# bir değerin liste içerisinde varlığını `in` ile kontrol etmek
+1 in li #=> True
+
+# "len" ile listenin uzunluğunu bulmak
+len(li) #=> 6
+
+# Tüpler listeler gibidir sadece değişmezler(immutable)
+tup = (1, 2, 3)
+tup[0] #=> 1
+tup[0] = 3  # TypeError fırlatılır.
+
+# Litelerde yapılanların hepsini tüplerde de yapılabilir
+len(tup) #=> 3
+tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
+tup[:2] #=> (1, 2)
+2 in tup #=> True
+
+# Tüplerin(veya listelerin) içerisindeki değerleri değişkenelere
+# atanabilir
+a, b, c = (1, 2, 3)     # a şu anda 1, b şu anda 2 ve c şu anda 3
+# Eğer parantez kullanmaz iseniz tüpler varsayılan olarak oluşturulur
+d, e, f = 4, 5, 6
+# şimdi iki değeri değiş tokuş etmek çok kolaydır.
+e, d = d, e     # d şimdi 5 ve e şimdi 4
+
+
+# Sözlükler (Dictionaries) key-value saklanır.
+empty_dict = {}
+# Sözlüklere önceden değer atama örneği
+filled_dict = {"one": 1, "two": 2, "three": 3}
+
+# Değere ulaşmak için [] kullanılır
+filled_dict["one"] #=> 1
+
+# Tüm anahtarlara(key) `keys()` metodu ile ulaşılır
+filled_dict.keys() #=> ["three", "two", "one"]
+# Not - Sözlüklerin anahtarlarının sıralı geleceği garanti değildir
+# Sonuçlarınız değer listesini aldığınızda tamamen eşleşmeyebilir 
+
+# Tüm değerleri almak için `values()` kullanabilirsiniz.
+filled_dict.values() #=> [3, 2, 1]
+# Not - Sıralama ile ilgili anahtarlar ile aynı durum geçerlidir.
+
+# Bir anahtarın sözlükte oluş olmadığını `in` ile kontrol edilebilir
+"one" in filled_dict #=> True
+1 in filled_dict #=> False
+
+# Olmayan bir anahtar çağrıldığında KeyError fırlatılır.
+filled_dict["four"] # KeyError
+
+# `get()` metodu KeyError fırlatılmasını önler
+filled_dict.get("one") #=> 1
+filled_dict.get("four") #=> None
+# get() metodu eğer anahtar mevcut değilse varsayılan bir değer atama
+# imknaı sağlar.
+filled_dict.get("one", 4) #=> 1
+filled_dict.get("four", 4) #=> 4
+
+# `setdefault()` metodu sözlüğe yeni bir key-value eşleşmesi eklemenin 
+# güvenli bir yoludur.
+filled_dict.setdefault("five", 5) #filled_dict["five"] is set to 5
+filled_dict.setdefault("five", 6) #filled_dict["five"] is still 5
+
+
+# Sets store ... well sets
+empty_set = set()
+# Bir demek değer ile bir "set" oluşturmak
+some_set = set([1,2,2,3,4]) # some_set is now set([1, 2, 3, 4])
+
+# Python 2.7'den beri {}'ler bir "set" tanımlaman için kullanılabilir
+filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4}
+
+# Bir set'e daha fazla eleman eklemek
+filled_set.add(5) # filled_set is now {1, 2, 3, 4, 5}
+
+# "&" işareti ile iki set'in kesişimlerini alınabilir
+other_set = {3, 4, 5, 6}
+filled_set & other_set #=> {3, 4, 5}
+
+# | işareti ile 
+filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
+
+# "-" işareti ile iki set'in farkları alınabilir
+{1,2,3,4} - {2,3,5} #=> {1, 4}
+
+# "in" ile değerin set içerisinde olup olmadığını kontrol edebilirsiniz
+2 in filled_set #=> True
+10 in filled_set #=> False
+
+
+####################################################
+## 3. Akış Denetimi
+####################################################
+
+# Bir değişken oluşturmak
+some_var = 5
+
+# Buradaki bir if ifadesi. Girintiler(Intentation) Python'da önemlidir!
+# "some_var is smaller than 10" yazdırılır.
+if some_var > 10:
+    print "some_var is totally bigger than 10."
+elif some_var < 10:    # elif ifadesi isteğe bağlıdır
+    print "some_var is smaller than 10."
+else:           # Bu da isteğe bağlıdır.
+    print "some_var is indeed 10."
+
+
+"""
+For döngüleri listeler üzerinde iterasyon yapar
+Ekrana yazdırılan:
+    dog is a mammal
+    cat is a mammal
+    mouse is a mammal
+"""
+for animal in ["dog", "cat", "mouse"]:
+    # Biçimlendirmeleri string'e katmak için % kullanabilirsiniz
+    print "%s is a mammal" % animal
+    
+"""
+`range(number)` ifadesi sıfırdan verilen sayıya kadar bir sayı listesi döner
+Ekrana yazdırılan:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print i
+
+"""
+While döngüsü koşul sağlanmayana kadar devam eder
+Ekrana yazdırılan:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print x
+    x += 1  # Shorthand for x = x + 1
+
+# try/except bloğu ile hatalar ayıklanabilir
+
+# Python 2.6 ve üstü için çalışacaktır:
+try:
+    # "raise" bir hata fırlatmak için kullanılabilir
+    raise IndexError("This is an index error")
+except IndexError as e:
+    pass    # Pass is just a no-op. Usually you would do recovery here.
+
+
+####################################################
+## 4. Fonksiyonlar
+####################################################
+
+
+# Yeni bir fonksiyon oluşturmak için `def` kullanılır
+def add(x, y):
+    print "x is %s and y is %s" % (x, y)
+    return x + y    # Return values with a return statement
+
+# Fonksiyonu parametre ile çağırmak
+add(5, 6) #=> prints out "x is 5 and y is 6" and returns 11
+
+# Diğer bir yol fonksiyonları anahtar argümanları ile çağırmak
+add(y=6, x=5)   # Anahtar argümanlarının sırası farklı da olabilir
+
+# Değişken sayıda parametresi olan bir fonksiyon tanımlayabilirsiniz
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3) #=> (1,2,3)
+
+# Değişken sayıda anahtar argümanlı parametre alan fonksiyonlar da 
+# tanımlayabilirsiniz.
+def keyword_args(**kwargs):
+    return kwargs
+
+# Şu şekilde kullanılacaktır
+keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
+
+# Eğer isterseniz ikisini aynı anda da yapabilirsiniz
+def all_the_args(*args, **kwargs):
+    print args
+    print kwargs
+"""
+all_the_args(1, 2, a=3, b=4) prints:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# Fonksiyonu çağırırken, args/kwargs'ın tam tersini de yapabilirsiniz!
+# Tüpü yaymak için * ve kwargs'ı yaymak için ** kullanın.
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args) # foo(1, 2, 3, 4) ile eşit
+all_the_args(**kwargs) # foo(a=3, b=4) ile eşit
+all_the_args(*args, **kwargs) # foo(1, 2, 3, 4, a=3, b=4) ile eşit
+
+# Python first-class fonksiyonlara sahiptir
+def create_adder(x):
+    def adder(y):
+        return x + y
+    return adder
+
+add_10 = create_adder(10)
+add_10(3) #=> 13
+
+# Anonymous fonksiyonlar da vardır
+(lambda x: x > 2)(3) #=> True
+
+# Dahili yüksek seviye fonksiyonlar vardır
+map(add_10, [1,2,3]) #=> [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
+
+# Map etme(maps) ve filtreleme(filtres) için liste kullanabiliriz. 
+[add_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
+
+
+####################################################
+## 5. Sınıflar
+####################################################
+
+# We subclass from object to get a class.
+class Human(object):
+    
+    # Bir sınıf özelliği. Bu sınıfın tüm `instance`larına paylaşılmıştır.
+    species = "H. sapiens"
+
+    # Basic initializer
+    def __init__(self, name):
+        # Metoda gelen argümanın değerini sınıfın elemanı olan `name` 
+        # değişkenine atama
+        self.name = name
+
+    # Bir instance metodu. Tüm metodlar ilk argüman olarak `self` 
+    # parametresini alır
+    def say(self, msg):
+       return "%s: %s" % (self.name, msg)
+
+    # Bir sınıf metodu tüm `instance`lar arasında paylaşılır
+    # İlk argüman olarak sınıfı çağırarak çağrılırlar
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # bBir statik metod bir sınıf ya da instance referansı olmadan çağrılır
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+
+# Bir sınıf örneği oluşturmak
+i = Human(name="Ian")
+print i.say("hi")     # "Ian: hi" çıktısı verir
+
+j = Human("Joel")
+print j.say("hello")  # "Joel: hello" çıktısı verir
+
+# Sınıf metodunu çağıralım
+i.get_species() #=> "H. sapiens"
+
+# Paylaşılan sınıf özellik değiştirelim.
+Human.species = "H. neanderthalensis"
+i.get_species() #=> "H. neanderthalensis"
+j.get_species() #=> "H. neanderthalensis"
+
+# Statik metodu çağırma
+Human.grunt() #=> "*grunt*"
+
+
+####################################################
+## 6. Modüller
+####################################################
+
+# Modülleri sayfaya dahil edebilirsiniz
+import math
+print math.sqrt(16) #=> 4
+
+# Modül içerisinden spesifik bir fonksiyonu getirebilirsiniz
+from math import ceil, floor
+print ceil(3.7)  #=> 4.0
+print floor(3.7) #=> 3.0
+
+# Modüldeki tüm fonksiyonları dahil edebilirsiniz
+# Uyarı: bu önerilmez
+from math import *
+
+# Modülün adını kısaltabilirsiniz
+import math as m
+math.sqrt(16) == m.sqrt(16) #=> True
+
+# Python modülleri sıradan python dosyalarıdır. Kendinize bir modül 
+# yazabilirsiniz, ve dahil edebilirsiniz. Modülün adı ile dosya adı
+# aynı olmalıdır.
+
+# Modüllerde tanımlanmış fonksiyon ve metodları öğrenebilirsiniz.
+import math
+dir(math)
+
+
+
+```
+
+## Daha fazlası için hazır mısınız?
+
+### Ücretsiz Dökümanlar
+
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [The Official Docs](http://docs.python.org/2.6/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [Python Module of the Week](http://pymotw.com/2/)
+
+### Dead Tree
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-- 
cgit v1.2.3


From 06144440549539c6a5fb714ca0dc7515028a195a Mon Sep 17 00:00:00 2001
From: Haydar Kulekci <haydarkulekci@gmail.com>
Date: Fri, 23 Aug 2013 00:09:16 +0300
Subject: removed whitespace from end of the file

---
 tr-tr/python-tr.html.markdown | 26 --------------------------
 1 file changed, 26 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/python-tr.html.markdown b/tr-tr/python-tr.html.markdown
index 410339dd..f7314f0f 100644
--- a/tr-tr/python-tr.html.markdown
+++ b/tr-tr/python-tr.html.markdown
@@ -500,29 +500,3 @@ dir(math)
 * [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
 * [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
 * [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-- 
cgit v1.2.3


From aaca821ee6886cf3888023bb770010f54015812d Mon Sep 17 00:00:00 2001
From: Haydar Kulekci <haydarkulekci@gmail.com>
Date: Fri, 23 Aug 2013 09:55:56 +0300
Subject: regular quotes instead of `.

---
 tr-tr/python-tr.html.markdown | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/python-tr.html.markdown b/tr-tr/python-tr.html.markdown
index f7314f0f..01285080 100644
--- a/tr-tr/python-tr.html.markdown
+++ b/tr-tr/python-tr.html.markdown
@@ -103,8 +103,8 @@ not False #=> True
 # None bir objedir
 None #=> None
 
-# `==` eşitliğini non objesi ile karşılaştırmak için kullanmayın.
-# Onun yerine `is` kullanın.
+# "==" eşitliğini non objesi ile karşılaştırmak için kullanmayın.
+# Onun yerine "is" kullanın.
 "etc" is None #=> False
 None is None  #=> True
 
@@ -135,7 +135,7 @@ some_var #=> 5
 # bilgi için kontrol akışı kısmına göz atınız.
 some_other_var  # isim hatası fırlatılır
 
-# isterseniz `if`i bir ifade gibi kullanabilirsiniz.
+# isterseniz "if"i bir ifade gibi kullanabilirsiniz.
 "yahoo!" if 3 > 2 else 2 #=> "yahoo!"
 
 # Listeler
@@ -158,7 +158,7 @@ li[0] #=> 1
 # Son elemanın değerine ulaşmak
 li[-1] #=> 3
 
-# Listede bulunmayan bir index'teki elemana erişirken `IndexError` hatası 
+# Listede bulunmayan bir index'teki elemana erişirken "IndexError" hatası 
 # fırlatılır 
 li[4] # IndexError fırlatılır
 
@@ -170,7 +170,7 @@ li[2:] #=> [4, 3]
 # Sonu ihmal etme
 li[:3] #=> [1, 2, 4]
 
-# `del` ile istenilen bir elemanı listeden silmek
+# "del" ile istenilen bir elemanı listeden silmek
 del li[2] # li is now [1, 2, 3]
 
 # Listeleri birbiri ile birleştirebilirsiniz.
@@ -179,7 +179,7 @@ li + other_li #=> [1, 2, 3, 4, 5, 6] - Not: li ve other_li yanlız bırakılır
 # extend ile listeleri birleştirmek
 li.extend(other_li) # Now li is [1, 2, 3, 4, 5, 6]
 
-# bir değerin liste içerisinde varlığını `in` ile kontrol etmek
+# bir değerin liste içerisinde varlığını "in" ile kontrol etmek
 1 in li #=> True
 
 # "len" ile listenin uzunluğunu bulmak
@@ -213,23 +213,23 @@ filled_dict = {"one": 1, "two": 2, "three": 3}
 # Değere ulaşmak için [] kullanılır
 filled_dict["one"] #=> 1
 
-# Tüm anahtarlara(key) `keys()` metodu ile ulaşılır
+# Tüm anahtarlara(key) "keys()" metodu ile ulaşılır
 filled_dict.keys() #=> ["three", "two", "one"]
 # Not - Sözlüklerin anahtarlarının sıralı geleceği garanti değildir
 # Sonuçlarınız değer listesini aldığınızda tamamen eşleşmeyebilir 
 
-# Tüm değerleri almak için `values()` kullanabilirsiniz.
+# Tüm değerleri almak için "values()" kullanabilirsiniz.
 filled_dict.values() #=> [3, 2, 1]
 # Not - Sıralama ile ilgili anahtarlar ile aynı durum geçerlidir.
 
-# Bir anahtarın sözlükte oluş olmadığını `in` ile kontrol edilebilir
+# Bir anahtarın sözlükte oluş olmadığını "in" ile kontrol edilebilir
 "one" in filled_dict #=> True
 1 in filled_dict #=> False
 
 # Olmayan bir anahtar çağrıldığında KeyError fırlatılır.
 filled_dict["four"] # KeyError
 
-# `get()` metodu KeyError fırlatılmasını önler
+# "get()" metodu KeyError fırlatılmasını önler
 filled_dict.get("one") #=> 1
 filled_dict.get("four") #=> None
 # get() metodu eğer anahtar mevcut değilse varsayılan bir değer atama
@@ -237,7 +237,7 @@ filled_dict.get("four") #=> None
 filled_dict.get("one", 4) #=> 1
 filled_dict.get("four", 4) #=> 4
 
-# `setdefault()` metodu sözlüğe yeni bir key-value eşleşmesi eklemenin 
+# "setdefault()" metodu sözlüğe yeni bir key-value eşleşmesi eklemenin 
 # güvenli bir yoludur.
 filled_dict.setdefault("five", 5) #filled_dict["five"] is set to 5
 filled_dict.setdefault("five", 6) #filled_dict["five"] is still 5
@@ -298,7 +298,7 @@ for animal in ["dog", "cat", "mouse"]:
     print "%s is a mammal" % animal
     
 """
-`range(number)` ifadesi sıfırdan verilen sayıya kadar bir sayı listesi döner
+"range(number)" ifadesi sıfırdan verilen sayıya kadar bir sayı listesi döner
 Ekrana yazdırılan:
     0
     1
@@ -336,7 +336,7 @@ except IndexError as e:
 ####################################################
 
 
-# Yeni bir fonksiyon oluşturmak için `def` kullanılır
+# Yeni bir fonksiyon oluşturmak için "def" kullanılır
 def add(x, y):
     print "x is %s and y is %s" % (x, y)
     return x + y    # Return values with a return statement
@@ -407,27 +407,27 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
 # We subclass from object to get a class.
 class Human(object):
     
-    # Bir sınıf özelliği. Bu sınıfın tüm `instance`larına paylaşılmıştır.
+    # Bir sınıf özelliği. Bu sınıfın tüm "instance"larına paylaşılmıştır.
     species = "H. sapiens"
 
     # Basic initializer
     def __init__(self, name):
-        # Metoda gelen argümanın değerini sınıfın elemanı olan `name` 
+        # Metoda gelen argümanın değerini sınıfın elemanı olan "name" 
         # değişkenine atama
         self.name = name
 
-    # Bir instance metodu. Tüm metodlar ilk argüman olarak `self` 
+    # Bir instance metodu. Tüm metodlar ilk argüman olarak "self" 
     # parametresini alır
     def say(self, msg):
        return "%s: %s" % (self.name, msg)
 
-    # Bir sınıf metodu tüm `instance`lar arasında paylaşılır
+    # Bir sınıf metodu tüm "instance"lar arasında paylaşılır
     # İlk argüman olarak sınıfı çağırarak çağrılırlar
     @classmethod
     def get_species(cls):
         return cls.species
 
-    # bBir statik metod bir sınıf ya da instance referansı olmadan çağrılır
+    # Bir statik metod bir sınıf ya da instance referansı olmadan çağrılır
     @staticmethod
     def grunt():
         return "*grunt*"
-- 
cgit v1.2.3


From c7a623b6494fc2c3cbacb31bed52996c98283655 Mon Sep 17 00:00:00 2001
From: Haydar Kulekci <haydarkulekci@gmail.com>
Date: Tue, 3 Sep 2013 23:21:03 +0300
Subject: update latest commits.

---
 tr-tr/c-tr.html.markdown   |  4 ++++
 tr-tr/php-tr.html.markdown | 18 ++++++++++++++++++
 2 files changed, 22 insertions(+)

(limited to 'tr-tr')

diff --git a/tr-tr/c-tr.html.markdown b/tr-tr/c-tr.html.markdown
index 50bca246..128901de 100644
--- a/tr-tr/c-tr.html.markdown
+++ b/tr-tr/c-tr.html.markdown
@@ -95,6 +95,10 @@ int main() {
     // is not evaluated (except VLAs (see below)).
     // The value it yields in this case is a compile-time constant.
     int a = 1;
+
+    // size_t bir objeyi temsil etmek için kullanılan 2 byte uzunluğundaki bir 
+    // işaretsiz tam sayı tipidir
+
     size_t size = sizeof(a++); // a++ is not evaluated
     printf("sizeof(a++) = %zu where a = %d\n", size, a);
     // prints "sizeof(a++) = 4 where a = 1" (on a 32-bit architecture)
diff --git a/tr-tr/php-tr.html.markdown b/tr-tr/php-tr.html.markdown
index 94bc31ff..c5576fd7 100644
--- a/tr-tr/php-tr.html.markdown
+++ b/tr-tr/php-tr.html.markdown
@@ -67,6 +67,9 @@ $float = 1.234;
 $float = 1.2e3;
 $float = 7E-10;
 
+// Değişken Silmek
+unset($int1)
+
 // Aritmetik
 $sum        = 1 + 1; // 2
 $difference = 2 - 1; // 1
@@ -183,6 +186,13 @@ $y = 0;
 echo $x; // => 2
 echo $z; // => 0
 
+// Dump'lar değişkenin tipi ve değerini yazdırır
+var_dump($z); // int(0) yazdırılacaktır
+
+// Print'ler ise değişkeni okunabilir bir formatta yazdıracaktır. 
+print_r($array); // Çıktı: Array ( [0] => One [1] => Two [2] => Three )
+
+
 /********************************
  * Mantık
  */
@@ -478,10 +488,18 @@ class MyClass
         print 'MyClass';
     }
 
+    //final anahtar kelimesi bu metodu override edilemez yapacaktır.
     final function youCannotOverrideMe()
     {
     }
 
+/*
+Bir sınıfın özelliğini ya da metodunu statik yaptığınız takdirde sınıfın bir 
+objesini oluşturmadan bu elemana erişebilirsiniz. Bir özellik statik tanımlanmış 
+ise obje üzerinden bu elemana erişilemez. (Statik metodlar öyle değildir.)
+*/
+
+
     public static function myStaticMethod()
     {
         print 'I am static';
-- 
cgit v1.2.3


From 75a7261f7e22fb321c2646123b4f1981f835003c Mon Sep 17 00:00:00 2001
From: Haydar Kulekci <haydarkulekci@gmail.com>
Date: Wed, 18 Sep 2013 15:51:20 +0300
Subject: added latest updates from php-en

---
 tr-tr/php-tr.html.markdown | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'tr-tr')

diff --git a/tr-tr/php-tr.html.markdown b/tr-tr/php-tr.html.markdown
index c5576fd7..3db437cf 100644
--- a/tr-tr/php-tr.html.markdown
+++ b/tr-tr/php-tr.html.markdown
@@ -146,6 +146,11 @@ echo $associative['One']; // 1 yazdıracaktır.
 $array = ['One', 'Two', 'Three'];
 echo $array[0]; // => "One"
 
+// Dizinin sonuna bir eleman ekleme
+$array[] = 'Four';
+
+// Diziden eleman silme
+unset($array[3]);
 
 /********************************
  * Çıktı
@@ -692,7 +697,7 @@ $cls = new SomeOtherNamespace\MyClass();
 
 Referans ve topluluk yazıları için [official PHP documentation](http://www.php.net/manual/) adresini ziyaret edin.
 
-Gncel en yi örnekler için [PHP Usulüne Uygun](http://kulekci.net/php-the-right-way/) adresini ziyaret edin.
+Güncel en yi örnekler için [PHP Usulüne Uygun](http://kulekci.net/php-the-right-way/) adresini ziyaret edin.
 
 Eğer bir paket yöneticisi olan dil kullandıysanız, [Composer](http://getcomposer.org/)'a bir göz atın.
 
-- 
cgit v1.2.3


From e9634e0741f6f25bcef5436b28f1d068ff48d0d9 Mon Sep 17 00:00:00 2001
From: Haydar Kulekci <haydarkulekci@gmail.com>
Date: Wed, 18 Sep 2013 16:18:29 +0300
Subject: objective-c translating to Turkish language

---
 tr-tr/objective-c-tr.html.markdown | 320 +++++++++++++++++++++++++++++++++++++
 1 file changed, 320 insertions(+)
 create mode 100644 tr-tr/objective-c-tr.html.markdown

(limited to 'tr-tr')

diff --git a/tr-tr/objective-c-tr.html.markdown b/tr-tr/objective-c-tr.html.markdown
new file mode 100644
index 00000000..854d70f6
--- /dev/null
+++ b/tr-tr/objective-c-tr.html.markdown
@@ -0,0 +1,320 @@
+---
+language: Objective-C
+contributors:
+    - ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
+    - ["Yannick Loriot", "https://github.com/YannickL"]
+filename: LearnObjectiveC-tr.m
+translators:
+    - ["Haydar KULEKCI", "http://scanf.info/"]
+lang: tr-tr
+---
+
+Objective-C Apple tarafından, OSX ve iOS işletim sistemleri ve onların
+kendi çatıları olan Cocoa ve Cocoa Touch için kullanılan bir programlama dilidir.
+Genel açamlı, object-oriented bir yapıya sahip programlama dilidir. C 
+programlama diline Smalltalk stilinde mesajlaşma ekler.  
+
+```cpp
+// Tek satır yorum // işaretleri ile başlar
+
+/*
+Çoklu satır yorum bu şekilde görünür.
+*/
+
+// #import ile Foundation başlıklarını projeye import edebiliriz. 
+#import <Foundation/Foundation.h>
+#import "MyClass.h"
+
+// Progarmınızı girişi bir main fonksiyonudur ve bir integer değer döner.
+int main (int argc, const char * argv[])
+{
+    // Programdaki bellek kullanımını kontrol etmek için autorelease bir 
+    // oluşturuyoruz. Autorelease bellekte kullanılmayan değerlerin kendi 
+    // kendini silmesi demektir.
+    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
+ 
+    // NSLog konsola bir satırlık bilgi yazdırmak için kullanılır.
+    NSLog(@"Hello World!"); // "Hello World!" değeri yazdırılır.
+ 
+    ///////////////////////////////////////
+    // Tipler & Değişkenler
+    ///////////////////////////////////////
+    
+    // Basit Tanımlamalar
+    int myPrimitive1  = 1;
+    long myPrimitive2 = 234554664565;
+    
+    // Nesne Tanımlamaları
+    // strongly-typed nesne tanımlaması için karakter değişken isminin önüne 
+    // * karakteri konulur.
+    MyClass *myObject1 = nil;  // Strong typing
+    id       myObject2 = nil;  // Weak typing
+    // %@ bir nesnedir.
+    // 'description' objelerin değerlerinin gösterilmesi için bir düzendir.
+    NSLog(@"%@ and %@", myObject1, [myObject2 description]); 
+            // "(null) and (null)" yazdırılacaktır.
+    
+    // Karakter Dizisi (String)
+    NSString *worldString = @"World";
+    NSLog(@"Hello %@!", worldString); // "Hello World!" yazdırılacaktır.
+    
+    // Karakterler
+    NSNumber *theLetterZNumber = @'Z';
+    char theLetterZ            = [theLetterZNumber charValue];
+    NSLog(@"%c", theLetterZ);
+
+    // Tamsayılar
+    NSNumber *fortyTwoNumber = @42;
+    int fortyTwo             = [fortyTwoNumber intValue];
+    NSLog(@"%i", fortyTwo);
+    
+    NSNumber *fortyTwoUnsignedNumber = @42U;
+    unsigned int fortyTwoUnsigned    = [fortyTwoUnsignedNumber unsignedIntValue];
+    NSLog(@"%u", fortyTwoUnsigned);
+    
+    NSNumber *fortyTwoShortNumber = [NSNumber numberWithShort:42];
+    short fortyTwoShort           = [fortyTwoShortNumber shortValue];
+    NSLog(@"%hi", fortyTwoShort);
+    
+    NSNumber *fortyTwoLongNumber = @42L;
+    long fortyTwoLong            = [fortyTwoLongNumber longValue];
+    NSLog(@"%li", fortyTwoLong);
+
+    // Kayan Noktalı Sayılar (Floats)
+    NSNumber *piFloatNumber = @3.141592654F;
+    float piFloat           = [piFloatNumber floatValue];
+    NSLog(@"%f", piFloat);
+    
+    NSNumber *piDoubleNumber = @3.1415926535;
+    piDouble                 = [piDoubleNumber doubleValue];
+    NSLog(@"%f", piDouble);
+
+    // BOOL Değerler
+    NSNumber *yesNumber = @YES;
+    NSNumber *noNumber  = @NO;
+
+    // Dizi objeleri
+    NSArray *anArray      = @[@1, @2, @3, @4];
+    NSNumber *thirdNumber = anArray[2];
+    NSLog(@"Third number = %@", thirdNumber); // "Third number = 3" yazdırılır
+
+    // Dictionary objeleri
+    NSDictionary *aDictionary = @{ @"key1" : @"value1", @"key2" : @"value2" };
+    NSObject *valueObject     = aDictionary[@"A Key"];
+    NSLog(@"Object = %@", valueObject); // "Object = (null)" yazıdılır
+
+    ///////////////////////////////////////
+    // Operatörler
+    ///////////////////////////////////////
+    
+    // Operatörler C dilindeki gibi çalışır.
+    // Örneğin:
+    2 + 5; // => 7
+    4.2f + 5.1f; // => 9.3f
+    3 == 2; // => 0 (NO)
+    3 != 2; // => 1 (YES)
+    1 && 1; // => 1 (Logical and)
+    0 || 1; // => 1 (Logical or)
+    ~0x0F; // => 0xF0 (bitwise negation)
+    0x0F & 0xF0; // => 0x00 (bitwise AND)
+    0x01 << 1; // => 0x02 (bitwise left shift (by 1))
+
+    ///////////////////////////////////////
+    // Kontrol Yapıları
+    ///////////////////////////////////////
+
+    // If-Else ifadesi
+    if (NO)
+    {
+        NSLog(@"I am never run");
+    } else if (0)
+    {
+        NSLog(@"I am also never run");
+    } else
+    {
+        NSLog(@"I print");
+    }
+
+    // Switch ifadesi
+    switch (2)
+    {
+        case 0:
+        {
+            NSLog(@"I am never run");
+        } break;
+        case 1:
+        {
+            NSLog(@"I am also never run");
+        } break;
+        default:
+        {
+            NSLog(@"I print");
+        } break;
+    }
+    
+    // While döngü ifadesi
+    int ii = 0;
+    while (ii < 4)
+    {
+        NSLog(@"%d,", ii++); // ii++, ii değişkenini kullanıldıktan 
+                             //sonra yerinde artırır.
+    } // =>        "0," 
+      //           "1,"
+      //           "2,"
+      //           "3," yazdırılır
+
+    // For döngü ifadesi
+    int jj;
+    for (jj=0; jj < 4; jj++)
+    {
+        NSLog(@"%d,", jj++);
+    } // =>        "0," 
+      //           "1,"
+      //           "2,"
+      //           "3," yazdırılır
+     
+    // Foreach ifadesi             
+    NSArray *values = @[@0, @1, @2, @3];
+    for (NSNumber *value in values)
+    {
+        NSLog(@"%@,", value);
+    } // =>        "0," 
+      //           "1,"
+      //           "2,"
+      //           "3," yazdırılır
+
+    // Try-Catch-Finally ifadesi
+    @try
+    {
+        // İfadelerinizi buraya yazın
+        @throw [NSException exceptionWithName:@"FileNotFoundException"
+                            reason:@"Sistemde Dosya Bulunamadı" userInfo:nil];
+    } @catch (NSException * e)
+    {
+        NSLog(@"Exception: %@", e);
+    } @finally
+    {
+        NSLog(@"Finally");
+    } // =>        "Exception: Sistemde Dosya Bulunamadı"
+      //           "Finally"
+      // yazdırılacaktır
+ 
+    ///////////////////////////////////////
+    // Objeler
+    ///////////////////////////////////////
+    
+    // Bellekten bir alan ayırmak ve objeyi burada oluşturmak bir obje örneği 
+    // oluşturalım. Bir obje allocate ve init aşamalarını bitirmeden tam olarak
+    // işlevsel değildir.
+    MyClass *myObject = [[MyClass alloc] init];
+    
+    // Objective-C nesne yönelimli programlama modelinin temelinde objelere 
+    // mesaj gönderme vardır.
+    // Objective-C'de bir method çağırılmaz, ona bir mesaj gönderilir.
+    [myObject instanceMethodWithParameter:@"Steve Jobs"];
+
+    // Programda kullanılan bellek temizlenir
+    [pool drain];
+    
+    // Program Sonu
+    return 0;
+}
+
+///////////////////////////////////////
+// Sınıflar ve Fonksiyonlar
+///////////////////////////////////////
+
+// Sınıfınızı (MyClass.h) header dosyasında tanımlayın:
+
+// Sınıf tanımlama yapısı:
+// @interface ClassName : ParentClassName <ImplementedProtocols>
+// {
+//    Üye değişken (member variable) tanımlaması;
+// }
+// -/+ (type) Method tanımlaması;
+// @end
+@interface MyClass : NSObject <MyCustomProtocol>
+{
+    int count;
+    id data;
+    NSString *name;
+}
+// getter ve setter için otomatik oluşturulmuş gösterim.
+@property int count;
+@property (copy) NSString *name; // Copy the object during assignment.
+@property (readonly) id data;    // Declare only a getter method.
+
+// Metodlar
++/- (return type)methodSignature:(Parameter Type *)parameterName;
+
+// "+" class metodları içindir
++ (NSString *)classMethod;
+
+// "-" instance metodu içindir
+- (NSString *)instanceMethodWithParmeter:(NSString *)string;
+- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number;
+
+@end
+
+// Metodların implementasyonlarını (MyClass.m) dosyasında yapıyoruz:
+
+@implementation UserObject
+
+// Obje bellekten silineceği (release) zaman çağırılır
+- (void)dealloc
+{
+}
+
+// Constructor'lar sınıf oluşturmanın bir yoludur
+// Bu varsayılan bir constructor'dur ve bir obje oluşturulurken çağrılır.
+- (id)init
+{
+    if ((self = [super init]))
+    {
+        self.count = 1;
+    }
+    return self;
+}
+
++ (NSString *)classMethod
+{
+    return [[self alloc] init];
+}
+
+- (NSString *)instanceMethodWithParmeter:(NSString *)string
+{
+    return @"New string";
+}
+
+- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number
+{
+    return @42;
+}
+
+// MyProtocol içerisinde metod tanımlamaları
+- (void)myProtocolMethod
+{
+    // ifadeler
+}
+
+@end
+
+/*
+ * Bir `protocol` herhangi bir sınıf tarafından implement edilen metodları tanımlar 
+ * `Protocol`ler sınıfların kendileri değildir. Onlar basitçe diğer objelerin 
+ * implementasyon için sorumlu oldukları bir arayüz (interface) tanımlarlar. 
+ */
+@protocol MyProtocol
+    - (void)myProtocolMethod;
+@end
+
+
+
+```
+## Daha Fazla Okuma
+
+[Vikipedi Objective-C](http://tr.wikipedia.org/wiki/Objective-C)
+
+[Objective-C Öğrenme](http://developer.apple.com/library/ios/referencelibrary/GettingStarted/Learning_Objective-C_A_Primer/)
+
+[Lise Öğrencileri için iOS: Başlangıç](http://www.raywenderlich.com/5600/ios-for-high-school-students-getting-started)
-- 
cgit v1.2.3


From f46b6cda6e88fad20e785e77ee0cd25e516dcc67 Mon Sep 17 00:00:00 2001
From: Haydar Kulekci <haydarkulekci@gmail.com>
Date: Wed, 18 Sep 2013 17:57:19 +0300
Subject: [brainfuck/tr] translating Brainfuck programming language to turkish

---
 tr-tr/brainfuck-tr.html.markdown | 86 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)
 create mode 100644 tr-tr/brainfuck-tr.html.markdown

(limited to 'tr-tr')

diff --git a/tr-tr/brainfuck-tr.html.markdown b/tr-tr/brainfuck-tr.html.markdown
new file mode 100644
index 00000000..a6f6f078
--- /dev/null
+++ b/tr-tr/brainfuck-tr.html.markdown
@@ -0,0 +1,86 @@
+---
+language: brainfuck
+filename: brainfuck-tr
+contributors:
+    - ["Prajit Ramachandran", "http://prajitr.github.io"]
+translators:
+    - ["Haydar KULEKCI", "http://scanf.info/"]
+lang: tr-tr
+---
+
+Brainfuck son derece minimal bir programlama dilidir. (Sadece 8 komut) ve 
+tamamen Turing'dir.
+
+```
+"><+-.,[]" (tırnak işaretleri hariç) karakterleri dışındaki her karakter 
+gözardı edilir.
+
+Brainfuck is represented by an array with 30,000 cells initialized to zero
+and a data pointer pointing at the current cell.
+
+There are eight commands:
++ : Geçerli hücrenin değerini bir artırır.
+- : Geçerli hücrenin değerini bir azaltır.
+> : Veri işaretçisini bir sonraki hücreye hareket ettirir(sağdaki hücreye).
+< : Veri işaretçisini bir önceki hücreye hareket ettirir(soldaki hücreye).
+. : Geçerli hücrenin ASCII değerini yazdırır (örn: 65 = 'A').
+, : Bir girdilik karakteri aktif hücre için okur.
+[ : Eğer geçerli hücredeki değer sıfır ise, ]ifadesine atlar. 
+    Diğer durumlarda bir sonraki yönergeye geçer.
+] : Eğer geçerli hücredeki değer sıfır ise, bir sonraki yönergeye geçer. 
+    Diğer durumlarda, [ ifadesine karşılık gelen yönergelere döner.
+
+[ ve ] bir while döngüsü oluşturur. Açıkça, dengeli olmalıdırlar.
+
+Basit bir Brainfuck programına göz atalım. 
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Bu program 'A' karaterini ekrana basar. İlk olarak, #1'inci hücre 6'ya artırılır.
+#1'inci hücre döngü için kullanılacaktır. Sonra, ([) döngüsüne girilir ve 
+#2'inci hücreye hareket edilir. #2'inci hücre 10 kez artırılır, #1'inci hücreye 
+geri dönülür. #1 hücresini bir azaltır. Bu döngü 6 kez gerçekleşir. (Bu 6 kez 
+azaltmak demektir, #1 hücresi 0 değerini alır ve bu noktada ] ifadesini atlar).
+
+Bu noktada, biz #1 hücresindeyiz, değeri şu anda 0 ve #2 hücresinin değeri 
+60'tır. Biz #2 hücresine hareket diyoruz ve bu hücreyi 5 defa artırıyoruz.
+#2'nin şu anki değeri 65 olur. Sonra #2 hücresinin ASCII karşılığını 
+yazdırıyoruz. 65 değerinin ASCII karşılığı 'A'dır. Ekrana 'A' yazılacaktır. 
+
+
+, [ > + < - ] > .
+
+Bu program kullanıcıdan bir girdi okur, ve karakteri bir diğer hücreye yazdırır,
+ve daha sonra aynı karakteri ekrana yazdırır.
+
+, ifadesi kullanıcıdan karakteri #1 hücresine okur. Sonra bir döngü 
+başlar. #2 hücresine hareket edilir, #2 hücresinin değeri bir artırılır, #1 
+hücresine geri dönülür, ve #1 hücresinin değer bir azaltılır. Bu #1 hücresinin
+değeri 0 olana kadar devam eder ve #2 hücresi #1'in eski değerini tutar. Çünkü 
+biz #1 hücresindeki verileri döngü süresince #2 hücresine taşıyoruz, ve sonunda
+#2 hücresinin ASCII değerini yazdırıyoruz.
+
+Boşluk karakteri sadece okunabilirliği artırmak içindir. Aşağıdaki gibi de 
+yazabilirsiniz.
+
+,[>+<-]>.
+
+
+Bu uygulamanın ne yaptığına bakalım:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>  
+
+Bu program 2 sayı alır, ve birbiri ile çarpar.
+
+Özetle, ilk olarak iki girdi alır. Sonra, #1 hücresinde şarta bağlı harici bir 
+döngü başlar. Sonra #2 ye hareket edilir, ve içerde #2 hücresine bağlı bir döngü
+daha başlar ve #3 hücresinin değerini artırır. Ama, Bir problem vardır: iç 
+döngünün sonunda #2'inci hücrenin değeri 0 olacaktır. Bunu çözmek için #4 
+hücresinin de değerini yükseltiyoruz, ve sonra #4 hücresinin değerini #2'ye 
+kopyalıyoruz.
+```
+
+İşte Brainfuck. Zor değil değil mi? Eğlenmek için kendi programınızı 
+yazabilirsiniz, veya farklı bir dilde Brainfuck yorumlayıcısı yazabilirsiniz.
+Yorumlayıcı oldukça basittir, ama mazoşist iseniz, Brainfuck içerisinde bir 
+Brainfuck yorumlayıcısı yazmayı deneyebilirsiniz.
-- 
cgit v1.2.3


From 95faf8f5d2515c01c8eaae233291cc240ebb071d Mon Sep 17 00:00:00 2001
From: Haydar Kulekci <haydarkulekci@gmail.com>
Date: Fri, 20 Sep 2013 14:19:16 +0300
Subject: some updates on brainfuck/tr . i missed out "not capitalized except
 at the start of a sentence" about brainfuck

---
 tr-tr/brainfuck-tr.html.markdown | 57 ++++++++++++++++++++--------------------
 1 file changed, 29 insertions(+), 28 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/brainfuck-tr.html.markdown b/tr-tr/brainfuck-tr.html.markdown
index a6f6f078..baca4217 100644
--- a/tr-tr/brainfuck-tr.html.markdown
+++ b/tr-tr/brainfuck-tr.html.markdown
@@ -8,44 +8,45 @@ translators:
 lang: tr-tr
 ---
 
-Brainfuck son derece minimal bir programlama dilidir. (Sadece 8 komut) ve 
-tamamen Turing'dir.
+Brainfuck (normalde brainfuck olarak bütün harfleri küçük olarak yazılır.) 
+son derece minimal bir programlama dilidir. (Sadece 8 komut) ve tamamen 
+Turing'dir.
 
 ```
-"><+-.,[]" (tırnak işaretleri hariç) karakterleri dışındaki her karakter 
+"><+-.,[]" (tırnak işaretleri hariç) karakterleri dışındaki her karakter
 gözardı edilir.
 
-Brainfuck is represented by an array with 30,000 cells initialized to zero
-and a data pointer pointing at the current cell.
+Brainfuck 30,000 hücresi olan ve ilk değerleri sıfır olarak atanmış bir
+dizidir. İşaretçi ilk hücreyi işaret eder.
 
-There are eight commands:
+Sekik komut vardır:
 + : Geçerli hücrenin değerini bir artırır.
 - : Geçerli hücrenin değerini bir azaltır.
 > : Veri işaretçisini bir sonraki hücreye hareket ettirir(sağdaki hücreye).
 < : Veri işaretçisini bir önceki hücreye hareket ettirir(soldaki hücreye).
 . : Geçerli hücrenin ASCII değerini yazdırır (örn: 65 = 'A').
 , : Bir girdilik karakteri aktif hücre için okur.
-[ : Eğer geçerli hücredeki değer sıfır ise, ]ifadesine atlar. 
+[ : Eğer geçerli hücredeki değer sıfır ise, ]ifadesine atlar.
     Diğer durumlarda bir sonraki yönergeye geçer.
-] : Eğer geçerli hücredeki değer sıfır ise, bir sonraki yönergeye geçer. 
+] : Eğer geçerli hücredeki değer sıfır ise, bir sonraki yönergeye geçer.
     Diğer durumlarda, [ ifadesine karşılık gelen yönergelere döner.
 
 [ ve ] bir while döngüsü oluşturur. Açıkça, dengeli olmalıdırlar.
 
-Basit bir Brainfuck programına göz atalım. 
+Basit bir brainfuck programına göz atalım.
 
 ++++++ [ > ++++++++++ < - ] > +++++ .
 
 Bu program 'A' karaterini ekrana basar. İlk olarak, #1'inci hücre 6'ya artırılır.
-#1'inci hücre döngü için kullanılacaktır. Sonra, ([) döngüsüne girilir ve 
-#2'inci hücreye hareket edilir. #2'inci hücre 10 kez artırılır, #1'inci hücreye 
-geri dönülür. #1 hücresini bir azaltır. Bu döngü 6 kez gerçekleşir. (Bu 6 kez 
+#1'inci hücre döngü için kullanılacaktır. Sonra, ([) döngüsüne girilir ve
+#2'inci hücreye hareket edilir. #2'inci hücre 10 kez artırılır, #1'inci hücreye
+geri dönülür. #1 hücresini bir azaltır. Bu döngü 6 kez gerçekleşir. (Bu 6 kez
 azaltmak demektir, #1 hücresi 0 değerini alır ve bu noktada ] ifadesini atlar).
 
-Bu noktada, biz #1 hücresindeyiz, değeri şu anda 0 ve #2 hücresinin değeri 
+Bu noktada, biz #1 hücresindeyiz, değeri şu anda 0 ve #2 hücresinin değeri
 60'tır. Biz #2 hücresine hareket diyoruz ve bu hücreyi 5 defa artırıyoruz.
-#2'nin şu anki değeri 65 olur. Sonra #2 hücresinin ASCII karşılığını 
-yazdırıyoruz. 65 değerinin ASCII karşılığı 'A'dır. Ekrana 'A' yazılacaktır. 
+#2'nin şu anki değeri 65 olur. Sonra #2 hücresinin ASCII karşılığını
+yazdırıyoruz. 65 değerinin ASCII karşılığı 'A'dır. Ekrana 'A' yazılacaktır.
 
 
 , [ > + < - ] > .
@@ -53,14 +54,14 @@ yazdırıyoruz. 65 değerinin ASCII karşılığı 'A'dır. Ekrana 'A' yazılaca
 Bu program kullanıcıdan bir girdi okur, ve karakteri bir diğer hücreye yazdırır,
 ve daha sonra aynı karakteri ekrana yazdırır.
 
-, ifadesi kullanıcıdan karakteri #1 hücresine okur. Sonra bir döngü 
-başlar. #2 hücresine hareket edilir, #2 hücresinin değeri bir artırılır, #1 
+, ifadesi kullanıcıdan karakteri #1 hücresine okur. Sonra bir döngü
+başlar. #2 hücresine hareket edilir, #2 hücresinin değeri bir artırılır, #1
 hücresine geri dönülür, ve #1 hücresinin değer bir azaltılır. Bu #1 hücresinin
-değeri 0 olana kadar devam eder ve #2 hücresi #1'in eski değerini tutar. Çünkü 
+değeri 0 olana kadar devam eder ve #2 hücresi #1'in eski değerini tutar. Çünkü
 biz #1 hücresindeki verileri döngü süresince #2 hücresine taşıyoruz, ve sonunda
 #2 hücresinin ASCII değerini yazdırıyoruz.
 
-Boşluk karakteri sadece okunabilirliği artırmak içindir. Aşağıdaki gibi de 
+Boşluk karakteri sadece okunabilirliği artırmak içindir. Aşağıdaki gibi de
 yazabilirsiniz.
 
 ,[>+<-]>.
@@ -68,19 +69,19 @@ yazabilirsiniz.
 
 Bu uygulamanın ne yaptığına bakalım:
 
-,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>  
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
 
 Bu program 2 sayı alır, ve birbiri ile çarpar.
 
-Özetle, ilk olarak iki girdi alır. Sonra, #1 hücresinde şarta bağlı harici bir 
+Özetle, ilk olarak iki girdi alır. Sonra, #1 hücresinde şarta bağlı harici bir
 döngü başlar. Sonra #2 ye hareket edilir, ve içerde #2 hücresine bağlı bir döngü
-daha başlar ve #3 hücresinin değerini artırır. Ama, Bir problem vardır: iç 
-döngünün sonunda #2'inci hücrenin değeri 0 olacaktır. Bunu çözmek için #4 
-hücresinin de değerini yükseltiyoruz, ve sonra #4 hücresinin değerini #2'ye 
+daha başlar ve #3 hücresinin değerini artırır. Ama, Bir problem vardır: iç
+döngünün sonunda #2'inci hücrenin değeri 0 olacaktır. Bunu çözmek için #4
+hücresinin de değerini yükseltiyoruz, ve sonra #4 hücresinin değerini #2'ye
 kopyalıyoruz.
 ```
 
-İşte Brainfuck. Zor değil değil mi? Eğlenmek için kendi programınızı 
-yazabilirsiniz, veya farklı bir dilde Brainfuck yorumlayıcısı yazabilirsiniz.
-Yorumlayıcı oldukça basittir, ama mazoşist iseniz, Brainfuck içerisinde bir 
-Brainfuck yorumlayıcısı yazmayı deneyebilirsiniz.
+İşte brainfuck. Zor değil değil mi? Eğlenmek için kendi programınızı
+yazabilirsiniz, veya farklı bir dilde brainfuck yorumlayıcısı yazabilirsiniz.
+Yorumlayıcı oldukça basittir, ama mazoşist iseniz, brainfuck içerisinde bir
+brainfuck yorumlayıcısı yazmayı deneyebilirsiniz.
-- 
cgit v1.2.3


From eab554a7a7f2869ff7dac9f54acce9a7ed55cfa4 Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Mon, 8 Sep 2014 13:08:28 +0200
Subject: Review docs for added rouge lexers and update those with new
 highlighters

---
 tr-tr/objective-c-tr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tr-tr')

diff --git a/tr-tr/objective-c-tr.html.markdown b/tr-tr/objective-c-tr.html.markdown
index 854d70f6..f27cbf08 100644
--- a/tr-tr/objective-c-tr.html.markdown
+++ b/tr-tr/objective-c-tr.html.markdown
@@ -14,7 +14,7 @@ kendi çatıları olan Cocoa ve Cocoa Touch için kullanılan bir programlama di
 Genel açamlı, object-oriented bir yapıya sahip programlama dilidir. C 
 programlama diline Smalltalk stilinde mesajlaşma ekler.  
 
-```cpp
+```objective_c
 // Tek satır yorum // işaretleri ile başlar
 
 /*
-- 
cgit v1.2.3


From ef6544a8868d3b19a115804b2db3962d91ad7979 Mon Sep 17 00:00:00 2001
From: Geoffrey Liu <liug.2012@gmail.com>
Date: Sun, 12 Oct 2014 14:24:42 -0700
Subject: Capitalize language names for translations.

#137
---
 tr-tr/php-tr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tr-tr')

diff --git a/tr-tr/php-tr.html.markdown b/tr-tr/php-tr.html.markdown
index 3db437cf..5258d785 100644
--- a/tr-tr/php-tr.html.markdown
+++ b/tr-tr/php-tr.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: php
+language: PHP
 filename: learnphp-tr.php
 contributors:
     - ["Malcolm Fell", "http://emarref.net/"]
-- 
cgit v1.2.3


From 427875663c221ae11ff3b8a8a6e6d66e89b36ac2 Mon Sep 17 00:00:00 2001
From: Melih Mucuk <melihmucuk@gmail.com>
Date: Wed, 31 Dec 2014 11:56:23 +0200
Subject: basic

---
 tr-tr/csharp-tr.html.markdown | 824 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 824 insertions(+)
 create mode 100644 tr-tr/csharp-tr.html.markdown

(limited to 'tr-tr')

diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown
new file mode 100644
index 00000000..ecbc2b18
--- /dev/null
+++ b/tr-tr/csharp-tr.html.markdown
@@ -0,0 +1,824 @@
+---
+language: c#
+contributors:
+    - ["Irfan Charania", "https://github.com/irfancharania"]
+    - ["Max Yankov", "https://github.com/golergka"]
+    - ["Melvyn Laïly", "http://x2a.yt"]
+    - ["Shaun McCarthy", "http://www.shaunmccarthy.com"]
+    - ["Melih Mucuk", "http://melihmucuk.com"]
+filename: LearnCSharp.cs
+---
+
+C# zarif ve tip güvenli nesne yönelimli bir dil olup geliştiricilerin .NET framework üzerinde çalışan güçlü ve güvenli uygulamalar geliştirmesini sağlar.
+
+[Daha fazlasını okuyun.](http://msdn.microsoft.com/en-us/library/vstudio/z1zx9t92.aspx)
+
+```c#
+// Tek satırlık yorumlar // ile başlar 
+/*
+Birden fazla satırlı yorumlar buna benzer
+*/
+/// <summary>
+/// Bu bir XML dokümantasyon yorumu
+/// </summary>
+
+// Uygulamanın kullanacağı ad alanlarını belirtin
+using System;
+using System.Collections.Generic;
+using System.Data.Entity;
+using System.Dynamic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Net;
+using System.Threading.Tasks;
+using System.IO;
+
+// Kodu düzenlemek için paketler içinde alan tanımlayın
+namespace Learning
+{
+    // Her .cs dosyası, dosya ile aynı isimde en az bir sınıf içermeli
+    // bu kurala uymak zorunda değilsiniz ancak mantıklı olan yol budur.
+    public class LearnCSharp
+    {
+        // TEMEL SÖZ DİZİMİ - daha önce Java ya da C++ kullandıysanız İLGİNÇ ÖZELLİKLER'e geçin
+        public static void Syntax() 
+        {
+            // Satırları yazdırmak için Console.WriteLine kullanın
+            Console.WriteLine("Merhaba Dünya");
+            Console.WriteLine(
+                "Integer: " + 10 +
+                " Double: " + 3.14 +
+                " Boolean: " + true);
+
+            // Yeni satıra geçmeden yazdırmak için Console.Write kullanın
+            Console.Write("Merhaba ");
+            Console.Write("Dünya");
+
+            ///////////////////////////////////////////////////
+            // Tipler & Değişkenler
+            //
+            // Bir değişken tanımlamak için <tip> <isim> kullanın
+            ///////////////////////////////////////////////////
+
+            // Sbyte - Signed 8-bit integer
+            // (-128 <= sbyte <= 127)
+            sbyte fooSbyte = 100;
+
+            // Byte - Unsigned 8-bit integer
+            // (0 <= byte <= 255)
+            byte fooByte = 100;
+
+            // Short - 16-bit integer
+            // Signed - (-32,768 <= short <= 32,767)
+            // Unsigned - (0 <= ushort <= 65,535)
+            short fooShort = 10000;
+            ushort fooUshort = 10000;
+
+            // Integer - 32-bit integer
+            int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
+            uint fooUint = 1; // (0 <= uint <= 4,294,967,295)
+
+            // Long - 64-bit integer
+            long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+            ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
+            // Numbers default to being int or uint depending on size.
+            // L is used to denote that this variable value is of type long or ulong
+
+            // Double - Double-precision 64-bit IEEE 754 Floating Point
+            double fooDouble = 123.4; // Precision: 15-16 digits
+
+            // Float - Single-precision 32-bit IEEE 754 Floating Point
+            float fooFloat = 234.5f; // Precision: 7 digits
+            // f is used to denote that this variable value is of type float
+
+            // Decimal - a 128-bits data type, with more precision than other floating-point types,
+            // suited for financial and monetary calculations
+            decimal fooDecimal = 150.3m;
+
+            // Boolean - true & false
+            bool fooBoolean = true; // or false
+
+            // Char - A single 16-bit Unicode character
+            char fooChar = 'A';
+
+            // Strings -- unlike the previous base types which are all value types,
+            // a string is a reference type. That is, you can set it to null
+            string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)";
+            Console.WriteLine(fooString);
+
+            // You can access each character of the string with an indexer:
+            char charFromString = fooString[1]; // => 'e'
+            // Strings are immutable: you can't do fooString[1] = 'X';
+
+            // Compare strings with current culture, ignoring case
+            string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);
+
+            // Formatting, based on sprintf
+            string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2);
+
+            // Dates & Formatting
+            DateTime fooDate = DateTime.Now;
+            Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
+
+            // You can split a string over two lines with the @ symbol. To escape " use ""
+            string bazString = @"Here's some stuff
+on a new line! ""Wow!"", the masses cried";
+
+            // Use const or read-only to make a variable immutable
+            // const values are calculated at compile time
+            const int HOURS_I_WORK_PER_WEEK = 9001;
+
+            ///////////////////////////////////////////////////
+            // Data Structures
+            ///////////////////////////////////////////////////
+
+            // Arrays - zero indexed
+            // The array size must be decided upon declaration
+            // The format for declaring an array is follows:
+            // <datatype>[] <var name> = new <datatype>[<array size>];
+            int[] intArray = new int[10];
+
+            // Another way to declare & initialize an array
+            int[] y = { 9000, 1000, 1337 };
+
+            // Indexing an array - Accessing an element
+            Console.WriteLine("intArray @ 0: " + intArray[0]);
+            // Arrays are mutable.
+            intArray[1] = 1;
+
+            // Lists
+            // Lists are used more frequently than arrays as they are more flexible
+            // The format for declaring a list is follows:
+            // List<datatype> <var name> = new List<datatype>();
+            List<int> intList = new List<int>();
+            List<string> stringList = new List<string>();
+            List<int> z = new List<int> { 9000, 1000, 1337 }; // intialize
+            // The <> are for generics - Check out the cool stuff section
+
+            // Lists don't default to a value;
+            // A value must be added before accessing the index
+            intList.Add(1);
+            Console.WriteLine("intList @ 0: " + intList[0]);
+
+            // Others data structures to check out:
+            // Stack/Queue
+            // Dictionary (an implementation of a hash map)
+            // HashSet
+            // Read-only Collections
+            // Tuple (.Net 4+)
+
+            ///////////////////////////////////////
+            // Operators
+            ///////////////////////////////////////
+            Console.WriteLine("\n->Operators");
+
+            int i1 = 1, i2 = 2; // Shorthand for multiple declarations
+
+            // Arithmetic is straightforward
+            Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3
+
+            // Modulo
+            Console.WriteLine("11%3 = " + (11 % 3)); // => 2
+
+            // Comparison operators
+            Console.WriteLine("3 == 2? " + (3 == 2)); // => false
+            Console.WriteLine("3 != 2? " + (3 != 2)); // => true
+            Console.WriteLine("3 > 2? " + (3 > 2)); // => true
+            Console.WriteLine("3 < 2? " + (3 < 2)); // => false
+            Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true
+            Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true
+
+            // Bitwise operators!
+            /*
+            ~       Unary bitwise complement
+            <<      Signed left shift
+            >>      Signed right shift
+            &       Bitwise AND
+            ^       Bitwise exclusive OR
+            |       Bitwise inclusive OR
+            */
+
+            // Incrementations
+            int i = 0;
+            Console.WriteLine("\n->Inc/Dec-rementation");
+            Console.WriteLine(i++); //i = 1. Post-Incrementation
+            Console.WriteLine(++i); //i = 2. Pre-Incrementation
+            Console.WriteLine(i--); //i = 1. Post-Decrementation
+            Console.WriteLine(--i); //i = 0. Pre-Decrementation
+
+            ///////////////////////////////////////
+            // Control Structures
+            ///////////////////////////////////////
+            Console.WriteLine("\n->Control Structures");
+
+            // If statements are c-like
+            int j = 10;
+            if (j == 10)
+            {
+                Console.WriteLine("I get printed");
+            }
+            else if (j > 10)
+            {
+                Console.WriteLine("I don't");
+            }
+            else
+            {
+                Console.WriteLine("I also don't");
+            }
+
+            // Ternary operators
+            // A simple if/else can be written as follows
+            // <condition> ? <true> : <false>
+            string isTrue = (true) ? "True" : "False";
+
+            // While loop
+            int fooWhile = 0;
+            while (fooWhile < 100)
+            {
+                //Iterated 100 times, fooWhile 0->99
+                fooWhile++;
+            }
+
+            // Do While Loop
+            int fooDoWhile = 0;
+            do
+            {
+                //Iterated 100 times, fooDoWhile 0->99
+                fooDoWhile++;
+            } while (fooDoWhile < 100);
+
+            //for loop structure => for(<start_statement>; <conditional>; <step>)
+            for (int fooFor = 0; fooFor < 10; fooFor++)
+            {
+                //Iterated 10 times, fooFor 0->9
+            }
+
+            // For Each Loop
+            // foreach loop structure => foreach(<iteratorType> <iteratorName> in <enumerable>)
+            // The foreach loop loops over any object implementing IEnumerable or IEnumerable<T>
+            // All the collection types (Array, List, Dictionary...) in the .Net framework
+            // implement one or both of these interfaces.
+            // (The ToCharArray() could be removed, because a string also implements IEnumerable)
+            foreach (char character in "Hello World".ToCharArray())
+            {
+                //Iterated over all the characters in the string
+            }
+
+            // Switch Case
+            // A switch works with the byte, short, char, and int data types.
+            // It also works with enumerated types (discussed in Enum Types),
+            // the String class, and a few special classes that wrap
+            // primitive types: Character, Byte, Short, and Integer.
+            int month = 3;
+            string monthString;
+            switch (month)
+            {
+                case 1:
+                    monthString = "January";
+                    break;
+                case 2:
+                    monthString = "February";
+                    break;
+                case 3:
+                    monthString = "March";
+                    break;
+                // You can assign more than one case to an action
+                // But you can't add an action without a break before another case
+                // (if you want to do this, you would have to explicitly add a goto case x
+                case 6:
+                case 7:
+                case 8:
+                    monthString = "Summer time!!";
+                    break;
+                default:
+                    monthString = "Some other month";
+                    break;
+            }
+
+            ///////////////////////////////////////
+            // Converting Data Types And Typecasting
+            ///////////////////////////////////////
+
+            // Converting data
+
+            // Convert String To Integer
+            // this will throw an Exception on failure
+            int.Parse("123");//returns an integer version of "123"
+
+            // try parse will default to type default on failure
+            // in this case: 0
+            int tryInt;
+            if (int.TryParse("123", out tryInt)) // Function is boolean
+                Console.WriteLine(tryInt);       // 123
+
+            // Convert Integer To String
+            // Convert class has a number of methods to facilitate conversions
+            Convert.ToString(123);
+            // or
+            tryInt.ToString();
+        }
+
+        ///////////////////////////////////////
+        // CLASSES - see definitions at end of file
+        ///////////////////////////////////////
+        public static void Classes()
+        {
+            // See Declaration of objects at end of file
+
+            // Use new to instantiate a class
+            Bicycle trek = new Bicycle();
+
+            // Call object methods
+            trek.SpeedUp(3); // You should always use setter and getter methods
+            trek.Cadence = 100;
+
+            // ToString is a convention to display the value of this Object.
+            Console.WriteLine("trek info: " + trek.Info());
+
+            // Instantiate a new Penny Farthing
+            PennyFarthing funbike = new PennyFarthing(1, 10);
+            Console.WriteLine("funbike info: " + funbike.Info());
+
+            Console.Read();
+        } // End main method
+
+        // CONSOLE ENTRY A console application must have a main method as an entry point
+        public static void Main(string[] args)
+        {
+            OtherInterestingFeatures();
+        }
+
+        //
+        // INTERESTING FEATURES
+        //
+        
+        // DEFAULT METHOD SIGNATURES
+
+        public // Visibility
+        static // Allows for direct call on class without object 
+        int // Return Type,
+        MethodSignatures(
+            int maxCount, // First variable, expects an int
+            int count = 0, // will default the value to 0 if not passed in
+            int another = 3,
+            params string[] otherParams // captures all other parameters passed to method
+        )
+        { 
+            return -1;
+        }
+
+        // Methods can have the same name, as long as the signature is unique
+        public static void MethodSignatures(string maxCount)
+        {
+        }
+
+        // GENERICS
+        // The classes for TKey and TValue is specified by the user calling this function.
+        // This method emulates the SetDefault of Python
+        public static TValue SetDefault<TKey, TValue>(
+            IDictionary<TKey, TValue> dictionary, 
+            TKey key, 
+            TValue defaultItem)
+        {
+            TValue result;
+            if (!dictionary.TryGetValue(key, out result))
+                return dictionary[key] = defaultItem;
+            return result;
+        }
+
+        // You can narrow down the objects that are passed in 
+        public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
+        {
+            // We can iterate, since T is a IEnumerable
+            foreach (var item in toPrint)
+                // Item is an int
+                Console.WriteLine(item.ToString());
+        }
+
+        public static void OtherInterestingFeatures()
+        {
+            // OPTIONAL PARAMETERS
+            MethodSignatures(3, 1, 3, "Some", "Extra", "Strings");
+            MethodSignatures(3, another: 3); // explicity set a parameter, skipping optional ones
+
+            // EXTENSION METHODS
+            int i = 3;
+            i.Print(); // Defined below
+
+            // NULLABLE TYPES - great for database interaction / return values
+            // any value type (i.e. not a class) can be made nullable by suffixing a ?
+            // <type>? <var name> = <value>
+            int? nullable = null; // short hand for Nullable<int>
+            Console.WriteLine("Nullable variable: " + nullable);
+            bool hasValue = nullable.HasValue; // true if not null
+
+            // ?? is syntactic sugar for specifying default value (coalesce)
+            // in case variable is null
+            int notNullable = nullable ?? 0; // 0
+
+            // IMPLICITLY TYPED VARIABLES - you can let the compiler work out what the type is:
+            var magic = "magic is a string, at compile time, so you still get type safety";
+            // magic = 9; will not work as magic is a string, not an int
+
+            // GENERICS
+            //
+            var phonebook = new Dictionary<string, string>() { 
+                {"Sarah", "212 555 5555"} // Add some entries to the phone book
+            };
+
+            // Calling SETDEFAULT defined as a generic above
+            Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // No Phone
+            // nb, you don't need to specify the TKey and TValue since they can be 
+            // derived implicitly
+            Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555
+
+            // LAMBDA EXPRESSIONS - allow you to write code in line
+            Func<int, int> square = (x) => x * x; // Last T item is the return value
+            Console.WriteLine(square(3)); // 9
+
+            // DISPOSABLE RESOURCES MANAGEMENT - let you handle unmanaged resources easily.
+            // Most of objects that access unmanaged resources (file handle, device contexts, etc.)
+            // implement the IDisposable interface. The using statement takes care of 
+            // cleaning those IDisposable objects for you.
+            using (StreamWriter writer = new StreamWriter("log.txt"))
+            {
+                writer.WriteLine("Nothing suspicious here");
+                // At the end of scope, resources will be released.
+                // Even if an exception is thrown.
+            } 
+
+            // PARALLEL FRAMEWORK
+            // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx
+            var websites = new string[] { 
+                "http://www.google.com", "http://www.reddit.com", 
+                "http://www.shaunmccarthy.com"
+            };
+            var responses = new Dictionary<string, string>();
+            
+            // Will spin up separate threads for each request, and join on them
+            // before going to the next step!
+            Parallel.ForEach(websites, 
+                new ParallelOptions() {MaxDegreeOfParallelism = 3}, // max of 3 threads
+                website =>
+            {
+                // Do something that takes a long time on the file
+                using (var r = WebRequest.Create(new Uri(website)).GetResponse())
+                {
+                    responses[website] = r.ContentType;
+                }
+            });
+
+            // This won't happen till after all requests have been completed
+            foreach (var key in responses.Keys)
+                Console.WriteLine("{0}:{1}", key, responses[key]);
+
+            // DYNAMIC OBJECTS (great for working with other languages)
+            dynamic student = new ExpandoObject();
+            student.FirstName = "First Name"; // No need to define class first!
+
+            // You can even add methods (returns a string, and takes in a string)
+            student.Introduce = new Func<string, string>(
+                (introduceTo) => string.Format("Hey {0}, this is {1}", student.FirstName, introduceTo));
+            Console.WriteLine(student.Introduce("Beth"));
+
+            // IQUERYABLE<T> - almost all collections implement this, which gives you a lot of 
+            // very useful Map / Filter / Reduce style methods
+            var bikes = new List<Bicycle>();
+            bikes.Sort(); // Sorts the array
+            bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // Sorts based on wheels
+            var result = bikes
+                .Where(b => b.Wheels > 3) // Filters - chainable (returns IQueryable of previous type)
+                .Where(b => b.IsBroken && b.HasTassles)
+                .Select(b => b.ToString()); // Map - we only this selects, so result is a IQueryable<string>
+
+            var sum = bikes.Sum(b => b.Wheels); // Reduce - sums all the wheels in the collection
+
+            // Create a list of IMPLICIT objects based on some parameters of the bike
+            var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });
+            // Hard to show here, but you get type ahead completion since the compiler can implicitly work
+            // out the types above!
+            foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))
+                Console.WriteLine(bikeSummary.Name);
+
+            // ASPARALLEL
+            // And this is where things get wicked - combines linq and parallel operations
+            var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);
+            // this will happen in parallel! Threads will automagically be spun up and the 
+            // results divvied amongst them! Amazing for large datasets when you have lots of 
+            // cores
+
+            // LINQ - maps a store to IQueryable<T> objects, with delayed execution
+            // e.g. LinqToSql - maps to a database, LinqToXml maps to an xml document
+            var db = new BikeRepository();
+
+            // execution is delayed, which is great when querying a database
+            var filter = db.Bikes.Where(b => b.HasTassles); // no query run
+            if (42 > 6) // You can keep adding filters, even conditionally - great for "advanced search" functionality
+                filter = filter.Where(b => b.IsBroken); // no query run
+
+            var query = filter
+                .OrderBy(b => b.Wheels)
+                .ThenBy(b => b.Name)
+                .Select(b => b.Name); // still no query run
+
+            // Now the query runs, but opens a reader, so only populates are you iterate through
+            foreach (string bike in query) 
+                Console.WriteLine(result);
+            
+
+
+        }
+
+    } // End LearnCSharp class
+
+    // You can include other classes in a .cs file
+
+    public static class Extensions
+    {
+        // EXTENSION FUNCTIONS
+        public static void Print(this object obj)
+        {
+            Console.WriteLine(obj.ToString());
+        }
+    }
+
+    // Class Declaration Syntax:
+    // <public/private/protected/internal> class <class name>{
+    //    //data fields, constructors, functions all inside.
+    //    //functions are called as methods in Java.
+    // }
+
+    public class Bicycle
+    {
+        // Bicycle's Fields/Variables
+        public int Cadence // Public: Can be accessed from anywhere
+        {
+            get // get - define a method to retrieve the property
+            {
+                return _cadence;
+            }
+            set // set - define a method to set a proprety
+            {
+                _cadence = value; // Value is the value passed in to the setter
+            }
+        }
+        private int _cadence;
+
+        protected virtual int Gear // Protected: Accessible from the class and subclasses
+        {
+            get; // creates an auto property so you don't need a member field
+            set;
+        }
+
+        internal int Wheels // Internal: Accessible from within the assembly
+        {
+            get;
+            private set; // You can set modifiers on the get/set methods
+        }
+
+        int _speed; // Everything is private by default: Only accessible from within this class. 
+                    // can also use keyword private
+        public string Name { get; set; }
+
+        // Enum is a value type that consists of a set of named constants
+        // It is really just mapping a name to a value (an int, unless specified otherwise).
+        // The approved types for an enum are byte, sbyte, short, ushort, int, uint, long, or ulong.
+        // An enum can't contain the same value twice.
+        public enum BikeBrand
+        {
+            AIST,
+            BMC,
+            Electra = 42, //you can explicitly set a value to a name
+            Gitane // 43
+        }
+        // We defined this type inside a Bicycle class, so it is a nested type
+        // Code outside of this class should reference this type as Bicycle.Brand
+
+        public BikeBrand Brand; // After declaring an enum type, we can declare the field of this type
+
+        // Static members belong to the type itself rather then specific object.
+        // You can access them without a reference to any object:
+        // Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated);
+        static public int BicyclesCreated = 0;
+
+        // readonly values are set at run time
+        // they can only be assigned upon declaration or in a constructor
+        readonly bool _hasCardsInSpokes = false; // read-only private
+
+        // Constructors are a way of creating classes
+        // This is a default constructor
+        public Bicycle() 
+        {
+            this.Gear = 1; // you can access members of the object with the keyword this
+            Cadence = 50;  // but you don't always need it
+            _speed = 5;
+            Name = "Bontrager";
+            Brand = BikeBrand.AIST;
+            BicyclesCreated++;
+        }
+
+        // This is a specified constructor (it contains arguments)
+        public Bicycle(int startCadence, int startSpeed, int startGear,
+                       string name, bool hasCardsInSpokes, BikeBrand brand) 
+            : base() // calls base first
+        {
+            Gear = startGear; 
+            Cadence = startCadence;
+            _speed = startSpeed;
+            Name = name; 
+            _hasCardsInSpokes = hasCardsInSpokes;
+            Brand = brand;
+        }
+
+        // Constructors can be chained
+        public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
+            this(startCadence, startSpeed, 0, "big wheels", true, brand)
+        {
+        }
+
+        // Function Syntax:
+        // <public/private/protected> <return type> <function name>(<args>)
+
+        // classes can implement getters and setters for their fields
+        // or they can implement properties (this is the preferred way in C#)
+
+        // Method parameters can have default values.
+        // In this case, methods can be called with these parameters omitted
+        public void SpeedUp(int increment = 1)
+        {
+            _speed += increment;
+        }
+
+        public void SlowDown(int decrement = 1)
+        {
+            _speed -= decrement;
+        }
+
+        // properties get/set values
+        // when only data needs to be accessed, consider using properties.
+        // properties may have either get or set, or both
+        private bool _hasTassles; // private variable
+        public bool HasTassles // public accessor
+        {
+            get { return _hasTassles; }
+            set { _hasTassles = value; }
+        }
+
+        // You can also define an automatic property in one line
+        // this syntax will create a backing field automatically.
+        // You can set an access modifier on either the getter or the setter (or both)
+        // to restrict its access:
+        public bool IsBroken { get; private set; }
+
+        // Properties can be auto-implemented
+        public int FrameSize
+        {
+            get;
+            // you are able to specify access modifiers for either get or set
+            // this means only Bicycle class can call set on Framesize
+            private set;
+        }
+
+        // It's also possible to define custom Indexers on objects.
+        // All though this is not entirely useful in this example, you
+        // could do bicycle[0] which yields "chris" to get the first passenger or
+        // bicycle[1] = "lisa" to set the passenger. (of this apparent quattrocycle)
+        private string[] passengers = { "chris", "phil", "darren", "regina" }
+
+        public string this[int i]
+        {
+            get {
+                return passengers[i];
+            }
+
+            set {
+                return passengers[i] = value;
+            }
+        }
+
+        //Method to display the attribute values of this Object.
+        public virtual string Info()
+        {
+            return "Gear: " + Gear +
+                    " Cadence: " + Cadence +
+                    " Speed: " + _speed +
+                    " Name: " + Name +
+                    " Cards in Spokes: " + (_hasCardsInSpokes ? "yes" : "no") +
+                    "\n------------------------------\n"
+                    ;
+        }
+
+        // Methods can also be static. It can be useful for helper methods
+        public static bool DidWeCreateEnoughBycles()
+        {
+            // Within a static method, we only can reference static class members
+            return BicyclesCreated > 9000;
+        } // If your class only needs static members, consider marking the class itself as static.
+
+
+    } // end class Bicycle
+
+    // PennyFarthing is a subclass of Bicycle
+    class PennyFarthing : Bicycle
+    {
+        // (Penny Farthings are those bicycles with the big front wheel.
+        // They have no gears.)
+
+        // calling parent constructor
+        public PennyFarthing(int startCadence, int startSpeed) :
+            base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra)
+        {
+        }
+
+        protected override int Gear
+        {
+            get
+            {
+                return 0;
+            }
+            set
+            {
+                throw new ArgumentException("You can't change gears on a PennyFarthing");
+            }
+        }
+
+        public override string Info()
+        {
+            string result = "PennyFarthing bicycle ";
+            result += base.ToString(); // Calling the base version of the method
+            return result;
+        }
+    }
+
+    // Interfaces only contain signatures of the members, without the implementation.
+    interface IJumpable
+    {
+        void Jump(int meters); // all interface members are implicitly public
+    }
+
+    interface IBreakable
+    {
+        bool Broken { get; } // interfaces can contain properties as well as methods & events
+    }
+
+    // Class can inherit only one other class, but can implement any amount of interfaces
+    class MountainBike : Bicycle, IJumpable, IBreakable
+    {
+        int damage = 0;
+
+        public void Jump(int meters)
+        {
+            damage += meters;
+        }
+
+        public bool Broken
+        {
+            get
+            {
+                return damage > 100;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Used to connect to DB for LinqToSql example. 
+    /// EntityFramework Code First is awesome (similar to Ruby's ActiveRecord, but bidirectional)
+    /// http://msdn.microsoft.com/en-us/data/jj193542.aspx
+    /// </summary>
+    public class BikeRepository : DbSet
+    {
+        public BikeRepository()
+            : base()
+        {
+        }
+
+        public DbSet<Bicycle> Bikes { get; set; }
+    }
+} // End Namespace
+```
+
+## Topics Not Covered
+
+ * Flags
+ * Attributes
+ * Static properties
+ * Exceptions, Abstraction
+ * ASP.NET (Web Forms/MVC/WebMatrix)
+ * Winforms
+ * Windows Presentation Foundation (WPF)
+
+## Further Reading
+
+ * [DotNetPerls](http://www.dotnetperls.com)
+ * [C# in Depth](http://manning.com/skeet2)
+ * [Programming C#](http://shop.oreilly.com/product/0636920024064.do)
+ * [LINQ](http://shop.oreilly.com/product/9780596519254.do)
+ * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx)
+ * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials)
+ * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials)
+ * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials)
+ * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208)
+
+
+
+[C# Coding Conventions](http://msdn.microsoft.com/en-us/library/vstudio/ff926074.aspx)
-- 
cgit v1.2.3


From 32174fe9ce787f9135bda27dd3d3fddc9b0225bd Mon Sep 17 00:00:00 2001
From: Melih Mucuk <melihmucuk@gmail.com>
Date: Wed, 31 Dec 2014 12:01:40 +0200
Subject: types

---
 tr-tr/csharp-tr.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown
index ecbc2b18..29c29145 100644
--- a/tr-tr/csharp-tr.html.markdown
+++ b/tr-tr/csharp-tr.html.markdown
@@ -81,8 +81,8 @@ namespace Learning
             // Long - 64-bit integer
             long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
             ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
-            // Numbers default to being int or uint depending on size.
-            // L is used to denote that this variable value is of type long or ulong
+            // Sayılar boyutlarına göre ön tanımlı olarak int ya da uint olabilir.
+            // L, bir değerin long ya da ulong tipinde olduğunu belirtmek için kullanılır.
 
             // Double - Double-precision 64-bit IEEE 754 Floating Point
             double fooDouble = 123.4; // Precision: 15-16 digits
-- 
cgit v1.2.3


From 20a921fd03a8274e817944f5732b7b69f4267abd Mon Sep 17 00:00:00 2001
From: Melih Mucuk <melihmucuk@gmail.com>
Date: Wed, 31 Dec 2014 16:07:18 +0200
Subject: arrays

---
 tr-tr/csharp-tr.html.markdown | 52 +++++++++++++++++++++----------------------
 1 file changed, 26 insertions(+), 26 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown
index 29c29145..8c6a7d43 100644
--- a/tr-tr/csharp-tr.html.markdown
+++ b/tr-tr/csharp-tr.html.markdown
@@ -82,63 +82,63 @@ namespace Learning
             long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
             ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
             // Sayılar boyutlarına göre ön tanımlı olarak int ya da uint olabilir.
-            // L, bir değerin long ya da ulong tipinde olduğunu belirtmek için kullanılır.
+            // L, değişken değerinin long ya da ulong tipinde olduğunu belirtmek için kullanılır.
 
-            // Double - Double-precision 64-bit IEEE 754 Floating Point
-            double fooDouble = 123.4; // Precision: 15-16 digits
+            // Double - Çift hassasiyetli 64-bit IEEE 754 kayan sayı
+            double fooDouble = 123.4; // Hassasiyet: 15-16 basamak
 
-            // Float - Single-precision 32-bit IEEE 754 Floating Point
-            float fooFloat = 234.5f; // Precision: 7 digits
-            // f is used to denote that this variable value is of type float
+            // Float - Tek hassasiyetli 32-bit IEEE 754 kayan sayı
+            float fooFloat = 234.5f; // Hassasiyet: 7 basamak
+            // f, değişken değerinin float tipinde olduğunu belirtmek için kullanılır.
 
-            // Decimal - a 128-bits data type, with more precision than other floating-point types,
-            // suited for financial and monetary calculations
+            // Decimal - 128-bit veri tiğinde ve diğer kayan sayı veri tiplerinden daha hassastır,
+            // finansal ve mali hesaplamalar için uygundur.
             decimal fooDecimal = 150.3m;
 
             // Boolean - true & false
-            bool fooBoolean = true; // or false
+            bool fooBoolean = true; // veya false
 
-            // Char - A single 16-bit Unicode character
+            // Char - 16-bitlik tek bir unicode karakter
             char fooChar = 'A';
 
-            // Strings -- unlike the previous base types which are all value types,
-            // a string is a reference type. That is, you can set it to null
+            // Strings -- Önceki baz tiplerinin hepsi değer tipiyken,
+            // string bir referans tipidir. Null değer atayabilirsiniz
             string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)";
             Console.WriteLine(fooString);
 
-            // You can access each character of the string with an indexer:
+            // İndeks numarası kullanarak bir string'in bütün karakterlerine erişilebilirsiniz: 
             char charFromString = fooString[1]; // => 'e'
-            // Strings are immutable: you can't do fooString[1] = 'X';
+            // String'ler değiştirilemez: fooString[1] = 'X' işlemini yapamazsınız;
 
-            // Compare strings with current culture, ignoring case
+            // String'leri geçerli kültür değeri ve büyük küçük harf duyarlılığı olmadan karşılaştırma
             string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);
 
-            // Formatting, based on sprintf
+            // sprintf baz alınarak formatlama
             string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2);
 
-            // Dates & Formatting
+            // Tarihler & Formatlama
             DateTime fooDate = DateTime.Now;
             Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
 
-            // You can split a string over two lines with the @ symbol. To escape " use ""
+            // Bir string'i iki satıra bölmek için @ sembolü kullanabilirsiniz. " işaretinden kaçmak için "" kullanın
             string bazString = @"Here's some stuff
 on a new line! ""Wow!"", the masses cried";
 
-            // Use const or read-only to make a variable immutable
-            // const values are calculated at compile time
+            // Bir değişkeni değiştirilemez yapmak için const ya da read-only kullanın. 
+            // const değerleri derleme sırasında hesaplanır
             const int HOURS_I_WORK_PER_WEEK = 9001;
 
             ///////////////////////////////////////////////////
-            // Data Structures
+            // Veri Yapıları
             ///////////////////////////////////////////////////
 
-            // Arrays - zero indexed
-            // The array size must be decided upon declaration
-            // The format for declaring an array is follows:
-            // <datatype>[] <var name> = new <datatype>[<array size>];
+            // Diziler - Sıfır indeksli
+            // Dizi boyutuna tanımlama sırasında karar verilmelidir.
+            // Dizi tanımlama formatı şöyledir:
+            // <veri tipi>[] <değişken ismi> = new <veri tipi>[<dizi boyutu>];
             int[] intArray = new int[10];
 
-            // Another way to declare & initialize an array
+            // Bir diğer dizi tanımlama formatı şöyledir:
             int[] y = { 9000, 1000, 1337 };
 
             // Indexing an array - Accessing an element
-- 
cgit v1.2.3


From 4ba98e1b9782ac8dc1a476296fb9cf1095943787 Mon Sep 17 00:00:00 2001
From: Melih Mucuk <melihmucuk@gmail.com>
Date: Wed, 31 Dec 2014 16:46:49 +0200
Subject: swithc case

---
 tr-tr/csharp-tr.html.markdown | 98 +++++++++++++++++++++----------------------
 1 file changed, 49 insertions(+), 49 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown
index 8c6a7d43..1ecf18e8 100644
--- a/tr-tr/csharp-tr.html.markdown
+++ b/tr-tr/csharp-tr.html.markdown
@@ -141,46 +141,46 @@ on a new line! ""Wow!"", the masses cried";
             // Bir diğer dizi tanımlama formatı şöyledir:
             int[] y = { 9000, 1000, 1337 };
 
-            // Indexing an array - Accessing an element
+            // Bir diziyi indeksleme - Bir elemente erişme
             Console.WriteLine("intArray @ 0: " + intArray[0]);
-            // Arrays are mutable.
+            // Diziler değiştirilebilir.
             intArray[1] = 1;
 
-            // Lists
-            // Lists are used more frequently than arrays as they are more flexible
-            // The format for declaring a list is follows:
-            // List<datatype> <var name> = new List<datatype>();
+            // Listeler
+            // Listeler daha esnek oldukları için dizilerden daha sık kullanılırlar.
+            // Bir liste tanımlama formatı şöyledir:
+            // List<veri tipi> <değişken ismi> = new List<veri tipi>();
             List<int> intList = new List<int>();
             List<string> stringList = new List<string>();
-            List<int> z = new List<int> { 9000, 1000, 1337 }; // intialize
-            // The <> are for generics - Check out the cool stuff section
+            List<int> z = new List<int> { 9000, 1000, 1337 }; // tanımlama
+            // <> işareti genelleme içindir - Güzel özellikler sekmesini inceleyin
 
-            // Lists don't default to a value;
-            // A value must be added before accessing the index
+            // Listelerin varsayılan bir değeri yoktur;
+            // İndekse erişmeden önce değer eklenmiş olmalıdır
             intList.Add(1);
             Console.WriteLine("intList @ 0: " + intList[0]);
 
-            // Others data structures to check out:
-            // Stack/Queue
-            // Dictionary (an implementation of a hash map)
-            // HashSet
-            // Read-only Collections
-            // Tuple (.Net 4+)
+            // Diğer veri yapıları için şunlara bakın:
+            // Stack/Queue (Yığın/Kuyruk)
+            // Dictionary (hash map'in uygulanması) (Sözlük)
+            // HashSet (karma seti)
+            // Read-only Collections (Değiştirilemez koleksiyonlar)
+            // Tuple (.Net 4+) (tüp)
 
             ///////////////////////////////////////
-            // Operators
+            // Operatörler
             ///////////////////////////////////////
             Console.WriteLine("\n->Operators");
 
-            int i1 = 1, i2 = 2; // Shorthand for multiple declarations
+            int i1 = 1, i2 = 2; // Birden çok tanımlamanın kısa yolu
 
-            // Arithmetic is straightforward
+            // Aritmetik basittir
             Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3
 
-            // Modulo
+            // Mod
             Console.WriteLine("11%3 = " + (11 % 3)); // => 2
 
-            // Comparison operators
+            // Karşılaştırma operatörleri
             Console.WriteLine("3 == 2? " + (3 == 2)); // => false
             Console.WriteLine("3 != 2? " + (3 != 2)); // => true
             Console.WriteLine("3 > 2? " + (3 > 2)); // => true
@@ -188,17 +188,17 @@ on a new line! ""Wow!"", the masses cried";
             Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true
             Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true
 
-            // Bitwise operators!
+            // Bit düzeyi operatörleri!
             /*
-            ~       Unary bitwise complement
-            <<      Signed left shift
-            >>      Signed right shift
-            &       Bitwise AND
-            ^       Bitwise exclusive OR
-            |       Bitwise inclusive OR
+            ~       Tekli bit tamamlayıcısı
+            <<      Sola kaydırma Signed left shift
+            >>      Sağa kaydırma Signed right shift
+            &       Bit düzeyi AND
+            ^       Bit düzeyi harici OR
+            |       Bit düzeyi kapsayan OR
             */
 
-            // Incrementations
+            // Arttırma
             int i = 0;
             Console.WriteLine("\n->Inc/Dec-rementation");
             Console.WriteLine(i++); //i = 1. Post-Incrementation
@@ -207,11 +207,11 @@ on a new line! ""Wow!"", the masses cried";
             Console.WriteLine(--i); //i = 0. Pre-Decrementation
 
             ///////////////////////////////////////
-            // Control Structures
+            // Kontrol Yapıları
             ///////////////////////////////////////
             Console.WriteLine("\n->Control Structures");
 
-            // If statements are c-like
+            // If ifadesi c benzeridir
             int j = 10;
             if (j == 10)
             {
@@ -226,47 +226,47 @@ on a new line! ""Wow!"", the masses cried";
                 Console.WriteLine("I also don't");
             }
 
-            // Ternary operators
-            // A simple if/else can be written as follows
-            // <condition> ? <true> : <false>
+            // Üçlü operatörler
+            // Basit bir if/else ifadesi şöyle yazılabilir
+            // <koşul> ? <true> : <false>
             string isTrue = (true) ? "True" : "False";
 
-            // While loop
+            // While döngüsü
             int fooWhile = 0;
             while (fooWhile < 100)
             {
-                //Iterated 100 times, fooWhile 0->99
+                //100 kere tekrarlanır, fooWhile 0->99
                 fooWhile++;
             }
 
-            // Do While Loop
+            // Do While Döngüsü
             int fooDoWhile = 0;
             do
             {
-                //Iterated 100 times, fooDoWhile 0->99
+                //100 kere tekrarlanır, fooDoWhile 0->99
                 fooDoWhile++;
             } while (fooDoWhile < 100);
 
-            //for loop structure => for(<start_statement>; <conditional>; <step>)
+            //for döngüsü yapısı => for(<başlangıç ifadesi>; <koşul>; <adım>)
             for (int fooFor = 0; fooFor < 10; fooFor++)
             {
-                //Iterated 10 times, fooFor 0->9
+                //10 kere tekrarlanır, fooFor 0->9
             }
 
-            // For Each Loop
-            // foreach loop structure => foreach(<iteratorType> <iteratorName> in <enumerable>)
-            // The foreach loop loops over any object implementing IEnumerable or IEnumerable<T>
-            // All the collection types (Array, List, Dictionary...) in the .Net framework
-            // implement one or both of these interfaces.
-            // (The ToCharArray() could be removed, because a string also implements IEnumerable)
+            // For Each Döngüsü
+            // foreach döngüsü yapısı => foreach(<yineleyici tipi> <yineleyici ismi> in <enumerable>)
+            // foreach döngüsü, IEnumerable ya da IEnumerable<T> e dönüştürülmüş herhangi bir obje üzerinde döngü yapabilir
+            // .Net framework üzerindeki bütün koleksiyon tiplerinden (Dizi, Liste, Sözlük...)
+            // biri ya da hepsi uygulanarak gerçekleştirilebilir.
+            // (ToCharArray() silindi, çünkü string'ler aynı zamanda IEnumerable'dır.)
             foreach (char character in "Hello World".ToCharArray())
             {
-                //Iterated over all the characters in the string
+                //String içindeki bütün karakterler üzerinde döner
             }
 
             // Switch Case
-            // A switch works with the byte, short, char, and int data types.
-            // It also works with enumerated types (discussed in Enum Types),
+            // Bir switch byte, short, char ve int veri tipleri ile çalışır.
+            // Aynı zamanda sıralı tipler ilede çalışabilir.(Enum Tipleri bölümünde tartışıldı),
             // the String class, and a few special classes that wrap
             // primitive types: Character, Byte, Short, and Integer.
             int month = 3;
-- 
cgit v1.2.3


From 9b1b260c6c3510ccbcc213dd37175ae4383cf08f Mon Sep 17 00:00:00 2001
From: Melih Mucuk <melihmucuk@gmail.com>
Date: Wed, 31 Dec 2014 17:13:30 +0200
Subject: classes

---
 tr-tr/csharp-tr.html.markdown | 50 +++++++++++++++++++++----------------------
 1 file changed, 25 insertions(+), 25 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown
index 1ecf18e8..37a1090a 100644
--- a/tr-tr/csharp-tr.html.markdown
+++ b/tr-tr/csharp-tr.html.markdown
@@ -266,9 +266,9 @@ on a new line! ""Wow!"", the masses cried";
 
             // Switch Case
             // Bir switch byte, short, char ve int veri tipleri ile çalışır.
-            // Aynı zamanda sıralı tipler ilede çalışabilir.(Enum Tipleri bölümünde tartışıldı),
-            // the String class, and a few special classes that wrap
-            // primitive types: Character, Byte, Short, and Integer.
+            // Aynı zamanda sıralı tipler ile de çalışabilir.(Enum Tipleri bölümünde tartışıldı),
+            // String sınıfı, ve bir kaç özel sınıf kaydırılır
+            // basit tipler: Character, Byte, Short, and Integer.
             int month = 3;
             string monthString;
             switch (month)
@@ -282,9 +282,9 @@ on a new line! ""Wow!"", the masses cried";
                 case 3:
                     monthString = "March";
                     break;
-                // You can assign more than one case to an action
-                // But you can't add an action without a break before another case
-                // (if you want to do this, you would have to explicitly add a goto case x
+                // Bir aksiyon için birden fazla durum atayabilirsiniz
+                // Ancak, break olmadan yeni bir durum ekleyemezsiniz
+                // (Eğer bunu yapmak istiyorsanız, goto komutu eklemek zorundasınız)
                 case 6:
                 case 7:
                 case 8:
@@ -296,51 +296,51 @@ on a new line! ""Wow!"", the masses cried";
             }
 
             ///////////////////////////////////////
-            // Converting Data Types And Typecasting
+            // Veri Tipleri Dönüştürme ve Typecasting
             ///////////////////////////////////////
 
-            // Converting data
+            // Veri Dönüştürme
 
-            // Convert String To Integer
-            // this will throw an Exception on failure
-            int.Parse("123");//returns an integer version of "123"
+            // String'i Integer'a Dönüştürme
+            // bu başarısız olursa hata fırlatacaktır
+            int.Parse("123");// "123" 'in Integer değerini döndürür
 
-            // try parse will default to type default on failure
-            // in this case: 0
+            // try parse hata durumunda değişkene varsayılan bir değer atamak için kullanılır
+            // bu durumda: 0
             int tryInt;
-            if (int.TryParse("123", out tryInt)) // Function is boolean
+            if (int.TryParse("123", out tryInt)) // Fonksiyon boolean'dır
                 Console.WriteLine(tryInt);       // 123
 
-            // Convert Integer To String
-            // Convert class has a number of methods to facilitate conversions
+            // Integer'ı String'e Dönüştürme
+            // Convert sınıfı dönüştürme işlemini kolaylaştırmak için bir dizi metoda sahiptir
             Convert.ToString(123);
-            // or
+            // veya
             tryInt.ToString();
         }
 
         ///////////////////////////////////////
-        // CLASSES - see definitions at end of file
+        // SINIFLAR - dosyanın sonunda tanımları görebilirsiniz
         ///////////////////////////////////////
         public static void Classes()
         {
-            // See Declaration of objects at end of file
+            // Obje tanımlamalarını dosyanın sonunda görebilirsiniz
 
-            // Use new to instantiate a class
+            // Bir sınıfı türetmek için new kullanın
             Bicycle trek = new Bicycle();
 
-            // Call object methods
-            trek.SpeedUp(3); // You should always use setter and getter methods
+            // Obje metodlarını çağırma
+            trek.SpeedUp(3); // Her zaman setter ve getter metodları kullanmalısınız
             trek.Cadence = 100;
 
-            // ToString is a convention to display the value of this Object.
+            // ToString objenin değerini göstermek için kullanılır.
             Console.WriteLine("trek info: " + trek.Info());
 
-            // Instantiate a new Penny Farthing
+            // Yeni bir Penny Farthing sınıfı türetmek
             PennyFarthing funbike = new PennyFarthing(1, 10);
             Console.WriteLine("funbike info: " + funbike.Info());
 
             Console.Read();
-        } // End main method
+        } // Ana metodun sonu
 
         // CONSOLE ENTRY A console application must have a main method as an entry point
         public static void Main(string[] args)
-- 
cgit v1.2.3


From 765e4d3be987edd441b5f3cdee83543645fca642 Mon Sep 17 00:00:00 2001
From: Melih Mucuk <melihmucuk@gmail.com>
Date: Wed, 31 Dec 2014 19:30:07 +0200
Subject: lasssstttt

---
 tr-tr/csharp-tr.html.markdown | 232 +++++++++++++++++++++---------------------
 1 file changed, 114 insertions(+), 118 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown
index 37a1090a..cfbee5e8 100644
--- a/tr-tr/csharp-tr.html.markdown
+++ b/tr-tr/csharp-tr.html.markdown
@@ -153,7 +153,7 @@ on a new line! ""Wow!"", the masses cried";
             List<int> intList = new List<int>();
             List<string> stringList = new List<string>();
             List<int> z = new List<int> { 9000, 1000, 1337 }; // tanımlama
-            // <> işareti genelleme içindir - Güzel özellikler sekmesini inceleyin
+            // <> işareti generic ifadeler içindir - Güzel özellikler sekmesini inceleyin
 
             // Listelerin varsayılan bir değeri yoktur;
             // İndekse erişmeden önce değer eklenmiş olmalıdır
@@ -342,39 +342,39 @@ on a new line! ""Wow!"", the masses cried";
             Console.Read();
         } // Ana metodun sonu
 
-        // CONSOLE ENTRY A console application must have a main method as an entry point
+        // KONSOLE BAŞLANGICI Bir konsol uygulaması başlangıç olarak mutlaka ana metod'a sahip olmalı
         public static void Main(string[] args)
         {
             OtherInterestingFeatures();
         }
 
         //
-        // INTERESTING FEATURES
+        // İLGİNÇ ÖZELLİKLER
         //
         
-        // DEFAULT METHOD SIGNATURES
+        // VARSAYILAN METOD TANIMLAMALARI
 
-        public // Visibility
-        static // Allows for direct call on class without object 
-        int // Return Type,
+        public // Görünebilir
+        static // Sınıf üzerinden obje türetmeden çağırılabilir
+        int // Dönüş Tipi,
         MethodSignatures(
-            int maxCount, // First variable, expects an int
-            int count = 0, // will default the value to 0 if not passed in
+            int maxCount, // İlk değişken, int değer bekler
+            int count = 0, // Eğer değer gönderilmezse varsayılan olarak 0 değerini alır
             int another = 3,
-            params string[] otherParams // captures all other parameters passed to method
+            params string[] otherParams // Metoda gönderilen diğer bütün parametreleri alır
         )
         { 
             return -1;
         }
 
-        // Methods can have the same name, as long as the signature is unique
+        // Metodlar tanımlamalar benzersiz ise aynı isimleri alabilirler
         public static void MethodSignatures(string maxCount)
         {
         }
 
-        // GENERICS
-        // The classes for TKey and TValue is specified by the user calling this function.
-        // This method emulates the SetDefault of Python
+        // GENERIC'LER
+        // TKey ve TValue değerleri kullanıcı tarafından bu fonksiyon çağırılırken belirtilir.
+        // Bu metod Python'daki SetDefault'a benzer
         public static TValue SetDefault<TKey, TValue>(
             IDictionary<TKey, TValue> dictionary, 
             TKey key, 
@@ -386,68 +386,66 @@ on a new line! ""Wow!"", the masses cried";
             return result;
         }
 
-        // You can narrow down the objects that are passed in 
+        // Gönderilen objeleri daraltabilirsiniz
         public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
         {
-            // We can iterate, since T is a IEnumerable
+            // Eğer T IEnumerable ise tekrarlayabiliriz
             foreach (var item in toPrint)
-                // Item is an int
+                // Item bir int
                 Console.WriteLine(item.ToString());
         }
 
         public static void OtherInterestingFeatures()
         {
-            // OPTIONAL PARAMETERS
+            // İSTEĞE BAĞLI PARAMETRELER
             MethodSignatures(3, 1, 3, "Some", "Extra", "Strings");
-            MethodSignatures(3, another: 3); // explicity set a parameter, skipping optional ones
+            MethodSignatures(3, another: 3); // isteğe bağlı olanlar gönderilmedi
 
-            // EXTENSION METHODS
+            // UZANTI METODLARI
             int i = 3;
-            i.Print(); // Defined below
+            i.Print(); // Aşağıda tanımlandı
 
-            // NULLABLE TYPES - great for database interaction / return values
-            // any value type (i.e. not a class) can be made nullable by suffixing a ?
-            // <type>? <var name> = <value>
-            int? nullable = null; // short hand for Nullable<int>
+            // NULLABLE TYPES - veri tabanı işlemleri için uygun / return values
+            // Herhangi bir değer tipi sonuna ? eklenerek nullable yapılabilir (sınıflar hariç)
+            // <tip>? <değiken ismi> = <değer>
+            int? nullable = null; // Nullable<int> için kısa yol
             Console.WriteLine("Nullable variable: " + nullable);
-            bool hasValue = nullable.HasValue; // true if not null
+            bool hasValue = nullable.HasValue; // eğer null değilse true döner
 
-            // ?? is syntactic sugar for specifying default value (coalesce)
-            // in case variable is null
+            // ?? varsayılan değer belirlemek için söz dizimsel güzel bir özellik
+            // bu durumda değişken null'dır
             int notNullable = nullable ?? 0; // 0
 
-            // IMPLICITLY TYPED VARIABLES - you can let the compiler work out what the type is:
+            // TİPİ BELİRTİLMEMİŞ DEĞİŞKENLER - compiler değişkenin tipini bilmeden çalışabilir:
             var magic = "magic is a string, at compile time, so you still get type safety";
-            // magic = 9; will not work as magic is a string, not an int
+            // magic = 9; string gibi çalışmayacaktır, bu bir int değil
 
-            // GENERICS
+            // GENERIC'LER
             //
             var phonebook = new Dictionary<string, string>() { 
-                {"Sarah", "212 555 5555"} // Add some entries to the phone book
+                {"Sarah", "212 555 5555"} // Telefon rehberine bir kaç numara ekleyelim.
             };
 
-            // Calling SETDEFAULT defined as a generic above
-            Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // No Phone
-            // nb, you don't need to specify the TKey and TValue since they can be 
-            // derived implicitly
+            // Yukarıda generic olarak tanımlanan SETDEFAULT'u çağırma
+            Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // Telefonu yok
+            // TKey ve TValue tipini belirtmek zorunda değilsiniz
             Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555
 
-            // LAMBDA EXPRESSIONS - allow you to write code in line
-            Func<int, int> square = (x) => x * x; // Last T item is the return value
+            // LAMBDA IFADELERİ - satır içinde kod yazmanıza olanak sağlar
+            Func<int, int> square = (x) => x * x; // Son T nesnesi dönüş değeridir
             Console.WriteLine(square(3)); // 9
 
-            // DISPOSABLE RESOURCES MANAGEMENT - let you handle unmanaged resources easily.
-            // Most of objects that access unmanaged resources (file handle, device contexts, etc.)
-            // implement the IDisposable interface. The using statement takes care of 
-            // cleaning those IDisposable objects for you.
+            // TEK KULLANIMLIK KAYNAK YÖNETİMİ -  Yönetilemeyen kaynakların üstesinden kolayca gelebilirsiniz.
+            // Bir çok obje yönetilemeyen kaynaklara (dosya yakalama, cihaz içeriği, vb.)
+            // IDisposable arabirimi ile erişebilir. Using ifadesi sizin için IDisposable objeleri temizler.
             using (StreamWriter writer = new StreamWriter("log.txt"))
             {
                 writer.WriteLine("Nothing suspicious here");
-                // At the end of scope, resources will be released.
-                // Even if an exception is thrown.
+                // Bu bölümün sonunda kaynaklar temilenir.
+                // Hata fırlatılmış olsa bile.
             } 
 
-            // PARALLEL FRAMEWORK
+            // PARALEL FRAMEWORK
             // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx
             var websites = new string[] { 
                 "http://www.google.com", "http://www.reddit.com", 
@@ -455,73 +453,71 @@ on a new line! ""Wow!"", the masses cried";
             };
             var responses = new Dictionary<string, string>();
             
-            // Will spin up separate threads for each request, and join on them
-            // before going to the next step!
+            // Her istek farklı bir thread de işlem görecek 
+            // bir sonraki işleme geçmeden birleştirilecek.
             Parallel.ForEach(websites, 
-                new ParallelOptions() {MaxDegreeOfParallelism = 3}, // max of 3 threads
+                new ParallelOptions() {MaxDegreeOfParallelism = 3}, // en fazla 3 thread kullanmak için
                 website =>
             {
-                // Do something that takes a long time on the file
+                // Uzun sürecek bir işlem yapın
                 using (var r = WebRequest.Create(new Uri(website)).GetResponse())
                 {
                     responses[website] = r.ContentType;
                 }
             });
 
-            // This won't happen till after all requests have been completed
+            // Bütün istekler tamamlanmadan bu döndü çalışmayacaktır.
             foreach (var key in responses.Keys)
                 Console.WriteLine("{0}:{1}", key, responses[key]);
 
-            // DYNAMIC OBJECTS (great for working with other languages)
+            // DİNAMİK OBJELER (diğer dillerle çalışırken kullanmak için uygun)
             dynamic student = new ExpandoObject();
-            student.FirstName = "First Name"; // No need to define class first!
+            student.FirstName = "First Name"; // Önce yeni bir sınıf tanımlamanız gerekmez!
 
-            // You can even add methods (returns a string, and takes in a string)
+            // Hatta metod bile ekleyebilirsiniz (bir string döner, ve bir string alır)
             student.Introduce = new Func<string, string>(
                 (introduceTo) => string.Format("Hey {0}, this is {1}", student.FirstName, introduceTo));
             Console.WriteLine(student.Introduce("Beth"));
 
-            // IQUERYABLE<T> - almost all collections implement this, which gives you a lot of 
-            // very useful Map / Filter / Reduce style methods
+            // IQUERYABLE<T> - neredeyse bütün koleksiyonlar bundan türer, bu size bir çok
+            // kullanışlı Map / Filter / Reduce stili metod sağlar.
             var bikes = new List<Bicycle>();
-            bikes.Sort(); // Sorts the array
-            bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // Sorts based on wheels
+            bikes.Sort(); // Dizi sıralama
+            bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // Wheels baz alınarak sıralama
             var result = bikes
-                .Where(b => b.Wheels > 3) // Filters - chainable (returns IQueryable of previous type)
+                .Where(b => b.Wheels > 3) // Filters- chainable (bir önceki tipin IQueryable'ını döner)
                 .Where(b => b.IsBroken && b.HasTassles)
-                .Select(b => b.ToString()); // Map - we only this selects, so result is a IQueryable<string>
+                .Select(b => b.ToString()); // Map - sadece bunu seçiyoruz, yani sonuç bir IQueryable<string> olacak
 
-            var sum = bikes.Sum(b => b.Wheels); // Reduce - sums all the wheels in the collection
+            var sum = bikes.Sum(b => b.Wheels); // Reduce - koleksiyonda bulunan bütün wheel değerlerinin toplamı
 
-            // Create a list of IMPLICIT objects based on some parameters of the bike
+            // Bike içindeki bazı parametreleri baz alarak bir liste oluşturmak
             var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });
-            // Hard to show here, but you get type ahead completion since the compiler can implicitly work
-            // out the types above!
+            // Burada göstermek zor ama, compiler yukaridaki tipleri çözümleyebilirse derlenmeden önce tipi verebilir.
             foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))
                 Console.WriteLine(bikeSummary.Name);
 
             // ASPARALLEL
-            // And this is where things get wicked - combines linq and parallel operations
+            // Linq ve paralel işlemlerini birleştirme
             var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);
-            // this will happen in parallel! Threads will automagically be spun up and the 
-            // results divvied amongst them! Amazing for large datasets when you have lots of 
-            // cores
+            // bu paralel bir şekilde gerçekleşecek! Threadler otomatik ve sihirli bir şekilde işleri paylaşacak! 
+            // Birden fazla çekirdeğiniz varsa büyük veri setleri ile kullanmak için oldukça uygun bir yapı.
 
-            // LINQ - maps a store to IQueryable<T> objects, with delayed execution
-            // e.g. LinqToSql - maps to a database, LinqToXml maps to an xml document
+            // LINQ - IQueryable<T> objelerini mapler ve saklar, gecikmeli bir işlemdir
+            // e.g. LinqToSql - veri tabanını mapler, LinqToXml xml dökümanlarını mapler.
             var db = new BikeRepository();
 
-            // execution is delayed, which is great when querying a database
-            var filter = db.Bikes.Where(b => b.HasTassles); // no query run
-            if (42 > 6) // You can keep adding filters, even conditionally - great for "advanced search" functionality
-                filter = filter.Where(b => b.IsBroken); // no query run
+            // işlem gecikmelidir, bir veri tabanı üzerinde sorgulama yaparken harikadır.
+            var filter = db.Bikes.Where(b => b.HasTassles); // sorgu henüz çalışmadı
+            if (42 > 6) // Filtreler eklemeye devam edebilirsiniz - ileri düzey arama fonksiyonları için harikadır
+                filter = filter.Where(b => b.IsBroken); // sorgu henüz çalışmadı
 
             var query = filter
                 .OrderBy(b => b.Wheels)
                 .ThenBy(b => b.Name)
-                .Select(b => b.Name); // still no query run
+                .Select(b => b.Name); // hala sorgu çalışmadı
 
-            // Now the query runs, but opens a reader, so only populates are you iterate through
+            // Şimdi sorgu çalışıyor, reader'ı açar ama sadece sizin sorgunuza uyanlar foreach döngüsüne girer.
             foreach (string bike in query) 
                 Console.WriteLine(result);
             
@@ -529,98 +525,98 @@ on a new line! ""Wow!"", the masses cried";
 
         }
 
-    } // End LearnCSharp class
+    } // LearnCSharp sınıfının sonu
 
-    // You can include other classes in a .cs file
+    // Bir .cs dosyasına diğer sınıflarıda dahil edebilirsiniz
 
     public static class Extensions
     {
-        // EXTENSION FUNCTIONS
+        // UZANTI FONKSİYONLARI
         public static void Print(this object obj)
         {
             Console.WriteLine(obj.ToString());
         }
     }
 
-    // Class Declaration Syntax:
-    // <public/private/protected/internal> class <class name>{
-    //    //data fields, constructors, functions all inside.
-    //    //functions are called as methods in Java.
+    // Sınıf Tanımlama Sözdizimi:
+    // <public/private/protected/internal> class <sınıf ismi>{
+    //    //veri alanları, kurucular , fonksiyonlar hepsi içindedir.
+    //    //Fonksiyonlar Java'daki gibi metod olarak çağırılır.
     // }
 
     public class Bicycle
     {
-        // Bicycle's Fields/Variables
-        public int Cadence // Public: Can be accessed from anywhere
+        // Bicycle'ın Alanları/Değişkenleri
+        public int Cadence // Public: herhangi bir yerden erişilebilir
         {
-            get // get - define a method to retrieve the property
+            get // get - değeri almak için tanımlanan metod
             {
                 return _cadence;
             }
-            set // set - define a method to set a proprety
+            set // set - değer atamak için tanımlanan metod
             {
-                _cadence = value; // Value is the value passed in to the setter
+                _cadence = value; // Değer setter'a gönderilen value değeridir
             }
         }
         private int _cadence;
 
-        protected virtual int Gear // Protected: Accessible from the class and subclasses
+        protected virtual int Gear // Protected: Sınıf ve alt sınıflar tarafından erişilebilir
         {
-            get; // creates an auto property so you don't need a member field
+            get; // bir üye alanına ihtiyacınız yok, bu otomatik olarak bir değer oluşturacaktır
             set;
         }
 
-        internal int Wheels // Internal: Accessible from within the assembly
+        internal int Wheels // Internal: Assembly tarafından erişilebilir
         {
             get;
-            private set; // You can set modifiers on the get/set methods
+            private set; // Nitelik belirleyicileri get/set metodlarında atayabilirsiniz
         }
 
-        int _speed; // Everything is private by default: Only accessible from within this class. 
-                    // can also use keyword private
+        int _speed; // Her şey varsayılan olarak private'dır : Sadece sınıf içinden erişilebilir.
+                    // İsterseniz yinede private kelimesini kullanabilirsiniz.
         public string Name { get; set; }
 
-        // Enum is a value type that consists of a set of named constants
-        // It is really just mapping a name to a value (an int, unless specified otherwise).
-        // The approved types for an enum are byte, sbyte, short, ushort, int, uint, long, or ulong.
-        // An enum can't contain the same value twice.
+        // Enum sabitler kümesinden oluşan bir değer tipidir.
+        // Gerçekten sadece bir isim ile bir değeri tutmak için kullanılır. (aksi belirtilmedikçe bir int'dir).
+        // İzin verilen enum tipleri şunlardır byte, sbyte, short, ushort, int, uint, long, veya ulong.
+        // Bir enum aynı değeri birden fazla sayıda barındıramaz.
         public enum BikeBrand
         {
             AIST,
             BMC,
-            Electra = 42, //you can explicitly set a value to a name
+            Electra = 42, // bir isme tam bir değer verebilirsiniz
             Gitane // 43
         }
-        // We defined this type inside a Bicycle class, so it is a nested type
-        // Code outside of this class should reference this type as Bicycle.Brand
+        // Bu tipi Bicycle sınıfı içinde tanımladığımız için bu bir bağımlı tipdir.
+        // Bu sınıf dışında kullanmak için tipi Bicycle.Brand olarak kullanmamız gerekir
 
-        public BikeBrand Brand; // After declaring an enum type, we can declare the field of this type
+        public BikeBrand Brand; // Enum tipini tanımladıktan sonra alan tipini tanımlayabiliriz
 
-        // Static members belong to the type itself rather then specific object.
-        // You can access them without a reference to any object:
+        // Static üyeler belirli bir obje yerine kendi tipine aittir
+        // Onlara bir obje referans göstermeden erişebilirsiniz:
         // Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated);
         static public int BicyclesCreated = 0;
 
-        // readonly values are set at run time
-        // they can only be assigned upon declaration or in a constructor
+        // readonly değerleri çalışma zamanında atanır
+        // onlara sadece tanımlama yapılarak ya da kurucular içinden atama yapılabilir
         readonly bool _hasCardsInSpokes = false; // read-only private
 
-        // Constructors are a way of creating classes
-        // This is a default constructor
+        // Kurucular sınıf oluşturmanın bir yoludur
+        // Bu bir varsayılan kurucudur.
         public Bicycle() 
         {
-            this.Gear = 1; // you can access members of the object with the keyword this
-            Cadence = 50;  // but you don't always need it
+            this.Gear = 1; // bu objenin üyelerine this anahtar kelimesi ile ulaşılır
+            Cadence = 50;  // ama her zaman buna ihtiyaç duyulmaz
             _speed = 5;
             Name = "Bontrager";
             Brand = BikeBrand.AIST;
             BicyclesCreated++;
         }
 
-        // This is a specified constructor (it contains arguments)
+        // Bu belirlenmiş bir kurucudur. (argümanlar içerir)
         public Bicycle(int startCadence, int startSpeed, int startGear,
                        string name, bool hasCardsInSpokes, BikeBrand brand) 
-            : base() // calls base first
+            : base() // önce base'i çağırın
         {
             Gear = startGear; 
             Cadence = startCadence;
@@ -630,20 +626,20 @@ on a new line! ""Wow!"", the masses cried";
             Brand = brand;
         }
 
-        // Constructors can be chained
+        // Kurucular zincirleme olabilir
         public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
             this(startCadence, startSpeed, 0, "big wheels", true, brand)
         {
         }
 
-        // Function Syntax:
-        // <public/private/protected> <return type> <function name>(<args>)
+        // Fonksiyon Sözdizimi:
+        // <public/private/protected> <dönüş tipi> <fonksiyon ismi>(<argümanlar>)
 
-        // classes can implement getters and setters for their fields
-        // or they can implement properties (this is the preferred way in C#)
+        // sınıflar getter ve setter'ları alanları için kendisi uygular
+        // veya kendisi özellikleri uygulayabilir (C# da tercih edilen yol budur)
 
-        // Method parameters can have default values.
-        // In this case, methods can be called with these parameters omitted
+        // Metod parametreleri varsayılan değerlere sahip olabilir.
+        // Bu durumda, metodlar bu parametreler olmadan çağırılabilir.
         public void SpeedUp(int increment = 1)
         {
             _speed += increment;
-- 
cgit v1.2.3


From 3f305ab2831b9e3a1ca9dce35ab42386989e9a61 Mon Sep 17 00:00:00 2001
From: Melih Mucuk <melihmucuk@gmail.com>
Date: Wed, 31 Dec 2014 20:07:15 +0200
Subject: completed

---
 tr-tr/csharp-tr.html.markdown | 71 +++++++++++++++++++++----------------------
 1 file changed, 35 insertions(+), 36 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown
index cfbee5e8..e5cd3730 100644
--- a/tr-tr/csharp-tr.html.markdown
+++ b/tr-tr/csharp-tr.html.markdown
@@ -636,7 +636,7 @@ on a new line! ""Wow!"", the masses cried";
         // <public/private/protected> <dönüş tipi> <fonksiyon ismi>(<argümanlar>)
 
         // sınıflar getter ve setter'ları alanları için kendisi uygular
-        // veya kendisi özellikleri uygulayabilir (C# da tercih edilen yol budur)
+        // veya property'ler eklenebilir (C# da tercih edilen yol budur)
 
         // Metod parametreleri varsayılan değerlere sahip olabilir.
         // Bu durumda, metodlar bu parametreler olmadan çağırılabilir.
@@ -650,35 +650,34 @@ on a new line! ""Wow!"", the masses cried";
             _speed -= decrement;
         }
 
-        // properties get/set values
-        // when only data needs to be accessed, consider using properties.
-        // properties may have either get or set, or both
-        private bool _hasTassles; // private variable
+        // property'lerin get/set değerleri
+        // sadece veri gerektiği zaman erişilebilir, kullanmak için bunu göz önünde bulundurun.
+        // property'ler sadece get ya da set'e sahip olabilir veya ikisine birden
+        private bool _hasTassles; // private değişken
         public bool HasTassles // public accessor
         {
             get { return _hasTassles; }
             set { _hasTassles = value; }
         }
 
-        // You can also define an automatic property in one line
-        // this syntax will create a backing field automatically.
-        // You can set an access modifier on either the getter or the setter (or both)
-        // to restrict its access:
+        // Ayrıca tek bir satırda otomatik property tanımlayabilirsiniz. 
+        // bu söz dizimi otomatik olarak alan oluşturacaktır.
+        // Erişimi kısıtlamak için nitelik belirleyiciler getter veya setter'a ya da ikisine birden atanabilir:
         public bool IsBroken { get; private set; }
 
-        // Properties can be auto-implemented
+        // Property'ler otomatik eklenmiş olabilir
         public int FrameSize
         {
             get;
-            // you are able to specify access modifiers for either get or set
-            // this means only Bicycle class can call set on Framesize
+            // nitelik beliryecileri get veya set için tanımlayabilirsiniz
+            // bu sadece Bicycle sınıfı Framesize değerine atama yapabilir demektir
             private set;
         }
 
-        // It's also possible to define custom Indexers on objects.
-        // All though this is not entirely useful in this example, you
-        // could do bicycle[0] which yields "chris" to get the first passenger or
-        // bicycle[1] = "lisa" to set the passenger. (of this apparent quattrocycle)
+        // Ayrıca obje üzerinde özel indeksleyici belirlemek mümkündür.
+        // Tüm bunlar bu örnek için çok kullanışlı değil,
+        // bicycle[0] ile ilk yolcu olan "chris" i almak mümkün veya
+        // bicycle[1] = "lisa" ile yolcuyu atayabilirsiniz. (bariz quattrocycle)
         private string[] passengers = { "chris", "phil", "darren", "regina" }
 
         public string this[int i]
@@ -692,7 +691,7 @@ on a new line! ""Wow!"", the masses cried";
             }
         }
 
-        //Method to display the attribute values of this Object.
+        //Bu objenin nitelik değerlerini göstermek için bir metod.
         public virtual string Info()
         {
             return "Gear: " + Gear +
@@ -704,23 +703,23 @@ on a new line! ""Wow!"", the masses cried";
                     ;
         }
 
-        // Methods can also be static. It can be useful for helper methods
+        // Metodlar static olabilir. Yardımcı metodlar için kullanışlı olabilir.
         public static bool DidWeCreateEnoughBycles()
         {
-            // Within a static method, we only can reference static class members
+            // Bir static metod içinde sadece static sınıf üyeleri referans gösterilebilir
             return BicyclesCreated > 9000;
-        } // If your class only needs static members, consider marking the class itself as static.
+        } // Eğer sınıfınızın sadece static üyelere ihtiyacı varsa, sınıfın kendisini static yapmayı düşünebilirsiniz.
 
 
-    } // end class Bicycle
+    } // Bicycle sınıfı sonu
 
-    // PennyFarthing is a subclass of Bicycle
+    // PennyFarthing , Bicycle sınıfının alt sınıfıdır.
     class PennyFarthing : Bicycle
     {
-        // (Penny Farthings are those bicycles with the big front wheel.
-        // They have no gears.)
+        // (Penny Farthing'ler ön jantı büyük bisikletlerdir.
+        // Vitesleri yoktur.)
 
-        // calling parent constructor
+        // Ana kurucuyu çağırmak
         public PennyFarthing(int startCadence, int startSpeed) :
             base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra)
         {
@@ -741,23 +740,23 @@ on a new line! ""Wow!"", the masses cried";
         public override string Info()
         {
             string result = "PennyFarthing bicycle ";
-            result += base.ToString(); // Calling the base version of the method
+            result += base.ToString(); // Metodun temel versiyonunu çağırmak
             return result;
         }
     }
 
-    // Interfaces only contain signatures of the members, without the implementation.
+    // Arabirimler sadece üyelerin izlerini içerir, değerlerini değil.
     interface IJumpable
     {
-        void Jump(int meters); // all interface members are implicitly public
+        void Jump(int meters); // bütün arbirim üyeleri public'tir
     }
 
     interface IBreakable
     {
-        bool Broken { get; } // interfaces can contain properties as well as methods & events
+        bool Broken { get; } // arabirimler property'leri, metodları ve olayları içerebilir
     }
 
-    // Class can inherit only one other class, but can implement any amount of interfaces
+    // Sınıflar sadece tek bir sınıftan miras alabilir ama sınırsız sayıda arabirime sahip olabilir
     class MountainBike : Bicycle, IJumpable, IBreakable
     {
         int damage = 0;
@@ -777,8 +776,8 @@ on a new line! ""Wow!"", the masses cried";
     }
 
     /// <summary>
-    /// Used to connect to DB for LinqToSql example. 
-    /// EntityFramework Code First is awesome (similar to Ruby's ActiveRecord, but bidirectional)
+    /// LinqToSql örneği veri tabanına bağlanmak için kullanılır.
+    /// EntityFramework Code First harika! (Ruby'deki ActiveRecord'a benzer, ama iki yönlü)
     /// http://msdn.microsoft.com/en-us/data/jj193542.aspx
     /// </summary>
     public class BikeRepository : DbSet
@@ -790,10 +789,10 @@ on a new line! ""Wow!"", the masses cried";
 
         public DbSet<Bicycle> Bikes { get; set; }
     }
-} // End Namespace
+} // Namespace sonu
 ```
 
-## Topics Not Covered
+## İşlenmeyen Konular
 
  * Flags
  * Attributes
@@ -803,7 +802,7 @@ on a new line! ""Wow!"", the masses cried";
  * Winforms
  * Windows Presentation Foundation (WPF)
 
-## Further Reading
+## Daha Fazlasını Okuyun
 
  * [DotNetPerls](http://www.dotnetperls.com)
  * [C# in Depth](http://manning.com/skeet2)
@@ -817,4 +816,4 @@ on a new line! ""Wow!"", the masses cried";
 
 
 
-[C# Coding Conventions](http://msdn.microsoft.com/en-us/library/vstudio/ff926074.aspx)
+[C# Kodlama Adetleri](http://msdn.microsoft.com/en-us/library/vstudio/ff926074.aspx)
-- 
cgit v1.2.3


From 634efbb8caaf02feba5f09edd450df1d684e6660 Mon Sep 17 00:00:00 2001
From: Melih Mucuk <melihmucuk@gmail.com>
Date: Wed, 31 Dec 2014 20:08:42 +0200
Subject: csharp/tr

---
 tr-tr/csharp-tr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tr-tr')

diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown
index e5cd3730..c20f90ad 100644
--- a/tr-tr/csharp-tr.html.markdown
+++ b/tr-tr/csharp-tr.html.markdown
@@ -789,7 +789,7 @@ on a new line! ""Wow!"", the masses cried";
 
         public DbSet<Bicycle> Bikes { get; set; }
     }
-} // Namespace sonu
+} // namespace sonu
 ```
 
 ## İşlenmeyen Konular
-- 
cgit v1.2.3


From 71eda7df766a2be9777d977b8b3b946e37ee82d9 Mon Sep 17 00:00:00 2001
From: Melih Mucuk <melihmucuk@gmail.com>
Date: Wed, 31 Dec 2014 20:11:54 +0200
Subject: csharp/tr

---
 tr-tr/csharp-tr.html.markdown | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'tr-tr')

diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown
index c20f90ad..3573bbd4 100644
--- a/tr-tr/csharp-tr.html.markdown
+++ b/tr-tr/csharp-tr.html.markdown
@@ -11,6 +11,8 @@ filename: LearnCSharp.cs
 
 C# zarif ve tip güvenli nesne yönelimli bir dil olup geliştiricilerin .NET framework üzerinde çalışan güçlü ve güvenli uygulamalar geliştirmesini sağlar.
 
+[Yazım yanlışları ve öneriler için bana ulaşabilirsiniz](mailto:melihmucuk@gmail.com)
+
 [Daha fazlasını okuyun.](http://msdn.microsoft.com/en-us/library/vstudio/z1zx9t92.aspx)
 
 ```c#
-- 
cgit v1.2.3


From 3cb53d9e43143d330cd65c2f29fff93ffa0110f4 Mon Sep 17 00:00:00 2001
From: Melih Mucuk <melihmucuk@gmail.com>
Date: Wed, 31 Dec 2014 20:18:46 +0200
Subject: csharp/tr

---
 tr-tr/csharp-tr.html.markdown | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'tr-tr')

diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown
index 3573bbd4..7755ed44 100644
--- a/tr-tr/csharp-tr.html.markdown
+++ b/tr-tr/csharp-tr.html.markdown
@@ -5,8 +5,11 @@ contributors:
     - ["Max Yankov", "https://github.com/golergka"]
     - ["Melvyn Laïly", "http://x2a.yt"]
     - ["Shaun McCarthy", "http://www.shaunmccarthy.com"]
+translators:
     - ["Melih Mucuk", "http://melihmucuk.com"]
+lang: tr-tr
 filename: LearnCSharp.cs
+
 ---
 
 C# zarif ve tip güvenli nesne yönelimli bir dil olup geliştiricilerin .NET framework üzerinde çalışan güçlü ve güvenli uygulamalar geliştirmesini sağlar.
-- 
cgit v1.2.3


From c5c8004450567a4be4c814e3c18725688c1601b2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eray=20Ayd=C4=B1n?= <eray@erayaydin.me>
Date: Wed, 25 Mar 2015 19:50:46 +0200
Subject: Primitive Datatypes and Operators

---
 tr-tr/python3-tr.html.markdown | 645 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 645 insertions(+)
 create mode 100644 tr-tr/python3-tr.html.markdown

(limited to 'tr-tr')

diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
new file mode 100644
index 00000000..d815e4f9
--- /dev/null
+++ b/tr-tr/python3-tr.html.markdown
@@ -0,0 +1,645 @@
+---
+language: python3
+contributors:
+    - ["Louie Dinh", "http://pythonpracticeprojects.com"]
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+translators:
+    - ["Eray AYDIN", "http://erayaydin.me/"]
+lang: tr-tr
+filename: learnpython3-tr.py
+---
+
+Python,90ların başlarında Guido Van Rossum tarafından oluşturulmuştur. En popüler olan dillerden biridir. Beni Python'a aşık eden sebep onun syntax beraklığı. Çok basit bir çalıştırılabilir söz koddur.
+
+Not: Bu makale Python 3 içindir. Eğer Python 2.7 öğrenmek istiyorsanız [burayı](http://learnxinyminutes.com/docs/python/) kontrol edebilirsiniz.
+
+```python
+
+# Single line comments start with a number symbol.
+
+""" Multiline strings can be written
+    using three "s, and are often used
+    as comments
+"""
+
+####################################################
+## 1. Primitive Datatypes and Operators
+####################################################
+
+# You have numbers
+3  # => 3
+
+# Math is what you would expect
+1 + 1  # => 2
+8 - 1  # => 7
+10 * 2  # => 20
+
+# Except division which returns floats by default
+35 / 5  # => 7.0
+
+# Result of integer division truncated down both for positive and negative. 
+5 // 3     # => 1
+5.0 // 3.0 # => 1.0 # works on floats too
+-5 // 3  # => -2
+-5.0 // 3.0 # => -2.0
+
+# When you use a float, results are floats
+3 * 2.0 # => 6.0
+
+# Modulo operation
+7 % 3 # => 1
+
+# Exponentiation (x to the yth power)
+2**4 # => 16
+
+# Enforce precedence with parentheses
+(1 + 3) * 2  # => 8
+
+# Boolean values are primitives
+True
+False
+
+# negate with not
+not True  # => False
+not False  # => True
+
+# Boolean Operators
+# Note "and" and "or" are case-sensitive
+True and False #=> False
+False or True #=> True
+
+# Note using Bool operators with ints
+0 and 2 #=> 0
+-5 or 0 #=> -5
+0 == False #=> True 
+2 == True #=> False 
+1 == True #=> True
+
+# Equality is ==
+1 == 1  # => True
+2 == 1  # => False
+
+# Inequality is !=
+1 != 1  # => False
+2 != 1  # => True
+
+# More comparisons
+1 < 10  # => True
+1 > 10  # => False
+2 <= 2  # => True
+2 >= 2  # => True
+
+# Comparisons can be chained!
+1 < 2 < 3  # => True
+2 < 3 < 2  # => False
+
+# Strings are created with " or '
+"This is a string."
+'This is also a string.'
+
+# Strings can be added too! But try not to do this.
+"Hello " + "world!"  # => "Hello world!"
+
+# A string can be treated like a list of characters
+"This is a string"[0]  # => 'T'
+
+# .format can be used to format strings, like this:
+"{} can be {}".format("strings", "interpolated")
+
+# You can repeat the formatting arguments to save some typing.
+"{0} be nimble, {0} be quick, {0} jump over the {1}".format("Jack", "candle stick")
+#=> "Jack be nimble, Jack be quick, Jack jump over the candle stick"
+
+# You can use keywords if you don't want to count.
+"{name} wants to eat {food}".format(name="Bob", food="lasagna") #=> "Bob wants to eat lasagna"
+
+# If your Python 3 code also needs to run on Python 2.5 and below, you can also
+# still use the old style of formatting:
+"%s can be %s the %s way" % ("strings", "interpolated", "old")
+
+
+# None is an object
+None  # => None
+
+# Don't use the equality "==" symbol to compare objects to None
+# Use "is" instead. This checks for equality of object identity.
+"etc" is None  # => False
+None is None  # => True
+
+# None, 0, and empty strings/lists/dicts all evaluate to False.
+# All other values are True
+bool(0)  # => False
+bool("")  # => False
+bool([]) #=> False
+bool({}) #=> False
+
+
+####################################################
+## 2. Variables and Collections
+####################################################
+
+# Python has a print function
+print("I'm Python. Nice to meet you!")
+
+# No need to declare variables before assigning to them. 
+# Convention is to use lower_case_with_underscores
+some_var = 5
+some_var  # => 5
+
+# Accessing a previously unassigned variable is an exception.
+# See Control Flow to learn more about exception handling.
+some_unknown_var  # Raises a NameError
+
+# Lists store sequences
+li = []
+# You can start with a prefilled list
+other_li = [4, 5, 6]
+
+# Add stuff to the end of a list with append
+li.append(1)    # li is now [1]
+li.append(2)    # li is now [1, 2]
+li.append(4)    # li is now [1, 2, 4]
+li.append(3)    # li is now [1, 2, 4, 3]
+# Remove from the end with pop
+li.pop()        # => 3 and li is now [1, 2, 4]
+# Let's put it back
+li.append(3)    # li is now [1, 2, 4, 3] again.
+
+# Access a list like you would any array
+li[0]  # => 1
+# Look at the last element
+li[-1]  # => 3
+
+# Looking out of bounds is an IndexError
+li[4]  # Raises an IndexError
+
+# You can look at ranges with slice syntax.
+# (It's a closed/open range for you mathy types.)
+li[1:3]  # => [2, 4]
+# Omit the beginning
+li[2:]  # => [4, 3]
+# Omit the end
+li[:3]  # => [1, 2, 4]
+# Select every second entry
+li[::2]   # =>[1, 4]
+# Revert the list
+li[::-1]   # => [3, 4, 2, 1]
+# Use any combination of these to make advanced slices
+# li[start:end:step]
+
+# Remove arbitrary elements from a list with "del"
+del li[2]   # li is now [1, 2, 3]
+
+# You can add lists
+# Note: values for li and for other_li are not modified.
+li + other_li   # => [1, 2, 3, 4, 5, 6] 
+
+# Concatenate lists with "extend()"
+li.extend(other_li)   # Now li is [1, 2, 3, 4, 5, 6]
+
+# Check for existence in a list with "in"
+1 in li   # => True
+
+# Examine the length with "len()"
+len(li)   # => 6
+
+
+# Tuples are like lists but are immutable.
+tup = (1, 2, 3)
+tup[0]   # => 1
+tup[0] = 3  # Raises a TypeError
+
+# You can do all those list thingies on tuples too
+len(tup)   # => 3
+tup + (4, 5, 6)   # => (1, 2, 3, 4, 5, 6)
+tup[:2]   # => (1, 2)
+2 in tup   # => True
+
+# You can unpack tuples (or lists) into variables
+a, b, c = (1, 2, 3)     # a is now 1, b is now 2 and c is now 3
+# Tuples are created by default if you leave out the parentheses
+d, e, f = 4, 5, 6
+# Now look how easy it is to swap two values
+e, d = d, e     # d is now 5 and e is now 4
+
+
+# Dictionaries store mappings
+empty_dict = {}
+# Here is a prefilled dictionary
+filled_dict = {"one": 1, "two": 2, "three": 3}
+
+# Look up values with []
+filled_dict["one"]   # => 1
+
+# Get all keys as a list with "keys()". 
+# We need to wrap the call in list() because we are getting back an iterable. We'll talk about those later.
+# Note - Dictionary key ordering is not guaranteed.
+# Your results might not match this exactly.
+list(filled_dict.keys())   # => ["three", "two", "one"]
+
+
+# Get all values as a list with "values()". Once again we need to wrap it in list() to get it out of the iterable.
+# Note - Same as above regarding key ordering.
+list(filled_dict.values())   # => [3, 2, 1]
+
+
+# Check for existence of keys in a dictionary with "in"
+"one" in filled_dict   # => True
+1 in filled_dict   # => False
+
+# Looking up a non-existing key is a KeyError
+filled_dict["four"]   # KeyError
+
+# Use "get()" method to avoid the KeyError
+filled_dict.get("one")   # => 1
+filled_dict.get("four")   # => None
+# The get method supports a default argument when the value is missing
+filled_dict.get("one", 4)   # => 1
+filled_dict.get("four", 4)   # => 4
+
+# "setdefault()" inserts into a dictionary only if the given key isn't present
+filled_dict.setdefault("five", 5)  # filled_dict["five"] is set to 5
+filled_dict.setdefault("five", 6)  # filled_dict["five"] is still 5
+
+# Adding to a dictionary
+filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4}
+#filled_dict["four"] = 4  #another way to add to dict
+
+# Remove keys from a dictionary with del
+del filled_dict["one"]  # Removes the key "one" from filled dict
+
+
+# Sets store ... well sets
+empty_set = set()
+# Initialize a set with a bunch of values. Yeah, it looks a bit like a dict. Sorry.
+some_set = {1, 1, 2, 2, 3, 4}   # some_set is now {1, 2, 3, 4}
+
+# Can set new variables to a set
+filled_set = some_set
+
+# Add one more item to the set 
+filled_set.add(5)   # filled_set is now {1, 2, 3, 4, 5}
+
+# Do set intersection with &
+other_set = {3, 4, 5, 6}
+filled_set & other_set   # => {3, 4, 5}
+
+# Do set union with |
+filled_set | other_set   # => {1, 2, 3, 4, 5, 6}
+
+# Do set difference with -
+{1, 2, 3, 4} - {2, 3, 5}   # => {1, 4}
+
+# Check for existence in a set with in
+2 in filled_set   # => True
+10 in filled_set   # => False
+
+
+####################################################
+## 3. Control Flow and Iterables
+####################################################
+
+# Let's just make a variable
+some_var = 5
+
+# Here is an if statement. Indentation is significant in python!
+# prints "some_var is smaller than 10"
+if some_var > 10:
+    print("some_var is totally bigger than 10.")
+elif some_var < 10:    # This elif clause is optional.
+    print("some_var is smaller than 10.")
+else:                  # This is optional too.
+    print("some_var is indeed 10.")
+
+
+"""
+For loops iterate over lists
+prints:
+    dog is a mammal
+    cat is a mammal
+    mouse is a mammal
+"""
+for animal in ["dog", "cat", "mouse"]:
+    # You can use format() to interpolate formatted strings
+    print("{} is a mammal".format(animal))
+
+"""
+"range(number)" returns a list of numbers
+from zero to the given number
+prints:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print(i)
+
+"""
+While loops go until a condition is no longer met.
+prints:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print(x)
+    x += 1  # Shorthand for x = x + 1
+
+# Handle exceptions with a try/except block
+try:
+    # Use "raise" to raise an error
+    raise IndexError("This is an index error")
+except IndexError as e:
+    pass    # Pass is just a no-op. Usually you would do recovery here.
+except (TypeError, NameError):
+    pass    # Multiple exceptions can be handled together, if required.
+else:   # Optional clause to the try/except block. Must follow all except blocks
+    print("All good!")   # Runs only if the code in try raises no exceptions
+
+# Python offers a fundamental abstraction called the Iterable.
+# An iterable is an object that can be treated as a sequence.
+# The object returned the range function, is an iterable.
+
+filled_dict = {"one": 1, "two": 2, "three": 3}
+our_iterable = filled_dict.keys()
+print(our_iterable) #=> range(1,10). This is an object that implements our Iterable interface
+
+# We can loop over it.
+for i in our_iterable:
+    print(i)    # Prints one, two, three
+
+# However we cannot address elements by index.
+our_iterable[1]  # Raises a TypeError
+
+# An iterable is an object that knows how to create an iterator.
+our_iterator = iter(our_iterable)
+
+# Our iterator is an object that can remember the state as we traverse through it.
+# We get the next object by calling the __next__ function.
+our_iterator.__next__()  #=> "one"
+
+# It maintains state as we call __next__.
+our_iterator.__next__()  #=> "two"
+our_iterator.__next__()  #=> "three"
+
+# After the iterator has returned all of its data, it gives you a StopIterator Exception
+our_iterator.__next__() # Raises StopIteration
+
+# You can grab all the elements of an iterator by calling list() on it.
+list(filled_dict.keys())  #=> Returns ["one", "two", "three"]
+
+
+####################################################
+## 4. Functions
+####################################################
+
+# Use "def" to create new functions
+def add(x, y):
+    print("x is {} and y is {}".format(x, y))
+    return x + y    # Return values with a return statement
+
+# Calling functions with parameters
+add(5, 6)   # => prints out "x is 5 and y is 6" and returns 11
+
+# Another way to call functions is with keyword arguments
+add(y=6, x=5)   # Keyword arguments can arrive in any order.
+
+# You can define functions that take a variable number of
+# positional arguments
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3)   # => (1, 2, 3)
+
+# You can define functions that take a variable number of
+# keyword arguments, as well
+def keyword_args(**kwargs):
+    return kwargs
+
+# Let's call it to see what happens
+keyword_args(big="foot", loch="ness")   # => {"big": "foot", "loch": "ness"}
+
+
+# You can do both at once, if you like
+def all_the_args(*args, **kwargs):
+    print(args)
+    print(kwargs)
+"""
+all_the_args(1, 2, a=3, b=4) prints:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# When calling functions, you can do the opposite of args/kwargs!
+# Use * to expand tuples and use ** to expand kwargs.
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args)   # equivalent to foo(1, 2, 3, 4)
+all_the_args(**kwargs)   # equivalent to foo(a=3, b=4)
+all_the_args(*args, **kwargs)   # equivalent to foo(1, 2, 3, 4, a=3, b=4)
+
+
+# Function Scope                                                                
+x = 5
+
+def setX(num):
+    # Local var x not the same as global variable x
+    x = num # => 43
+    print (x) # => 43
+    
+def setGlobalX(num):
+    global x
+    print (x) # => 5
+    x = num # global var x is now set to 6
+    print (x) # => 6
+
+setX(43)
+setGlobalX(6)
+
+
+# Python has first class functions
+def create_adder(x):
+    def adder(y):
+        return x + y
+    return adder
+
+add_10 = create_adder(10)
+add_10(3)   # => 13
+
+# There are also anonymous functions
+(lambda x: x > 2)(3)   # => True
+
+# TODO - Fix for iterables
+# There are built-in higher order functions
+map(add_10, [1, 2, 3])   # => [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
+
+# We can use list comprehensions for nice maps and filters
+# List comprehension stores the output as a list which can itself be a nested list
+[add_10(i) for i in [1, 2, 3]]  # => [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5]   # => [6, 7]
+
+####################################################
+## 5. Classes
+####################################################
+
+
+# We subclass from object to get a class.
+class Human(object):
+
+    # A class attribute. It is shared by all instances of this class
+    species = "H. sapiens"
+
+    # Basic initializer, this is called when this class is instantiated.
+    # Note that the double leading and trailing underscores denote objects
+    # or attributes that are used by python but that live in user-controlled
+    # namespaces. Methods(or objects or attributes) like: __init__, __str__, 
+    # __repr__ etc. are called magic methods (or sometimes called dunder methods)  
+    # You should not invent such names on your own.
+    def __init__(self, name):
+        # Assign the argument to the instance's name attribute
+        self.name = name
+
+    # An instance method. All methods take "self" as the first argument
+    def say(self, msg):
+        return "{name}: {message}".format(name=self.name, message=msg)
+
+    # A class method is shared among all instances
+    # They are called with the calling class as the first argument
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # A static method is called without a class or instance reference
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+
+# Instantiate a class
+i = Human(name="Ian")
+print(i.say("hi"))     # prints out "Ian: hi"
+
+j = Human("Joel")
+print(j.say("hello"))  # prints out "Joel: hello"
+
+# Call our class method
+i.get_species()   # => "H. sapiens"
+
+# Change the shared attribute
+Human.species = "H. neanderthalensis"
+i.get_species()   # => "H. neanderthalensis"
+j.get_species()   # => "H. neanderthalensis"
+
+# Call the static method
+Human.grunt()   # => "*grunt*"
+
+
+####################################################
+## 6. Modules
+####################################################
+
+# You can import modules
+import math
+print(math.sqrt(16))  # => 4
+
+# You can get specific functions from a module
+from math import ceil, floor
+print(ceil(3.7))  # => 4.0
+print(floor(3.7))   # => 3.0
+
+# You can import all functions from a module.
+# Warning: this is not recommended
+from math import *
+
+# You can shorten module names
+import math as m
+math.sqrt(16) == m.sqrt(16)   # => True
+
+# Python modules are just ordinary python files. You
+# can write your own, and import them. The name of the
+# module is the same as the name of the file.
+
+# You can find out which functions and attributes
+# defines a module.
+import math
+dir(math)
+
+
+####################################################
+## 7. Advanced
+####################################################
+
+# Generators help you make lazy code
+def double_numbers(iterable):
+    for i in iterable:
+        yield i + i
+
+# A generator creates values on the fly.
+# Instead of generating and returning all values at once it creates one in each
+# iteration.  This means values bigger than 15 wont be processed in
+# double_numbers.
+# Note range is a generator too. Creating a list 1-900000000 would take lot of
+# time to be made
+# We use a trailing underscore in variable names when we want to use a name that 
+# would normally collide with a python keyword
+range_ = range(1, 900000000)
+# will double all numbers until a result >=30 found
+for i in double_numbers(range_):
+    print(i)
+    if i >= 30:
+        break
+
+
+# Decorators
+# in this example beg wraps say
+# Beg will call say. If say_please is True then it will change the returned
+# message
+from functools import wraps
+
+
+def beg(target_function):
+    @wraps(target_function)
+    def wrapper(*args, **kwargs):
+        msg, say_please = target_function(*args, **kwargs)
+        if say_please:
+            return "{} {}".format(msg, "Please! I am poor :(")
+        return msg
+
+    return wrapper
+
+
+@beg
+def say(say_please=False):
+    msg = "Can you buy me a beer?"
+    return msg, say_please
+
+
+print(say())  # Can you buy me a beer?
+print(say(say_please=True))  # Can you buy me a beer? Please! I am poor :(
+```
+
+## Ready For More?
+
+### Free Online
+
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com)
+
+* [The Official Docs](http://docs.python.org/3/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+* [Python Course](http://www.python-course.eu/index.php)
+
+### Dead Tree
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
+
-- 
cgit v1.2.3


From 46273c1ffe60c581968c9b43d1fb603a881823e2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eray=20Ayd=C4=B1n?= <eray@erayaydin.me>
Date: Wed, 25 Mar 2015 20:34:27 +0200
Subject: Variables and Collections

---
 tr-tr/python3-tr.html.markdown | 297 ++++++++++++++++++++---------------------
 1 file changed, 148 insertions(+), 149 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
index d815e4f9..4939f219 100644
--- a/tr-tr/python3-tr.html.markdown
+++ b/tr-tr/python3-tr.html.markdown
@@ -17,119 +17,119 @@ Not: Bu makale Python 3 içindir. Eğer Python 2.7 öğrenmek istiyorsanız [bur
 
 ```python
 
-# Single line comments start with a number symbol.
+# Tek satırlık yorum satırı kare(#) işareti ile başlamaktadır.
 
-""" Multiline strings can be written
-    using three "s, and are often used
-    as comments
+""" Çok satırlı olmasını istediğiniz yorumlar
+    üç adet tırnak(") işareti ile
+    yapılmaktadır
 """
 
 ####################################################
-## 1. Primitive Datatypes and Operators
+## 1. Temel Veri Türleri ve Operatörler
 ####################################################
 
-# You have numbers
+# Sayılar
 3  # => 3
 
-# Math is what you would expect
+# Tahmin edebileceğiniz gibi matematik
 1 + 1  # => 2
 8 - 1  # => 7
 10 * 2  # => 20
 
-# Except division which returns floats by default
+# Bölme işlemi varsayılan olarak onluk döndürür
 35 / 5  # => 7.0
 
-# Result of integer division truncated down both for positive and negative. 
+# Tam sayı bölmeleri, pozitif ve negatif sayılar için aşağıya yuvarlar
 5 // 3     # => 1
-5.0 // 3.0 # => 1.0 # works on floats too
+5.0 // 3.0 # => 1.0 # onluklar için de bu böyledir
 -5 // 3  # => -2
 -5.0 // 3.0 # => -2.0
 
-# When you use a float, results are floats
+# Onluk kullanırsanız, sonuç da onluk olur
 3 * 2.0 # => 6.0
 
-# Modulo operation
+# Kalan operatörü
 7 % 3 # => 1
 
-# Exponentiation (x to the yth power)
+# Üs (2 üzeri 4)
 2**4 # => 16
 
-# Enforce precedence with parentheses
+# Parantez ile önceliği değiştirebilirsiniz
 (1 + 3) * 2  # => 8
 
-# Boolean values are primitives
+# Boolean(Doğru-Yanlış) değerleri standart
 True
 False
 
-# negate with not
+# 'değil' ile terse çevirme
 not True  # => False
 not False  # => True
 
-# Boolean Operators
-# Note "and" and "or" are case-sensitive
+# Boolean Operatörleri
+# "and" ve "or" büyük küçük harf duyarlıdır
 True and False #=> False
 False or True #=> True
 
-# Note using Bool operators with ints
+# Bool operatörleri ile sayı kullanımı
 0 and 2 #=> 0
 -5 or 0 #=> -5
 0 == False #=> True 
 2 == True #=> False 
 1 == True #=> True
 
-# Equality is ==
+# Eşitlik kontrolü ==
 1 == 1  # => True
 2 == 1  # => False
 
-# Inequality is !=
+# Eşitsizlik Kontrolü !=
 1 != 1  # => False
 2 != 1  # => True
 
-# More comparisons
+# Diğer karşılaştırmalar
 1 < 10  # => True
 1 > 10  # => False
 2 <= 2  # => True
 2 >= 2  # => True
 
-# Comparisons can be chained!
+# Zincirleme şeklinde karşılaştırma da yapabilirsiniz!
 1 < 2 < 3  # => True
 2 < 3 < 2  # => False
 
-# Strings are created with " or '
-"This is a string."
-'This is also a string.'
+# Yazı(Strings) " veya ' işaretleri ile oluşturulabilir
+"Bu bir yazı."
+'Bu da bir yazı.'
 
-# Strings can be added too! But try not to do this.
-"Hello " + "world!"  # => "Hello world!"
+# Yazılar da eklenebilir! Fakat bunu yapmanızı önermem.
+"Merhaba " + "dünya!"  # => "Merhaba dünya!"
 
-# A string can be treated like a list of characters
-"This is a string"[0]  # => 'T'
+# Bir yazı(string) karakter listesi gibi işlenebilir
+"Bu bir yazı"[0]  # => 'B'
 
-# .format can be used to format strings, like this:
-"{} can be {}".format("strings", "interpolated")
+# .format ile yazıyı biçimlendirebilirsiniz, şu şekilde:
+"{} da ayrıca {}".format("yazılar", "işlenebilir")
 
-# You can repeat the formatting arguments to save some typing.
-"{0} be nimble, {0} be quick, {0} jump over the {1}".format("Jack", "candle stick")
-#=> "Jack be nimble, Jack be quick, Jack jump over the candle stick"
+# Biçimlendirme işleminde aynı argümanı da birden fazla kullanabilirsiniz.
+"{0} çeviktir, {0} hızlıdır, {0} , {1} üzerinden atlayabilir".format("Ahmet", "şeker çubuğu")
+#=> "Ahmet çeviktir, Ahmet hızlıdır, Ahmet , şeker çubuğu üzerinden atlayabilir"
 
-# You can use keywords if you don't want to count.
-"{name} wants to eat {food}".format(name="Bob", food="lasagna") #=> "Bob wants to eat lasagna"
+# Argümanın sırasını saymak istemiyorsanız, anahtar kelime kullanabilirsiniz.
+"{isim} yemek olarak {yemek} istiyor".format(isim="Ahmet", yemek="patates") #=> "Ahmet yemek olarak patates istiyor"
 
-# If your Python 3 code also needs to run on Python 2.5 and below, you can also
-# still use the old style of formatting:
-"%s can be %s the %s way" % ("strings", "interpolated", "old")
+# Eğer Python 3 kodunuz ayrıca Python 2.5 ve üstünde çalışmasını istiyorsanız, 
+# eski stil formatlamayı kullanabilirsiniz:
+"%s bu %s yolla da %s" % ("yazılar", "eski", "biçimlendirilebilir")
 
 
-# None is an object
+# Hiçbir şey(none) da bir objedir
 None  # => None
 
-# Don't use the equality "==" symbol to compare objects to None
-# Use "is" instead. This checks for equality of object identity.
-"etc" is None  # => False
+# Bir değerin none ile eşitlik kontrolü için "==" sembolünü kullanmayın
+# Bunun yerine "is" kullanın. Obje türünün eşitliğini kontrol edecektir.
+"vb" is None  # => False
 None is None  # => True
 
-# None, 0, and empty strings/lists/dicts all evaluate to False.
-# All other values are True
+# None, 0, ve boş yazılar/listeler/sözlükler hepsi False değeri döndürü.
+# Diğer veriler ise True değeri döndürür
 bool(0)  # => False
 bool("")  # => False
 bool([]) #=> False
@@ -137,164 +137,163 @@ bool({}) #=> False
 
 
 ####################################################
-## 2. Variables and Collections
+## 2. Değişkenler ve Koleksiyonlar
 ####################################################
 
-# Python has a print function
-print("I'm Python. Nice to meet you!")
+# Python bir yazdırma fonksiyonuna sahip
+print("Ben Python. Tanıştığıma memnun oldum!")
 
-# No need to declare variables before assigning to them. 
-# Convention is to use lower_case_with_underscores
-some_var = 5
-some_var  # => 5
+# Değişkenlere veri atamak için önce değişkeni oluşturmanıza gerek yok. 
+# Düzenli bir değişken için hepsi_kucuk_ve_alt_cizgi_ile_ayirin
+bir_degisken = 5
+bir_degisken  # => 5
 
-# Accessing a previously unassigned variable is an exception.
-# See Control Flow to learn more about exception handling.
-some_unknown_var  # Raises a NameError
+# Önceden tanımlanmamış değişkene erişmek hata oluşturacaktır.
+# Kontrol akışları başlığından hata kontrolünü öğrenebilirsiniz.
+bir_bilinmeyen_degisken  # NameError hatası oluşturur
 
-# Lists store sequences
+# Listeler ile sıralamaları tutabilirsiniz
 li = []
-# You can start with a prefilled list
-other_li = [4, 5, 6]
-
-# Add stuff to the end of a list with append
-li.append(1)    # li is now [1]
-li.append(2)    # li is now [1, 2]
-li.append(4)    # li is now [1, 2, 4]
-li.append(3)    # li is now [1, 2, 4, 3]
-# Remove from the end with pop
-li.pop()        # => 3 and li is now [1, 2, 4]
-# Let's put it back
-li.append(3)    # li is now [1, 2, 4, 3] again.
-
-# Access a list like you would any array
+# Önceden doldurulmuş listeler ile başlayabilirsiniz
+diger_li = [4, 5, 6]
+
+# 'append' ile listenin sonuna ekleme yapabilirsiniz
+li.append(1)    # li artık [1] oldu
+li.append(2)    # li artık [1, 2] oldu
+li.append(4)    # li artık [1, 2, 4] oldu
+li.append(3)    # li artık [1, 2, 4, 3] oldu
+# 'pop' ile listenin son elementini kaldırabilirsiniz
+li.pop()        # => 3 ve li artık [1, 2, 4]
+# Çıkarttığımız tekrardan ekleyelim
+li.append(3)    # li yeniden [1, 2, 4, 3] oldu.
+
+# Dizi gibi listeye erişim sağlayın
 li[0]  # => 1
-# Look at the last element
+# Son elemente bakın
 li[-1]  # => 3
 
-# Looking out of bounds is an IndexError
-li[4]  # Raises an IndexError
+# Listede olmayan bir elemente erişim sağlamaya çalışmak IndexError hatası oluşturur
+li[4]  # IndexError hatası oluşturur
 
-# You can look at ranges with slice syntax.
-# (It's a closed/open range for you mathy types.)
+# Bir kısmını almak isterseniz.
 li[1:3]  # => [2, 4]
-# Omit the beginning
+# Başlangıç belirtmezseniz
 li[2:]  # => [4, 3]
-# Omit the end
+# Sonu belirtmesseniz
 li[:3]  # => [1, 2, 4]
-# Select every second entry
+# Her ikişer objeyi seçme
 li[::2]   # =>[1, 4]
-# Revert the list
+# Listeyi tersten almak
 li[::-1]   # => [3, 4, 2, 1]
-# Use any combination of these to make advanced slices
-# li[start:end:step]
+# Kombinasyonları kullanarak gelişmiş bir şekilde listenin bir kısmını alabilirsiniz
+# li[baslangic:son:adim]
 
-# Remove arbitrary elements from a list with "del"
-del li[2]   # li is now [1, 2, 3]
+# "del" ile isteğe bağlı, elementleri listeden kaldırabilirsiniz
+del li[2]   # li artık [1, 2, 3] oldu
 
-# You can add lists
-# Note: values for li and for other_li are not modified.
-li + other_li   # => [1, 2, 3, 4, 5, 6] 
+# Listelerde de ekleme yapabilirsiniz
+# Not: değerler üzerinde değişiklik yapılmaz.
+li + diger_li   # => [1, 2, 3, 4, 5, 6] 
 
-# Concatenate lists with "extend()"
-li.extend(other_li)   # Now li is [1, 2, 3, 4, 5, 6]
+# Listeleri birbirine bağlamak için "extend()" kullanılabilir
+li.extend(diger_li)   #  li artık [1, 2, 3, 4, 5, 6] oldu
 
-# Check for existence in a list with "in"
+# Listedeki bir elementin olup olmadığı kontrolü "in" ile yapılabilir
 1 in li   # => True
 
-# Examine the length with "len()"
+# Uzunluğu öğrenmek için "len()" kullanılabilir
 len(li)   # => 6
 
 
-# Tuples are like lists but are immutable.
+# Tüpler listeler gibidir fakat değiştirilemez.
 tup = (1, 2, 3)
 tup[0]   # => 1
-tup[0] = 3  # Raises a TypeError
+tup[0] = 3  # TypeError hatası oluşturur
 
-# You can do all those list thingies on tuples too
+# Diğer liste işlemlerini tüplerde de uygulayabilirsiniz
 len(tup)   # => 3
 tup + (4, 5, 6)   # => (1, 2, 3, 4, 5, 6)
 tup[:2]   # => (1, 2)
 2 in tup   # => True
 
-# You can unpack tuples (or lists) into variables
-a, b, c = (1, 2, 3)     # a is now 1, b is now 2 and c is now 3
-# Tuples are created by default if you leave out the parentheses
+# Tüpleri(veya listeleri) değişkenlere açabilirsiniz
+a, b, c = (1, 2, 3)     # 'a' artık 1, 'b' artık 2 ve 'c' artık 3
+# Eğer parantez kullanmazsanız varsayılan oalrak tüpler oluşturulur
 d, e, f = 4, 5, 6
-# Now look how easy it is to swap two values
-e, d = d, e     # d is now 5 and e is now 4
+# 2 değeri birbirine değiştirmek bu kadar kolay
+e, d = d, e     # 'd' artık 5 ve 'e' artık 4
 
 
-# Dictionaries store mappings
-empty_dict = {}
-# Here is a prefilled dictionary
-filled_dict = {"one": 1, "two": 2, "three": 3}
+# Sözlükler anahtar kodlarla verileri tutar
+bos_sozl = {}
+# Önceden doldurulmuş sözlük oluşturma
+dolu_sozl = {"bir": 1, "iki": 2, "uc": 3}
 
-# Look up values with []
-filled_dict["one"]   # => 1
+# Değere bakmak için [] kullanalım
+dolu_sozl["bir"]   # => 1
 
-# Get all keys as a list with "keys()". 
-# We need to wrap the call in list() because we are getting back an iterable. We'll talk about those later.
-# Note - Dictionary key ordering is not guaranteed.
-# Your results might not match this exactly.
-list(filled_dict.keys())   # => ["three", "two", "one"]
+# Bütün anahtarları almak için  "keys()" kullanılabilir. 
+# Listelemek için list() kullanacağınız çünkü dönen değerin işlenmesi gerekiyor. Bu konuya daha sonra değineceğiz.
+# Not - Sözlük anahtarlarının sıralaması kesin değildir.
+# Beklediğiniz çıktı sizinkiyle tam uyuşmuyor olabilir.
+list(dolu_sozl.keys())   # => ["uc", "iki", "bir"]
 
 
-# Get all values as a list with "values()". Once again we need to wrap it in list() to get it out of the iterable.
-# Note - Same as above regarding key ordering.
-list(filled_dict.values())   # => [3, 2, 1]
+# Tüm değerleri almak için "values()" kullanacağız. Dönen değeri biçimlendirmek için de list() kullanmamız gerekiyor
+# Not - Sıralama değişebilir.
+list(dolu_sozl.values())   # => [3, 2, 1]
 
 
-# Check for existence of keys in a dictionary with "in"
-"one" in filled_dict   # => True
-1 in filled_dict   # => False
+# Bir anahtarın sözlükte olup olmadığını "in" ile kontrol edebilirsiniz
+"bir" in dolu_sozl   # => True
+1 in dolu_sozl   # => False
 
-# Looking up a non-existing key is a KeyError
-filled_dict["four"]   # KeyError
+# Olmayan bir anahtardan değer elde etmek isterseniz KeyError sorunu oluşacaktır.
+dolu_sozl["dort"]   # KeyError hatası oluşturur
 
-# Use "get()" method to avoid the KeyError
-filled_dict.get("one")   # => 1
-filled_dict.get("four")   # => None
-# The get method supports a default argument when the value is missing
-filled_dict.get("one", 4)   # => 1
-filled_dict.get("four", 4)   # => 4
+# "get()" metodu ile değeri almaya çalışırsanız KeyError sorunundan kurtulursunuz
+dolu_sozl.get("bir")   # => 1
+dolu_sozl.get("dort")   # => None
+# "get" metoduna parametre belirterek değerin olmaması durumunda varsayılan bir değer döndürebilirsiniz.
+dolu_sozl.get("bir", 4)   # => 1
+dolu_sozl.get("dort", 4)   # => 4
 
-# "setdefault()" inserts into a dictionary only if the given key isn't present
-filled_dict.setdefault("five", 5)  # filled_dict["five"] is set to 5
-filled_dict.setdefault("five", 6)  # filled_dict["five"] is still 5
+# "setdefault()" metodu sözlükte, belirttiğiniz anahtarın [olmaması] durumunda varsayılan bir değer atayacaktır
+dolu_sozl.setdefault("bes", 5)  # dolu_sozl["bes"] artık 5 değerine sahip
+dolu_sozl.setdefault("bes", 6)  # dolu_sozl["bes"] değişmedi, hala 5 değerine sahip
 
-# Adding to a dictionary
-filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4}
-#filled_dict["four"] = 4  #another way to add to dict
+# Sözlüğe ekleme
+dolu_sozl.update({"dort":4}) #=> {"bir": 1, "iki": 2, "uc": 3, "dort": 4}
+#dolu_sozl["dort"] = 4  #sözlüğe eklemenin bir diğer yolu
 
-# Remove keys from a dictionary with del
-del filled_dict["one"]  # Removes the key "one" from filled dict
+# Sözlükten anahtar silmek için 'del' kullanılabilir
+del dolu_sozl["bir"]  # "bir" anahtarını dolu sözlükten silecektir
 
 
-# Sets store ... well sets
-empty_set = set()
-# Initialize a set with a bunch of values. Yeah, it looks a bit like a dict. Sorry.
-some_set = {1, 1, 2, 2, 3, 4}   # some_set is now {1, 2, 3, 4}
+# Setler ... set işte :D 
+bos_set = set()
+# Seti bir veri listesi ile de oluşturabilirsiniz. Evet, biraz sözlük gibi duruyor. Üzgünüm.
+bir_set = {1, 1, 2, 2, 3, 4}   # bir_set artık {1, 2, 3, 4}
 
-# Can set new variables to a set
-filled_set = some_set
+# Sete yeni setler ekleyebilirsiniz
+dolu_set = bir_set
 
-# Add one more item to the set 
-filled_set.add(5)   # filled_set is now {1, 2, 3, 4, 5}
+# Sete bir diğer öğe ekleme 
+dolu_set.add(5)   # dolu_set artık {1, 2, 3, 4, 5} oldu
 
-# Do set intersection with &
-other_set = {3, 4, 5, 6}
-filled_set & other_set   # => {3, 4, 5}
+# Setlerin çakışan kısımlarını almak için '&' kullanabilirsiniz
+diger_set = {3, 4, 5, 6}
+dolu_set & diger_set   # => {3, 4, 5}
 
-# Do set union with |
-filled_set | other_set   # => {1, 2, 3, 4, 5, 6}
+# '|' ile aynı olan elementleri almayacak şekilde setleri birleştirebilirsiniz
+dolu_set | diger_set   # => {1, 2, 3, 4, 5, 6}
 
-# Do set difference with -
+# Farklılıkları almak için "-" kullanabilirsiniz
 {1, 2, 3, 4} - {2, 3, 5}   # => {1, 4}
 
-# Check for existence in a set with in
-2 in filled_set   # => True
-10 in filled_set   # => False
+# Bir değerin olup olmadığının kontrolü için "in" kullanılabilir
+2 in dolu_set   # => True
+10 in dolu_set   # => False
 
 
 ####################################################
-- 
cgit v1.2.3


From 1ab0a6eb5e73079393844719da067c37e84b8fef Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eray=20Ayd=C4=B1n?= <eray@erayaydin.me>
Date: Wed, 25 Mar 2015 21:05:25 +0200
Subject: Control Flow and Iterables

---
 tr-tr/python3-tr.html.markdown | 109 ++++++++++++++++++++---------------------
 1 file changed, 54 insertions(+), 55 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
index 4939f219..b1806e7b 100644
--- a/tr-tr/python3-tr.html.markdown
+++ b/tr-tr/python3-tr.html.markdown
@@ -297,37 +297,37 @@ dolu_set | diger_set   # => {1, 2, 3, 4, 5, 6}
 
 
 ####################################################
-## 3. Control Flow and Iterables
+## 3. Kontrol Akışları ve Temel Soyutlandırma
 ####################################################
 
-# Let's just make a variable
-some_var = 5
+# Bir değişken oluşturalım
+bir_degisken = 5
 
-# Here is an if statement. Indentation is significant in python!
-# prints "some_var is smaller than 10"
-if some_var > 10:
-    print("some_var is totally bigger than 10.")
-elif some_var < 10:    # This elif clause is optional.
-    print("some_var is smaller than 10.")
-else:                  # This is optional too.
-    print("some_var is indeed 10.")
+# Burada bir "if" ifadesi var. Girinti(boşluk,tab) python için önemlidir!
+# çıktı olarak "bir_degisken 10 dan küçük" yazar
+if bir_degisken > 10:
+    print("bir_degisken 10 dan büyük")
+elif bir_degisken < 10:    # Bu 'elif' ifadesi zorunlu değildir.
+    print("bir_degisken 10 dan küçük")
+else:                  # Bu ifade de zorunlu değil.
+    print("bir_degisken değeri 10")
 
 
 """
-For loops iterate over lists
-prints:
-    dog is a mammal
-    cat is a mammal
-    mouse is a mammal
+Döngülerle lsiteleri döngüye alabilirsiniz
+çıktı:
+    köpek bir memeli hayvandır
+    kedi bir memeli hayvandır
+    fare bir memeli hayvandır
 """
-for animal in ["dog", "cat", "mouse"]:
-    # You can use format() to interpolate formatted strings
-    print("{} is a mammal".format(animal))
+for hayvan in ["köpek", "kedi, "fare"]:
+    # format ile kolayca yazıyı biçimlendirelim
+    print("{} bir memeli hayvandır".format(hayvan))
 
 """
-"range(number)" returns a list of numbers
-from zero to the given number
-prints:
+"range(sayi)" bir sayı listesi döndür
+0'dan belirttiğiniz sayıyıa kadar
+çıktı:
     0
     1
     2
@@ -337,8 +337,8 @@ for i in range(4):
     print(i)
 
 """
-While loops go until a condition is no longer met.
-prints:
+'While' döngüleri koşul çalıştıkça işlemleri gerçekleştirir.
+çıktı:
     0
     1
     2
@@ -347,50 +347,49 @@ prints:
 x = 0
 while x < 4:
     print(x)
-    x += 1  # Shorthand for x = x + 1
+    x += 1  # Uzun hali x = x + 1
 
-# Handle exceptions with a try/except block
+# Hataları kontrol altına almak için try/except bloklarını kullanabilirsiniz
 try:
-    # Use "raise" to raise an error
-    raise IndexError("This is an index error")
+    # Bir hata oluşturmak için "raise" kullanabilirsiniz
+    raise IndexError("Bu bir index hatası")
 except IndexError as e:
-    pass    # Pass is just a no-op. Usually you would do recovery here.
+    pass    # Önemsiz, devam et.
 except (TypeError, NameError):
-    pass    # Multiple exceptions can be handled together, if required.
-else:   # Optional clause to the try/except block. Must follow all except blocks
-    print("All good!")   # Runs only if the code in try raises no exceptions
+    pass    # Çoklu bir şekilde hataları kontrol edebilirsiniz, tabi gerekirse.
+else:   # İsteğe bağlı bir kısım. Eğer hiçbir hata kontrol mekanizması desteklemiyorsa bu blok çalışacaktır
+    print("Her şey iyi!")   # IndexError, TypeError ve NameError harici bir hatada bu blok çalıştı
 
-# Python offers a fundamental abstraction called the Iterable.
-# An iterable is an object that can be treated as a sequence.
-# The object returned the range function, is an iterable.
+# Temel Soyutlandırma, bir objenin işlenmiş halidir.
+# Aşağıdaki örnekte; Obje, range fonksiyonuna temel soyutlandırma gönderdi.
 
-filled_dict = {"one": 1, "two": 2, "three": 3}
-our_iterable = filled_dict.keys()
-print(our_iterable) #=> range(1,10). This is an object that implements our Iterable interface
+dolu_sozl = {"bir": 1, "iki": 2, "uc": 3}
+temel_soyut = dolu_sozl.keys()
+print(temel_soyut) #=> range(1,10). Bu obje temel soyutlandırma arayüzü ile oluşturuldu
 
-# We can loop over it.
-for i in our_iterable:
-    print(i)    # Prints one, two, three
+# Temel Soyutlandırılmış objeyi döngüye sokabiliriz.
+for i in temel_soyut:
+    print(i)    # Çıktısı: bir, iki, uc
 
-# However we cannot address elements by index.
-our_iterable[1]  # Raises a TypeError
+# Fakat, elementin anahtarına değerine.
+temel_soyut[1]  # TypeError hatası!
 
-# An iterable is an object that knows how to create an iterator.
-our_iterator = iter(our_iterable)
+# 'iterable' bir objenin nasıl temel soyutlandırıldığıdır.
+iterator = iter(temel_soyut)
 
-# Our iterator is an object that can remember the state as we traverse through it.
-# We get the next object by calling the __next__ function.
-our_iterator.__next__()  #=> "one"
+# 'iterator' o obje üzerinde yaptığımız değişiklikleri hatırlayacaktır
+# Bir sonraki objeyi almak için __next__ fonksiyonunu kullanabilirsiniz.
+iterator.__next__()  #=> "bir"
 
-# It maintains state as we call __next__.
-our_iterator.__next__()  #=> "two"
-our_iterator.__next__()  #=> "three"
+# Bir önceki __next__ fonksiyonumuzu hatırlayıp bir sonraki kullanımda bu sefer ondan bir sonraki objeyi döndürecektir
+iterator.__next__()  #=> "iki"
+iterator.__next__()  #=> "uc"
 
-# After the iterator has returned all of its data, it gives you a StopIterator Exception
-our_iterator.__next__() # Raises StopIteration
+# Bütün nesneleri aldıktan sonra bir daha __next__ kullanımınızda, StopIterator hatası oluşturacaktır.
+iterator.__next__() # StopIteration hatası
 
-# You can grab all the elements of an iterator by calling list() on it.
-list(filled_dict.keys())  #=> Returns ["one", "two", "three"]
+# iterator'deki tüm nesneleri almak için list() kullanabilirsiniz.
+list(dolu_sozl.keys())  #=> Returns ["bir", "iki", "uc"]
 
 
 ####################################################
-- 
cgit v1.2.3


From 71d688379641a91f6247920962a005d9af635a70 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eray=20Ayd=C4=B1n?= <eray@erayaydin.me>
Date: Wed, 25 Mar 2015 21:26:00 +0200
Subject: Functions

---
 tr-tr/python3-tr.html.markdown | 100 ++++++++++++++++++++---------------------
 1 file changed, 48 insertions(+), 52 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
index b1806e7b..6babb7d0 100644
--- a/tr-tr/python3-tr.html.markdown
+++ b/tr-tr/python3-tr.html.markdown
@@ -393,93 +393,89 @@ list(dolu_sozl.keys())  #=> Returns ["bir", "iki", "uc"]
 
 
 ####################################################
-## 4. Functions
+## 4. Fonksiyonlar
 ####################################################
 
-# Use "def" to create new functions
-def add(x, y):
-    print("x is {} and y is {}".format(x, y))
-    return x + y    # Return values with a return statement
+# "def" ile yeni fonksiyonlar oluşturabilirsiniz
+def topla(x, y):
+    print("x = {} ve y = {}".format(x, y))
+    return x + y    # Değer döndürmek için 'return' kullanmalısınız
 
-# Calling functions with parameters
-add(5, 6)   # => prints out "x is 5 and y is 6" and returns 11
+# Fonksiyonu parametleri ile çağırıyoruz
+topla(5, 6)   # => çıktı "x = 5 ve y = 6" ve değer olarak 11 döndürür
 
-# Another way to call functions is with keyword arguments
-add(y=6, x=5)   # Keyword arguments can arrive in any order.
+# Bir diğer fonksiyon çağırma yöntemi de anahtar değerleri ile belirtmek
+topla(y=6, x=5)   # Anahtar değeri belirttiğiniz için parametre sıralaması önemsiz.
 
-# You can define functions that take a variable number of
-# positional arguments
-def varargs(*args):
-    return args
+# Sınırsız sayıda argüman da alabilirsiniz
+def argumanlar(*argumanlar):
+    return argumanlar
 
-varargs(1, 2, 3)   # => (1, 2, 3)
+argumanlar(1, 2, 3)   # => (1, 2, 3)
 
-# You can define functions that take a variable number of
-# keyword arguments, as well
-def keyword_args(**kwargs):
-    return kwargs
+# Parametrelerin anahtar değerlerini almak isterseniz
+def anahtar_par(**anahtarlar):
+    return anahtar
 
-# Let's call it to see what happens
-keyword_args(big="foot", loch="ness")   # => {"big": "foot", "loch": "ness"}
+# Çalıştırdığımızda
+anahtar_par(anah1="deg1", anah2="deg2")   # => {"anah1": "deg1", "anah2": "deg2"}
 
 
-# You can do both at once, if you like
-def all_the_args(*args, **kwargs):
-    print(args)
-    print(kwargs)
+# İsterseniz, bu ikisini birden kullanabilirsiniz
+def tum_argumanlar(*argumanlar, **anahtarla):
+    print(argumanlar)
+    print(anahtarla)
 """
-all_the_args(1, 2, a=3, b=4) prints:
+tum_argumanlar(1, 2, a=3, b=4) çıktı:
     (1, 2)
     {"a": 3, "b": 4}
 """
 
-# When calling functions, you can do the opposite of args/kwargs!
-# Use * to expand tuples and use ** to expand kwargs.
-args = (1, 2, 3, 4)
-kwargs = {"a": 3, "b": 4}
-all_the_args(*args)   # equivalent to foo(1, 2, 3, 4)
-all_the_args(**kwargs)   # equivalent to foo(a=3, b=4)
-all_the_args(*args, **kwargs)   # equivalent to foo(1, 2, 3, 4, a=3, b=4)
+# Fonksiyonu çağırırken de aynısını kullanabilirsiniz
+argumanlar = (1, 2, 3, 4)
+anahtarla = {"a": 3, "b": 4}
+tum_argumanlar(*argumanlar)   # = foo(1, 2, 3, 4)
+tum_argumanlar(**anahtarla)   # = foo(a=3, b=4)
+tum_argumanlar(*argumanlar, **anahtarla)   # = foo(1, 2, 3, 4, a=3, b=4)
 
 
-# Function Scope                                                                
+# Fonksiyonlarda kullanacağımız bir değişken oluşturalım                                  
 x = 5
 
-def setX(num):
-    # Local var x not the same as global variable x
-    x = num # => 43
+def belirleX(sayi):
+    # Fonksiyon içerisindeki x ile global tanımladığımız x aynı değil
+    x = sayi # => 43
     print (x) # => 43
     
-def setGlobalX(num):
+def globalBelirleX(sayi):
     global x
     print (x) # => 5
-    x = num # global var x is now set to 6
+    x = sayi # global olan x değişkeni artık 6
     print (x) # => 6
 
-setX(43)
-setGlobalX(6)
+belirleX(43)
+globalBelirleX(6)
 
 
-# Python has first class functions
-def create_adder(x):
-    def adder(y):
+# Sınıf fonksiyonları oluşturma
+def toplama_olustur(x):
+    def topla(y):
         return x + y
-    return adder
+    return topla
 
-add_10 = create_adder(10)
-add_10(3)   # => 13
+ekle_10 = toplama_olustur(10)
+ekle_10(3)   # => 13
 
-# There are also anonymous functions
+# Bilinmeyen fonksiyon
 (lambda x: x > 2)(3)   # => True
 
 # TODO - Fix for iterables
-# There are built-in higher order functions
-map(add_10, [1, 2, 3])   # => [11, 12, 13]
+# Belirli sayıdan yükseğini alma fonksiyonu
+map(ekle_10, [1, 2, 3])   # => [11, 12, 13]
 filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
 
-# We can use list comprehensions for nice maps and filters
-# List comprehension stores the output as a list which can itself be a nested list
-[add_10(i) for i in [1, 2, 3]]  # => [11, 12, 13]
+# Filtreleme işlemi için liste comprehensions da kullanabiliriz
+[ekle_10(i) for i in [1, 2, 3]]  # => [11, 12, 13]
 [x for x in [3, 4, 5, 6, 7] if x > 5]   # => [6, 7]
 
 ####################################################
-- 
cgit v1.2.3


From e34c67290a311c32a208793f44e5d0d51bf37bc4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eray=20Ayd=C4=B1n?= <eray@erayaydin.me>
Date: Wed, 25 Mar 2015 21:36:52 +0200
Subject: Classes

---
 tr-tr/python3-tr.html.markdown | 68 ++++++++++++++++++++----------------------
 1 file changed, 33 insertions(+), 35 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
index 6babb7d0..ee858fb6 100644
--- a/tr-tr/python3-tr.html.markdown
+++ b/tr-tr/python3-tr.html.markdown
@@ -479,59 +479,57 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
 [x for x in [3, 4, 5, 6, 7] if x > 5]   # => [6, 7]
 
 ####################################################
-## 5. Classes
+## 5. Sınıflar
 ####################################################
 
 
-# We subclass from object to get a class.
-class Human(object):
+# Sınıf oluşturmak için objeden alt sınıf oluşturacağız.
+class Insan(obje):
 
-    # A class attribute. It is shared by all instances of this class
-    species = "H. sapiens"
+    # Sınıf değeri. Sınıfın tüm nesneleri tarafından kullanılabilir
+    tur = "H. sapiens"
 
-    # Basic initializer, this is called when this class is instantiated.
-    # Note that the double leading and trailing underscores denote objects
-    # or attributes that are used by python but that live in user-controlled
-    # namespaces. Methods(or objects or attributes) like: __init__, __str__, 
-    # __repr__ etc. are called magic methods (or sometimes called dunder methods)  
-    # You should not invent such names on your own.
-    def __init__(self, name):
-        # Assign the argument to the instance's name attribute
-        self.name = name
+    # Basit başlatıcı, Sınıf çağrıldığında tetiklenecektir.
+    # Dikkat edin, iki adet alt çizgi(_) bulunmakta. Bunlar
+    # python tarafından tanımlanan isimlerdir. 
+    # Kendinize ait bir fonksiyon oluştururken __fonksiyon__ kullanmayınız!
+    def __init__(self, isim):
+        # Parametreyi sınıfın değerine atayalım
+        self.isim = isim
 
-    # An instance method. All methods take "self" as the first argument
-    def say(self, msg):
-        return "{name}: {message}".format(name=self.name, message=msg)
+    # Bir metot. Bütün metotlar ilk parametre olarak "self "alır.
+    def soyle(self, mesaj):
+        return "{isim}: {mesaj}".format(isim=self.name, mesaj=mesaj)
 
-    # A class method is shared among all instances
-    # They are called with the calling class as the first argument
+    # Bir sınıf metotu bütün nesnelere paylaştırılır
+    # İlk parametre olarak sınıf alırlar
     @classmethod
-    def get_species(cls):
-        return cls.species
+    def getir_tur(snf):
+        return snf.tur
 
-    # A static method is called without a class or instance reference
+    # Bir statik metot, sınıf ve nesnesiz çağrılır
     @staticmethod
     def grunt():
         return "*grunt*"
 
 
-# Instantiate a class
-i = Human(name="Ian")
-print(i.say("hi"))     # prints out "Ian: hi"
+# Sınıfı çağıralım
+i = Insan(isim="Ahmet")
+print(i.soyle("merhaba"))     # çıktı "Ahmet: merhaba"
 
-j = Human("Joel")
-print(j.say("hello"))  # prints out "Joel: hello"
+j = Insan("Ali")
+print(j.soyle("selam"))  # çıktı "Ali: selam"
 
-# Call our class method
-i.get_species()   # => "H. sapiens"
+# Sınıf metodumuzu çağıraim
+i.getir_tur()   # => "H. sapiens"
 
-# Change the shared attribute
-Human.species = "H. neanderthalensis"
-i.get_species()   # => "H. neanderthalensis"
-j.get_species()   # => "H. neanderthalensis"
+# Paylaşılan değeri değiştirelim
+Insan.tur = "H. neanderthalensis"
+i.getir_tur()   # => "H. neanderthalensis"
+j.getir_tur()   # => "H. neanderthalensis"
 
-# Call the static method
-Human.grunt()   # => "*grunt*"
+# Statik metodumuzu çağıralım
+Insan.grunt()   # => "*grunt*"
 
 
 ####################################################
-- 
cgit v1.2.3


From 4d74369df3a33f22442ce5938768500d55e9fa94 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eray=20Ayd=C4=B1n?= <eray@erayaydin.me>
Date: Thu, 26 Mar 2015 15:23:45 +0200
Subject: Modules

---
 tr-tr/python3-tr.html.markdown | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
index ee858fb6..83ce892d 100644
--- a/tr-tr/python3-tr.html.markdown
+++ b/tr-tr/python3-tr.html.markdown
@@ -533,32 +533,32 @@ Insan.grunt()   # => "*grunt*"
 
 
 ####################################################
-## 6. Modules
+## 6. Moduller
 ####################################################
 
-# You can import modules
+# Modülleri içe aktarabilirsiniz
 import math
 print(math.sqrt(16))  # => 4
 
-# You can get specific functions from a module
+# Modülden belirli bir fonksiyonları alabilirsiniz
 from math import ceil, floor
 print(ceil(3.7))  # => 4.0
 print(floor(3.7))   # => 3.0
 
-# You can import all functions from a module.
-# Warning: this is not recommended
+# Modüldeki tüm fonksiyonları içe aktarabilirsiniz
+# Dikkat: bunu yapmanızı önermem.
 from math import *
 
-# You can shorten module names
+# Modül isimlerini değiştirebilirsiniz.
+# Not: Modül ismini kısaltmanız çok daha iyi olacaktır
 import math as m
 math.sqrt(16) == m.sqrt(16)   # => True
 
-# Python modules are just ordinary python files. You
-# can write your own, and import them. The name of the
-# module is the same as the name of the file.
+# Python modulleri aslında birer python dosyalarıdır.
+# İsterseniz siz de yazabilir ve içe aktarabilirsiniz Modulün
+# ismi ile dosyanın ismi aynı olacaktır.
 
-# You can find out which functions and attributes
-# defines a module.
+# Moduldeki fonksiyon ve değerleri öğrenebilirsiniz.
 import math
 dir(math)
 
-- 
cgit v1.2.3


From fde928afa6ef076087acf6c2dbfde0b53ba46e99 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eray=20Ayd=C4=B1n?= <eray@erayaydin.me>
Date: Thu, 26 Mar 2015 15:36:05 +0200
Subject: Advanced

---
 tr-tr/python3-tr.html.markdown | 62 ++++++++++++++++++++----------------------
 1 file changed, 30 insertions(+), 32 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
index 83ce892d..fcd57229 100644
--- a/tr-tr/python3-tr.html.markdown
+++ b/tr-tr/python3-tr.html.markdown
@@ -564,56 +564,54 @@ dir(math)
 
 
 ####################################################
-## 7. Advanced
+## 7. Gelişmiş
 ####################################################
 
-# Generators help you make lazy code
-def double_numbers(iterable):
-    for i in iterable:
+# Oluşturucular uzun uzun kod yazmamanızı sağlayacak ve yardımcı olacaktır
+def kare_sayilar(nesne):
+    for i in nesne:
         yield i + i
 
-# A generator creates values on the fly.
-# Instead of generating and returning all values at once it creates one in each
-# iteration.  This means values bigger than 15 wont be processed in
-# double_numbers.
-# Note range is a generator too. Creating a list 1-900000000 would take lot of
-# time to be made
-# We use a trailing underscore in variable names when we want to use a name that 
-# would normally collide with a python keyword
+# Bir oluşturucu(generator) değerleri anında oluşturur.
+# Bir seferde tüm değerleri oluşturup göndermek yerine teker teker her oluşumdan
+# sonra geri döndürür.  Bu demektir ki, kare_sayilar fonksiyonumuzda 15'ten büyük
+# değerler işlenmeyecektir.
+# Not: range() da bir oluşturucu(generator)dur. 1-900000000 arası bir liste yapmaya çalıştığınızda
+# çok fazla vakit alacaktır.
+# Python tarafından belirlenen anahtar kelimelerden kaçınmak için basitçe alt çizgi(_) kullanılabilir. 
 range_ = range(1, 900000000)
-# will double all numbers until a result >=30 found
-for i in double_numbers(range_):
+# kare_sayilar'dan dönen değer 30'a ulaştığında durduralım
+for i in kare_sayilar(range_):
     print(i)
     if i >= 30:
         break
 
 
-# Decorators
-# in this example beg wraps say
-# Beg will call say. If say_please is True then it will change the returned
-# message
+# Dekoratörler
+# Bu örnekte,
+# Eğer lutfen_soyle True ise dönen değer değişecektir.
 from functools import wraps
 
 
-def beg(target_function):
-    @wraps(target_function)
-    def wrapper(*args, **kwargs):
-        msg, say_please = target_function(*args, **kwargs)
-        if say_please:
-            return "{} {}".format(msg, "Please! I am poor :(")
-        return msg
+def yalvar(hedef_fonksiyon):
+    @wraps(hedef_fonksiyon)
+    def metot(*args, **kwargs):
+        msj, lutfen_soyle = hedef_fonksiyon(*args, **kwargs)
+        if lutfen_soyle:
+            return "{} {}".format(msj, "Lütfen! Artık dayanamıyorum :(")
+        return msj
 
-    return wrapper
+    return metot
 
 
-@beg
-def say(say_please=False):
-    msg = "Can you buy me a beer?"
-    return msg, say_please
+@yalvar
+def soyle(lutfen_soyle=False):
+    msj = "Bana soda alır mısın?"
+    return msj, lutfen_soyle
 
 
-print(say())  # Can you buy me a beer?
-print(say(say_please=True))  # Can you buy me a beer? Please! I am poor :(
+print(soyle())  # Bana soda alır mısın?
+print(soyle(lutfen_soyle=True))  # Ban soda alır mısın? Lutfen! Artık dayanamıyorum :(
 ```
 
 ## Ready For More?
-- 
cgit v1.2.3


From c26eb3384b7c1201d903acfdee67b1709696c249 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eray=20Ayd=C4=B1n?= <eray@erayaydin.me>
Date: Thu, 26 Mar 2015 15:36:45 +0200
Subject: Ready To More?

---
 tr-tr/python3-tr.html.markdown | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
index fcd57229..2477c5da 100644
--- a/tr-tr/python3-tr.html.markdown
+++ b/tr-tr/python3-tr.html.markdown
@@ -614,9 +614,9 @@ print(soyle())  # Bana soda alır mısın?
 print(soyle(lutfen_soyle=True))  # Ban soda alır mısın? Lutfen! Artık dayanamıyorum :(
 ```
 
-## Ready For More?
+## Daha Fazlasına Hazır Mısınız?
 
-### Free Online
+### Ücretsiz Online
 
 * [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
 * [Dive Into Python](http://www.diveintopython.net/)
@@ -627,7 +627,7 @@ print(soyle(lutfen_soyle=True))  # Ban soda alır mısın? Lutfen! Artık dayana
 * [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
 * [Python Course](http://www.python-course.eu/index.php)
 
-### Dead Tree
+### Kitaplar
 
 * [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
 * [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
-- 
cgit v1.2.3


From 212ba8301419923cffb82fa4d4ef7c91832b6096 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eray=20Ayd=C4=B1n?= <eray@erayaydin.me>
Date: Mon, 30 Mar 2015 21:26:26 +0000
Subject: Markdown tr-tr language

---
 tr-tr/markdown-tr.html.markdown | 251 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 251 insertions(+)
 create mode 100644 tr-tr/markdown-tr.html.markdown

(limited to 'tr-tr')

diff --git a/tr-tr/markdown-tr.html.markdown b/tr-tr/markdown-tr.html.markdown
new file mode 100644
index 00000000..bac8f6fc
--- /dev/null
+++ b/tr-tr/markdown-tr.html.markdown
@@ -0,0 +1,251 @@
+---
+language: markdown
+contributors:
+    - ["Dan Turkel", "http://danturkel.com/"]
+translators:
+    - ["Eray AYDIN", "http://erayaydin.me/"]
+lang: tr-tr
+filename: markdown-tr.md
+---
+
+Markdown, 2004 yılında John Gruber tarafından oluşturuldu. Asıl amacı kolay okuma ve yazmayı sağlamakla beraber kolayca HTML (artık bir çok diğer formatlara) dönüşüm sağlamaktır.
+
+
+```markdown
+<!-- Markdown, HTML'i kapsar, yani her HTML dosyası geçerli bir Markdown dosyasıdır, bu demektir
+ki Markdown içerisinde HTML etiketleri kullanabiliriz, örneğin bu yorum elementi, ve
+markdown işleyicisinde etki etmezler. Fakat, markdown dosyası içerisinde HTML elementi oluşturursanız,
+bu elementin içeriğinde markdown söz dizimlerini kullanamazsınız. -->
+
+<!-- Markdown ayrıca işleyiciden işleyiciye farklılık gösterebilir. Bu rehberde
+evrensel özelliklere uygun anlatımlar olacaktır. Bir çok işleyici bu rehberdeki
+anlatımları destekler -->
+
+<!-- Başlıklar -->
+<!-- Kolayca <h1>'den <h6>'ya HTML etiketleri oluşturabilirsiniz.
+Kare (#) sayısı bu elementin numarasını belirleyecek ve devamında getirdiğiniz
+yazı bu elementin içeriği olacaktır
+-->
+# Bu bir <h1>
+## Bu bir <h2>
+### Bu bir <h3>
+#### Bu bir <h4>
+##### Bu bir <h5>
+###### Bu bir <h6>
+
+<!-- Markdown ayrıca h1 ve h2 için 2 alternatif yol daha taşır -->
+Bu bir h1
+=========
+
+Bu bir h2
+---------
+
+<!-- Basit yazı stilleri -->
+<!-- Markdown ile yazılar kolayca italik ve kalın belirtilebilir -->
+*Bu yazı italik.*
+_Bu yazı da italik._
+
+**Bu yazı kalın.**
+__Bu yazı da kalın.__
+
+***Bu yazı hem kalın hem italik.***
+**_Bu da öyle!_**
+*__Hatta bu bile!__*
+
+<!-- Github Flavored Markdown'da ayrıca üstü çizgili karakter de desteklenir: -->
+~~Bu yazı üstü çizili olarak gözükecek.~~
+
+<!-- Paragraflar bir veya daha fazla boş satırla ayrılır. -->
+
+Bu bir paragraf. Paragrafın içeriğine devam ediyorum, eğlenceli değil mi?
+
+Şimdi 2. paragrafıma geçtim.
+Hala 2. paragraftayım, çünkü boş bir satır bırakmadım.
+
+Bu da 3. paragrafım!
+
+<!-- HTML'de her satır için <br /> etiketi kullanmak ister misiniz, Bir
+paragrafı bitirdikten sonra 2 veya daha fazla boşluk bırakın ve yeni paragrafa
+başlayın, bu bir <br /> etiketi sayılacaktır  -->
+
+Bu yazının sonunda 2 boşluk var (bu satırı seçerek kontrol edebilirsiniz).  
+
+Bir üst satırda <br /> etiketi var!
+
+<!-- Blok yazılarının yapımı oldukça kolay, (>) karakteri ile yapabilirsiniz  -->
+
+> Bu bir blok etiketi. Satırlara ayırmak için
+> her satırın başında `>` karakter yerleştirmeli veya tek satırda bütün içeriği yazabilirsiniz.
+> Satır `>` karakteri ile başladığı sürece sorun yok. 
+
+> Ayrıca alt alta da blok elementi açabilirsiniz
+>> iç içe yani
+> düzgün değil mi ?
+
+<!-- Listeler -->
+<!-- Numarasız listeler için yıldız, artı, veya tire kullanabilirsiniz -->
+
+* Nesne
+* Nesne
+* Bir başka nesne
+
+veya
+
++ Nesne
++ Nesne
++ Bir başka nesne
+
+veya
+
+- Nesne
+- Nesne
+- Son bir nesne
+
+<!-- Numaralı liste için başına sıralı bir şekilde sayı eklemeniz yeterli -->
+
+1. İlk nesne
+2. İkinci nesne
+3. Üçüncü nesne
+
+<!-- İsterseniz sıralı bir şekilde yazmak zorunda değilsiniz, markdown
+biçimlendirirken sizin için sıralayacaktır, fakat bunu önermiyorum. Markdown dosyasının
+düzgün gözükmesi için önerilen metodu uygulamanızı tavsiye ederim -->
+
+1. İlk nesne
+1. İkinci nesne
+1. Üçüncü nesne
+
+<!-- (Bunun çıktısı ile, sıralı olarak yazdığımız örneğin çıktısı aynı olacaktır) -->
+
+<!-- Ayrıca alt alta liste oluşturabilirsiniz -->
+
+1. İlk nesne
+2. İkinci nesne
+3. Üçüncü nesne
+    * Alt nesne
+    * Alt nesne
+4. Dördüncü nesne
+
+<!-- Ayrıca görev listeleri de bulunmakta. HTML seçim kutusu(checkbox) oluşturacaktır. -->
+Kutunun içerisinde `x` yoksa eğer seçim kutusu boş olacaktır.
+- [ ] Yapılacak ilk görev.
+- [ ] Yapılması gereken bir başka görev
+Aşağıdaki seçim kutusu ise içi dolu olacaktır.
+- [x] Bu görev başarıyla yapıldı
+
+<!-- Kod blokları -->
+<!-- Kod bloklarını(<code> elementi) belirtmek için 4 adet boşluk veya bir
+tab karakterini kullanabilirsiniz -->
+
+    Bu bir kod
+    öyle mi?
+
+<!-- Ayrıca kod içerisinde girinti kullanmak istiyorsanız tekrar `tab` veya `4 boşluk`
+kullanabilirsiniz -->
+
+    my_array.each do |item|
+        puts item
+    end
+
+<!-- Yazı içerisinde kod belirtmek için sorgu tırnağı (`) kullanabilirsiniz -->
+
+Ahmet `go_to()` fonksiyonun ne yaptığını bilmiyor!
+
+<!-- Github Flavored Markdown'da, kod içerisinde aydınlatma kullanabilirsiniz -->
+
+\`\`\`ruby <!-- buradaki ters slaş (\) işaretlerini kullanmayın, sadece ```ruby ! -->
+def foobar
+    puts "Hello world!"
+end
+\`\`\` <!-- burada da (\) işaretlerini kullanmayın, sadece ``` -->
+
+<!-- Yukarıdaki örnekte girinti kullanmanıza gerek yok, Github da 
+``` işaretinden sonra belirttiğiniz yazılım diline göre gerekli
+syntax aydınlatmaları uygulanacaktır -->
+
+<!-- Düz çizgi (<hr />) -->
+<!-- Düz çizgiler 3 veya daha fazla yıldız/çizgi ile yapılabilir. Boşluklar önemsiz. -->
+
+***
+---
+- - -
+****************
+
+<!-- Linkler -->
+<!-- Markdown'daki en güzel şeylerden biri kolayca link oluşturmaktır. 
+Linkte göstermek istediğiniz yazıyı [] içerisine yerleştirin ve sonuna parantezler içerisinde ()
+gideceği adresi belirtin -->
+
+[Bana tıkla!](http://test.com)
+
+<!-- Ayrıca linke `title` özelliği eklemek için tırnakları kullanabilirsiniz -->
+
+[Bana tıkla!](http://test.com "Test.com'a gider")
+
+<!-- Bağıl yollar da çalışıyor. -->
+[Müzik dinle](/muzik/).
+
+<!-- Markdown ayrıca referans linklerini de destekler -->
+
+[Bu linke tıklayarak][link1] daha detaylı bilgi alabilirsiniz!
+[Ayrıca bu linki de inceleyin][foobar] tabi istiyorsanız.
+
+[link1]: http://test.com/ "harika!"
+[foobar]: http://foobar.biz/ "okey!"
+
+<!--Başlık ayrıca tek tırnak veya parantez içinde olabilir, veya direk yazılabilir.
+Referans döküman içerisindeki herhangi bir yer olabilir ve referans IDsi 
+benzersiz olduğu sürece sorunsuz çalışacaktır. -->
+
+<!-- Ayrıca "dolaylı adlandırma" bulunmaktadır, "dolaylı adlandırma", linkin yazısının
+aynı zamanda onun idsi olmasıdır -->
+
+[Bu][] bir link.
+[bu]: http://bubirlink.com
+
+<!-- Fakat bu çok tercih edilen bir yöntem değil. -->
+
+<!-- Resimler -->
+<!-- Resimler aslında linklere çok benziyor fakat başında ünlem bulunuyor! -->
+![Bu alt etiketine gelecek içerik](http://imgur.com/resmim.jpg "Bu da isteğe bağlı olan bir başlık")
+
+<!-- Referanslar resimler için de geçerli -->
+![Bu alt etiketi.][resmim]
+
+[resmim]: bagil/linkler/de/calisiyor.jpg "Başlık isterseniz buraya girebilirsiniz"
+
+<!-- Çeşitli -->
+<!-- Oto-linkler -->
+
+<http://testwebsite.com/> ile
+[http://testwebsite.com/](http://testwebsite.com) aynı şeyler
+
+<!-- Oto-linkler epostaları da destekler -->
+
+<foo@bar.com>
+
+<!-- Kaçış karakterleri -->
+
+Bu yazının *yıldızlar arasında gözükmesini* istiyorum fakat italik olmamasını istiyorum,
+bunun için, şu şekilde: \*bu yazı italik değil, yıldızlar arasında\*.
+
+<!-- Tablolar -->
+<!-- Tablolar sadece Github Flavored Markdown'da destekleniyor ve açıkçası
+performansı çok yoruyorlar, fakat illa ki kullanmak isterseniz: -->
+
+| Sütun1       | Sütun 2  | Sütün 3       |
+| :----------- | :------: | ------------: |
+| Sola dayalı  | Ortalı   | Sağa dayalı   |
+| test         | test     | test          |
+
+<!-- ayrıca, bunun aynısı -->
+
+Sütun 1 | Sütun 2 | Sütun 3
+:-- | :-: | --:
+Çok çirkin göözüküyor | değil | mi?
+
+<!-- Bitiş! -->
+
+```
+
+Daha detaylı bilgi için, John Gruber'in resmi söz dizimi yazısını [buradan](http://daringfireball.net/projects/markdown/syntax) veya Adam Pritchard'ın mükemmel hatırlatma kağıdını [buradan](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) inceleyebilirsiniz.
-- 
cgit v1.2.3


From 919f255a58d7af0a65d0fbf9b5232317ec20db28 Mon Sep 17 00:00:00 2001
From: Thiago van Dieten <nktakumi@gmail.com>
Date: Sun, 2 Aug 2015 12:58:23 +0300
Subject: Fix 'filename' collision between csharp{,-tr}.html.markdown

Both were set to LearnCSharp.cs, so the live site has been serving the Turkish version for English.
---
 tr-tr/csharp-tr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tr-tr')

diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown
index 7755ed44..a68026a5 100644
--- a/tr-tr/csharp-tr.html.markdown
+++ b/tr-tr/csharp-tr.html.markdown
@@ -8,7 +8,7 @@ contributors:
 translators:
     - ["Melih Mucuk", "http://melihmucuk.com"]
 lang: tr-tr
-filename: LearnCSharp.cs
+filename: LearnCSharp-tr.cs
 
 ---
 
-- 
cgit v1.2.3


From 036577916e76fe4df512da1b6c9253e1f51a5175 Mon Sep 17 00:00:00 2001
From: ozgur sahin <ozgursahin555@gmail.com>
Date: Sat, 22 Aug 2015 18:31:39 +0300
Subject: [Swift/tr] Turkish For Swift

---
 tr-tr/swift-tr.html.markdown | 590 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 590 insertions(+)
 create mode 100644 tr-tr/swift-tr.html.markdown

(limited to 'tr-tr')

diff --git a/tr-tr/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown
new file mode 100644
index 00000000..41835e13
--- /dev/null
+++ b/tr-tr/swift-tr.html.markdown
@@ -0,0 +1,590 @@
+---
+language: swift
+contributors:
+  - ["Özgür Şahin", "https://github.com/ozgurshn/"]
+filename: learnswift.swift
+---
+
+Swift iOS ve OSX platformlarında geliştirme yapmak için Apple tarafından oluşturulan yeni bir programlama dilidir.  Objective - C ile beraber kullanılabilecek ve de hatalı kodlara karşı daha esnek bir yapı sunacak bir şekilde tasarlanmıştır. Swift 2014 yılında Apple'ın geliştirici konferansı WWDC de tanıtıldı. Xcode 6+'a dahil edilen LLVM derleyici ile geliştirildi.
+
+The official [Swift Programming Language](https://itunes.apple.com/us/book/swift-programming-language/id881256329) book from Apple is now available via iBooks.  
+
+Apple'ın resmi [Swift Programlama Dili](https://itunes.apple.com/us/book/swift-programming-language/id881256329) kitabı iBooks'ta yerini aldı.
+
+See also Apple's [getting started guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html), which has a complete tutorial on Swift.  
+
+Ayrıca Swift ile gelen tüm özellikleri görmek için Apple'ın [başlangıç kılavuzu](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html)na bakmanızda yarar var.
+
+
+
+```swift
+// modülü import etme
+import UIKit
+
+//
+// MARK: Temeller
+//
+
+
+//XCode işaretlemelerle kodunuzu bölümlere ayırmanızı ve sağ üstteki metot
+ listesinde gruplama yapmanıza olanak sağlıyor
+// MARK: Bölüm işareti
+// TODO: Daha sonra yapılacak
+// FIXME: Bu kodu düzelt
+
+ 
+//Swift 2 de, println ve print metotları print komutunda birleştirildi. Print
+ otomatik olarak yeni satır ekliyor.  
+print("Merhaba dünya") // println print olarak kullanılıyor.
+print("Merhaba dünya", appendNewLine: false) // yeni bir satır eklemeden yazar.
+
+// variables (var) değer atandıktan sonra değiştirilebilir.
+// constants (let) değer atndıktan sonra değiştirilemez.
+
+var degiskenim = 42
+let øπΩ = "deger" // unicode degişken adları
+let π = 3.1415926
+let convenience = "keyword" // bağlamsal değişken adı
+let isim = "ahmet"; let soyad = "un" // farklı ifadeler noktalı virgül 
+kullanılarak ayrılabilir.
+let `class` = "keyword" // rezerve edilmiş keywordler tek tırnak içerisine 
+alınarak değişken adı olarak kullanılabilir
+let doubleOlduguBelli: Double = 70
+let intDegisken = 0007 // 7
+let largeIntDegisken = 77_000 // 77000
+let etiket = "birseyler " + String(degiskenim) // Cast etme
+let piYazi = "Pi = \(π), Pi 2 = \(π * 2)" // String içerisine değiken yazdırma
+
+
+// Builde özel değişkenler
+// -D build ayarını kullanır.
+#if false
+    print("yazılmadı")
+    let buildDegiskeni= 3
+#else
+    let buildDegiskeni = 7
+#endif
+print("Build degiskeni: \(buildDegiskeni)") // Build degeri: 7
+
+/*  
+    Optionals Swift dilinde bazı değerleri veya yokluğu (None) bir değişkende 
+    	tutmanıza olanak sağlar.  
+    
+    Swift'te her bir degişkeninin bir değeri olması gerektiğinden, nil değeri 
+    	 bile Optional değer olarak saklanır.
+
+    Optional<T> bir enum'dır.
+*/
+var baziOptionalString: String? = "optional" // nil olabilir.
+// yukarıdakiyle aynı ama ? bir postfix (sona eklenir) operatördür. (kolay 
+okunabilir)
+var someOptionalString2: Optional<String> = "optional"  
+
+
+if baziOptionalString != nil {
+    // ben nil değilim
+    if baziOptionalString!.hasPrefix("opt") {
+        print("ön eki var")
+    }
+    
+    let bos = baziOptionalString?.isEmpty
+}
+baziOptionalString = nil
+
+// belirgin olarak acilan(unwrap) opsiyonel (optional) değer
+var acilanString: String! = "Değer bekleniliyor"
+//yukarıdakiyle aynı ama ! bir postfix operatördür (kolay okunabilir)
+var acilanString2: ImplicitlyUnwrappedOptional<String> = "Değer bekleniliyor."
+
+if let baziOpsiyonelSabitString = baziOptionalString {
+    // eğer bir değeri varsa, nil değilse
+    if ! baziOpsiyonelSabitString("tamam") {
+        // ön eke sahip değil
+    }
+}
+
+// Swift değişkenlerde herhangi bir tip saklanabilir.
+// AnyObject == id
+// Objective-C deki `id` den farklı olarak, AnyObject tüm değişkenlerle
+ çalışabilir (Class, Int, struct, etc)
+var herhangiBirObject: AnyObject = 7
+herhangiBirObject = "Değer string olarak değişti, iyi bir yöntem değil ama mümkün"
+
+/*
+    Yorumlar buraya
+    
+    /*
+        İç içe yorum yazılması da mümkün
+    */
+*/
+
+//
+// MARK: Koleksiyonlar
+//
+
+/*
+    	Array ve Dictionary tipleri aslında structdırlar. Bu yüzden `let` ve `var` 
+    	ayrıca bu tipleri tanımlarken değişebilir(var) veya değişemez(let) 
+    	olduğunu 	belirtir.
+    	
+*/
+
+// Diziler
+var liste = ["balik", "su", "limon"]
+liste[1] = "şişe su"
+let bosDizi = [String]() // let == değiştirilemez
+let bosDizi2 = Array<String>() // yukarıdakiyle aynı
+var bosDegistirilebilirDizi = [String]() // var == değişebilir
+
+
+// Dictionary
+var meslekler = [
+    "Kamil": "Kaptan",
+    "Ayse": "Analist"
+]
+meslekler["Cansu"] = "Halkla İlişkiler"
+let bosDictionary = [String: Float]() // let == değiştirilemez
+let bosDictionary2 = Dictionary<String, Float>() // yukarıdakiyle aynı
+var bosDegistirilebirDictionary = [String: Float]() // var == değiştirilebilir
+
+
+//
+// MARK: Kontroller
+//
+
+// for döngüsü (dizi)
+let dizi = [1, 1, 2, 3, 5]
+for deger in dizi {
+    if deger == 1 {
+        print("Bir!")
+    } else {
+        print("Bir degil!")
+    }
+}
+
+// for döngüsü (dictionary)
+var dict = ["one": 1, "two": 2]
+for (key, value) in dict {
+    print("\(key): \(value)")
+}
+
+// for döngüsü (aralık)
+for i in -1...liste.count {
+    print(i)
+}
+liste[1...2] = ["et", "yogurt"]
+// ..<  kullanarak son elemanı çıkartabilirsiniz
+
+// while döngüsü
+var i = 1
+while i < 1000 {
+    i *= 2
+}
+
+// do-while döngüsü
+do {
+    print("merhaba")
+} while 1 == 2
+
+// Switch
+// Çok güçlü, `if` ifadesenin daha kolay okunabilir hali olarak düşünün
+// String, object örnekleri, ve primitif tipleri (Int, Double, vs) destekler.
+let sebze = "kırmızı biber"
+switch sebze {
+case "sogan":
+    let sebzeYorumu = "Biraz da domates ekle"
+case "domates", "salata":
+    let sebzeYorumu = "İyi bir sandviç olur"
+case let lokalScopeDegeri where lokalScopeDegeri.hasSuffix("biber"):
+    let sebzeYorumu = "Acı bir \(lokalScopeDegeri)?"
+default: // zorunludur (tüm olasılıkları yakalamak icin)
+    let sebzeYorumu = "Corbadaki herseyin tadı güzel"
+}
+
+
+//
+// MARK: Fonksiyonlar
+//
+
+// Fonksiyonlar first-class tiplerdir, yani başka fonksiyon içine konabilir
+// ve parametre olarak geçirilebilirler.
+
+// Swift dökümanlarıylaa birlikte Fonksiyonlar (format as reStructedText)
+
+/**
+    selamlama işlemi
+
+    :param: isim e isim
+    :param: gun  e A gun
+    :returns: isim ve gunu iceren bir String
+*/
+func selam(isim: String, gun: String) -> String {
+    return "Merhaba \(isim), bugün \(gun)."
+}
+selam("Can", "Salı")
+
+// fonksiyon parametre davranışı hariç yukarıdakine benzer
+func selam2(#gerekliIsim: String, disParametreIsmi lokalParamtreIsmi: String) -> String {
+    return "Merhaba \(gerekliIsim), bugün \(lokalParamtreIsmi)"
+}
+selam2(gerekliIsim:"Can", disParametreIsmi: "Salı")
+
+// Bir tuple ile birden fazla deger dönen fonksiyon
+func fiyatlariGetir() -> (Double, Double, Double) {
+    return (3.59, 3.69, 3.79)
+}
+let fiyatTuple = fiyatlariGetir()
+let fiyat = fiyatTuple.2 // 3.79
+// _ (alt çizgi) kullanımı Tuple degerlerini veya diğer değerleri görmezden
+gelir
+let (_, fiyat1, _) = fiyatTuple // fiyat1 == 3.69
+print(fiyat1 == fiyatTuple.1) // true
+print("Benzin fiyatı: \(fiyat)")
+
+// Çeşitli Argümanlar
+func ayarla(sayilar: Int...) {
+    // its an array
+    let sayi = sayilar[0]
+    let argumanSAyisi = sayilar.count
+}
+
+// fonksiyonu parametre olarak geçirme veya döndürme
+func arttirmaIslemi() -> (Int -> Int) {
+    func birEkle(sayi: Int) -> Int {
+        return 1 + sayi
+    }
+    return birEkle
+}
+var arttir = arttirmaIslemi()
+arttir(7)
+
+// referans geçirme
+func yerDegistir(inout a: Int, inout b: Int) {
+    let tempA = a
+    a = b
+    b = tempA
+}
+var someIntA = 7
+var someIntB = 3
+yerDegistir(&someIntA, &someIntB)
+print(someIntB) // 7
+
+
+//
+// MARK: Closurelar
+//
+var sayilar = [1, 2, 6]
+
+// Fonksiyonlar özelleştirilmiş closurelardır. ({})
+
+// Closure örneği.
+// `->` parametrelerle dönüş tipini birbirinden ayırır
+// `in` closure başlığını closure bodysinden ayırır.
+sayilar.map({
+    (sayi: Int) -> Int in
+    let sonuc = 3 * sayi
+    return sonuc
+})
+
+// eger tip biliniyorsa, yukarıdaki gibi, şöyle yapabiliriz
+sayilar = sayilar.map({ sayi in 3 * sayi })
+// Hatta bunu
+//sayilar = sayilar.map({ $0 * 3 })
+
+print(sayilar) // [3, 6, 18]
+
+// Trailing closure
+sayilar = sorted(sayilar) { $0 > $1 }
+
+print(sayilar) // [18, 6, 3]
+
+// Super kısa hali ise, < operatörü tipleri çıkartabildiği için
+
+sayilar = sorted(sayilar, < )
+
+print(sayilar) // [3, 6, 18]
+
+//
+// MARK: Yapılar
+//
+
+// Structurelar ve sınıflar birçok aynı özelliğe sahiptir.
+struct IsimTablosu {
+    let isimler = [String]()
+    
+    // Özelleştirilmiş dizi erişimi
+    subscript(index: Int) -> String {
+        return isimler[index]
+    }
+}
+
+// Structurelar otomatik oluşturulmuş kurucu metoda sahiptir.
+let isimTablosu = IsimTablosu(isimler: ["Ben", "Onlar"])
+let isim = isimTablosu[1]
+print("İsim \(name)") // İsim Onlar
+
+//
+// MARK: Sınıflar
+//
+
+// Sınıflar, structurelar ve üyeleri 3 seviye erişime sahiptir.
+// Bunlar: internal (default), public, private
+
+public class Sekil {
+    public func alaniGetir() -> Int {
+        return 0;
+    }
+}
+
+// Sınıfın tüm değişkenleri ve metotları publictir.
+// Eğer sadece veriyi yapılandırılmış bir objede
+// saklamak istiyorsanız, `struct` kullanmalısınız.
+
+internal class Rect: Sekil {
+    var yanUzunluk: Int = 1
+    
+    // Özelleştirilmiş getter ve setter propertyleri
+    private var cevre: Int {
+        get {
+            return 4 * yanUzunluk
+        }
+        set {
+            // `newValue ` setterlarda yeni değere erişimi sağlar
+            yanUzunluk = newValue / 4
+        }
+    }
+    
+    // Bir değişkene geç atama(lazy load) yapmak
+    // altSekil getter cağrılana dek nil (oluşturulmamış) olarak kalır
+    lazy var altSekil = Rect(yanUzunluk: 4)
+    
+    // Eğer özelleştirilmiş getter ve setter a ihtiyacınız yoksa,
+    // ama bir değişkene get veya set yapıldıktan sonra bir işlem yapmak 
+    // istiyorsanız, `willSet` ve `didSet` metotlarını kullanabilirsiniz
+    var identifier: String = "defaultID" {
+        // `willSet` argümanı yeni değer için değişkenin adı olacaktır.
+        willSet(someIdentifier) {
+            print(someIdentifier)
+        }
+    }
+    
+    init(yanUzunluk: Int) {
+        self. yanUzunluk = yanUzunluk
+        // super.init i her zaman özelleştirilmiş değerleri oluşturduktan sonra
+         çağırın
+        super.init()
+    }
+    
+    func kisalt() {
+        if yanUzunluk > 0 {
+            --yanUzunluk
+        }
+    }
+    
+    override func alaniGetir() -> Int {
+        return yanUzunluk * yanUzunluk
+    }
+}
+
+// Basit `Kare` sınıfI `Rect` sınıfını extend ediyor.
+class Kare: Rect {
+    convenience init() {
+        self.init(yanUzunluk: 5)
+    }
+}
+
+var benimKarem = Kare()
+print(m benimKarem.alaniGetir()) // 25
+benimKarem.kisalt()
+print(benimKarem.yanUzunluk) // 4
+
+// sınıf örneğini cast etme
+let birSekil = benimKarem as Sekil
+
+// örnekleri karşılaştır, objeleri karşılaştıran == (equal to) ile aynı değil  
+if benimKarem === benimKarem {
+    print("Evet, bu benimKarem")
+}
+
+// Opsiyonel init
+class Daire: Sekil {
+    var yaricap: Int
+    override func alaniGetir() -> Int {
+        return 3 * yaricap * yaricap
+    }
+    
+    // Eğer init opsiyonelse (nil dönebilir) `init` den sonra soru işareti
+    // son eki ekle.
+    init?(yaricap: Int) {
+        self.yaricap = yaricap
+        super.init()
+        
+        if yaricap <= 0 {
+            return nil
+        }
+    }
+}
+
+var benimDairem = Daire(radius: 1)
+print(benimDairem?.alaniGetir())    // Optional(3)
+print(benimDairem!. alaniGetir())    // 3
+var benimBosDairem = Daire(yaricap: -1)
+print(benimBosDairem?. alaniGetir())    // "nil"
+if let daire = benimBosDairem {
+    // benimBosDairem nil olduğu için çalışmayacak
+    print("circle is not nil")
+}
+
+
+//
+// MARK: Enumlar
+//
+
+// Enumlar opsiyonel olarak özel bir tip veya kendi tiplerinde olabilirler.
+// Sınıflar gibi metotlar içerebilirler.
+
+enum Kart {
+    case Kupa, Maca, Sinek, Karo
+    func getIcon() -> String {
+        switch self {
+        case .Maca: return "♤"
+        case .Kupa: return "♡"
+        case .Karo: return "♢"
+        case .Sinek: return "♧"
+        }
+    }
+}
+
+// Enum değerleri kısayol syntaxa izin verir. Eğer değişken tipi açık olarak belirtildiyse enum tipini yazmaya gerek kalmaz.
+var kartTipi: Kart = .Kupa
+
+// Integer olmayan enumlar direk değer (rawValue) atama gerektirir.
+enum KitapAdi: String {
+    case John = "John"
+    case Luke = "Luke"
+}
+print("Name: \(KitapAdi.John.rawValue)")
+
+// Değerlerle ilişkilendirilmiş Enum
+enum Mobilya {
+    // Int ile ilişkilendirilmiş
+    case Masa(yukseklik: Int)
+    // String ve Int ile ilişkilendirilmiş
+    case Sandalye(String, Int)
+    
+    func aciklama() -> String {
+        switch self {
+        case .Masa(let yukseklik):
+            return "Masa boyu \(yukseklik) cm"
+        case .Sandalye(let marka, let yukseklik):
+            return "\(brand) marka sandalyenin boyu \(yukseklik) cm"
+        }
+    }
+}
+
+var masa: Mobilya = .Masa(yukseklik: 80)
+print(masa.aciklama())     // "Masa boyu 80 cm"
+var sandalye = Mobilya.Sandalye("Foo", 40)
+print(sandalye.aciklama())    // "Foo marka sandalyenin boyu 40 cm"
+
+
+//
+// MARK: Protokoller
+//
+
+// `protocol` onu kullanan tiplerin bazı özel değişkenleri, metotları,
+// tip metotlarını,opertörleri ve alt indisleri (subscripts) içermesini
+// zorunlu hale getirebilir.
+
+protocol SekilUretici {
+    var aktif: Bool { get set }
+    func sekilOlustur() -> Sekil
+}
+
+// @objc ile tanımlanan protokoller, uygunluğu kontrol edebilmenizi sağlayacak
+// şekilde opsiyonel fonksiyonlara izin verir
+@objc protocol SekliDondur {
+    optional func sekillendirilmis()
+    optional func sekillendirilebilir() -> Bool
+}
+
+class BenimSeklim: Rect {
+    var delegate: SekliDondur?
+    
+    func buyut() {
+        yanUzlunluk += 2
+
+	// Bir çalışma zamanı hatası("optional chaining") fırlatmak yerine nil 
+	//değeri görmezden gelerek nil dönmek için opsiyonel değişken, metot veya
+	// altindisten sonra soru işareti koyabilirsiniz.
+        if let izinVeriyormu = self.delegate?.sekillendirilebilir?() {
+            // önce delegate i sonra metodu test edin
+            self.delegate?.sekillendirilmis?()
+        }
+    }
+}
+
+
+//
+// MARK: Diğerleri
+//
+
+// `extension`lar: Var olan tiplere ekstra özellikler ekleyin
+
+// Kare artık `Printable` protokolüne uyuyor.
+extension Kare: Printable {
+    var description: String {
+        return "Alan: \(alaniGetir()) - ID: \(self.identifier)"
+    }
+}
+
+print("Kare: \(benimKarem)")
+
+// Dahili tipleri de yeni özellikler ekleyebilirsiniz
+extension Int {
+    var customProperty: String {
+        return "Bu sayı \(self)"
+    }
+    
+    func carp(num: Int) -> Int {
+        return num * self
+    }
+}
+
+print(7.customProperty) // "Bu sayı 7"
+print(14.carp(3)) // 42
+
+// Genericler: Java ve C#'a benzer şekilde. `where` anahtar kelimesini
+// kullanarak genericlerin özelliklerini belirleyin
+
+func indexiBul<T: Equatable>(dizi: [T], bulunacakDeger: T) -> Int? {
+    for (index, deger) in enumerate(dizi) {
+        if deger == bulunacakDeger {
+            return index
+        }
+    }
+    return nil
+}
+let bulunanIndex = indexiBul([1, 2, 3, 4], 3)
+print(bulunanIndex == 2) // true
+
+// Operatorler:
+// Özel operatorler şu karakterlerle başlayabilir:
+//      / = - + * % < > ! & | ^ . ~
+// veya
+// Unicode math, symbol, arrow, dingbat, ve line/box karakterleri.
+prefix operator !!! {}
+
+// Yan uzunluğu 3 katına çıkartan prefix operatörü
+prefix func !!! (inout sekil: Kare) -> Kare {
+    sekil.YanUzunluk *= 3
+    return sekil
+}
+
+// güncel deger
+print(benimKarem.YanUzunluk)  // 4
+
+// yan uzunluğu !!! operatorü kullanarak 3 katına çıkar
+!!!benimKarem
+print(benimKarem.YanUzunluk) // 12
+```
-- 
cgit v1.2.3


From f72588075d0cd200d53893ad51129844df17aea7 Mon Sep 17 00:00:00 2001
From: ozgur sahin <ozgursahin555@gmail.com>
Date: Sun, 4 Oct 2015 22:01:10 +0300
Subject: swift-tr.html.markdown

Translated some English sentences.
---
 tr-tr/swift-tr.html.markdown | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

(limited to 'tr-tr')

diff --git a/tr-tr/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown
index 41835e13..c13f5ecf 100644
--- a/tr-tr/swift-tr.html.markdown
+++ b/tr-tr/swift-tr.html.markdown
@@ -3,16 +3,14 @@ language: swift
 contributors:
   - ["Özgür Şahin", "https://github.com/ozgurshn/"]
 filename: learnswift.swift
+lang: tr-tr
 ---
 
 Swift iOS ve OSX platformlarında geliştirme yapmak için Apple tarafından oluşturulan yeni bir programlama dilidir.  Objective - C ile beraber kullanılabilecek ve de hatalı kodlara karşı daha esnek bir yapı sunacak bir şekilde tasarlanmıştır. Swift 2014 yılında Apple'ın geliştirici konferansı WWDC de tanıtıldı. Xcode 6+'a dahil edilen LLVM derleyici ile geliştirildi.
-
-The official [Swift Programming Language](https://itunes.apple.com/us/book/swift-programming-language/id881256329) book from Apple is now available via iBooks.  
+ 
 
 Apple'ın resmi [Swift Programlama Dili](https://itunes.apple.com/us/book/swift-programming-language/id881256329) kitabı iBooks'ta yerini aldı.
 
-See also Apple's [getting started guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html), which has a complete tutorial on Swift.  
-
 Ayrıca Swift ile gelen tüm özellikleri görmek için Apple'ın [başlangıç kılavuzu](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/RoadMapiOS/index.html)na bakmanızda yarar var.
 
 
@@ -243,7 +241,7 @@ print("Benzin fiyatı: \(fiyat)")
 
 // Çeşitli Argümanlar
 func ayarla(sayilar: Int...) {
-    // its an array
+    // bu bir dizidir
     let sayi = sayilar[0]
     let argumanSAyisi = sayilar.count
 }
-- 
cgit v1.2.3


From b1984042c845a73333972715e88a3d7a2e8cfdd7 Mon Sep 17 00:00:00 2001
From: Guntbert Reiter <guntbert@gmx.at>
Date: Sun, 4 Oct 2015 16:44:24 +0200
Subject: Put demonstrative condition into ternary expression

It should be made clear that the part before the ternary operator is
indeed a condition, most often created as some comparison expression.
---
 tr-tr/csharp-tr.html.markdown | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'tr-tr')

diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown
index a68026a5..91c7c269 100644
--- a/tr-tr/csharp-tr.html.markdown
+++ b/tr-tr/csharp-tr.html.markdown
@@ -234,7 +234,8 @@ on a new line! ""Wow!"", the masses cried";
             // Üçlü operatörler
             // Basit bir if/else ifadesi şöyle yazılabilir
             // <koşul> ? <true> : <false>
-            string isTrue = (true) ? "True" : "False";
+            int toCompare = 17;
+            string isTrue = toCompare == 17 ? "True" : "False";
 
             // While döngüsü
             int fooWhile = 0;
-- 
cgit v1.2.3