summaryrefslogtreecommitdiffhomepage
path: root/tr-tr
diff options
context:
space:
mode:
Diffstat (limited to 'tr-tr')
-rw-r--r--tr-tr/brainfuck-tr.html.markdown87
-rw-r--r--tr-tr/c-tr.html.markdown488
-rw-r--r--tr-tr/csharp-tr.html.markdown825
-rw-r--r--tr-tr/markdown-tr.html.markdown251
-rw-r--r--tr-tr/objective-c-tr.html.markdown320
-rw-r--r--tr-tr/php-tr.html.markdown705
-rw-r--r--tr-tr/python-tr.html.markdown502
-rw-r--r--tr-tr/python3-tr.html.markdown635
-rw-r--r--tr-tr/swift-tr.html.markdown588
9 files changed, 4401 insertions, 0 deletions
diff --git a/tr-tr/brainfuck-tr.html.markdown b/tr-tr/brainfuck-tr.html.markdown
new file mode 100644
index 00000000..baca4217
--- /dev/null
+++ b/tr-tr/brainfuck-tr.html.markdown
@@ -0,0 +1,87 @@
+---
+language: brainfuck
+filename: brainfuck-tr
+contributors:
+ - ["Prajit Ramachandran", "http://prajitr.github.io"]
+translators:
+ - ["Haydar KULEKCI", "http://scanf.info/"]
+lang: tr-tr
+---
+
+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
+gözardı edilir.
+
+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.
+
+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.
+ 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.
diff --git a/tr-tr/c-tr.html.markdown b/tr-tr/c-tr.html.markdown
new file mode 100644
index 00000000..128901de
--- /dev/null
+++ b/tr-tr/c-tr.html.markdown
@@ -0,0 +1,488 @@
+---
+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.
+*/
+
+// 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.
+
+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 (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 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)
+
+ // 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");
+ }
+
+ // 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
+
+///////////////////////////////////////
+// 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;
+};
+
+// 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(){
+
+ 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/)
+
+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
diff --git a/tr-tr/csharp-tr.html.markdown b/tr-tr/csharp-tr.html.markdown
new file mode 100644
index 00000000..91c7c269
--- /dev/null
+++ b/tr-tr/csharp-tr.html.markdown
@@ -0,0 +1,825 @@
+---
+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"]
+translators:
+ - ["Melih Mucuk", "http://melihmucuk.com"]
+lang: tr-tr
+filename: LearnCSharp-tr.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#
+// 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)
+ // Sayılar boyutlarına göre ön tanımlı olarak int ya da uint olabilir.
+ // L, değişken değerinin long ya da ulong tipinde olduğunu belirtmek için kullanılır.
+
+ // Double - Çift hassasiyetli 64-bit IEEE 754 kayan sayı
+ double fooDouble = 123.4; // Hassasiyet: 15-16 basamak
+
+ // 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 - 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; // veya false
+
+ // Char - 16-bitlik tek bir unicode karakter
+ char fooChar = 'A';
+
+ // 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);
+
+ // İndeks numarası kullanarak bir string'in bütün karakterlerine erişilebilirsiniz:
+ char charFromString = fooString[1]; // => 'e'
+ // String'ler değiştirilemez: fooString[1] = 'X' işlemini yapamazsınız;
+
+ // 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);
+
+ // sprintf baz alınarak formatlama
+ string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2);
+
+ // Tarihler & Formatlama
+ DateTime fooDate = DateTime.Now;
+ Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
+
+ // 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";
+
+ // 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;
+
+ ///////////////////////////////////////////////////
+ // Veri Yapıları
+ ///////////////////////////////////////////////////
+
+ // 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];
+
+ // Bir diğer dizi tanımlama formatı şöyledir:
+ int[] y = { 9000, 1000, 1337 };
+
+ // Bir diziyi indeksleme - Bir elemente erişme
+ Console.WriteLine("intArray @ 0: " + intArray[0]);
+ // Diziler değiştirilebilir.
+ intArray[1] = 1;
+
+ // 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 }; // tanımlama
+ // <> 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
+ intList.Add(1);
+ Console.WriteLine("intList @ 0: " + intList[0]);
+
+ // 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)
+
+ ///////////////////////////////////////
+ // Operatörler
+ ///////////////////////////////////////
+ Console.WriteLine("\n->Operators");
+
+ int i1 = 1, i2 = 2; // Birden çok tanımlamanın kısa yolu
+
+ // Aritmetik basittir
+ Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3
+
+ // Mod
+ Console.WriteLine("11%3 = " + (11 % 3)); // => 2
+
+ // 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
+ Console.WriteLine("3 < 2? " + (3 < 2)); // => false
+ Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true
+ Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true
+
+ // Bit düzeyi operatörleri!
+ /*
+ ~ 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
+ */
+
+ // Arttırma
+ 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
+
+ ///////////////////////////////////////
+ // Kontrol Yapıları
+ ///////////////////////////////////////
+ Console.WriteLine("\n->Control Structures");
+
+ // If ifadesi c benzeridir
+ 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");
+ }
+
+ // Üçlü operatörler
+ // Basit bir if/else ifadesi şöyle yazılabilir
+ // <koşul> ? <true> : <false>
+ int toCompare = 17;
+ string isTrue = toCompare == 17 ? "True" : "False";
+
+ // While döngüsü
+ int fooWhile = 0;
+ while (fooWhile < 100)
+ {
+ //100 kere tekrarlanır, fooWhile 0->99
+ fooWhile++;
+ }
+
+ // Do While Döngüsü
+ int fooDoWhile = 0;
+ do
+ {
+ //100 kere tekrarlanır, fooDoWhile 0->99
+ fooDoWhile++;
+ } while (fooDoWhile < 100);
+
+ //for döngüsü yapısı => for(<başlangıç ifadesi>; <koşul>; <adım>)
+ for (int fooFor = 0; fooFor < 10; fooFor++)
+ {
+ //10 kere tekrarlanır, fooFor 0->9
+ }
+
+ // 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())
+ {
+ //String içindeki bütün karakterler üzerinde döner
+ }
+
+ // Switch Case
+ // Bir switch byte, short, char ve int veri tipleri ile çalışır.
+ // 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)
+ {
+ case 1:
+ monthString = "January";
+ break;
+ case 2:
+ monthString = "February";
+ break;
+ case 3:
+ monthString = "March";
+ break;
+ // 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:
+ monthString = "Summer time!!";
+ break;
+ default:
+ monthString = "Some other month";
+ break;
+ }
+
+ ///////////////////////////////////////
+ // Veri Tipleri Dönüştürme ve Typecasting
+ ///////////////////////////////////////
+
+ // Veri Dönüştürme
+
+ // 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 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)) // Fonksiyon boolean'dır
+ Console.WriteLine(tryInt); // 123
+
+ // 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);
+ // veya
+ tryInt.ToString();
+ }
+
+ ///////////////////////////////////////
+ // SINIFLAR - dosyanın sonunda tanımları görebilirsiniz
+ ///////////////////////////////////////
+ public static void Classes()
+ {
+ // Obje tanımlamalarını dosyanın sonunda görebilirsiniz
+
+ // Bir sınıfı türetmek için new kullanın
+ Bicycle trek = new Bicycle();
+
+ // Obje metodlarını çağırma
+ trek.SpeedUp(3); // Her zaman setter ve getter metodları kullanmalısınız
+ trek.Cadence = 100;
+
+ // ToString objenin değerini göstermek için kullanılır.
+ Console.WriteLine("trek info: " + trek.Info());
+
+ // Yeni bir Penny Farthing sınıfı türetmek
+ PennyFarthing funbike = new PennyFarthing(1, 10);
+ Console.WriteLine("funbike info: " + funbike.Info());
+
+ Console.Read();
+ } // Ana metodun sonu
+
+ // KONSOLE BAŞLANGICI Bir konsol uygulaması başlangıç olarak mutlaka ana metod'a sahip olmalı
+ public static void Main(string[] args)
+ {
+ OtherInterestingFeatures();
+ }
+
+ //
+ // İLGİNÇ ÖZELLİKLER
+ //
+
+ // VARSAYILAN METOD TANIMLAMALARI
+
+ public // Görünebilir
+ static // Sınıf üzerinden obje türetmeden çağırılabilir
+ int // Dönüş Tipi,
+ MethodSignatures(
+ 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 // Metoda gönderilen diğer bütün parametreleri alır
+ )
+ {
+ return -1;
+ }
+
+ // Metodlar tanımlamalar benzersiz ise aynı isimleri alabilirler
+ public static void MethodSignatures(string maxCount)
+ {
+ }
+
+ // 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,
+ TValue defaultItem)
+ {
+ TValue result;
+ if (!dictionary.TryGetValue(key, out result))
+ return dictionary[key] = defaultItem;
+ return result;
+ }
+
+ // Gönderilen objeleri daraltabilirsiniz
+ public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
+ {
+ // Eğer T IEnumerable ise tekrarlayabiliriz
+ foreach (var item in toPrint)
+ // Item bir int
+ Console.WriteLine(item.ToString());
+ }
+
+ public static void OtherInterestingFeatures()
+ {
+ // İSTEĞE BAĞLI PARAMETRELER
+ MethodSignatures(3, 1, 3, "Some", "Extra", "Strings");
+ MethodSignatures(3, another: 3); // isteğe bağlı olanlar gönderilmedi
+
+ // UZANTI METODLARI
+ int i = 3;
+ i.Print(); // Aşağıda tanımlandı
+
+ // 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; // eğer null değilse true döner
+
+ // ?? 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
+
+ // 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; string gibi çalışmayacaktır, bu bir int değil
+
+ // GENERIC'LER
+ //
+ var phonebook = new Dictionary<string, string>() {
+ {"Sarah", "212 555 5555"} // Telefon rehberine bir kaç numara ekleyelim.
+ };
+
+ // 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 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
+
+ // 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");
+ // Bu bölümün sonunda kaynaklar temilenir.
+ // Hata fırlatılmış olsa bile.
+ }
+
+ // 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",
+ "http://www.shaunmccarthy.com"
+ };
+ var responses = new Dictionary<string, string>();
+
+ // 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}, // en fazla 3 thread kullanmak için
+ website =>
+ {
+ // Uzun sürecek bir işlem yapın
+ using (var r = WebRequest.Create(new Uri(website)).GetResponse())
+ {
+ responses[website] = r.ContentType;
+ }
+ });
+
+ // Bütün istekler tamamlanmadan bu döndü çalışmayacaktır.
+ foreach (var key in responses.Keys)
+ Console.WriteLine("{0}:{1}", key, responses[key]);
+
+ // DİNAMİK OBJELER (diğer dillerle çalışırken kullanmak için uygun)
+ dynamic student = new ExpandoObject();
+ student.FirstName = "First Name"; // Önce yeni bir sınıf tanımlamanız gerekmez!
+
+ // 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> - 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(); // 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 (bir önceki tipin IQueryable'ını döner)
+ .Where(b => b.IsBroken && b.HasTassles)
+ .Select(b => b.ToString()); // Map - sadece bunu seçiyoruz, yani sonuç bir IQueryable<string> olacak
+
+ var sum = bikes.Sum(b => b.Wheels); // Reduce - koleksiyonda bulunan bütün wheel değerlerinin toplamı
+
+ // 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 });
+ // 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
+ // Linq ve paralel işlemlerini birleştirme
+ var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);
+ // 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 - 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();
+
+ // 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); // hala sorgu çalışmadı
+
+ // Ş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);
+
+
+
+ }
+
+ } // LearnCSharp sınıfının sonu
+
+ // Bir .cs dosyasına diğer sınıflarıda dahil edebilirsiniz
+
+ public static class Extensions
+ {
+ // UZANTI FONKSİYONLARI
+ public static void Print(this object obj)
+ {
+ Console.WriteLine(obj.ToString());
+ }
+ }
+
+ // 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'ın Alanları/Değişkenleri
+ public int Cadence // Public: herhangi bir yerden erişilebilir
+ {
+ get // get - değeri almak için tanımlanan metod
+ {
+ return _cadence;
+ }
+ set // set - değer atamak için tanımlanan metod
+ {
+ _cadence = value; // Değer setter'a gönderilen value değeridir
+ }
+ }
+ private int _cadence;
+
+ protected virtual int Gear // Protected: Sınıf ve alt sınıflar tarafından erişilebilir
+ {
+ get; // bir üye alanına ihtiyacınız yok, bu otomatik olarak bir değer oluşturacaktır
+ set;
+ }
+
+ internal int Wheels // Internal: Assembly tarafından erişilebilir
+ {
+ get;
+ private set; // Nitelik belirleyicileri get/set metodlarında atayabilirsiniz
+ }
+
+ 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 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, // bir isme tam bir değer verebilirsiniz
+ Gitane // 43
+ }
+ // 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; // Enum tipini tanımladıktan sonra alan tipini tanımlayabiliriz
+
+ // 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 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
+
+ // Kurucular sınıf oluşturmanın bir yoludur
+ // Bu bir varsayılan kurucudur.
+ public Bicycle()
+ {
+ 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++;
+ }
+
+ // Bu belirlenmiş bir kurucudur. (argümanlar içerir)
+ public Bicycle(int startCadence, int startSpeed, int startGear,
+ string name, bool hasCardsInSpokes, BikeBrand brand)
+ : base() // önce base'i çağırın
+ {
+ Gear = startGear;
+ Cadence = startCadence;
+ _speed = startSpeed;
+ Name = name;
+ _hasCardsInSpokes = hasCardsInSpokes;
+ Brand = brand;
+ }
+
+ // Kurucular zincirleme olabilir
+ public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
+ this(startCadence, startSpeed, 0, "big wheels", true, brand)
+ {
+ }
+
+ // Fonksiyon Sözdizimi:
+ // <public/private/protected> <dönüş tipi> <fonksiyon ismi>(<argümanlar>)
+
+ // sınıflar getter ve setter'ları alanları için kendisi uygular
+ // 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.
+ public void SpeedUp(int increment = 1)
+ {
+ _speed += increment;
+ }
+
+ public void SlowDown(int decrement = 1)
+ {
+ _speed -= decrement;
+ }
+
+ // 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; }
+ }
+
+ // 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; }
+
+ // Property'ler otomatik eklenmiş olabilir
+ public int FrameSize
+ {
+ get;
+ // nitelik beliryecileri get veya set için tanımlayabilirsiniz
+ // bu sadece Bicycle sınıfı Framesize değerine atama yapabilir demektir
+ private set;
+ }
+
+ // 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]
+ {
+ get {
+ return passengers[i];
+ }
+
+ set {
+ return passengers[i] = value;
+ }
+ }
+
+ //Bu objenin nitelik değerlerini göstermek için bir metod.
+ public virtual string Info()
+ {
+ return "Gear: " + Gear +
+ " Cadence: " + Cadence +
+ " Speed: " + _speed +
+ " Name: " + Name +
+ " Cards in Spokes: " + (_hasCardsInSpokes ? "yes" : "no") +
+ "\n------------------------------\n"
+ ;
+ }
+
+ // Metodlar static olabilir. Yardımcı metodlar için kullanışlı olabilir.
+ public static bool DidWeCreateEnoughBycles()
+ {
+ // Bir static metod içinde sadece static sınıf üyeleri referans gösterilebilir
+ return BicyclesCreated > 9000;
+ } // Eğer sınıfınızın sadece static üyelere ihtiyacı varsa, sınıfın kendisini static yapmayı düşünebilirsiniz.
+
+
+ } // Bicycle sınıfı sonu
+
+ // PennyFarthing , Bicycle sınıfının alt sınıfıdır.
+ class PennyFarthing : Bicycle
+ {
+ // (Penny Farthing'ler ön jantı büyük bisikletlerdir.
+ // Vitesleri yoktur.)
+
+ // Ana kurucuyu çağırmak
+ 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(); // Metodun temel versiyonunu çağırmak
+ return result;
+ }
+ }
+
+ // Arabirimler sadece üyelerin izlerini içerir, değerlerini değil.
+ interface IJumpable
+ {
+ void Jump(int meters); // bütün arbirim üyeleri public'tir
+ }
+
+ interface IBreakable
+ {
+ bool Broken { get; } // arabirimler property'leri, metodları ve olayları içerebilir
+ }
+
+ // 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;
+
+ public void Jump(int meters)
+ {
+ damage += meters;
+ }
+
+ public bool Broken
+ {
+ get
+ {
+ return damage > 100;
+ }
+ }
+ }
+
+ /// <summary>
+ /// 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
+ {
+ public BikeRepository()
+ : base()
+ {
+ }
+
+ public DbSet<Bicycle> Bikes { get; set; }
+ }
+} // namespace sonu
+```
+
+## İşlenmeyen Konular
+
+ * Flags
+ * Attributes
+ * Static properties
+ * Exceptions, Abstraction
+ * ASP.NET (Web Forms/MVC/WebMatrix)
+ * Winforms
+ * Windows Presentation Foundation (WPF)
+
+## Daha Fazlasını Okuyun
+
+ * [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# Kodlama Adetleri](http://msdn.microsoft.com/en-us/library/vstudio/ff926074.aspx)
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.
diff --git a/tr-tr/objective-c-tr.html.markdown b/tr-tr/objective-c-tr.html.markdown
new file mode 100644
index 00000000..f27cbf08
--- /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.
+
+```objective_c
+// 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)
diff --git a/tr-tr/php-tr.html.markdown b/tr-tr/php-tr.html.markdown
new file mode 100644
index 00000000..5258d785
--- /dev/null
+++ b/tr-tr/php-tr.html.markdown
@@ -0,0 +1,705 @@
+---
+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;
+
+// Değişken Silmek
+unset($int1)
+
+// 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"
+
+// Dizinin sonuna bir eleman ekleme
+$array[] = 'Four';
+
+// Diziden eleman silme
+unset($array[3]);
+
+/********************************
+ * Çı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
+
+// 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
+ */
+$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 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';
+ }
+}
+
+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.
+
+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.
+
+Genel standartlar için PHP Framework Interoperability Group'unun [PSR standards](https://github.com/php-fig/fig-standards) ziyaret edebilirsiniz.
+
diff --git a/tr-tr/python-tr.html.markdown b/tr-tr/python-tr.html.markdown
new file mode 100644
index 00000000..01285080
--- /dev/null
+++ b/tr-tr/python-tr.html.markdown
@@ -0,0 +1,502 @@
+---
+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
+
+ # Bir 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)
diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
new file mode 100644
index 00000000..2477c5da
--- /dev/null
+++ b/tr-tr/python3-tr.html.markdown
@@ -0,0 +1,635 @@
+---
+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
+
+# Tek satırlık yorum satırı kare(#) işareti ile başlamaktadır.
+
+""" Çok satırlı olmasını istediğiniz yorumlar
+ üç adet tırnak(") işareti ile
+ yapılmaktadır
+"""
+
+####################################################
+## 1. Temel Veri Türleri ve Operatörler
+####################################################
+
+# Sayılar
+3 # => 3
+
+# Tahmin edebileceğiniz gibi matematik
+1 + 1 # => 2
+8 - 1 # => 7
+10 * 2 # => 20
+
+# Bölme işlemi varsayılan olarak onluk döndürür
+35 / 5 # => 7.0
+
+# Tam sayı bölmeleri, pozitif ve negatif sayılar için aşağıya yuvarlar
+5 // 3 # => 1
+5.0 // 3.0 # => 1.0 # onluklar için de bu böyledir
+-5 // 3 # => -2
+-5.0 // 3.0 # => -2.0
+
+# Onluk kullanırsanız, sonuç da onluk olur
+3 * 2.0 # => 6.0
+
+# Kalan operatörü
+7 % 3 # => 1
+
+# Üs (2 üzeri 4)
+2**4 # => 16
+
+# Parantez ile önceliği değiştirebilirsiniz
+(1 + 3) * 2 # => 8
+
+# Boolean(Doğru-Yanlış) değerleri standart
+True
+False
+
+# 'değil' ile terse çevirme
+not True # => False
+not False # => True
+
+# Boolean Operatörleri
+# "and" ve "or" büyük küçük harf duyarlıdır
+True and False #=> False
+False or True #=> True
+
+# Bool operatörleri ile sayı kullanımı
+0 and 2 #=> 0
+-5 or 0 #=> -5
+0 == False #=> True
+2 == True #=> False
+1 == True #=> True
+
+# Eşitlik kontrolü ==
+1 == 1 # => True
+2 == 1 # => False
+
+# Eşitsizlik Kontrolü !=
+1 != 1 # => False
+2 != 1 # => True
+
+# Diğer karşılaştırmalar
+1 < 10 # => True
+1 > 10 # => False
+2 <= 2 # => True
+2 >= 2 # => True
+
+# Zincirleme şeklinde karşılaştırma da yapabilirsiniz!
+1 < 2 < 3 # => True
+2 < 3 < 2 # => False
+
+# Yazı(Strings) " veya ' işaretleri ile oluşturulabilir
+"Bu bir yazı."
+'Bu da bir yazı.'
+
+# Yazılar da eklenebilir! Fakat bunu yapmanızı önermem.
+"Merhaba " + "dünya!" # => "Merhaba dünya!"
+
+# Bir yazı(string) karakter listesi gibi işlenebilir
+"Bu bir yazı"[0] # => 'B'
+
+# .format ile yazıyı biçimlendirebilirsiniz, şu şekilde:
+"{} da ayrıca {}".format("yazılar", "işlenebilir")
+
+# 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"
+
+# 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"
+
+# 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")
+
+
+# Hiçbir şey(none) da bir objedir
+None # => None
+
+# 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, 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
+bool({}) #=> False
+
+
+####################################################
+## 2. Değişkenler ve Koleksiyonlar
+####################################################
+
+# Python bir yazdırma fonksiyonuna sahip
+print("Ben Python. Tanıştığıma memnun oldum!")
+
+# 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
+
+# Ö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
+
+# Listeler ile sıralamaları tutabilirsiniz
+li = []
+# Ö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
+# Son elemente bakın
+li[-1] # => 3
+
+# Listede olmayan bir elemente erişim sağlamaya çalışmak IndexError hatası oluşturur
+li[4] # IndexError hatası oluşturur
+
+# Bir kısmını almak isterseniz.
+li[1:3] # => [2, 4]
+# Başlangıç belirtmezseniz
+li[2:] # => [4, 3]
+# Sonu belirtmesseniz
+li[:3] # => [1, 2, 4]
+# Her ikişer objeyi seçme
+li[::2] # =>[1, 4]
+# Listeyi tersten almak
+li[::-1] # => [3, 4, 2, 1]
+# Kombinasyonları kullanarak gelişmiş bir şekilde listenin bir kısmını alabilirsiniz
+# li[baslangic:son:adim]
+
+# "del" ile isteğe bağlı, elementleri listeden kaldırabilirsiniz
+del li[2] # li artık [1, 2, 3] oldu
+
+# Listelerde de ekleme yapabilirsiniz
+# Not: değerler üzerinde değişiklik yapılmaz.
+li + diger_li # => [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
+
+# Listedeki bir elementin olup olmadığı kontrolü "in" ile yapılabilir
+1 in li # => True
+
+# Uzunluğu öğrenmek için "len()" kullanılabilir
+len(li) # => 6
+
+
+# Tüpler listeler gibidir fakat değiştirilemez.
+tup = (1, 2, 3)
+tup[0] # => 1
+tup[0] = 3 # TypeError hatası oluşturur
+
+# 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
+
+# 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
+# 2 değeri birbirine değiştirmek bu kadar kolay
+e, d = d, e # 'd' artık 5 ve 'e' artık 4
+
+
+# Sözlükler anahtar kodlarla verileri tutar
+bos_sozl = {}
+# Önceden doldurulmuş sözlük oluşturma
+dolu_sozl = {"bir": 1, "iki": 2, "uc": 3}
+
+# Değere bakmak için [] kullanalım
+dolu_sozl["bir"] # => 1
+
+# 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"]
+
+
+# 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]
+
+
+# Bir anahtarın sözlükte olup olmadığını "in" ile kontrol edebilirsiniz
+"bir" in dolu_sozl # => True
+1 in dolu_sozl # => False
+
+# Olmayan bir anahtardan değer elde etmek isterseniz KeyError sorunu oluşacaktır.
+dolu_sozl["dort"] # KeyError hatası oluşturur
+
+# "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()" 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
+
+# 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
+
+# Sözlükten anahtar silmek için 'del' kullanılabilir
+del dolu_sozl["bir"] # "bir" anahtarını dolu sözlükten silecektir
+
+
+# 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}
+
+# Sete yeni setler ekleyebilirsiniz
+dolu_set = bir_set
+
+# Sete bir diğer öğe ekleme
+dolu_set.add(5) # dolu_set artık {1, 2, 3, 4, 5} oldu
+
+# Setlerin çakışan kısımlarını almak için '&' kullanabilirsiniz
+diger_set = {3, 4, 5, 6}
+dolu_set & diger_set # => {3, 4, 5}
+
+# '|' ile aynı olan elementleri almayacak şekilde setleri birleştirebilirsiniz
+dolu_set | diger_set # => {1, 2, 3, 4, 5, 6}
+
+# Farklılıkları almak için "-" kullanabilirsiniz
+{1, 2, 3, 4} - {2, 3, 5} # => {1, 4}
+
+# Bir değerin olup olmadığının kontrolü için "in" kullanılabilir
+2 in dolu_set # => True
+10 in dolu_set # => False
+
+
+####################################################
+## 3. Kontrol Akışları ve Temel Soyutlandırma
+####################################################
+
+# Bir değişken oluşturalım
+bir_degisken = 5
+
+# 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")
+
+
+"""
+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 hayvan in ["köpek", "kedi, "fare"]:
+ # format ile kolayca yazıyı biçimlendirelim
+ print("{} bir memeli hayvandır".format(hayvan))
+
+"""
+"range(sayi)" bir sayı listesi döndür
+0'dan belirttiğiniz sayıyıa kadar
+çıktı:
+ 0
+ 1
+ 2
+ 3
+"""
+for i in range(4):
+ print(i)
+
+"""
+'While' döngüleri koşul çalıştıkça işlemleri gerçekleştirir.
+çıktı:
+ 0
+ 1
+ 2
+ 3
+"""
+x = 0
+while x < 4:
+ print(x)
+ x += 1 # Uzun hali x = x + 1
+
+# Hataları kontrol altına almak için try/except bloklarını kullanabilirsiniz
+try:
+ # Bir hata oluşturmak için "raise" kullanabilirsiniz
+ raise IndexError("Bu bir index hatası")
+except IndexError as e:
+ pass # Önemsiz, devam et.
+except (TypeError, NameError):
+ 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ı
+
+# Temel Soyutlandırma, bir objenin işlenmiş halidir.
+# Aşağıdaki örnekte; Obje, range fonksiyonuna temel soyutlandırma gönderdi.
+
+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
+
+# Temel Soyutlandırılmış objeyi döngüye sokabiliriz.
+for i in temel_soyut:
+ print(i) # Çıktısı: bir, iki, uc
+
+# Fakat, elementin anahtarına değerine.
+temel_soyut[1] # TypeError hatası!
+
+# 'iterable' bir objenin nasıl temel soyutlandırıldığıdır.
+iterator = iter(temel_soyut)
+
+# '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"
+
+# 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"
+
+# Bütün nesneleri aldıktan sonra bir daha __next__ kullanımınızda, StopIterator hatası oluşturacaktır.
+iterator.__next__() # StopIteration hatası
+
+# iterator'deki tüm nesneleri almak için list() kullanabilirsiniz.
+list(dolu_sozl.keys()) #=> Returns ["bir", "iki", "uc"]
+
+
+####################################################
+## 4. Fonksiyonlar
+####################################################
+
+# "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
+
+# Fonksiyonu parametleri ile çağırıyoruz
+topla(5, 6) # => çıktı "x = 5 ve y = 6" ve değer olarak 11 döndürür
+
+# 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.
+
+# Sınırsız sayıda argüman da alabilirsiniz
+def argumanlar(*argumanlar):
+ return argumanlar
+
+argumanlar(1, 2, 3) # => (1, 2, 3)
+
+# Parametrelerin anahtar değerlerini almak isterseniz
+def anahtar_par(**anahtarlar):
+ return anahtar
+
+# Çalıştırdığımızda
+anahtar_par(anah1="deg1", anah2="deg2") # => {"anah1": "deg1", "anah2": "deg2"}
+
+
+# İsterseniz, bu ikisini birden kullanabilirsiniz
+def tum_argumanlar(*argumanlar, **anahtarla):
+ print(argumanlar)
+ print(anahtarla)
+"""
+tum_argumanlar(1, 2, a=3, b=4) çıktı:
+ (1, 2)
+ {"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)
+
+
+# Fonksiyonlarda kullanacağımız bir değişken oluşturalım
+x = 5
+
+def belirleX(sayi):
+ # Fonksiyon içerisindeki x ile global tanımladığımız x aynı değil
+ x = sayi # => 43
+ print (x) # => 43
+
+def globalBelirleX(sayi):
+ global x
+ print (x) # => 5
+ x = sayi # global olan x değişkeni artık 6
+ print (x) # => 6
+
+belirleX(43)
+globalBelirleX(6)
+
+
+# Sınıf fonksiyonları oluşturma
+def toplama_olustur(x):
+ def topla(y):
+ return x + y
+ return topla
+
+ekle_10 = toplama_olustur(10)
+ekle_10(3) # => 13
+
+# Bilinmeyen fonksiyon
+(lambda x: x > 2)(3) # => True
+
+# TODO - Fix for iterables
+# 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]
+
+# 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]
+
+####################################################
+## 5. Sınıflar
+####################################################
+
+
+# Sınıf oluşturmak için objeden alt sınıf oluşturacağız.
+class Insan(obje):
+
+ # Sınıf değeri. Sınıfın tüm nesneleri tarafından kullanılabilir
+ tur = "H. sapiens"
+
+ # 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
+
+ # 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)
+
+ # Bir sınıf metotu bütün nesnelere paylaştırılır
+ # İlk parametre olarak sınıf alırlar
+ @classmethod
+ def getir_tur(snf):
+ return snf.tur
+
+ # Bir statik metot, sınıf ve nesnesiz çağrılır
+ @staticmethod
+ def grunt():
+ return "*grunt*"
+
+
+# Sınıfı çağıralım
+i = Insan(isim="Ahmet")
+print(i.soyle("merhaba")) # çıktı "Ahmet: merhaba"
+
+j = Insan("Ali")
+print(j.soyle("selam")) # çıktı "Ali: selam"
+
+# Sınıf metodumuzu çağıraim
+i.getir_tur() # => "H. sapiens"
+
+# Paylaşılan değeri değiştirelim
+Insan.tur = "H. neanderthalensis"
+i.getir_tur() # => "H. neanderthalensis"
+j.getir_tur() # => "H. neanderthalensis"
+
+# Statik metodumuzu çağıralım
+Insan.grunt() # => "*grunt*"
+
+
+####################################################
+## 6. Moduller
+####################################################
+
+# Modülleri içe aktarabilirsiniz
+import math
+print(math.sqrt(16)) # => 4
+
+# Modülden belirli bir fonksiyonları alabilirsiniz
+from math import ceil, floor
+print(ceil(3.7)) # => 4.0
+print(floor(3.7)) # => 3.0
+
+# Modüldeki tüm fonksiyonları içe aktarabilirsiniz
+# Dikkat: bunu yapmanızı önermem.
+from math import *
+
+# 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 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.
+
+# Moduldeki fonksiyon ve değerleri öğrenebilirsiniz.
+import math
+dir(math)
+
+
+####################################################
+## 7. Gelişmiş
+####################################################
+
+# 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
+
+# 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)
+# 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
+
+
+# Dekoratörler
+# Bu örnekte,
+# Eğer lutfen_soyle True ise dönen değer değişecektir.
+from functools import wraps
+
+
+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 metot
+
+
+@yalvar
+def soyle(lutfen_soyle=False):
+ msj = "Bana soda alır mısın?"
+ return msj, lutfen_soyle
+
+
+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 :(
+```
+
+## Daha Fazlasına Hazır Mısınız?
+
+### Ücretsiz 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)
+
+### 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)
+* [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)
+
diff --git a/tr-tr/swift-tr.html.markdown b/tr-tr/swift-tr.html.markdown
new file mode 100644
index 00000000..c13f5ecf
--- /dev/null
+++ b/tr-tr/swift-tr.html.markdown
@@ -0,0 +1,588 @@
+---
+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.
+
+
+Apple'ın resmi [Swift Programlama Dili](https://itunes.apple.com/us/book/swift-programming-language/id881256329) kitabı iBooks'ta yerini aldı.
+
+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...) {
+ // bu bir dizidir
+ 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
+```