├── .gitattributes ├── .gitignore ├── LICENCE ├── README.md └── python_tutorial ├── data_types ├── binary_types │ ├── bytearrays.md │ ├── bytes.md │ ├── memoryview.md │ └── pics │ │ ├── 1.png │ │ └── 2.png ├── boolean_types │ └── boolean_types.md ├── mapping_types │ └── dictionary.md ├── numeric_types │ └── numeric_types.md ├── sequence_types │ ├── list.md │ ├── range.md │ ├── sequence_type_info.md │ └── tuple.md ├── set_types │ ├── frozenset.md │ ├── pics │ │ ├── 1.png │ │ ├── 10.png │ │ ├── 11.png │ │ ├── 2.png │ │ ├── 3.png │ │ ├── 4.png │ │ ├── 5.png │ │ ├── 6.png │ │ ├── 7.png │ │ ├── 8.png │ │ └── 9.png │ └── set.md └── text_types │ ├── character_encoding.md │ ├── escape_sequences.md │ ├── pics │ └── 1.jpg │ └── strings.md ├── external_resources_operations ├── file_operations.md ├── pics │ ├── 1.png │ ├── 2.png │ ├── 3.png │ ├── 4.png │ ├── 5.png │ ├── 6.png │ └── 7.png └── with_ve_context_manager.md ├── functions ├── build-in_functions.md ├── comprehension.md ├── decorators.md ├── functions.md ├── generators.md ├── iterators.md └── pics │ └── 1.png ├── import_system ├── modules.md └── packets.md ├── modules ├── json │ └── genel.md └── numpy │ ├── arithmetic_functions.md │ ├── array_creation.md │ ├── array_manipulation.md │ ├── binary_functions.md │ ├── broadcasting.md │ ├── copy_view.md │ ├── functions_for_rounding.md │ ├── i_o_operations.md │ ├── indexing_slicing.md │ ├── iterating_over_array.md │ ├── linear_algebra.md │ ├── matplotlib.md │ ├── matrix_library.md │ ├── ndarray_attributes.md │ ├── ndarray_object.md │ ├── numpy_data_types.md │ ├── pics │ ├── 1.jpg │ ├── 2.png │ ├── 3.png │ ├── 4.png │ ├── 5.png │ ├── 6.png │ └── 7.png │ ├── sort_search_counting_functions.md │ ├── statistical_functions.md │ ├── string_functions.md │ ├── trigonometric_functions.md │ └── what_is_numpy.md ├── opp ├── Inheritance.md ├── abstract.md ├── beginning_of_classes.md ├── class_members.md ├── composition.md ├── pics │ ├── 1.png │ ├── 10.png │ ├── 11.png │ ├── 12.png │ ├── 2.png │ ├── 3.png │ ├── 4.png │ ├── 5.png │ ├── 6.png │ ├── 7.png │ ├── 8.png │ └── 9.png ├── property.md └── what_is_object.md └── temel_bilgiler ├── basic_concepts.md ├── error_catching.md ├── if-elif-else.md ├── operators.md ├── pics ├── 1.png ├── 2.png ├── 3.png ├── 4.png ├── 5.png └── 6.png ├── print_and_input.md ├── statements_expressions_keywords.md └── while-for_loops.md /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | python_tutorial/modules/django/ 2 | python_tutorial/modules/mysql/ 3 | python_tutorial/modules/pyqt6/ 4 | python_tutorial/modules/sqlite/ -------------------------------------------------------------------------------- /LICENCE: -------------------------------------------------------------------------------- 1 | This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License. 2 | To view a copy of this license, visit https://creativecommons.org/licenses/by-nc-sa/4.0/. -------------------------------------------------------------------------------- /python_tutorial/data_types/binary_types/memoryview.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Python Buffer Protocol](#1) 4 | - [Bellek Görüntüsü (Memoryview)](#2) 5 | - [Memoryview Methodları](#2.1) 6 | - [`cast(format, shape)` Methodu](#2.1.1).1.1) 7 | - [`contiguous` Methodu](#2.1.2) 8 | - [`c_contiguous` Methodu](#2.1.2.1) 9 | - [`f_contiguous` Methodu](#2.1.2.2) 10 | - [`format` Methodu](#2.1.3) 11 | - [`hex(sep, bytes_per_sep)` Methodu](#2.1.4) 12 | - [`itemsize` Methodu](#2.1.5) 13 | - [`nbytes` Methodu](#2.1.6) 14 | - [`ndim` Methodu](#2.1.7) 15 | - [`obj` Methodu](#2.1.8) 16 | - [`readonly` Methodu](#2.1.9) 17 | - [`release()` Methodu](#2.1.10) 18 | - [`shape` Methodu](#2.1.11) 19 | - [`strides` Methodu](#2.1.12) 20 | - [`suboffsets` Methodu](#2.1.13) 21 | - [`tobytes(order=None)` Methodu](#2.1.14).1.14) 22 | - [`tolist()` Methodu](#2.1.15) 23 | - [`toreadonly()` Methodu](#2.1.16) 24 | 25 |

Python Buffer Protocol

26 | 27 | Buffer protocol, bir objenin internal data'sına (dahili veri) erişmenin (access) bir yolunu sağlar. Bu internal data bir memory array veya buffer'dır. Buffer protocol, bir objenin internal data'sını (buffer'lar) açığa çıkarmasına (expose) ve diğerlerini intermediate copying olmadan bu buffer'lara erişmesine (access) izin verir. Bu protocol'e yalnızca [C-API](https://docs.python.org/3/c-api/ "https://docs.python.org/3/c-api/") düzeyinde erişilebilir ve normal codebase'i kullanmaz. Bu nedenler aynı protocol'ü normal Python codebase'e maruz bırakmak için (in order to expose) memoryview mevcuttur. 28 | 29 | Memoryview, Python'da buffer protocol'ünü ortaya çıkarmanın (expose) güvenli bir yoludur. Memoryview, bir `memoryview` objesi oluşturarak bir objenin internal buffer'larına erişmenizi sağlar. 30 | 31 | Buffer protocol ve Memoryview neden önemlidir? Bir obje üzerinde herhangi bir eylem (bir objenin fonksiyonunu çağırmak (call) veya bir array'ı dilimlemek) gerçekleştirdiğimizde, Python'un o objenin bir kopyasını oluşturması gerektiğini hatırlamamız gerekir. Büyük data'larla çalışıyorsanız (örneğin bir image'in binary data'ları), neredeyse hiçbir işe yaramayan büyük data yığınlarının (huge chunks of data) gereksiz yere kopyalarını oluştururuz. Buffer protocol'ünü kullanarak, büyük data'ları kopyalamadan use/modify işlemleri için başka bir objeye erişim verebiliriz. Bu da programın daha hızlı çalışmasını sağlar. Buralar işin teknik kısmı. Şimdi anlayabileceğimiz dilden anlatayım. 32 | 33 | Bir array düşünün. Array'e element (item) eklemek için her defasında boyutunu yükseltmeniz gerekir (örneğin 10'luk bir array'e 11. elementi eklemek için o array'in boyutunu 11'e yükseltmeniz gerekir). Bu işlemi her defasında baştan tekrar tekrar yapmak sisteme ek iş yükü bindirir. Buffer protocol, bellekten (memory) örneğin 100 elementlik bir buffer alır ve array'e her element eklediğinizde yeniden boyutlandırma işlemi yapmaktan sistemi kurtarır. Bu durum sistemi ek iş yükünden kurtardığı için hız konusunda bir kazanç sağlasa da bellekten (memory) yer çalar (çünkü örneğin 100'lük yer alıp 10 kullanırsanız, 90 yeri boşuna işgal etmiş olursunuz). Bu yüzden buffer kullandırken atanan boyutun tamamını kullanmaya dikkat etmeliyiz. Yani Buffer protocol'ünü kullanırsan, büyük data'larla uğraşırken (use/modify işlemleri yaparken) o büyük data'lar buffer sınırları içerisindeyse, büyük data'ları kopyalarken falan boyut adaptasyonu ile uğraşmana gerek kalmaz. 34 | 35 |

Bellek Görüntüsü (Memoryview)

36 | 37 | `memoryview(object)` fonksiyonu, `object` parametresine argüman olarak girilen objenin bellek görünümü nesnesini (memoryview object) döndürür. `memoryview` fonksiyonu argüman olarak sadece [bytes-like object](https://docs.python.org/3/glossary.html#term-bytes-like-object "https://docs.python.org/3/glossary.html#term-bytes-like-object") (`bytes`, `bytearray`) kabul eder. Örnek: 38 | ```py 39 | print(memoryview(b'abcefg')) # Output: 40 | ``` 41 | Daha fazla bilgi için: 42 | - [Memoryview Type](https://docs.python.org/3/library/stdtypes.html#memoryview) 43 | - [Programiz Memoryview Function](https://www.programiz.com/python-programming/methods/built-in/memoryview) 44 | 45 | **Not:** Memoryview konusu low level (C-like) dilleri alakadar eden bir konudur. Python high level bir dil olduğu için alakadar etmez. `memoryview` konusunun bellek seviyesinde çalışmayacakların pek işine yarayacağını düşünmediğim için bu başlığın detaylarına inmeyeceğim. Bellek seviyesinde çalışmak isteyenler seri bir şekilde bu tutorial'ı kapatıp C-like dillere yönelsinler. Buradan sonraki başlıklarda sadece kaynak linki vereceğim, açıklama olmayacak. 46 | 47 |

Memoryview Methodları

48 | 49 |

cast(format, shape) Methodu

50 | 51 | Bilgi için [tıklayınız](https://docs.python.org/3/library/stdtypes.html#memoryview.cast). 52 | 53 |

contiguous Methodu

54 | 55 | Bilgi için [tıklayınız](https://docs.python.org/3/library/stdtypes.html#memoryview.contiguous "https://docs.python.org/3/library/stdtypes.html#memoryview.contiguous"). 56 | 57 |

c_contiguous Methodu

58 | 59 | Bilgi için [tıklayınız](https://docs.python.org/3/library/stdtypes.html#memoryview.c_contiguous "https://docs.python.org/3/library/stdtypes.html#memoryview.c_contiguous") 60 | 61 |

f_contiguous Methodu

62 | 63 | Bilgi için [tıklayınız](https://docs.python.org/3/library/stdtypes.html#memoryview.f_contiguous "https://docs.python.org/3/library/stdtypes.html#memoryview.f_contiguous") 64 | 65 |

format Methodu

66 | 67 | Bilgi için [tıklayınız](https://docs.python.org/3/library/stdtypes.html#memoryview.format "https://docs.python.org/3/library/stdtypes.html#memoryview.format"). 68 | 69 |

hex(sep, bytes_per_sep) Methodu

70 | 71 | Bilgi için [tıklayınız](https://docs.python.org/3/library/stdtypes.html#memoryview.hex "https://docs.python.org/3/library/stdtypes.html#memoryview.hex"). 72 | 73 |

itemsize Methodu

74 | 75 | Bilgi için [tıklayınız](https://docs.python.org/3/library/stdtypes.html#memoryview.itemsize "https://docs.python.org/3/library/stdtypes.html#memoryview.itemsize"). 76 | 77 |

nbytes Methodu

78 | 79 | Bilgi için [tıklayınız](https://docs.python.org/3/library/stdtypes.html#memoryview.nbytes "https://docs.python.org/3/library/stdtypes.html#memoryview.nbytes"). 80 | 81 |

ndim Methodu

82 | 83 | Bilgi için [tıklayınız](https://docs.python.org/3/library/stdtypes.html#memoryview.ndim "https://docs.python.org/3/library/stdtypes.html#memoryview.ndim"). 84 | 85 |

obj Methodu

86 | 87 | Bilgi için [tıklayınız](https://docs.python.org/3/library/stdtypes.html#memoryview.obj "https://docs.python.org/3/library/stdtypes.html#memoryview.obj"). 88 | 89 |

readonly Methodu

90 | 91 | Bilgi için [tıklayınız](https://docs.python.org/3/library/stdtypes.html#memoryview.readonly "https://docs.python.org/3/library/stdtypes.html#memoryview.readonly"). 92 | 93 |

release() Methodu

94 | 95 | Bilgi için [tıklayınız](https://docs.python.org/3/library/stdtypes.html#memoryview.release "https://docs.python.org/3/library/stdtypes.html#memoryview.release"). 96 | 97 |

shape Methodu

98 | 99 | Bilgi için [tıklayınız](https://docs.python.org/3/library/stdtypes.html#memoryview.shape "https://docs.python.org/3/library/stdtypes.html#memoryview.shape"). 100 | 101 |

strides Methodu

102 | 103 | Bilgi için [tıklayınız](https://docs.python.org/3/library/stdtypes.html#memoryview.strides "https://docs.python.org/3/library/stdtypes.html#memoryview.strides"). 104 | 105 |

suboffsets Methodu

106 | 107 | Bilgi için [tıklayınız](https://docs.python.org/3/library/stdtypes.html#memoryview.suboffsets "https://docs.python.org/3/library/stdtypes.html#memoryview.suboffsets"). 108 | 109 |

tobytes(order=None) Methodu

110 | 111 | Bilgi için [tıklayınız](https://docs.python.org/3/library/stdtypes.html#memoryview.tobytes "https://docs.python.org/3/library/stdtypes.html#memoryview.tobytes"). 112 | 113 |

tolist() Methodu

114 | 115 | Bilgi için [tıklayınız](https://docs.python.org/3/library/stdtypes.html#memoryview.tolist "https://docs.python.org/3/library/stdtypes.html#memoryview.tolist"). 116 | 117 |

toreadonly() Methodu

118 | 119 | Bilgi için [tıklayınız](https://docs.python.org/3/library/stdtypes.html#memoryview.toreadonly "https://docs.python.org/3/library/stdtypes.html#memoryview.toreadonly") 120 | 121 | 122 | -------------------------------------------------------------------------------- /python_tutorial/data_types/binary_types/pics/1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/data_types/binary_types/pics/1.png -------------------------------------------------------------------------------- /python_tutorial/data_types/binary_types/pics/2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/data_types/binary_types/pics/2.png -------------------------------------------------------------------------------- /python_tutorial/data_types/boolean_types/boolean_types.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | - [`bool(x)` Fonksiyonu](#1) 3 | - [Boolean Type Fonksiyonları](#1.1) 4 | - [`as_integer_ratio()` Methodu](#1.1.1) 5 | - [`bit_length()` Methodu](#1.1.2) 6 | - [`to_bytes(length, byteorder, signed=False)` Methodu](#1.1.3) 7 | - [`from_bytes(bytes, byteorder, signed=False)` Methodu](#1.1.4) 8 | - [`conjugate()` Methodu](#1.1.5) 9 | - [`denominator` Methodu](#1.1.6) 10 | - [`numerator` Methodu](#1.1.7) 11 | - [`imag()` Methodu](#1.1.8) 12 | - [`real()` Methodu](#1.1.9) 13 | 14 |

bool(x) Fonksiyonu

15 | 16 | `x` parametresine girilen argümanın boolean karşılığınız verir. Bu argüman [truth testing procedure](https://docs.python.org/3/library/stdtypes.html#truth "https://docs.python.org/3/library/stdtypes.html#truth")'e göre dönüştürülür. Eğer `x` parametresine `False` ya da `False` değerine karşılık gelen bir ifade (`""`, 0 vs.) girilmişse ya da bir değer girilmemişse (**omitted**, yani ihmal etmek) `False`; aksi taktirde `True` döndürür. `bool` class'ı, `int` class'ının subclass'ıdır. Bu yüzden daha fazla subclass'landırılamaz. Daha fazla bilgi için [tıklayınız](https://docs.python.org/3/library/functions.html#bool "https://docs.python.org/3/library/functions.html#bool"). 17 | 18 |

Boolean Type Methodları

19 | 20 |

as_integer_ratio() Methodu

21 | 22 | Birbirine bölündüğünde uygulandığı boolean değeri veren iki sayı döndürür. Bu iki sayı `tuple` içinde döndürülür. Örnek: 23 | ```py 24 | print(True.as_integer_ratio()) # Output: (1, 1) 25 | print(False.as_integer_ratio()) # Output: (0, 1) 26 | ``` 27 | 28 |

bit_length() Methodu

29 | 30 | `bit_length()` methodu, uygulandığı boolean değerin bit uzunluğunu döndürür. `bin()` fonksiyonu, kendisine argüman olarak verilen integer'ın bit karşılığını döndürür (Örnek: `print(bin(True))`: `0b1`). `len(bin()[2:])` kodu ile `bit_length()` methodunun yaptığı iş benzer gibi gözüksede kesinlikle birbiri yerine kullanılamaz. Örnek: 31 | ```py 32 | print(True.bit_length()) # Output: 1 (`1` 1 birim uzunluğundadır) 33 | print(False.bit_length()) # Output: 0 (`0` 0 birim uzunluğundadır) 34 | print(len(bin(True)[2:])) # Output: 1 (`1` 1 birim uzunluğundadır) 35 | print(len(bin(False)[2:])) # Output: 1 (`1` 1 birim uzunluğundadır) 36 | print(len(bin(True))) # Output: 3 (`0b1` 1 birim uzunluğundadır) 37 | print(len(bin(False))) # Output: 3 (`0b0` 1 birim uzunluğundadır) 38 | ``` 39 | `False` değerinin binary değeri `0b0`'dır. Bu değer yokluğu temsil ettiği için `bit_length` methodu doğru sonuç olan `0`'ı döndürür. Ama `len(bin()[2:])` kodu sadece `0b`'dan sonra bir şey olup olmadığına baktığı için istenilen sonucu vermez. 40 | 41 |

to_bytes(length, byteorder, signed=False) Methodu

42 | 43 | Uygulandığı boolean değeri temsil eden byte array döndürür. Örnek: 44 | ```py 45 | print(True.to_bytes(1, byteorder='big')) # Output: b'\x01' 46 | print(False.to_bytes(1, byteorder='big')) # Output: b'\x00' 47 | ``` 48 | Boolean değerler length bytes kullanılarak temsil edilir. `to_bytes` methodunun uygulandığı boolean değer, en az `length` parametresinde argüman olarak girilen integer'ın belirttiği uzunluk kadar olmalı. `length` parametresinde argüman olarak girilen boolean değerden daha uzun olursa, fazlalıklar null (`b'\x00'`) ile doldurur; kısa olursa, `OverflowError: int too big to convert` hatası yükseltilir. Zaten boolean değerler maksimum 1, minimum 0 uzunluğunda olabilir. Örnek: 49 | ```py 50 | print(True.to_bytes(1, byteorder='big')) # Output: b'\x01' 51 | print(True.to_bytes(0, byteorder='big')) # OverflowError: int too big to convert 52 | print(False.to_bytes(1, byteorder='big')) # Output: b'\x00' 53 | print(False.to_bytes(0, byteorder='big')) # Output: b'' 54 | ``` 55 | `False` değeri yokluğu ifade ettiği için `length` parametresinde argüman olarak `0` integer'ını girmemiz bir soruna neden olmaz ve boşluklar null `\x00` ile doldurulur. 56 | 57 | `byteorder` parametresine girilen argüman ile `to_bytes` methodunun uygulandığı boolean değeri temsil etmek için kullanılan bayt sırasını (order) belirlenir. `byteorder` parametresine argüman olarak `"big"` girilirse, en önemli byte (the most significant byte) byte array'ın başında, `"little"` girilirse, en önemli byte (the most significant byte) byte array'ın sonunda olur. `big` ve `little` bir nevi birbirinin aynalanmış halidir. Örnek: 58 | ```py 59 | print(True.to_bytes(10, byteorder='big')) # Output: b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01' 60 | print(True.to_bytes(10, byteorder='little')) # Output: b'\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00' 61 | print(False.to_bytes(10, byteorder='big')) # Output: b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' 62 | print(False.to_bytes(10, byteorder='little')) # Output: b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' 63 | ``` 64 | `signed` parametresine girilen argüman ile, `to_bytes` methodunun uygulandığı boolean değerin negatif mi pozitif mi olduğunu belirtirsiniz. Default değeri `False`'dır ve pozitif sayıları ifade eder. `True` ise negatif sayıları temsil eder. `signed` parametresine argüman olarak `True` verip, bu methodu pozitif bir sayıya uygularsınız `OverflowError` hatası alırsınız. Örnek: 65 | ```py 66 | print(True.to_bytes(1, byteorder='big', signed=False)) # Output: b'\x01' 67 | print(False.to_bytes(1, byteorder='big', signed=True)) # Output: b'\x00' 68 | print(False.to_bytes(1, byteorder='big', signed=False)) # Output: b'\x00' 69 | ``` 70 | Boolean değerler sadece `True` ve `False`'dan ibarettir. Bu yüzden `signed` parametresi herhangi bir şeye etki etmez çünkü etki edecek karmaşıklıkta bir şey yok ortada. Sadece `True` ve `False` var. 71 | 72 |

from_bytes(bytes, byteorder, signed=False) Methodu

73 | 74 | `bytes` parametresine argüman olarak girilen byte array'ı temsil eden boolean değeri döndürür. `from_bytes` methodu bir class method olduğu için direkt `bool` class'ına veya boolean type bir objeye uygulanabilir. Örnek: 75 | ```py 76 | print(bool.from_bytes(b'\x01', byteorder='big')) # Output: True 77 | print(bool.from_bytes(b'\x00', byteorder='big')) # Output: False 78 | ``` 79 | `bytes` parametresine girilen argüman [bytes-like object](https://docs.python.org/3/glossary.html#term-bytes-like-object "https://docs.python.org/3/glossary.html#term-bytes-like-object") veya bir iterable producing bytes olabilir. Örnek: 80 | ```py 81 | print(bool.from_bytes(b'\x04\x00', byteorder='big')) # Output: True 82 | print(bool.from_bytes([255, 0, 0], byteorder='big')) # Output: True 83 | 84 | print(bool.from_bytes(b'\x00', byteorder='big')) # Output: False 85 | print(bool.from_bytes([0, 0, 0], byteorder='big')) # Output: False 86 | ``` 87 | `byteorder` parametresine girilen argüman ile, `bytes` parametresine argüman olarak girilen bytes objesinin bayt sırasını (order) belirler. `byteorder` parametresine argüman olarak `"big"` girilirse, en önemli byte (the most significant byte) byte array'ın başında, `"little"` girilirse, en önemli byte (the most significant byte) byte array'ın sonunda olur. `big` ve `little` bir nevi birbirinin aynalanmış halidir. Örnek: 88 | ```py 89 | print(bool.from_bytes(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01', byteorder='big')) # Output: True 90 | print(bool.from_bytes(b'\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00', byteorder='little')) # Output: True 91 | ``` 92 | `signed` parametresine girilen argüman ile, `to_bytes` methodunun uygulandığı integer'ın negatif mi pozitif mi olduğunu belirtirsiniz. Default değeri `False`'dır ve pozitif sayıları ifade eder. `True` ise negatif sayıları temsil eder ama boolean değerler için buna gerek yoktur çünkü sadece `True` ve `False` vardır. Örnek: 93 | ```py 94 | print(bool.from_bytes(b'\x01', byteorder='big', signed=True)) # Output: True 95 | print(bool.from_bytes(b'\x01', byteorder='big', signed=False)) # Output: True 96 | print(bool.from_bytes(b'\x00', byteorder='big', signed=True)) # Output: False 97 | print(bool.from_bytes(b'\x00', byteorder='big', signed=False)) # Output: False 98 | ``` 99 | 100 |

conjugate() Methodu

101 | 102 | Herhangi bir float'ın complex eşleniği (conjugate) olan `self`'i (yani uygulandığı boolean değeri) döndürür. Örnek: 103 | ```py 104 | print(True.conjugate()) # Output: 1 105 | print(False.conjugate()) # Output: 0 106 | ``` 107 | 108 |

denominator Methodu

109 | 110 | Uygulandığı boolean değerin en küçük terimli paydasını içeren property'dir (ne olduğu class'lar konusunda anlatılacak. şimdilik bir değeri tutan variable olarak düşünün). Boolean değerlerin paydası 1 olduğu için her zaman 1 döndürür. Örnek: 111 | ```py 112 | print(True.denominator) # Output: 1 113 | print(False.denominator) # Output: 1 114 | ``` 115 | 116 |

numerator Methodu

117 | 118 | Uygulandığı boolean değerin en küçük terimli payını içeren property'dir (ne olduğu class'lar konusunda anlatılacak. şimdilik bir değeri tutan variable olarak düşünün). Uygulandığı boolean değerin paydası kendisi olduğu için uygulandığı boolean değerin döndürür. Örnek: 119 | ```py 120 | print(True.numerator) # Output: 1 121 | print(False.numerator) # Output: 0 122 | ``` 123 | 124 |

imag() Methodu

125 | 126 | Uygulandığı boolean değerin `imag` (sanal) kısmını içeren bir property'dir (ne olduğu class'lar konusunda anlatılacak. şimdilik bir değeri tutan variable olarak düşünün). Örnek: 127 | ```py 128 | print(complex(True)) # Output: (1+0j) 129 | print(True.imag) # Output: 0 130 | 131 | print(complex(False)) # Output: 0j 132 | print(False.imag) # Output: 0 133 | ``` 134 | 135 |

real() Methodu

136 | 137 | Uygulandığı boolean değerin `real` (gerçek) kısmını içeren bir property'dir (ne olduğu class'lar konusunda anlatılacak. şimdilik bir değeri tutan variable olarak düşünün). Örnek: 138 | ```py 139 | print(complex(True)) # Output: (1+0j) 140 | print(True.real) # Output: 1 141 | 142 | print(complex(False)) # Output: 0j 143 | print(False.real) # Output: 0 144 | ``` 145 | -------------------------------------------------------------------------------- /python_tutorial/data_types/sequence_types/range.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Range](#1) 4 | - [Range Methodları](#1.1) 5 | - [`index(value)` Methodu](#1.1.1) 6 | - [`count(value)` Methodu](#1.1.2) 7 | 8 |

Range

9 | 10 | Range, belli bir sayısal aralığı temsil eden spesifik obje türüne verilen isimdir. `range()` build-in fonksiyonu ile range objeleri yaratabilirsiniz. `range(start=0, stop, step=1)` syntax'ına sahip bu fonksiyonuna girilen argümanlar integer type ya da `__index__` methodu uygulanmış (implement) bir obje olabilir. 11 | - `start` parametresine girilen integer type argüman, başlangıç değerini ifade eder ve dahil edilir. Örneğin `print(tuple(range(2,5))) # Output: (2,3,4)` gördüğünüz gibi start parametresine girilen `2` dahil edilmiş. `start` parametresi girilmezse (omitted, ihmal etmek) bu parametre default değeri olan `0`'ı kullanır. 12 | - `stop` parametresine girilen integer type argüman, bitiş değerini ifade eder ve dahil edilmez. Örneğin `print(tuple(range(2,5))) # Output: (2,3,4)` gördüğünüz gibi stop parametresine girilen `5` dahil edilmiş. 13 | - `step` parametresine girilen integer type argüman, atlama değerini ifade eder. `step` parametresi girilmezse (omitted, ihmal etmek) bu parametre default değeri olan `1`'ı kullanır. Bu parametre `0` olarak girilirse `ValueError: range() arg 3 must not be zero` hatası yükseltilir çünkü matematiksel olarak bir sayıya `0` ekleyerek o sayıyı arttıramadığınız için `range()` fonksiyonunun amacına aykırı bir durum oluşuyor ve hata yükseltiliyor. 14 | - `step` pozitif bir değer olursa, bir `r` varaible'ına atanmış `range()` fonksiyonunun her bir öğesi `i >= 0` ve `r[i] < stop` olmak üzere, `r[i] = start + step*i` formülü ile hesaplanır. Örnek: 15 | ``` 16 | `i >= 0` ve `r[i] < stop` olmak üzere, `r[i] = start + step*i` 17 | 18 | range(0,5,1) -> 0, 1, 2, 3, 4 19 | 20 | `0 >= 0` ve `r[0] < 5` -> 0 < 5 olmak üzere, `r[0] = 0 + 1*0` -> 0 = 0 + 1*0` √ 21 | `1 >= 0` ve `r[1] < 5` -> 1 < 5 olmak üzere, `r[1] = 0 + 1*1` -> 1 = 0 + 1*1` √ 22 | `2 >= 0` ve `r[2] < 5` -> 2 < 5 olmak üzere, `r[2] = 0 + 1*2` -> 2 = 0 + 1*2` √ 23 | `3 >= 0` ve `r[3] < 5` -> 3 < 5 olmak üzere, `r[3] = 0 + 1*3` -> 3 = 0 + 1*3` √ 24 | `4 >= 0` ve `r[4] < 5` -> 4 < 5 olmak üzere, `r[4] = 0 + 1*4` -> 4 = 0 + 1*4` √ 25 | `5 >= 0` ve `r[5] < 0` -> 5 < 5 olmak üzere, `r[5] = 0 + 1*5` -> 5 = 0 + 1*5` X (5 < 5 sağlamadığı için r[5] dahil edilmez.) 26 | 27 | Not: 5 < 5 sağlamadığı için r[5] dahil edilmez. 28 | ``` 29 | - `step` negatif bir değer olursa, bir `r` variable'ına atanmış `range()` fonksiyonunun her bir öğesi `i >= 0` ve `r[i] > stop` olmak üzere, `r[i] = start + step*i` formülü ile hesaplanır. Örnek: 30 | ``` 31 | `i >= 0` ve `r[i] > stop` olmak üzere, `r[i] = start + step*i` 32 | 33 | range(5,0,-1) -> 5, 4, 3, 2, 1 34 | 35 | `0 >= 0` ve `r[0] > 0` -> 5 > 0 olmak üzere, `r[0] = 5 + -1*0` -> 5 = 5 + -1*0` √ 36 | `1 >= 0` ve `r[1] > 0` -> 4 > 0 olmak üzere, `r[1] = 5 + -1*1` -> 4 = 5 + -1*1` √ 37 | `2 >= 0` ve `r[2] > 0` -> 3 > 0 olmak üzere, `r[2] = 5 + -1*2` -> 3 = 5 + -1*2` √ 38 | `3 >= 0` ve `r[3] > 0` -> 2 > 0 olmak üzere, `r[3] = 5 + -1*3` -> 2 = 5 + -1*3` √ 39 | `4 >= 0` ve `r[4] > 0` -> 1 > 0 olmak üzere, `r[4] = 5 + -1*4` -> 1 = 5 + -1*4` √ 40 | `5 >= 0` ve `r[5] > 0` -> 0 > 0 olmak üzere, `r[5] = 5 + -1*5` -> 1 = 5 + -1*5` X (0 > 0 sağlamadığı için r[5] dahil edilmez.) 41 | ``` 42 | - `range(0,5,-1)` ve `range(5,0,1)` gibi tanımlanmış fonksiyonlar yukarıda bahsedilen formülleri sağlamadığı için boş kümedir, dolayısıyla bunları liste veya tuple'a dönüştürmek isterseniz elinize boş liste ve tuple geçer. Bu yüzden `start`, `stop` ve `step` parametrelerine argüman girerken bu förmüle uymasına dikkat edin. 43 | 44 | `range()` fonksiyonu örnekleri: 45 | ```py 46 | print(list(range(10))) # Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 47 | print(list(range(1, 11))) # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 48 | print(list(range(0, 30, 5))) # Output: [0, 5, 10, 15, 20, 25] 49 | print(list(range(0, 10, 3))) # Output: [0, 3, 6, 9] 50 | print(list(range(0, -10, -1))) # Output: [0, -1, -2, -3, -4, -5, -6, -7, -8, -9] 51 | 52 | print(list(range(0))) # Output: [] 53 | print(list(range(0, 10, -1))) # Output: [] 54 | print(list(range(10, 0, 1))) # Output: [] 55 | ``` 56 | 57 | **Not:** `sys.maxsize`, `Py_ssize_t` type bir variable'ın alabileceği max sayıdır. Yani işletim sisteminin bit'lerle ifade edebileceği max büyüklükteki sayıdır. 32 bir sistemlerde `2**31 - 1`, 64 bir sistemlerde `2**63 - 1` kadardır. `sys.maxsize` değerinden daha büyük büyük sayılara izin verilir ama `len()` gibi bazı özellikler (features) `OverflowError` hatasına neden olabilir. Örnek: 58 | ```py 59 | print(range(2**63-1)) # Output: range(0, 9223372036854775807) 60 | print(range(2**63)) # Output: range(0, 9223372036854775808) 61 | print(range(2**64)) # Output: range(0, 18446744073709551616) 62 | print(range(2**128)) # Output: range(0, 340282366920938463463374607431768211456) 63 | print(len(range(2**63-1))) # Output: 9223372036854775807 64 | print(len(range(2**63))) # OverflowError: Python int too large to convert to C ssize_t 65 | ``` 66 | 67 | **Not:** `range`'ler, concatenation ve repetition dışında tüm [common sequence operation'ları](https://docs.python.org/3/library/stdtypes.html?highlight=range#typesseq-common "https://docs.python.org/3/library/stdtypes.html?highlight=range#typesseq-common") uygular (implement). Çünkü range obje'leri yalnızca strict bir pattern'i takip eden sequence'ları takip edebilir. Concatenation ve repetition genellikle bu pattern'leri ihlal eder (violate). Burası baya ayrıntı. Merak ettiyseniz terimleri kendiniz araştırabilirsiniz. 68 | 69 | **Not:** `range` type'ın `list` ya da `tuple` type'dan avantajlı olmasının sebebi, `range` type sadece `start`, `stop` ve `step` verilerini tuttuğu için `range(0,1,1)` objesi ile `range(0,255,1)` objesinin bellek boyutu aynıdır ama `list(range(0,1,1))` ile `list(range(0,255,1))`'in boyutu aynı değildir. 70 | ```py 71 | print(list(range(0,1,1)).__sizeof__()) # Output: 48 72 | print(list(range(0,9999,1)).__sizeof__()) # Output: 80048 73 | print(range(0,1,1).__sizeof__()) # Output: 48 74 | print(range(0,9999,1).__sizeof__()) # Output: 48 75 | 76 | print(range(2**63-1)) # Output: range(0, 9223372036854775807) 77 | print(list(range(2**63-1))) # MemoryError 78 | ``` 79 | 80 | **Not:** Range objeleri, diğer [Sequence Types](https://docs.python.org/3/library/stdtypes.html?highlight=range#typesseq) objelere dönüştürebilir, membership (`in`) operator'ı ile içeriğine erişebilir ve index'lenebilir (negatif index'lemeyi destekler). Daha fazla bilgi için [tıklayınız](https://newbedev.com/does-range-really-create-lists). 81 | ```py 82 | print(range(-10, 10, 2)) # Output: range(-10, 10, 2) 83 | print(*range(-10, 10, 2)) # Output: -10 -8 -6 -4 -2 0 2 4 6 8 84 | 85 | print(-6 in range(-10, 10, 2)) # Output: True 86 | print(-7 in range(-10, 10, 2)) # Output: False 87 | 88 | print(range(-10, 10, 2)[5]) # Output: 0 89 | print(range(-10, 10, 2)[:6]) # Output: range(-10, 2, 2) 90 | print(range(-10, 10, 2)[-1]) # Output: 8 91 | 92 | print(list(range(-10, 10, 2))) # Output: [-10, -8, -6, -4, -2, 0, 2, 4, 6, 8] 93 | print(tuple(range(-10, 10, 2))) # Output: (-10, -8, -6, -4, -2, 0, 2, 4, 6, 8) 94 | ``` 95 | 96 | **Not:** İki `range` objesinin üzerinde `==` ve `!=` işlemleri yapabiliriz. Bu işlemler, bu iki `range` objesinin içeriği aynı ya da farklı olmasına göre sonuçlar verir. Örnekler: 97 | ```py 98 | print(range(0) == range(2,1,3) or range(0,3,2) == range(0,4,2)) # Output: True (Çünkü hepsi boş) 99 | 100 | print(list(range(0,2,1))) # Output: [0, 1] 101 | print(list(range(1,-1,-1))) # Output: [1, 0] 102 | print(range(0,2,1) == range(1,-1,-1)) # Output: False 103 | 104 | print(range(0,2,1) == range(0,2,1)) # Output: True 105 | print(range(0,2,1) != range(0,2,1)) # Output: False 106 | 107 | print(range(0,2,1) == range(2,4,1)) # Output: False 108 | print(range(0,2,1) != range(2,4,1)) # Output: True 109 | ``` 110 | 111 | **Not:** [linspace recipe](https://code.activestate.com/recipes/579000/), floating point application'larda uygun lazy version bir range'in nasıl uygulanacağını (implement) gösterir. 112 | 113 |

Range Methodları

114 | 115 |

index(value) Methodu

116 | 117 | `value` parametresine argüman olarak girdiğiniz value'nun, uygulandığı range içinde kaçıncı index'de bulunduğunu söyler. Örnek: 118 | ```py 119 | print(list(range(0,11,2))) # Output: [0, 2, 4, 6, 8, 10] 120 | print(range(0,11,2).index(4)) # Output: 2 121 | ``` 122 | 123 |

count(value) Methodu

124 | 125 | `value` parametresine argüman olarak girdiğiniz value'nun, uygulandığı range içinde kaç kere geçtiğini söyler. Range objesinde girilen aralıktaki her sayı 1 kere bulunduğu için bu methodun sonucu her zaman `1` çıkar. Örnek: 126 | ```py 127 | print(list(range(0,11,2))) # Output: [0, 2, 4, 6, 8, 10] 128 | print(range(0,11,2).count(4)) # Output: 1 129 | ``` -------------------------------------------------------------------------------- /python_tutorial/data_types/sequence_types/sequence_type_info.md: -------------------------------------------------------------------------------- 1 |

Sequence Type (Dizi Türleri) Ön Bilgi

2 | 3 | Sequence, sıralı kümeyi (ordered set) ifade eden genel bir terimdir. Sequence type data type'ler şunlardır: 4 | - [String](./python_tutorial/data_types/text_types/strings.md) 5 | - [List](./python_tutorial/data_types/sequence_types/list.md) 6 | - [Tuple](./python_tutorial/data_types/sequence_types/tuple.md) 7 | - [Range](./python_tutorial/data_types/sequence_types/range.md) 8 | - [Bytes](./python_tutorial/data_types/binary_types/bytes.md) 9 | - [Byte Array](./python_tutorial/data_types/binary_types/bytearrays.md) -------------------------------------------------------------------------------- /python_tutorial/data_types/sequence_types/tuple.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Demet (Tuple)](#1) 4 | - [Tuple'larda İşlemler](#1.1) 5 | - [Tuple Üreteçleri (Tuple Comprehensions)](#1.2) 6 | - [Tuple Methodları](#1.3) 7 | - [`index(value, start, stop)` Methodu](#1.3.1) 8 | - [`count(value)` Methodu](#1.3.2) 9 | 10 |

Demetler (Tuples)

11 | 12 | Tuple'lar değiştirilemez (immutable) data type'dır. Bu yüzden bir Tuple'ı değiştirmek için onu yeniden tanımlamak (redefinition) gerekir. Tuple'lar genellikle değiştirilmesini istemediğiniz verileri saklarken kullanılır. `tuple(iterable)` build'in fonksiyonu ile tuple oluşturabilirsiniz veya uygun objeleri tuple'a objesi dönüştürebilirsiniz. Tuple'lar normal parantez (`()`) ile ifade edilir. Örnek: 13 | ```py 14 | t1 = () 15 | t2 = tuple() 16 | t3 = ("string", 17 | 1, 1.5, 15+5j, 18 | ("tuple", "Tuple"), 19 | ["liste", "Liste"], 20 | {"set", "Set"}, 21 | {"Sözlük": "dictionary"}) 22 | 23 | print(t1,t2,t3,sep="\n") 24 | ``` 25 | **Output:** 26 | ``` 27 | () 28 | () 29 | ('string', 1, 1.5, (15+5j), ('tuple', 'Tuple'), ['liste', 'Liste'], {'set', 'Set'}, {'Sözlük': 'dictionary'}) 30 | ``` 31 | Python'da parantez operator'ı, içine aldığı şeyin öncelliğini arttırmak için kullanıldığı için tek öğeli tuple tanımlarken sorun yaşayabilirsiniz. Örnek: 32 | ```py 33 | t1 = ("item 1") 34 | print(type(t1)) # Output: 35 | ``` 36 | Gördüğünüz gibi burada bir tuple değil bir string objesi tanımlamış olduk. String yerine herhangi bir şey olsa da aynı durumla karşılaşacaktınız. Çözümü: 37 | ```py 38 | t1 = ("item 1",) 39 | t2 = "item 1", 40 | t3 = tuple("item 1") 41 | print(type(t1), type(t2), type(t3)) # Output: 42 | ``` 43 | Gördüğünüz gibi öğeden sonra bir adet virgül operator'ı koyarak tuple belirtmiş olduk. Bunun yerine yukarıdaki gibi `tuple(iterable)` build'in fonksiyonunu da kullanabilirsiniz. 44 | 45 |

Tuple'larda İşlemler

46 | 47 | Bir tuple'ı dilimlerken `tuple_exp[Başlama index'i : bitiş index'i : atlama değeri]` syntax'ı kullanılır. Örnekler: 48 | ```py 49 | a = (0,1,2,3,4,5,6,7,8,9) 50 | 51 | # 4. index'ten başlar, (9. index'i dahil etmeden) 9. index'e kadar tuple'i yazdırır. 52 | print(a[4:9]) # Output: (4, 5, 6, 7, 8) 53 | 54 | # Başlangıç index'i belirtilmediği için en baştan (0. index'ten) başlar, (9. index'i dahil etmeden) 9. index'e kadar tuple'i yazdırır. 55 | print(a[:9]) # Output: (0, 1, 2, 3, 4, 5, 6, 7, 8) 56 | 57 | # Bitiş index'i belirtilmediği için 4. indexten başlar, en son index'e kadar tuple'i yazdırır. 58 | print(a[4:]) # Output: (4, 5, 6, 7, 8, 9) 59 | 60 | # Başlangıç ve bitiş intex'i belirtilmediği için tüm tuple'i yazdırır. 61 | print(a[:]) # Output: (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) 62 | 63 | # Başlangıç index'i belirtilmediği için en baştan (0. index'ten) başlar, (-1. index'i dahil etmeden) -1. index'e kadar (sonran bir önceki index) tuple'i yazdırır. 64 | print(a[:-1])# Output: (0, 1, 2, 3, 4, 5, 6, 7, 8) 65 | 66 | # Baştan sona index atlamadan tuple'i yazdırır. 67 | print(a[::1]) # (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) 68 | 69 | # Baştan sona 1 index atlaya atlaya tuple'i yazdırır. 70 | print(a[::2]) # Output: (0, 2, 4, 6, 8) 71 | 72 | # 4. index'ten başlar, (9. index'i dahil etmeden) 9. index'e kadar 2 index atlaya atlaya tuple'i yazdırır. 73 | print(a[0:9:3]) # Output: (0, 3, 6) 74 | 75 | # Sondan başa index atlamadan tuple'i yazdırır. (tuple'i ters çevirme) 76 | print(a[::-1]) # Output: (9, 8, 7, 6, 5, 4, 3, 2, 1, 0) 77 | ``` 78 | 79 | Tuple'ların öğe sayısına `len()` fonksiyonuyla ulaşılabilir. Örnek: 80 | ```py 81 | t1 = (1,2,3,4,5) 82 | print(len(t1)) # Output: 5 83 | ``` 84 | 85 | Tuple'larda aritmetik (sayısal) işlemler yapılabilir. Örnek: 86 | ```py 87 | print((1,2,3) + (4,5,6)) # Output: (1, 2, 3, 4, 5, 6) 88 | print((1,2,3) * 2) # Output: (1, 2, 3, 1, 2, 3) 89 | ``` 90 | Bir Tuple'a öğe eklemek için addition (toplama `+`) operator'ını kullanarak öğe ekleyebilirsiniz. Bu durum yeniden tanımlama (redefinition) işlemi olduğu için ve tuple değiştirilemez (immutable) data type olduğu için bu işlemden sonra eski tuple ile yeni tuple birbirinden farklı (ID'leri farklı) iki obje olacaktır. Örnek: 91 | ```py 92 | t1 = (1,2) 93 | id_1 = id(t1) 94 | t1 += (3,) 95 | id_2 = id(t1) 96 | print((id_1 == id_2)) # Output: False 97 | ``` 98 | 99 | Diğer iterable objeleri `tuple()` fonksiyonu ile tuple type'a dönüştürebilirsiniz. Örnek: 100 | ```py 101 | print(tuple(range(0,4))) # Output: (0, 1, 2, 3) 102 | print(tuple([0,1,2,3])) # Output: (0, 1, 2, 3) 103 | print(tuple({0,1,2,3})) # Output: (0, 1, 2, 3) 104 | print(tuple("0123")) # Output: ('0', '1', '2', '3') 105 | ``` 106 | 107 | Öğe sayısını bilmediğiniz tuple'ların son öğesine ulaşmak için iki yöntem: 108 | ```py 109 | t1 = (0,1,2,3,4) 110 | print(t1[len(t1)-1]) # Output: 4 111 | print(t1[-1]) # Output: 4 112 | ``` 113 | 114 | Tuple objesini tamamen silmek: 115 | ```py 116 | t1 = (1,2,3,4) 117 | del t1 118 | print(t1) # NameError: name 't1' is not defined 119 | ``` 120 | 121 | Bir tuple'ı kopyalamak ve sonuçları: 122 | ```py 123 | t1 = (1,2,3,4) 124 | t2 = t1 125 | print(t1) # Output: (1, 2, 3, 4) 126 | print(t2) # Output: (1, 2, 3, 4) 127 | print(id(t1) == id(t2)) # Output: True 128 | ``` 129 | `t2` ve `t2` aynı tuple objesine atıfta bulunmaktadır (refers to). 130 | 131 | Bir tuple içine tanımlanmış diğer index'lenebilir iterable objelerin index'lerine de erişebiliriz. Örnek: 132 | ```py 133 | t1 = ("string", 134 | ("tuple", "Tuple"), 135 | ["liste", "Liste"], 136 | {"Sözlük": "dictionary"}) 137 | 138 | print(t1[0][3]) # Output: i 139 | print(t1[1][0]) # Output: tuple 140 | print(t1[2][1]) # Output: Liste 141 | print(t1[3]["Sözlük"]) # Output: dictionary 142 | ``` 143 | `obje[index][index]` yapısını çalışma mantığı: 144 | - Python `a[b][c]` yapısını soldan sağa okumaya başladığı için önce `a[b]` kısmını okur ve `a` objesinin `b` index'ine gider ve böylece `a[b]` kodu, `a` objesinin `b` index'indeki objeye atıfta bulunmuş olur. Bu objeye `x` diyelim. 145 | - Bu işlemden sonra `a[b][c]` kodu Python'un gözünde `x[c]` koduna dönüşür. Python `x[c]` kodu için de aynı işlemleri yapar. 146 | - Python'u LEGO gibi düşünün. Kodları bütün olarak değil, parça parça yorumlayın. Böylelikle Python'un çalışma mantığını anlarsınız. Örneğin aşağıdaki iki kod tamamen aynı işi yapmaktadır: 147 | ```py 148 | t1 = ((((1,2), (3,4)), ((5,6), (7,8))), (((9,10), (11,12)), ((13,14), (15,16)))) 149 | 150 | a1 = t1[0] 151 | a2 = a1[0] 152 | a3 = a2[0] 153 | a4 = a3[0] 154 | print(a4) # Output: 1 155 | print(t1[0][0][0][0]) # Output: 1 156 | ``` 157 | 158 | **Tuple'ların listelerden bazı farkları:** Bir tuple'ın herhangi bir index'indeki öğesini başka bir şeyler değiştiremezsin veya silemezsin çünkü tuple'lar değiştirilemez (immutable) bir data type olduğu için listelerdeki gibi parça ekleme/çıkarma/silme işlemlerini desteklemez. Aşağıdaki örneklerdeki hata mesajlarında bu duruma vurgu yapılmış: 159 | ```py 160 | t1 = (1,2,3,4) 161 | print(t1) 162 | t1[1] = 0 # TypeError: 'tuple' object does not support item assignment 163 | print(t1) 164 | 165 | t1 = (1,2,3,4) 166 | print(t1) 167 | t1[:] = 5,6,7,8 # TypeError: 'tuple' object does not support item assignment 168 | print(t1) 169 | 170 | t1 = (1,2,3,4) 171 | del t1[:] 172 | print(t1) # TypeError: 'tuple' object does not support item deletion 173 | 174 | t1 = (1,2,3,4) 175 | del t1[0] # TypeError: 'tuple' object doesn't support item deletion 176 | print(t1) 177 | ``` 178 | 179 | 180 |

Tuple Üreteçleri (Tuple Comprehensions)

181 | 182 | **Comprehension**, tek satırda oluşturduğumuz **Generator** (daha sonra anlatılacak) yapısına verilen isimdir. `(expression for item in iterable)` syntax'ına sahiptir (parantezler dahil). Bu generator yapısı (**Generator Comprehension**) bir generator objesi oluşturmakta kullanılır. Daha sonra bu generator objesini tuple type'a dönüştürerek Tuple Comprehension oluşturabiliriz. Örnek: 183 | ```py 184 | tuple_exp = tuple(i for i in range(1,4)) 185 | print(tuple_exp) # Output: (1, 2, 3) 186 | ``` 187 | Burada `(i for i in range(1,4))` yerine `tuple(i for i in range(1,4))` kullanmamızın nedenini daha önce tek öğeli tuple oluşturma kısmında anlattım. Bu konu daha sonra comprehension başlığı altında daha detaylı anlatılacak. 188 | 189 |

Tuple Methodları

190 | 191 |

index(value, start, stop) Methodu

192 | 193 | `value` parametresine argüman olarak girdiğiniz value'nun, uygulandığı tuple içinde ilk kaçıncı index'de bulunduğunu söyler. `start` ve `stop` parametrelerine gireceğiniz integer argümanlarla, `index` methodunun hangi index'ler arasında arama yaparcağını belirleyebilirsiniz. Örnek: 194 | ```py 195 | t1 = ("a", ("b", "c"), "a") 196 | print(t1) # Output: ('a', ('b', 'c'), 'a') 197 | print(t1.index("a")) # Output: 0 198 | print(t1.index("a", 2)) # Output: 2 199 | print(t1.index(("b", "c"))) # Output: 1 200 | ``` 201 | 202 |

count(value) Methodu

203 | 204 | `value` parametresine argüman olarak girdiğiniz value'nun, uygulandığı tuple içinde kaç kere geçtiğini söyler. Nested tuple'larda eksik sonuç verebilir çünkü nested tuple'ı görmez. Örnek: 205 | ```py 206 | t1 = ("a","b",("a",),"c") 207 | print(t1.count("a")) # Output: 1 208 | ``` -------------------------------------------------------------------------------- /python_tutorial/data_types/set_types/pics/1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/data_types/set_types/pics/1.png -------------------------------------------------------------------------------- /python_tutorial/data_types/set_types/pics/10.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/data_types/set_types/pics/10.png -------------------------------------------------------------------------------- /python_tutorial/data_types/set_types/pics/11.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/data_types/set_types/pics/11.png -------------------------------------------------------------------------------- /python_tutorial/data_types/set_types/pics/2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/data_types/set_types/pics/2.png -------------------------------------------------------------------------------- /python_tutorial/data_types/set_types/pics/3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/data_types/set_types/pics/3.png -------------------------------------------------------------------------------- /python_tutorial/data_types/set_types/pics/4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/data_types/set_types/pics/4.png -------------------------------------------------------------------------------- /python_tutorial/data_types/set_types/pics/5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/data_types/set_types/pics/5.png -------------------------------------------------------------------------------- /python_tutorial/data_types/set_types/pics/6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/data_types/set_types/pics/6.png -------------------------------------------------------------------------------- /python_tutorial/data_types/set_types/pics/7.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/data_types/set_types/pics/7.png -------------------------------------------------------------------------------- /python_tutorial/data_types/set_types/pics/8.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/data_types/set_types/pics/8.png -------------------------------------------------------------------------------- /python_tutorial/data_types/set_types/pics/9.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/data_types/set_types/pics/9.png -------------------------------------------------------------------------------- /python_tutorial/data_types/text_types/character_encoding.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Encoding](#1) 4 | - [ASCII](#1.1) 5 | - [Genişletilmiş ASCII](#1.1.1) 6 | - [UNICODE](#1.2) 7 | - [UTF-8 Kod Çözücüsü](#1.2.1) 8 | - [Encoding Hataları](#2) 9 | - [Dosyalar ve Karakter Kodlama](#3) 10 | - [Karakter Kodlama İle İlgili Fonksiyonlar](#4) 11 | - [`repr(object)` Fonksiyonu](#4.1) 12 | - [`ascii(object)` Fonksiyonu](#4.2) 13 | - [`ord(c)` Fonksiyonu](#4.3) 14 | - [`chr(i)` Fonksiyonu](#4.4) 15 | 16 |

Encoding

17 | 18 | Bilgisayar, insanlar gibi kelimelerden anlamaz. Bilgisayar, elektrik sinyallerinden anlar. Elektrik sinyallerinin (0 ve +5 volt) hangi sayıya, hangi sayının da hangi karaktere karşılık geleceğini belirleyebilirsiniz. Bunun tam tersi olan karakterden sayılara, sayılardan da elektrik sinyallerine dönüşümü de belirleyebilirsiniz. Bu dönüştürme işlemlerine **Karakter kodlama (character encoding)** denir. Her encoding sistem aynı olmayacağı için global encoding sistemlerinin kullanımı yaygındır. 19 | 20 |

ASCII

21 | 22 | **American Standard Code for Information Interchange (Bilgi Alışverişi için Standart Amerikan Kodu)** kısaca **ASCII**, 7 bit'lik bir sistemdir. Amerika standartlarına göre yapıldığı için Türkçe karakter sıkıntısı yaşatan bir sistemdir. ASCII tablosuna [buradan](http://www.asciitable.com/) ulaşabilirsiniz veya kendiniz oluşturabilirsiniz: 23 | ```py 24 | for i in range(128): 25 | if i % 4 == 0: 26 | print("\n") 27 | print("{:<3}{:>8}\t".format(i, repr(chr(i))), sep="", end="") 28 | ``` 29 | 30 |

Genişletilmiş ASCII

31 | 32 | Normal ASCII 8. bit'i hata kontrol sisteminde kullandığı için 128 tane karakter kodlayabiliyordu. Genişletilmiş ASCII'de 8. bit'in hata kontrol sistemi için kullanılmasında vazgeçildi ve kodlanabilen karakter sayısı 256'ya çıktı. Farklı ülkelere gönderilmek için geliştirilen birbirinden farklı bu sayfalara genel olarak **kod sayfası** adı verildi. Microsoft şirketinin Türkiye'ye gönderdiği bilgisayarlarda tanımlı **cp857** adlı kod sayfasında 128 ile 256 aralığında Türkçe karakterlere de yer verilmişti. 8. bit'in kullanılmaya başlanmasıyla dünyadaki bütün dillerin kod sayfası oluşturulabiliyor. Genişletilmiş ASCII karakterinin kapladığı yer: `1 karakter == 1 byte == 8 bit` 33 | 34 |

UNICODE

35 | 36 | Geliştirilmiş ASCII'de farklı kod sayfası kullanan bilgisayarlar arasında kurulan yazılı iletişimde karakterlerin bozuk veya farklı çıkıyordu. Bunu önlemek için **UNICODE** standartı yapıldı. UNICODE sistemi ASCII'yi tamamen görmezden gelmez. Yani ASCII ile kodlanmış karakterler UNICODE'da da vardır. Bu sebeple ASCII, UNICODE'un bir alt kümesidir. Bu sayede ASCII ile çalışan sistemlerin tamamı UNICODE ile de çalışır. UNICODE ilk ortaya çıktığında 16 bit'lik bir sistemdi ve `2**16 = 65536` karakterin kodlanmasına izin veriyordu. Bugün ise bunun bir sınırı yok çünkü 'X bitlik sistem' kavramı artık UNICODE için geçerli değil. Bu sayede ASCII'ye kıyasla UNICODE, bir milyondan fazla karakter kodlamasına izin verir. Bunu yapabilmesini sağlayan şey ise, ASCII sistemi gibi karakteri doğrudan doğruya kodlamak yerine o karakteri tanımlamasıdır. Yani UNICODE'da her kararkter benzersiz bir **kod konumuna (code point)** karşılık gelir. UNICODE standartına ulaşmak için [tıklayınız](http://www.unicode.org/versions/Unicode6.2.0/UnicodeStandard-6.2.pdf). UNICODE tablosuna ulaşmak için [tıklayınız](https://unicode-table.com/tr/). 37 | 38 |

UTF-8 Kod Çözücüsü

39 | 40 | UNICODE karakterleri kendi kendine kodlanmaz. Bu sistemde tanımlanan karakterleri kodlama işi kod çözücülerin görevidir. UNICODE sistemi içinde **UTF-1**, **UTF-7**, **UTF-8**, **UTF-16** ve **UTF-32** adlı kod çözücüler bulunur. **UTF-8**, UNICODE sistemi içindeki en yaygın, bilinen ve kullanışlı kod çözücüdür. UTF-8 adlı kod çözücünün kodlayabildiği karakterlerin listesine ulaşmak için [tıklayınız](http://www.fileformat.info/info/charset/UTF-8/list.htm). Gelmiş geçmiş bütün sistemleri kodlayabilmek için 4 byte'lık sistem (`2**(8*4) = 2**32 = 4,294,967,296`) yeterli olacaktır. 41 | 42 | 1 byte'lık sistem ile temsil edilebilecek bir karakterin 4 byte'lık sistemle tanımlamaya çalıştığımızda boşu boşuna 4 kat fazla yer kaplamış olursunuz. Bu sorunun çözümü elbette sabit boyutlu karakter kodlama biçimleri yerine değişken boyutlu karakter kodlama biçimleri kullanmaktır. UTF-8 adlı kod çözücü, karakterleri değişken sayıda byte'lar halinde kodlayabilir. UTF-8, UNICODE sistemi içinde tanımlanmış karakterleri kodlayabilmek için 1 ile 4 byte arası değerleri kullanır. Böylece de bu kod çözücü UNICODE sistemi içinde tanımlanmış bütün karakterleri temsil edebilir. 43 | ```py 44 | harfler = "abcçdefgğhıijklmnoöprsştuüvyz" 45 | for s in harfler: 46 | print("{:<5}{:<15}{:<15}".format(s, str(s.encode("utf-8")), len(s.encode("utf-8")))) 47 | ``` 48 | Burada `harfler` variable'ına atanmış string'in her bir karakterinin UNICODE'da kaç byte yer kapladığını döndüren bir kod var. Buradaki `s.encode("utf-8")` komutları, `s` string'ini `encode()` methodu ile `utf-8`'e göre `bytes` data type'ına dönüştürüyor. `bytes` data type'ı `format()` methoduna sahip olmadığı için `s.encode("utf-8")` kodunu `str()` fonksiyonu ile string'e dönüştürüp kullanmalıyız. Bunu yapmak istemeyenler için alternatif: 49 | ```py 50 | harfler = "abcçdefgğhıijklmnoöprsştuüvyz" 51 | for s in harfler: 52 | print("{:<5}{!s:<15}{:<15}".format(s, s.encode("utf-8"), len(s.encode("utf-8")))) 53 | ``` 54 | `ord()` build-in fonksiyonu kullanarak UNICODE tablosundaki karakterlerin decimal karşılıklarını elde edebilirsiniz. Örnek: 55 | ```py 56 | print(ord("a")) # Output: 97 57 | ``` 58 | 59 |

Encoding Hataları

60 | 61 | Bir Python programı, kod sayfalarının farklı olmasın durumunda eksik karakterin yerine başka bir karakter koyamayacağı için (mesela `ç` yerine `c` koymaz çünkü her karakter spesifiktir) hata yükseltir. 62 | 63 |

Dosyalar ve Karakter Kodlama

64 | 65 | `open()` build-in fonksiyonu, dosya işlemlerinde ilgili dosyayı açmak için kullanılan bir fonksiyondur. Bu fonksiyonun konumuzla ilgili `encoding` ve `errors` adında iki parametresi vardır: 66 | - **encoding:** `encoding` parametresi, bir dosyanın hangi kod çözücü ile açılacağını belirtmemize olanak tanır. Python'da dosyalar default olarak, `locale` adlı bir modülün `getpreferredencoding()` adlı fonksiyonunu kullanarak öğrenebileceğiniz kod çözücü ile açılır. GNU/Linux, **UTF-8** ile çalışır ama Windows **cp1254** ile çalışır. Bu yüzden Windows cihazlarda encoding değerini UTF-8 olarak belirtmek önemlidir. Diğer bir önemli nokta da, cp1254 ile kodlanmış bir dosyayı UTF-8 ile açmaya çalışırsanız hata yükseltilir çünkü sayılar aynı karakterlerle eşleştirilememektedir. 67 | - **errors:** cp1254 ile kodlanmış bir dosyayı UTF-8 ile açmaya çalışırsanız program doğru çalışmaz. Bu gibi durumlarda Python'un nasıl davranacağını (daha önce `str()` fonksiyonunda da anlattığım) `errors` parametresine gireceğiniz argüman ile belirleyebilirsiniz. Bu argümanlardan biri olan `xmlcharrefreplace`'in `open()` fonksiyonunda kullanmasına Python tarafından izin verilmez. `replace` argümanı ise kodlanamayan karakterlerin yerine `\ufffd` karakterini yerleştirecektir. Bu karakter işlev bakımından `encode()` metodunu anlatırken anlattığım `?` işaretine benzer. Bu karaktere teknik olarak **UNICODE Değiştirme Karakteri (UNICODE Replacement Character)** adı verilir. Bazı yerlerde bu karakteri `�` şeklinde görebilirsiniz. 68 | 69 |

Karakter Kodlama İle İlgili Fonksiyonlar

70 | 71 |

repr(object) Fonksiyonu

72 | 73 | Python programlama dilinde nesneler, **Python'ın gözünden** ve **kullanıcının gözünden** olmak üzere 2 farklı şekilde ifade edilir. Örneğin kaçış dizilerini kullanıcının gözünden göremezken, Python'ın gözünden görebilirsiniz. `repr` fonksiyonu, karakter dizilerini Python'ın gözünden görmemizi sağlar. Örnek: 74 | ```py 75 | print("Karakter\nDizisi") 76 | print(repr("Karakter\nDizisi")) 77 | ``` 78 | **Output:** 79 | ``` 80 | Karakter 81 | Dizisi 82 | 'Karakter\nDizisi' 83 | ``` 84 | Gördüğünüz gibi `repr` fonksiyonu, string'leri tek tırnak içinde belirtir ve kaçış dizilerini görmemizi sağlar. Bu işlem yüzünden kaçış dizileri işlevlerini geçekleştiremez. Daha fazla bilgi için [tıklayınız](https://docs.python.org/3/library/functions.html#repr). 85 | 86 |

ascii(object) Fonksiyonu

87 | 88 | `object` parametresinde girilen objenin yazdırılabilir karşılığını döndürür. ASCII karakterlerin direkt kendisini döndürürken, ASCII olmayan karakterlerin `\x`, `\u` ya da `\U` karşılıklarını, yani **UNICODE kod konumlarını (code points)** döndürür. Örnek: 89 | ```py 90 | print(ascii("İ")) # Output: '\\u0130' 91 | print(ascii('şeker')) # Output: '\\u015feker' 92 | ``` 93 | `ascii()` fonksiyonu ile `str` data type'ın `encode()` methodu aynı sonuçları verir. 94 | ```py 95 | print(ascii("€")) # Output: '\u20ac' 96 | print("€".encode("unicode_escape")) # Output: b'\\u20ac' 97 | ``` 98 | Daha fazla bilgi için [tıklayınız](https://docs.python.org/3/library/functions.html#ascii). 99 | 100 |

ord(c) Fonksiyonu

101 | 102 | `c` parametresine girilen değerin UNICODE tablosundaki decimal karşılığını verir. 103 | ```py 104 | print(ord("€")) # Output: 8364 105 | ``` 106 | 107 |

chr(i) Fonksiyonu

108 | 109 | `i` parametresine girilen decimal değerin UNICODE karşılığını döndürür. `ord()` fonksiyonunun tam tersi işleve sahiptir. `i` parametresine girilen argüman 0 ile 1,114,111 arasındaysa bu fonksiyon çalışır ama değilse `ValueError` hatası yükseltilir. 110 | ```py 111 | print(chr(8364)) # Output: € 112 | ``` -------------------------------------------------------------------------------- /python_tutorial/data_types/text_types/escape_sequences.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Kaçış Dizisileri](#1) 4 | - [`\` Geçersiz Kılma (Backslash)](#1.1) 5 | - [`\n` Satır Atlama](#1.2) 6 | - [`\t` TAB](#1.3) 7 | - [`\a` Alert](#1.4) 8 | - [`\r` Aynı Satırın Başı](#1.5) 9 | - [`\v` Düşey Sekme](#1.6) 10 | - [`\b` İmleç Kaydırma](#1.7) 11 | - [`\u` Küçük UNICODE](#1.8) 12 | - [`\U` Büyük UNICODE](#1.9) 13 | - [`\N` Uzun Ad](#1.10) 14 | - [`\x` Hexadecimal Karakter](#1.11) 15 | - [`\f` Sayfa Başı](#1.12) 16 | - [`r` Etkisizleştirme](#1.13) 17 | 18 |

Kaçış Dizisileri

19 | 20 | Özel anlamları ve işlevleri olan karakterlerdir. ASCII'de tanımlanmıştır. ASCII tablosu: 21 | 22 | ![](./pics/1.jpg) 23 | 24 |

`\` Geçersiz Kılma (Backslash)

25 | 26 | Backslash, string kapsamında kendinden sonra gelen işaretin işlevini geçersiz kılar. Örnek: 27 | ```py 28 | print("Bu \" ve bu \' tırnak işaretidir.") # Output: Bu " ve bu ' tırnak işaretidir. 29 | print('İstanbul\'un insanları...') # Output: İstanbul'un insanları... 30 | print("Bu \\ backslash işaretidir.") # Output: Bu \ backslash işaretidir. 31 | ``` 32 | Bir string'i parçalamak için kullanılabilir. Örnek: 33 | ```py 34 | print("Python 1990 yılında Guido Van Rossum tarafından geliştirilmeye başlanmış, oldukça güçlü ve yetenekli bir programlama dilidir.") # Output: Python 1990 yılında Guido Van Rossum tarafından geliştirilmeye başlanmış, oldukça güçlü ve yetenekli bir programlama dilidir. 35 | 36 | print("Python 1990 yılında Guido Van Rossum \ 37 | tarafından geliştirilmeye başlanmış, oldukça \ 38 | güçlü ve yetenekli bir programlama dilidir.") # Output: Python 1990 yılında Guido Van Rossum tarafından geliştirilmeye başlanmış, oldukça güçlü ve yetenekli bir programlama dilidir. 39 | ``` 40 | 41 |

`\n` Satır Atlama

42 | 43 | Bir alt satıra geçmek için kullanılır. Örnek: 44 | ```py 45 | print("Selam\nBen\n\nPython") 46 | ``` 47 | **Output:** 48 | ``` 49 | Selam 50 | Ben 51 | 52 | Python 53 | ``` 54 | 55 |

`\t` TAB

56 | 57 | Kendinden sonra bir `TAB` boşluk bırakır. Bu boşluğun boyutu IDE'den IDE'ye farklılık gösterebilir. En genel kullanılan `TAB` boyutları 2 ya da 4 space (boşluk). 58 | ```py 59 | print("Selam\tBen\t\tPython") # Output: Selam Ben Python 60 | ``` 61 | 62 |

`\a` Alert

63 | 64 | Bir adet '*bip*' sesi ya da alert mesajı üretir. Her işletim sisteminde çalışmadığı için tercih edilmeyen bir komuttur. 65 | 66 |

`\r` Aynı Satırın Başı

67 | 68 | Kendinden sonra gelen ifadeyi kesip, satır başındaki kelimenin üstüne yazar. Örneğin `"Selamlar\rNaber"` karakter dizisindeki `Naber` karakter dizisi `Selamlar`'ın üstüne yazılıp `Naberlar` olur. 69 | ```py 70 | print("garip Keloğlan.\rBir ") # Output: Bir p Keloğlan. 71 | ``` 72 | 73 |

`\v` Düşey Sekme

74 | 75 | ``` 76 | düşey 77 | sekme 78 | ``` 79 | şeklinde bir görüntü elde edilir ama her işletim sisteminde çalışmadığı için tercih edilmez. Mesela ben win10 kullanıyorum ve `Selam♂Ben♂Python` şeklinde bir output aldım. 80 | 81 |

`\b` İmleç Kaydırma

82 | 83 | Kendinden önceki harfi silip cümleye devam eder. 84 | ```py 85 | print("google.com\b.tr") # Output: google.co.tr 86 | print('google' , '\b.' , '\bcom') # google.com 87 | ``` 88 | Gördüğünüz gibi `print()` fonksiyonunun `sep` parametresinde belirtilen boşluk karakterlerini sildi ve bu sayede `google . com` tarzı bir output yerine `google.com` tarzı bir output aldık. 89 | 90 |

`\u` Küçük UNICODE

91 | 92 | Karakterlerin UNICODE decimal karşılıklarını yazdırmamızı sağlar. 4 karakterden oluşur. 93 | ```py 94 | print("\u0130") # Output: İ 95 | print("\u0070") # Output: P 96 | ``` 97 | 98 |

`\U` Büyük UNICODE

99 | 100 | Karakterlerin UNICODE decimal karşılıklarını yazdırmamızı sağlar. 8 karakterden oluşur. 101 | ```py 102 | print("\U00000130") # Output: İ 103 | print("\U00000070") # Output: P 104 | ``` 105 |

`\N` Uzun Ad

106 | 107 | UNICODE sisteminde her karakterin tek ve benzersiz bir kod konumu olduğu gibi, tek ve benzersiz bir de uzun adı vardır. `\N` kaçış dizisi de bu uzun adları kullanarak, karşılık gelen değeri bize verir. 108 | ```py 109 | print("\N{LATIN SMALL LETTER A}") # Output: a 110 | print("\N{LATIN CAPITAL LETTER S WITH CEDILLA}") # Output: Ş 111 | ``` 112 | Bu uzun adlara ulaşmak için `unicodedata` modülünden yararlanabilirsiniz. 113 | ```py 114 | import unicodedata 115 | print(unicodedata.name('a')) 116 | print(unicodedata.name('Ş')) 117 | ``` 118 | 119 |

`\x` Hexadecimal Karakter

120 | 121 | Onaltılı (hexadecimal) sayma sistemindeki bir sayının karakter karşılığını gösterebilirsiniz. ASCII tablosundaki Hex kısmındaki ifadeler kullanılır. 122 | ```py 123 | print("\x41") # Output: A 124 | print("\x4E") # Output: N 125 | ``` 126 | 127 |

`\f` Sayfa Başı

128 | 129 | Kendinden önceki ve sonraki ifadeleri farklı sayfalara yazdırır. 130 | ```py 131 | f = open("deneme.txt", "w") 132 | print("deneme\fdeneme", file=f) 133 | f.close() 134 | ``` 135 | programını çalıştırdıktan sonra *deneme.txt* dosyasını *.docx* formatında çalıştırırsanız, deneme yazılarının farklı sayfalara yazdırıldığını görürsünüz. Günümüzde pek kullanılmaz. 136 | 137 |

`r` Etkisizleştirme

138 | 139 | `r` kaçış dizisi, karakter dizisi içinde geçen kaçış dizilerini geçersiz kılar. 140 | ```py 141 | print("Kaçış dizisi: '\'") # Output: Kaçış dizisi: '' 142 | print(r"Kaçış dizisi: '\'") # Output: Kaçış dizisi: '\' 143 | ``` 144 | Aynı şeyi backslash (`\`) kullanarak da yapabiliriz. Backslash'ı geçersiz kılmak için bazı yöntemler: 145 | ```py 146 | # Kaçış dizisinden sonra bir adet boşluk karakteri yerleştirmek: 147 | print("Kaçış dizisi: \ ") # Output: Kaçış dizisi: \ 148 | 149 | # Çift kaçış dizisi kullanmak: 150 | print("Kaçış dizisi: \\") # Output: Kaçış dizisi: \ 151 | 152 | # Karakter dizilerini birbiri ile toplayıp, çift kaçış dizisi kullanmak: 153 | print("Kaçış dizisi: " + "\\") # Output: Kaçış dizisi: \ 154 | 155 | # Karakter dizilerini farklı argüman olarak girip, çift kaçış dizisi kullanmak: 156 | print("Kaçış dizisi:", "\\") # Output: Kaçış dizisi: \ 157 | 158 | # Karakter dizilerini birbirine ekleyip, çift kaçış dizisi kullanmak: 159 | print("Kaçış dizisi: " "\\") # Output: Kaçış dizisi: \ 160 | ``` -------------------------------------------------------------------------------- /python_tutorial/data_types/text_types/pics/1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/data_types/text_types/pics/1.jpg -------------------------------------------------------------------------------- /python_tutorial/external_resources_operations/pics/1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/external_resources_operations/pics/1.png -------------------------------------------------------------------------------- /python_tutorial/external_resources_operations/pics/2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/external_resources_operations/pics/2.png -------------------------------------------------------------------------------- /python_tutorial/external_resources_operations/pics/3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/external_resources_operations/pics/3.png -------------------------------------------------------------------------------- /python_tutorial/external_resources_operations/pics/4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/external_resources_operations/pics/4.png -------------------------------------------------------------------------------- /python_tutorial/external_resources_operations/pics/5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/external_resources_operations/pics/5.png -------------------------------------------------------------------------------- /python_tutorial/external_resources_operations/pics/6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/external_resources_operations/pics/6.png -------------------------------------------------------------------------------- /python_tutorial/external_resources_operations/pics/7.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/external_resources_operations/pics/7.png -------------------------------------------------------------------------------- /python_tutorial/external_resources_operations/with_ve_context_manager.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Context Manager ve `with` Statement](#1) 4 | 5 |

Context Manager ve with Statement

6 | 7 | Context manager, kullanılan kaynakların geri iade edilmesi için ortaya çıkmış bir protocol'dür. Kaynaklar sınırsız değildir ve işletim sistemiden işletim sistemine boyutu değişir. Devamlı kaynak edinip geri iade etmezseniz, işletim sisteminiz bir noktadan sonra size engel (`OSError`) olacaktır. 8 | 9 | Context manager, işletim sistemi kaynağının sadece belitlenen bir context'de geçerli olmasını sağlar ve bu context'den çıkınca bu kaynak, Python tarafından otomatik olarak yok ediliyor. Bu protocol'ü kullanabilmemiz için belli kurallara uygun class'lar, construction'lar oluşturmamız gerekir. Context manager protocol'üne uygun yazdığımız class'ları kullanırken de `with` statement'den yararlanacağız. 10 | 11 | Python'da, harici kaynak (external resources) kullanımı ve kaynakların geri iadesi için kullanılan `with` statement bulunmaktadır. `with` statement, bu işlemleri **context management** protocol'üne uygun olarak yapmaktadır. `with` statement'in syntax'ı: 12 | ```py 13 | with as : 14 | # processes 15 | ``` 16 | 17 | Aşağıdaki yapı, Context manager protocol'üne uygun bir yapıdır: 18 | ```py 19 | try: 20 | # Dosyayı aç 21 | dosya = open(r"{}deneme.txt".format(__file__[:-6]), mode="r+", encoding="utf-8") 22 | # Dosya işlemleri 23 | dosya.write("Falan filan") 24 | except IOError: 25 | # Exception IO HATA MESAJI 26 | finally: 27 | # Dosyayı kapat 28 | dosya.close() 29 | ``` 30 | Bu yapıyı `with` statement ile de oluşturabiliriz. Örnek: 31 | ```py 32 | with open("deneme.txt", "w") as fw: 33 | fw.write("falan filan") 34 | ``` 35 | 36 | Context manager oluşturmanın 2 yöntemi vardır: 37 | - Class Kullanmak 38 | - `contexmanager` decorator kullanmak 39 | 40 | **İlk yöntem:** Bir class'ın context manager protocol'üne uygun olabilmesi için `__enter__(self)` ve `__exit__(self, exc_type, exc_value, traceback)` method'larını bulundurması gerekiyor. Örnek: 41 | ```py 42 | class A: 43 | def __init__(self): 44 | print("init çalıştı...") 45 | 46 | def __enter__(self): 47 | print('`__enter__` çağırıldı...') 48 | return self 49 | 50 | def __exit__(self, exc_type, exc_value, traceback): 51 | print('`__exit__` çağırıldı...') 52 | 53 | with A() as f: 54 | print("with bloğunun içindeyim...") 55 | ``` 56 | **Output:** 57 | ``` 58 | init çalıştı... (`A()`dan dolayı) 59 | `__enter__` çağırıldı... (`__enter__`den dolayı) 60 | with bloğunun içindeyim... (with statement'ın kod bloğundan dolayı) 61 | `__exit__` çağırıldı... (`__exit__`den dolayı) 62 | ``` 63 | Çalışma mantığı böyle. Şimdi dosya işlemlerine entegre edelim. Örnek: 64 | ```py 65 | class File: 66 | 67 | # Constructor metodumuzu yazalim 68 | def __init__(self, file_name, mode): 69 | self.file_name = file_name 70 | self.mode = mode 71 | 72 | def __enter__(self): 73 | # Islemleri yapildigi metod 74 | self.f_obj = open(self.file_name, self.mode) 75 | return self.f_obj 76 | 77 | def __exit__(self, exc_type, exc_val, traceback): 78 | # Dosya kapama islemi 79 | self.f_obj.close() 80 | 81 | 82 | with File('deneme.txt', 'w') as f_write: 83 | f_write.write('Test...') 84 | print(f"Dosya kapatıldı mı? [With Body] -> {f_write.closed}") # Output: Dosya Kapatildi mi? [With Body] -> False 85 | 86 | print(f"Dosya kapatıldı mı? [Out of with body] -> {f_write.closed}") # Output: Dosya kapatıldı mı? [Out of with body] -> True 87 | ``` 88 | Burada `with File('deneme.txt', 'w')` kısmında `__init__` kısmı, `as f_write` kısmında `__enter__` kısmı çalışıyor ve `return self.f_obj` kodundaki döndürülen `f_obj` dosya objesi `f_write` identifier'ına atanıyor. `with` bloğunda birtakım işlemler yaptıktan sonra `with`'den çıkınca dosya objesi otomatik olarak kapatıldığı için `__exit__` çalışıyor ve dosya objesi yok ediliyor (iade ediliyor, yok ediliyor (destroy) vs.) 89 | 90 | İkinci yöntem: `contextmanager` decorator'ı: 91 | ```py 92 | from contextlib import contextmanager 93 | 94 | @contextmanager 95 | def dosyaisleme(dosya_adi, mod): 96 | dosya = open(dosya_adi, mod) # contextmanager decorator'ı bu kısmı __init__ işleminde kullanır 97 | yield dosya # contextmanager decorator'ı bu kısmı __enter__ işleminde kullanır 98 | dosya.close() # contextmanager decorator'ı bu kısmı __exit__ işleminde kullanır 99 | 100 | with dosyaisleme('deneme.txt', 'w') as f_write: 101 | f_write.write('Test...') 102 | print(f"Dosya kapatıldı mı?[With Body] -> {f_write.closed}") # Output: Dosya kapatıldı mı?[With Body] -> False 103 | 104 | print(f"Dosya kapatıldı mı?[Out of with body] -> {f_write.closed}") # Output: Dosya kapatıldı mı?[Out of with body] -> True 105 | ``` 106 | Burada `with File('deneme.txt', 'w')` kısmına kadar `dosya = open(dosya_adi, mod)` kısmı, `as f_write` kısmında `yield dosya ` kısmı çalışıyor ve `dosya` objesi `f_write` identifier'ına atanıyor. `with` bloğunda birtakım işler yaptıktan sonra `with`'den çıkınca dosya otomatik olarak kapatıldığı için `dosya.close()` çalışıyor ve dosya objesi yokediliyor (iyade ediliyor, yok ediliyor (destroy) vs.). Python'da zaten `open` fonksiyonu olduğu için `dosyaisleme` gibi bir fonksiyona ihtiyacınız yok. (Buradaki `yield` statement'i daha sonra göreceksiniz) 107 | 108 | `@contextmanager` decorator yapısının kodunu incelersek `contextlib.py` içerisindeki `_GeneratorContextManager` isimli class'ı kullandığını göreceğiz. Class kodunu incelersek tıpkı bizim yazdığımız yapı gibi `__init__`, `__enter__` ve `__exit__` methodlarını göreceksiniz. 109 | 110 | with deyiminin dosya işlemleri dışında da kullanıldığı bazı yerler: 111 | - Context managerlar 112 | - Descriptorlar ve property methodları 113 | - `__slots__` 114 | - `__new__()` özel metodu 115 | - Singleton sınıflar (ve metaclasslar) 116 | - Enumerationlar (enum modülü) 117 | - Dekoratör fonksiyonlar 118 | - Database, API bağlantıları 119 | 120 | Yararlanabileceğiniz diğer kaynaklar: 121 | - [Real Python](https://realpython.com/python-with-statement/) 122 | - [Kerem Vatandas](https://medium.com/bilişim-hareketi/python-context-manager-159facf118bb) 123 | - [Barış Şimşek](https://www.youtube.com/watch?v=XcY4jDj4VkE) 124 | - [Python Tips](https://book.pythontips.com/en/latest/context_managers.html) 125 | - [Geeks for Geeks](https://www.geeksforgeeks.org/with-statement-in-python/) -------------------------------------------------------------------------------- /python_tutorial/functions/decorators.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Decorators](#1) 4 | 5 |

Decorators

6 | 7 | Python, mevcut bir koda işlevsellik (functionality) eklemek için decorator adı verilen bir özelliğe sahiptir. Buna **metaprogramming** de denir. Çünkü programın bir kısmı, compile time sırasında programın başka bir kısmını değiştirmeye (modify) çalışır. 8 | 9 | Python'da (Class'lar dahil) her şey bir objedir ve bir obje farklı isimlere (identifier) sahip olabilir. Örnek: 10 | ```py 11 | def first(msg): 12 | print(msg) 13 | 14 | second = first 15 | first("Hello") # Output: Hello 16 | second("Hello") # Output: Hello 17 | ``` 18 | Buradaki `first` ve `second` identifier'ları aynı fonksiyon objesine atıfta bulunmaktadır (refers to). 19 | 20 | Bir fonksiyon başka bir fonksiyona argüman olarak verilebilir. Diğer fonksiyonları argüman olarak alan fonksiyonlara **higher order function** denir. 21 | ```py 22 | def inc(x): 23 | return x + 1 24 | 25 | def dec(x): 26 | return x - 1 27 | 28 | def operate(func, x): 29 | result = func(x) 30 | return result 31 | 32 | print(operate(inc, 3)) # Output: 4 33 | print(operate(dec, 3)) # Output: 2 34 | ``` 35 | Buradaki `operate` fonksiyonu higher order function'dır. 36 | 37 | Ayrıca bir fonksiyon başka bir fonksiyonu döndürebilir. Örnek: 38 | ```py 39 | def is_called(): 40 | selamla = "Hello" 41 | def is_returned(): 42 | print(selamla) 43 | return is_returned 44 | 45 | var = is_called() 46 | var() # Output: Hello 47 | 48 | is_called()() # Output: Hello 49 | ``` 50 | Yukarıdaki gibi bir enclosing fonksiyonun içinde tanımlı nested fonksiyonu direkt `return` statement ile döndürmeye ve döndürülen fonksiyonu yukarıdaki gibi kullanmaya **Closure** denir. Closure'ın 3 şartı vardır: 51 | - Nested fonksiyona sahip olmak 52 | - Nested fonksiyon, enclosing fonksiyondaki en az bir value'ya atıfta bulunmalıdır (refers to). 53 | - enclosing fonksiyon, nested fonksiyonu döndürmelidir. 54 | 55 | Bu üç şartı sağlayan nested fonksiyonlar closure olur. Closure'lar, global value'ların kullanımını önleyebilir ve bu sayede bir tür veri gizleme (data hiding) sağlar. Çünkü closure fonksiyondaki variable'lara kullanıcı direkt olarak ulaşamaz (debugger ile falan bakamazsınız) ve fonksiyon çalışmayı sonlandırdıktan sonra local objeler bellekten silinir. 56 | 57 | Bütün fonksiyon objeleri `__closure__` methoduna sahiptir. `__closure__` methodu, enclosing fonksiyonda bulunan objeler arasından closure fonksiyonun kullandığı objeleri (variable, fonksiyon vs.) içeren cell'leri barındıran bir `tuble`'dır. Bu cell'lerdeki objelere de `cell_contents` methodu ile ulaşabilirsiniz. Closure olma şartlarının hepsini sağlayamayan fonksiyonlar closure olamazlar. Closure olmayan fonksiyonların `__closure__` methodu `None` value'suna sahiptir. Örnek: 58 | ```py 59 | def make_multiplier_of(x,y,z,r): 60 | toplam = x+y+z 61 | çarpım = toplam * r 62 | 63 | def number_two(): 64 | return 2 65 | 66 | def multiplier(): 67 | a123 = number_two 68 | print(a123) 69 | result = ((toplam+x+y+z)*çarpım)+a123() 70 | return result 71 | 72 | return multiplier 73 | 74 | var = make_multiplier_of(1,2,3,4) # multiplier fonksiyonunu döndürür. 75 | print(type(var.__closure__)) # Output: 76 | print(make_multiplier_of.__closure__) # Output: None 77 | print(var.__closure__[0], ":", var.__closure__[0].cell_contents) # Output: : .number_two at 0x00000161CABE5040> (number_two fonksiyonu) 78 | print(var.__closure__[1], ":", var.__closure__[1].cell_contents) # Output: : 6 (toplam variable'ı) 79 | print(var.__closure__[2], ":", var.__closure__[2].cell_contents) # Output: : 1 (kullanılan x argümanı) 80 | print(var.__closure__[3], ":", var.__closure__[3].cell_contents) # Output: : 2 (kullanılan y argümanı) 81 | print(var.__closure__[4], ":", var.__closure__[4].cell_contents) # Output: : 3 (kullanılan z argümanı) 82 | print(var.__closure__[5], ":", var.__closure__[5].cell_contents) # Output: : 24 (result veriable'ı) 83 | ``` 84 | 85 | `__call__()` special methodu uygulanan (implements) herhangi bir obje **callable** (çağırılabilir) olarak adlandırılabilir. Decorator callable döndüren bir callable'dir. Basitçe decorator, callable bir objeyi alır, bazı işlevsellik (functionality) ekler ve onu döndürür (`return`). Bir fonksiyonu decore etmek için `@{function_name}` syntax yapısı kullanılır. Örnek: 86 | ```py 87 | def decorator_maker(func): 88 | def inner(): 89 | print("Artık bu bir", end=" ") 90 | func() 91 | return inner 92 | 93 | def decorator_exp(): 94 | print("DECORATOR") 95 | 96 | decorator_exp = decorator_maker(decorator_exp) 97 | decorator_exp() # Output: Artık bu bir DECORATOR 98 | ``` 99 | ```py 100 | def decorator_maker(func): 101 | def inner(): 102 | print("Artık bu bir", end=" ") 103 | func() 104 | return inner 105 | 106 | @decorator_maker 107 | def decorator_exp(): 108 | print("DECORATOR") 109 | 110 | decorator_exp() # Output: Artık bu bir DECORATOR 111 | ``` 112 | Bu iki koddan `decorator_exp = decorator_maker(decorator_exp)` kodu ile `@decorator_maker` decorator'ının eşdeğer olduğu sonucunu çıkarabilirsiniz. Burada `decorator_exp` fonksiyonuna işlevsellik (functionality) eklendi. 113 | 114 | Parametreli fonksiyonları aşağıdaki örnekteki gibi decore edip kullanıyoruz: 115 | ```py 116 | def bölme(func): 117 | def inner(a, b): 118 | print(a, "ve", b, "sayılarının, bölme işlemine göre sonucu:", end=" ") 119 | if b == 0: 120 | print("Ops! Bölünemiyor...") 121 | return 122 | return func(a, b) 123 | return inner 124 | 125 | @bölme 126 | def bölme_işlemi(a, b): 127 | print(a/b) 128 | 129 | bölme_işlemi(4,2) # Output: 4 ve 2 sayılarının, bölme işlemine göre sonucu: 2.0 130 | bölme_işlemi(2,0) # Output: 2 ve 0 sayılarının, bölme işlemine göre sonucu: Ops! Bölünemiyor... 131 | ``` 132 | Burada `inner` fonksiyonu ile decore edilmiş `bölme_işlemi` fonksiyonunun aynı parametrelere sahip olduğunu farketmişsinizdir. Bundan "`inner` nested fonksiyonu decore edilen fonksiyon olarak kullanılıyor, başka bir deyişle decore edilen fonksiyon ile `inner` nested fonksiyonu birbiriyle ilişkilendiriliyor" sonucunu çıkarabilirsiniz. 133 | 134 | İstediğiniz kadar parametreyi `*args` ve `**kwargs` kullanarak tanımlayabilirsiniz. Örnek: 135 | ```py 136 | def printer(func): 137 | def inner(*args, **kwargs): 138 | func(*args, **kwargs) 139 | return inner 140 | 141 | @printer 142 | def prints(*args, **kwargs): 143 | print(*args, **kwargs) 144 | 145 | prints("Merhaba", "Ben", "Python!") # Output: Merhaba Ben Python! 146 | ``` 147 | Burada `**kwargs` tanımlasam da kullanmadım çünkü sadece `*args` ile işimi halledebiliyorum. 148 | 149 | Python'da birden fazla decorator zincirlenebilir (chaining). Yani bir fonksiyon birden fazla farklı (veya aynı) decorator ile decore edilebilir. Örnek: 150 | ```py 151 | def star(func): 152 | def inner(*args, **kwargs): 153 | print("*" * 30) 154 | func(*args, **kwargs) 155 | print("*" * 30) 156 | return inner 157 | 158 | def percent(func): 159 | def inner(*args, **kwargs): 160 | print("%" * 30) 161 | func(*args, **kwargs) 162 | print("%" * 30) 163 | return inner 164 | 165 | @star 166 | @percent 167 | def printer(msg): 168 | print(msg) 169 | 170 | printer(f"{'|'*11} Python {'|'*11}") 171 | ``` 172 | **Output:** 173 | ``` 174 | ****************************** 175 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 176 | ||||||||||| Python ||||||||||| 177 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 178 | ****************************** 179 | ``` 180 | Buradaki decorator'lar `printer = star(percent(printer))` kodu ile eşdeğerdir. Yani en alttaki decorator en içe yazılır ve böyle dışa doğru devam eder. Bu sıra önemlidir, dikkat edin! 181 | 182 | **Dikkat!** Buradan sonraki kısımları anlayabilmek için giriş seviye class bilginiz olmalıdır! 183 | 184 | Callable olan objeler decore edilebilir demiştik. Class'lar da callable bir obje oldukları için decore edilebilirler. Kullanıcının function gibi davranan bir obje yaratabilmesi için function gibi davranan bir obje döndürmesi gerekir. Bu nedenle `__call__` yararlı olabilir. Bir class'ı decore etmek için `@{class_name}` kullanılır. Mantığını anlamak için basit bir örnek: 185 | ```py 186 | class Class_Decorator: 187 | def __init__(self, func): 188 | self.func = func 189 | 190 | def __call__(self): 191 | # `func` çağırmadan önce bazı kodlar ekleyebilirsin 192 | self.func() 193 | # `func` çağırmadan sonra hala bazı kodlar ekleyebilirsin 194 | 195 | @Class_Decorator 196 | def func_exp(): 197 | print("Merhaba Python!") 198 | 199 | func_exp() #Output: Merhaba Python! 200 | ``` 201 | Buradaki mantık fonksiyon decorator'ları ile benzerdir. `@Class_Decorator` decorator'ı ile `func_exp = Class_Decorator(func_exp)` kodu eşdeğerdir. 202 | 203 | `*args` ve `**kwargs` parametrelerini de kullanabiliriz. Örnek: 204 | ```py 205 | class Class_Decorator: 206 | def __init__(self, func): 207 | self.func = func 208 | 209 | def __call__(self, *args, **kwargs): 210 | # `func` çağırmadan önce bazı kodlar ekleyebilirsin 211 | self.func(*args, **kwargs) 212 | # `func` çağırmadan sonra hala bazı kodlar ekleyebilirsin 213 | 214 | @Class_Decorator 215 | def func_exp(name, massage = "Merhaba"): 216 | print(f"{massage} {name}") 217 | 218 | func_exp("Python!") #Output: Merhaba Python! 219 | ``` 220 | 221 | Eğer decore edilen fonksiyon bir değer döndürüyorsa ve döndürülen bu değeri kullanacaksak, `__call__` methoduna bir `return` statement tanımlayabiliriz. Örnek: 222 | ```py 223 | class kare_al_decorator: 224 | def __init__(self, func): 225 | self.func = func 226 | 227 | def __call__(self, *args, **kwargs): 228 | # `func` çağırmadan önce bazı kodlar ekleyebilirsin 229 | return self.func(*args, **kwargs) 230 | 231 | @kare_al_decorator 232 | def kare_al(n): 233 | print(f"{n} sayısının karesi:", end=" ") 234 | return n * n 235 | 236 | print(kare_al(2)) # Output: 2 sayısının karesi: 4 237 | print(kare_al(4)) # Output: 4 sayısının karesi: 16 238 | print(kare_al(8)) # Output: 8 sayısının karesi: 64 239 | ``` -------------------------------------------------------------------------------- /python_tutorial/functions/generators.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Generators (Üreteçler)](#1) 4 | - [`yield` Statement](#1.1) 5 | 6 |

Generators (Üreteçler)

7 | 8 | **Dikkat:** Generator'ü anlatmaya başlamadan önce şunu kafanıza kazıyın! Her generator bir iterator'dır. Çünkü iterator, generator'ı da kapsayan genel bir kavramdır. Yani Generator'lar bir çeşit iterable objedir. 9 | 10 | `def` statement ile tanımladığımız bir fonksiyonun kod block'unun herhangi bir yerinde `yield` statement varsa, bu fonksiyon çağırıldığında bir generator objesi yaratılır (create). Örnek: 11 | ```py 12 | def func(p1): 13 | if p1 == 1: 14 | return 1 15 | else: 16 | yield 2 17 | 18 | exp1 = func(1) 19 | exp2 = func(2) 20 | print(func) # Output: 21 | print(exp1) # Output: 22 | print(exp2) # Output: 23 | ``` 24 | Gördüğünüz gibi `else` bloğu çalışsa da çalışmasa da `func` fonksiyonundan bir generator objesi yaratıldı (create). 25 | 26 | Bir fonksiyon `return` statement ile karşılaşınca sonlanır ve sonlandığı için kapsamındaki objeler ve değerler bellekten silinir ama bir generetor `yield` statement ile karşılaşınca sonlanmaz ve sonlanmadığı için local objeler ve değerler bellekten silinmez. Bu yüzden RAM'in dolmasına sebep olabilir. Bunu RAM'inizin doluluğunu gösteren bir uygulama (windows için görev yöneticisi) ile gözlemleyebilirsiniz. Aşağıda aunı işleve sahip bir fonksiyon ve bir generator örneği verilmiştir: 27 | ```py 28 | def function(): 29 | sayı = 0 30 | def say(): 31 | nonlocal sayı 32 | sayı += 1 33 | return sayı 34 | return say 35 | 36 | say = function() 37 | print(say) # Output: .say at 0x000001862C744040> 38 | print(say()) # Output: 1 39 | print(say()) # Output: 2 40 | print(say()) # Output: 3 41 | 42 | def generator(): 43 | sayı = 0 44 | while True: 45 | sayı += 1 46 | yield sayı 47 | 48 | genr = generator() 49 | print(genr) # Output: 50 | print(next(genr)) # Output: 1 51 | print(next(genr)) # Output: 2 52 | print(next(genr)) # Output: 3 53 | ``` 54 | 55 | Bir generator'a barındırdığı item sayısından fazla `next` methodu ya da fonksiyonu uygulanırsa, item bulunamadığı için generator yinelenemez ve `StopIteration` hatası yükseltilir. Generator objesi sonlandığında (yani `StopIteration` hatası oluştuğunda), local objeler ve değerler bellekten silinir. Örnek: 56 | ```py 57 | def generator(): 58 | i = 1 59 | yield 60 | 61 | genr = generator() 62 | genr.__next__() 63 | print(genr.gi_frame.f_locals) # Output: {'i': 1} 64 | try: 65 | print(next(genr)) # StopIteration 66 | except: 67 | pass 68 | print(genr.gi_frame) # Output: None 69 | ``` 70 | 71 | `next` fonksiyonu ve `__next__()` methodu, uygulandıkları generator objesinin `yield` statement'ları ile ilişkilidir. Yani her next işlemi bir `yield` statement tüketir. Örnek: 72 | ```py 73 | def generator_exp1(): 74 | yield 75 | 76 | gen1 = generator_exp1() 77 | loop_cnt = 0 78 | 79 | try: 80 | for y in range(100): 81 | gen1.__next__() 82 | loop_cnt += 1 83 | 84 | except StopIteration: 85 | print(loop_cnt) 86 | print("StopIteration hatası yükseltildi") 87 | ``` 88 | ``` 89 | 1 90 | StopIteration hatası yükseltildi 91 | ``` 92 | `generator_exp1` bir tane `yield` statement'a sahip olduğu için bu fonksiyondan türetilen generator objesi üzerinde `StopIteration` hatası yükseltilene kadar bir kere yield işlemi yapılabiliyor. Bu yüzden for loop bir kere yineleniyor (`loop_cnt` variable'ının `1` değerine sahip olması bunu kanıtlıyor). 93 | ```py 94 | def generator_exp2(): 95 | yield 96 | yield 97 | 98 | gen2 = generator_exp2() 99 | loop_cnt = 0 100 | 101 | try: 102 | for y in range(100): 103 | gen2.__next__() 104 | loop_cnt += 1 105 | 106 | except StopIteration: 107 | print(loop_cnt) 108 | print("StopIteration hatası yükseltildi") 109 | ``` 110 | ``` 111 | 2 112 | StopIteration hatası yükseltildi 113 | ``` 114 | `generator_exp2` iki tane `yield` statement'a sahip olduğu için bu fonksiyondan türetilen generator objesi üzerinde `StopIteration` hatası yükseltilene kadar iki kere yield işlemi yapılabiliyor. Bu yüzden for loop iki kere yineleniyor (`loop_cnt` variable'ının `2` değerine sahip olması bunu kanıtlıyor). bu iki örnekle "Her next işlemi bir `yield` statement tüketir" iddasını kanıtlamış olduk. Bundan sonra "Generator objesi her next'lendiğinde" dediğimde "Generator objesi her `yield` statement ile karşılaştığında" olarak anlayın. 115 | 116 | **Not:** Generator objeleri fonksiyonlar gibi çağırılabilir (callable) değildir. Çağırmaya çağışırsanız `TypeError: 'generator' object is not callable` hatası yükseltilir. Örnek: 117 | ```py 118 | def generator_exp(): 119 | i = 1 120 | j = 2 121 | k = 3 122 | yield 123 | 124 | gen = generator_exp() 125 | print(callable(generator_exp),callable(gen)) # Output: True False 126 | gen() # TypeError: 'generator' object is not callable 127 | ``` 128 | 129 | **Not:** `return` statement'ın Türkçe karşılığı "döndürmek", `yield` statement'ın Türkçe karşılığı "vermek"dir. Bundan sonra `yield` statement'dan "... değerini yield eder." şeklinde değil "... değerini verir." şeklinde bahsedeceğim. 130 | 131 | **Not:** Bir generator objesinin içerdiği bütün local objeler, bu generator objesinin `gi_frame` (frame objesi) adındaki propery methodunda bulunan `f_locals` dictionary'sinde bulunur. Örnek: 132 | ```py 133 | def generator_exp(): 134 | i = 1 135 | j = 2 136 | k = 3 137 | yield 138 | 139 | gen = generator_exp() 140 | gen.__next__() 141 | print(type(gen.gi_frame)) # Output: 142 | print(type(gen.gi_frame.f_locals)) # Output: 143 | print(gen.gi_frame.f_locals) # Output: {'i': 1, 'j': 2, 'k': 3} 144 | ``` 145 | 146 | ![](./pics/1.png) 147 | 148 | **Not:** `f_locals` dictionary'sindeki veriler, generator objesi her next'lendiğinde güncellenir. Yani generator next'lendiğinde, local variable'ların durumları kaydedilir. Örnek: 149 | ```py 150 | def generator_exp(): 151 | for i in ["a1", "a2"]: 152 | for j in ["b1", "b2"]: 153 | for k in ["c1", "c2"]: 154 | yield 155 | 156 | gen = generator_exp() 157 | 158 | for y in range(100): 159 | gen.__next__() 160 | print(gen.gi_frame.f_locals) 161 | ``` 162 | **Output:** 163 | ``` 164 | {'i': 'a1', 'j': 'b1', 'k': 'c1'} 165 | {'i': 'a1', 'j': 'b1', 'k': 'c2'} 166 | {'i': 'a1', 'j': 'b2', 'k': 'c1'} 167 | {'i': 'a1', 'j': 'b2', 'k': 'c2'} 168 | {'i': 'a2', 'j': 'b1', 'k': 'c1'} 169 | {'i': 'a2', 'j': 'b1', 'k': 'c2'} 170 | {'i': 'a2', 'j': 'b2', 'k': 'c1'} 171 | {'i': 'a2', 'j': 'b2', 'k': 'c2'} 172 | Traceback (most recent call last): 173 | File "d:\TP1.py", line 9, in 174 | gen.__next__() 175 | StopIteration 176 | ``` 177 | 178 | Iterator ile generator'ın farkları şunlardır: 179 | - Generator'lar fonksiyonlar gibi `def` statement ile tanımlanır. Iterator oluşturmak için `iter()` ve `next()` fonksiyonları kullanılır. 180 | 181 | - Generator `yield` statement'ını kullanır ama iterator kullanmaz. 182 | 183 | - Generator `yield` statement ile karşılaşınca local variable'ların durumları kaydedilir. Iterator, local variable'ları kullanmaz. Iterator'a yineleyebileceği (iterate) iterable bir obje vermeniz yeterlidir. Generator ve iterator'ın en büyük farkı budur. 184 | 185 | - Bir generator'a herhangi bir sayıda `yield` statement tanımlanabilir. 186 | 187 | - Bir class'a iterator uygulayarak (implement), iterator ile kullanım desteği kazandırılabilir. Örneğin `list` class'ına `__iter__` methodu uygulandığı (implement) için `list` class'ından türetilen objelerinden yararlanarak `iter()` fonksiyonu ile iterator objesi oluşturabiliyoruz. Generator objesi oluşturmak için bir class'a ihtiyaç yoktur. `yield` statement kullanmanız yeterlidir. Python onu generator objesine dönüştürecektir. 188 | 189 | - Generator oluşturmak için bir Python fonksiyonu (`def` statement ile tanımlanandan bahsediyorum) ya da **Comprehension** kullanabilirsiniz. Iterator oluşturmak için `iter()` fonksiyonlarını kullanmak zorundasınız. 190 | 191 | - Generator objesi ``, `` şeklindedir. Bir iterator, kullanılan iterable type'a (class'a) özel farklı formlar kazanır. Örneğin `list` type bir objeyi kullanarak oluşturulan iterator objesi ``, `` şeklinde; `tuple` type bir objeyi kullanarak oluşturulan iterator objesi `, ` şeklinde olacaktır. Diğer type'ları kendiniz deneyerek keşfedebilirsiniz. 192 | 193 | - iterator'lar generator'lara göre bellek açısından daha verimlidir (memory-efficient). `__sizeof__()` methodunu kullanarak generator'ın bellekte 96, iterator'ın 32 byte yer kapladığını görebilirsiniz. Örnek: 194 | ```py 195 | # For windows 10 pro 196 | iterator_exp = iter(tuple()) 197 | 198 | def generator_exp(): 199 | yield 200 | 201 | print(iterator_exp.__sizeof__()) # Output: 32 202 | print(generator_exp.__sizeof__()) # Output: 96 203 | ``` 204 | 205 | - Generator, ortak rutinlerde (co-routines) daha fazla işlevsellik (functionality) sağlar. 206 | 207 | - Generator'ler ve iterator'ler, **iterable object**'e (yinelenebilir sınıflar) örnektir. 208 | 209 |

yield Statement

210 | 211 | `yield` statement'in temel işlevi yukarıdaki kısımlarda anlatıldı. Bunlara ek olarak `yield` statement aşağıda anlatılan mekaniklere sahiptir. 212 | 213 | Bir generator'ın içinde başka bir generator yinelenebilir. Örnek: 214 | ```py 215 | def generator1(): 216 | yield "generator1 başladı" 217 | yield "generator1 bitti" 218 | 219 | def generator2(): 220 | yield "generator2 başladı" 221 | for i in generator1(): yield i 222 | yield "generator2 bitti" 223 | 224 | for i in generator2(): 225 | print(i) 226 | ``` 227 | **Output:** 228 | ``` 229 | generator2 başladı 230 | generator1 başladı 231 | generator1 bitti 232 | generator2 bitti 233 | ``` 234 | Buradaki olayın aynısı `yield from` kullanılarak elde edilebilir. Örnek: 235 | ```py 236 | def generator1(): 237 | yield "generator1 başladı" 238 | yield "generator1 bitti" 239 | 240 | def generator2(): 241 | yield "generator2 başladı" 242 | yield from generator1() # (generator1 direkt bitene kadar çalışır) 243 | yield "generator2 bitti" 244 | 245 | for i in generator2(): 246 | print(i) 247 | ``` 248 | **Output:** 249 | ``` 250 | generator2 başladı 251 | generator1 başladı 252 | generator1 bitti 253 | generator2 bitti 254 | ``` 255 | Yani `yield from generator1()` ile `for i in generator1(): yield i` aynı işleve sahiptirler. -------------------------------------------------------------------------------- /python_tutorial/functions/iterators.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Iterators (Yenileyiciler)](#1) 4 | 5 |

Iterators (Yenileyiciler)

6 | 7 | **Ön bilgi:** 'Iterate' ile 'Iterate over' kelimelerinin farkı şudur: 8 | - **Iterate:** Bir şeyi bir kere tekrarlamak anlamında kullanılan bir fiildir (repeat). 9 | - **Iterate over:** Bir şeyi sürekli tekrarlamak anlamında kullanılır (repeatedly). 10 | 11 | **Iterator** ile **Iterable** iki farklı kavramdır. Defalarca tekrarlanabilir (can iterate over) herhangi bir obje, iterable (tekrarlanabilir) bir objedir. `str`, `list`, `tuple`, `set`, `frozenset`, `dict`... gibi `__iter__` veya `__getitem__` methodlarına sahip type'lar (class'lar) iterable'dır. Collection type'lar (arrays) genellikle iterable'dir. Bazı collection örnekleri: 12 | 13 | - **List**, indexlenebilir (yani sıralı) ve değiştirilebilir (mutable) bir collection'dır. Duplicate members'a (Bir öğeden birden fazla olması) izin verir. 14 | 15 | - **Tuple**, indexlenebilir (yani sıralı) ve değiştirilemez (immutable) bir collection'dır. Duplicate members'a (Bir öğeden birden fazla olması) izin verir. 16 | 17 | - **Set**, indexlenemez (yani sırasız) ve değiştirilebilir (mutable) bir collection'dır. Duplicate members'a (Bir öğeden birden fazla olması) izin vermez. 18 | 19 | - **Dictionary**, indexlenebilir (yani sıralı) ve değiştirilebilir (mutable) bir collection'dır. Python 3.6'dan önce indexlenemezken (yani sırasız), Python 3.7'den itibaren indexlenebilir (yani sıralı) olmuştur. Duplicate members'a (Bir öğeden birden fazla olması) izin vermez. 20 | 21 | [**`iter()`**](https://docs.python.org/3/library/functions.html#iter "https://docs.python.org/3/library/functions.html#iter") fonksiyonu ile, iterable (tekrarlanabilir) bir objenin template'i (şablonu) kullanılarak bir iterator objesi oluşturulabilir. Bunu mümkün kılmak için iterable (tekrarlanabilir) bir objenin class'ının, iterator döndüren bir `__iter__` ya da `0` ile başlayan sıralı (sequential) index'lere sahip `__getitem__` methoduna ihtiyacı vardır. 22 | 23 | **Not:** Oluşturulan bu iterator objesi ile iterable obje arasında birbirlerini etkileyecek bir ilişki yoktur, birbirlerinden bağımsız/farklı objelerdir. Örnek: 24 | ```py 25 | liste1 = [1,2,3] 26 | liste2 = iter(liste1) 27 | 28 | print((type(liste1))) # Output: 29 | print((type(liste2))) # Output: 30 | print(liste1) # Output: [1, 2, 3] 31 | print(liste2) # Output: 32 | print(liste1 == liste2) # Output: False 33 | print(liste1 is liste2) # Output: False 34 | ``` 35 | 36 | **Not:** Bütün iterator'ler iterable'dir ama her iterable obje, iterator değildir. Örneğin `list` type bir obje iterable'dır ama iterator değildir. 37 | 38 | **Not:** `iter()` fonksiyonuna iterable (tekrarlanabilir) olmayan bir obje verilirse, `TypeError` hatası yükseltilir. Örnek: 39 | ```py 40 | temp = 123 41 | a = iter(temp) # TypeError: 'int' object is not iterable 42 | ``` 43 | 44 | Iterable bir obje tekrarlanamaz, yani içinde gezinemezsiniz. Iterator bir obje tekrarlanabilir, yani içinde gezinilebilir. Iterator'ler bunu mümkün kılan `__next__()` methoduna sahiptir. `__next__()` methodu veya `next()` build-in fonksiyonu kullanılarak bir iterator üzerinde iterate işlemi yapılabilir. Örnek: 45 | ```py 46 | liste = ["l", "i", "s", "t", "e"] 47 | liste_iter1 = iter(liste) 48 | liste_iter2 = iter(liste) 49 | 50 | print(next(liste_iter1)) # Output: l 51 | print(next(liste_iter1)) # Output: i 52 | print(next(liste_iter1)) # Output: s 53 | print(next(liste_iter1)) # Output: t 54 | print(next(liste_iter1)) # Output: e 55 | 56 | print(liste_iter2.__next__()) # Output: l 57 | print(liste_iter2.__next__()) # Output: i 58 | print(liste_iter2.__next__()) # Output: s 59 | print(liste_iter2.__next__()) # Output: t 60 | print(liste_iter2.__next__()) # Output: e 61 | ``` 62 | 63 | Bir iterator, içerdiği item sayısından fazla yenilenirse, başka kullanılabilir item bulamadığı için `StopIteration` hatası yükseltilir. Örnek: 64 | ```py 65 | liste = [1,2,3] 66 | iterator_exp1 = iter(liste) 67 | iterator_exp2 = iter(liste) 68 | 69 | print(iterator_exp2.__next__()) # Output: 1 70 | print(iterator_exp2.__next__()) # Output: 2 71 | print(iterator_exp2.__next__()) # Output: 3 72 | print(iterator_exp2.__next__()) # Output: StopIteration 73 | 74 | print(next(iterator_exp1)) # Output: 1 75 | print(next(iterator_exp1)) # Output: 2 76 | print(next(iterator_exp1)) # Output: 3 77 | print(next(iterator_exp1)) # Output: StopIteration 78 | ``` 79 | -------------------------------------------------------------------------------- /python_tutorial/functions/pics/1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/functions/pics/1.png -------------------------------------------------------------------------------- /python_tutorial/import_system/packets.md: -------------------------------------------------------------------------------- 1 | Paketler konusu için [Yazbel](https://python-istihza.yazbel.com/paketler.html) gayet yeterli bir kaynaktır. Buna ek olarak: 2 | - Windows için bütün modül ve paketleri upgrade (güncelleme de denebilir) etmek için PowerShell'i açın ve şu kodu yazın: 3 | ``` 4 | pip freeze | %{$_.split('==')[0]} | %{pip install --upgrade $_} 5 | ``` 6 | - Windows için `pip`'i upgrade (güncelleme de denebilir) etmek için PowerShell'i açın ve şu kodu yazın: 7 | ``` 8 | python -m pip install --upgrade pip 9 | ``` -------------------------------------------------------------------------------- /python_tutorial/modules/json/genel.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [İçindekiler](#i̇çindekiler) 4 | 5 |

JSON Nedir?

6 | 7 | Structured data'ları temsil etmek için kullanılan bir veri formatıdır. JSON, **J**ava**S**cript **O**bject **N**otation olarak da bilinir. JSON dosyaları, `.json` uzantılıdır. Python, JSON dosyalarıyla çalışmak için `json` modülüne sahiptir. JSON, JSON stringleriyle çalışır. JSON stringleri, Python dict yapısının tırnak içinde yazılarak yazılarak oluşturulan `str` type objelerdir. JSON stringleri üzerinde işlem yapabilmek için JSON to dict/dict to JSON string işlemleri yapmamız gerekiyor. 8 | 9 |

JSON to Dict

10 | 11 | JSON stringlerini Python dict yapısına çevirmek için `json.loads()` fonksiyonunu kullanırız. Syntax: 12 | ```py 13 | import json 14 | 15 | json.loads(s, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw) 16 | ``` 17 | - `s` parametresi, JSON stringi olmalıdır. 18 | - `cls` parametresi, JSON stringini dict yapısına çevirmek için kullanılacak class'ı temsil eder. 19 | - `object_hook` parametresi, JSON stringini dict yapısına çevirmek için kullanılacak fonksiyonu temsil eder. 20 | - `parse_float` parametresi, JSON stringindeki float değerleri çevirmek için kullanılacak fonksiyonu temsil eder. 21 | - `parse_int` parametresi, JSON stringindeki int değerleri çevirmek için kullanılacak fonksiyonu temsil eder. 22 | - `parse_constant` parametresi, JSON stringindeki sabit değerleri çevirmek için kullanılacak fonksiyonu temsil eder. 23 | - `object_pairs_hook` parametresi, JSON stringini dict yapısına çevirmek için kullanılacak fonksiyonu temsil eder. 24 | ```py 25 | import json 26 | 27 | json_string = '{"name": "John", "age": 30, "city": "New York"}' 28 | python_dict = json.loads(json_string) 29 | print(python_dict, type(python_dict)) 30 | ``` 31 | **Output:** 32 | ``` 33 | {'name': 'John', 'age': 30, 'city': 'New York'} 34 | ``` 35 | 36 |

Dict to JSON

37 | 38 | Python dict yapısını JSON stringine çevirmek için `json.dumps()` fonksiyonunu kullanırız. Syntax: 39 | ```py 40 | import json 41 | 42 | json.dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw) 43 | ``` 44 | - `obj` parametresi, dict yapısı olmalıdır. 45 | - `skipkeys` parametresi, dict yapısındaki key'lerin JSON stringine çevrilip çevrilmediğini belirler. 46 | - `ensure_ascii` parametresi, JSON stringindeki karakterlerin ASCII karakterlerine çevrilip çevrilmediğini belirler. 47 | - `check_circular` parametresi, dict yapısındaki circular referansları kontrol edip edilmeyeceğini belirler. 48 | - `allow_nan` parametresi, JSON stringindeki `NaN` ve `Infinity` değerlerinin çevrilip çevrilmediğini belirler. 49 | - `cls` parametresi, JSON stringini dict yapısına çevirmek için kullanılacak class'ı temsil eder. 50 | - `indent` parametresi, JSON stringindeki boşluk sayısını belirler. 51 | - `separators` parametresi, JSON stringindeki key-value ve eleman arasındaki ayırıcıyı belirler. 52 | - `default` parametresi, JSON stringini dict yapısına çevirmek için kullanılacak fonksiyonu temsil eder. 53 | - `sort_keys` parametresi, JSON stringindeki key'lerin sıralanıp sıralanmayacağını belirler. 54 | ```py 55 | import json 56 | 57 | python_dict = {"name": "John", "age": 30, "city": "New York"} 58 | json_string = json.dumps(python_dict) 59 | print(json_string, type(json_string)) 60 | ``` 61 | **Output:** 62 | ```json 63 | {"name": "John", "age": 30, "city": "New York"} 64 | ``` 65 | 66 |

Python read JSON file

67 | 68 | JSON dosyalarını okumak için `json.load()` fonksiyonunu kullanırız. Syntax: 69 | ```py 70 | import json 71 | 72 | json.load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw) 73 | ``` 74 | - `fp` parametresi, JSON dosyasının bulunduğu dosya objesidir. 75 | - `cls` parametresi, JSON stringini dict yapısına çevirmek için kullanılacak class'ı temsil eder. 76 | - `object_hook` parametresi, JSON stringini dict yapısına çevirmek için kullanılacak fonksiyonu temsil eder. 77 | - `parse_float` parametresi, JSON stringindeki float değerleri çevirmek için kullanılacak fonksiyonu temsil eder. 78 | - `parse_int` parametresi, JSON stringindeki int değerleri çevirmek için kullanılacak fonksiyonu temsil eder. 79 | - `parse_constant` parametresi, JSON stringindeki sabit değerleri çevirmek için kullanılacak fonksiyonu temsil eder. 80 | - `object_pairs_hook` parametresi, JSON stringini dict yapısına çevirmek için kullanılacak fonksiyonu temsil eder. 81 | ```py 82 | import json 83 | 84 | with open("data.json", "r") as f: 85 | python_dict = json.load(f) 86 | print(python_dict, type(python_dict)) 87 | ``` 88 | **Output:** 89 | ``` 90 | {'name': 'John', 'age': 30, 'city': 'New York'} 91 | ``` 92 | 93 |

Python write JSON file

94 | 95 | Python dict yapısını JSON dosyasına yazmak için `json.dump()` fonksiyonunu kullanırız. Syntax: 96 | ```py 97 | import json 98 | 99 | json.dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw) 100 | ``` 101 | - `obj` parametresi, dict yapısı olmalıdır. 102 | - `fp` parametresi, JSON dosyasının bulunduğu dosya objesidir. 103 | - `skipkeys` parametresi, dict yapısındaki key'lerin JSON stringine çevrilip çevrilmediğini belirler. 104 | - `ensure_ascii` parametresi, JSON stringindeki karakterlerin ASCII karakterlerine çevrilip çevrilmediğini belirler. 105 | - `check_circular` parametresi, dict yapısındaki circular referansları kontrol edip edilmeyeceğini belirler. 106 | - `allow_nan` parametresi, JSON stringindeki `NaN` ve `Infinity` değerlerinin çevrilip çevrilmediğini belirler. 107 | - `cls` parametresi, JSON stringini dict yapısına çevirmek için kullanılacak class'ı temsil eder. 108 | - `indent` parametresi, JSON stringindeki boşluk sayısını belirler. 109 | - `separators` parametresi, JSON stringindeki key-value ve eleman arasındaki ayırıcıyı belirler. 110 | - `default` parametresi, JSON stringini dict yapısına çevirmek için kullanılacak fonksiyonu temsil eder. 111 | - `sort_keys` parametresi, JSON stringindeki key'lerin sıralanıp sıralanmayacağını belirler. 112 | ```py 113 | import json 114 | 115 | python_dict = {"name": "John", "age": 30, "city": "New York"} 116 | with open("data.json", "w") as f: 117 | json.dump(python_dict, f) 118 | ``` -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/arithmetic_functions.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Arithmetic Functions](#1) 4 | - [add](#1.1) 5 | - [subtract](#1.2) 6 | - [multiply](#1.3) 7 | - [divide](#1.4) 8 | - [power](#1.5) 9 | - [mod](#1.6) 10 | - [remainder](#1.7) 11 | - [fmod](#1.8) 12 | - [absolute](#1.9) 13 | - [negative](#1.10) 14 | - [positive](#1.11) 15 | - [sign](#1.12) 16 | - [reciprocal](#1.13) 17 | - [real](#1.14) 18 | - [imag](#1.15) 19 | - [conj](#1.16) 20 | - [angle](#1.17) 21 | - [sum](#1.18) 22 | 23 |

Arithmetic Functions

24 | 25 |

add(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

26 | 27 | `x1` ve `x2` parametrelerine girilen array'lerin tüm değerlerinin toplamını alır. Örnek: 28 | ```py 29 | import numpy as np 30 | 31 | x1 = np.array([10, 20, 30]) 32 | x2 = np.array([1, 2, 3]) 33 | 34 | print(np.add(x1, x2)) 35 | ``` 36 | **Output:** 37 | ``` 38 | [11 22 33] 39 | ``` 40 | 41 |

subtract(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

42 | 43 | `x1` ve `x2` parametrelerine girilen array'lerin tüm değerlerinin farkını alır. Örnek: 44 | ```py 45 | import numpy as np 46 | 47 | x1 = np.array([10, 20, 30]) 48 | x2 = np.array([1, 2, 3]) 49 | 50 | print(np.subtract(x1, x2)) 51 | ``` 52 | **Output:** 53 | ``` 54 | [ 9 18 27] 55 | ``` 56 | 57 |

multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

58 | 59 | `x1` ve `x2` parametrelerine girilen array'lerin tüm değerlerinin çarpımını alır. Örnek: 60 | ```py 61 | import numpy as np 62 | 63 | x1 = np.array([10, 20, 30]) 64 | 65 | print(np.multiply(x1, 2)) 66 | ``` 67 | **Output:** 68 | ``` 69 | [20 40 60] 70 | ``` 71 | 72 |

divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

73 | 74 | `x1` ve `x2` parametrelerine girilen array'lerin tüm değerlerinin bölümünü alır. Örnek: 75 | ```py 76 | import numpy as np 77 | 78 | x1 = np.array([10, 20, 30]) 79 | 80 | print(np.divide(x1, 2)) 81 | ``` 82 | **Output:** 83 | ``` 84 | [ 5. 10. 15.] 85 | ``` 86 | 87 |

power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

88 | 89 | `x1` ve `x2` parametrelerine girilen array'lerin tüm değerlerinin üssünü alır. Örnek: 90 | ```py 91 | import numpy as np 92 | 93 | x1 = np.array([10, 20, 30]) 94 | 95 | print(np.power(x1, 2)) 96 | ``` 97 | **Output:** 98 | ``` 99 | [ 100 400 900] 100 | ``` 101 | 102 |

mod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

103 | 104 | `x1` ve `x2` parametrelerine girilen array'lerin tüm değerlerinin modunu alır. Örnek: 105 | ```py 106 | import numpy as np 107 | 108 | x1 = np.array([10, 20, 30]) 109 | 110 | print(np.mod(x1, 2)) 111 | ``` 112 | **Output:** 113 | ``` 114 | [0 0 0] 115 | ``` 116 | 117 |

remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

118 | 119 | `x1` ve `x2` parametrelerine girilen array'lerin tüm değerlerinin kalanını alır. Örnek: 120 | ```py 121 | import numpy as np 122 | 123 | x1 = np.array([10, 20, 30]) 124 | 125 | print(np.remainder(x1, 2)) 126 | ``` 127 | **Output:** 128 | ``` 129 | [0 0 0] 130 | ``` 131 | 132 |

fmod(x1, x2, /[, out1, out2, where, casting, order, dtype, subok, signature, extobj]) Methodu

133 | 134 | `x1` ve `x2` parametrelerine girilen array'lerin tüm değerlerinin kalanını alır. Örnek: 135 | ```py 136 | import numpy as np 137 | 138 | x1 = np.array([10, 20, 30]) 139 | 140 | print(np.fmod(x1, 2)) 141 | ``` 142 | **Output:** 143 | ``` 144 | [0 0 0] 145 | ``` 146 | 147 |

absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

148 | 149 | `x` parametresine girilen array'in tüm değerlerinin mutlak değerini alır. Örnek: 150 | ```py 151 | import numpy as np 152 | 153 | x = np.array([-1, 2, -3, 4]) 154 | 155 | print(np.absolute(x)) 156 | ``` 157 | **Output:** 158 | ``` 159 | [1 2 3 4] 160 | ``` 161 | 162 |

negative(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

163 | 164 | `x` parametresine girilen array'in tüm değerlerinin negatifini alır. Örnek: 165 | ```py 166 | import numpy as np 167 | 168 | x = np.array([-1, 2, -3, 4]) 169 | 170 | print(np.negative(x)) 171 | ``` 172 | **Output:** 173 | ``` 174 | [ 1 -2 3 -4] 175 | ``` 176 | 177 |

positive(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

178 | 179 | `x` parametresine girilen array'in tüm değerlerinin pozitifini alır. Örnek: 180 | ```py 181 | import numpy as np 182 | 183 | x = np.array([-1, 2, -3, 4]) 184 | 185 | print(np.positive(x)) 186 | ``` 187 | **Output:** 188 | ``` 189 | [-1 2 -3 4] 190 | ``` 191 | 192 |

sign(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

193 | 194 | `x` parametresine girilen array'in tüm değerlerinin işaretini alır. Örnek: 195 | ```py 196 | import numpy as np 197 | 198 | x = np.array([-1, 2, -3, 4]) 199 | 200 | print(np.sign(x)) 201 | ``` 202 | **Output:** 203 | ``` 204 | [-1 1 -1 1] 205 | ``` 206 | 207 |

reciprocal(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

208 | 209 | `x` parametresine girilen array'in tüm değerlerinin tersini alır. Örnek: 210 | ```py 211 | import numpy as np 212 | 213 | x = np.array([1, 2, 3, 4]) 214 | 215 | print(np.reciprocal(x)) 216 | ``` 217 | **Output:** 218 | ``` 219 | [1. 0.5 0.33333333 0.25 ] 220 | ``` 221 | 222 |

real(val) Methodu

223 | 224 | `val` parametresine girilen array'in tüm değerlerinin reel kısmını alır. Örnek: 225 | ```py 226 | import numpy as np 227 | 228 | val = np.array([1+2j, 3+4j, 5+6*1j]) 229 | 230 | print(np.real(val)) 231 | ``` 232 | **Output:** 233 | ``` 234 | [1. 3. 5.] 235 | ``` 236 | 237 |

imag(val) Methodu

238 | 239 | `val` parametresine girilen array'in tüm değerlerinin sanal kısmını alır. Örnek: 240 | ```py 241 | import numpy as np 242 | 243 | val = np.array([1+2j, 3+4j, 5+6*1j]) 244 | 245 | print(np.imag(val)) 246 | ``` 247 | **Output:** 248 | ``` 249 | [2. 4. 6.] 250 | ``` 251 | 252 |

conj(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

253 | 254 | `x` parametresine girilen array'in tüm değerlerinin kompleks kongüjünü alır. Örnek: 255 | ```py 256 | import numpy as np 257 | 258 | x = np.array([1+2j, 3+4j, 5+6j]) 259 | 260 | print(np.conj(x)) 261 | ``` 262 | **Output:** 263 | ``` 264 | [1.-2.j 3.-4.j 5.-6.j] 265 | ``` 266 | 267 |

angle(z, /, deg=False) Methodu

268 | 269 | `z` parametresine girilen array'in tüm değerlerinin açısını alır. Örnek: 270 | ```py 271 | import numpy as np 272 | 273 | z = np.array([1+2j, 3+4j, 5+6j]) 274 | 275 | print(np.angle(z)) 276 | ``` 277 | **Output:** 278 | ``` 279 | [1.10714872 0.92729522 0.87605805] 280 | ``` 281 | 282 |

sum(a, axis=None, dtype=None, ...) Methodu

283 | 284 | Uygulandığı array'in elementlerinin toplamını döndürür. Örnek: 285 | 286 | ```py 287 | import numpy as np 288 | a = np.array([[1,2],[3,4]]) 289 | print(a.sum()) # Output: 10 290 | ``` 291 | `axis` parametresinde belirttiğiniz axis'e göre farklı axisler arasında toplama işlemi yapar. Örnek: 292 | ```py 293 | import numpy as np 294 | a = np.array([[[1,1,1],[2,2,2]],[[3,3,3],[4,4,4]]]) 295 | print(a,end="\n-----------\n") 296 | print(a.sum(axis=0),end="\n-----------\n") 297 | print(a.sum(axis=1),end="\n-----------\n") 298 | print(a.sum(axis=2)) 299 | ``` 300 | **Output:** 301 | ``` 302 | [[[1 1 1] 303 | [2 2 2]] 304 | 305 | [[3 3 3] 306 | [4 4 4]]] 307 | ----------- 308 | [[4 4 4] 309 | [6 6 6]] 310 | ----------- 311 | [[3 3 3] 312 | [7 7 7]] 313 | ----------- 314 | [[ 3 6] 315 | [ 9 12]] 316 | ``` -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/binary_functions.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Binary Functions](#1) 4 | -[`bitwise_and` Methodu](#1.1) 5 | -[`bitwise_or` Methodu](#1.2) 6 | -[`bitwise_xor` Methodu](#1.3) 7 | -[`invert` Methodu](#1.4) 8 | -[`left_shift` Methodu](#1.5) 9 | -[`right_shift` Methodu](#1.6) 10 | - [Byte Swapping](#2) 11 | - [`ndarray.byteswap` Attribute'u](#2.1) 12 | 13 |

Binary Functions

14 | 15 |

bitwise_and(x1, x2, /, out=None, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

16 | 17 | `x1` ve `x2` parametrelerine girilen array'lerin bitleri arasında `and` işlemi yapar. Örnek: 18 | ```py 19 | import numpy as np 20 | 21 | a = np.array([1,2,3,4,5]) 22 | b = np.array([5,4,3,2,1]) 23 | 24 | print(np.bitwise_and(a,b)) 25 | ``` 26 | **Output:** 27 | ``` 28 | [1 0 3 0 1] 29 | ``` 30 | 31 |

bitwise_or(x1, x2, /, out=None, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

32 | 33 | `x1` ve `x2` parametrelerine girilen array'lerin bitleri arasında `or` işlemi yapar. Örnek: 34 | ```py 35 | import numpy as np 36 | 37 | a = np.array([1,2,3,4,5]) 38 | b = np.array([5,4,3,2,1]) 39 | 40 | print(np.bitwise_or(a,b)) 41 | ``` 42 | **Output:** 43 | ``` 44 | [5 6 3 6 5] 45 | ``` 46 | 47 |

bitwise_xor(x1, x2, /, out=None, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

48 | 49 | `x1` ve `x2` parametrelerine girilen array'lerin bitleri arasında `xor` işlemi yapar. Örnek: 50 | ```py 51 | import numpy as np 52 | 53 | a = np.array([1,2,3,4,5]) 54 | b = np.array([5,4,3,2,1]) 55 | 56 | print(np.bitwise_xor(a,b)) 57 | ``` 58 | **Output:** 59 | ``` 60 | [4 6 0 6 4] 61 | ``` 62 | 63 |

invert(x, /, out=None, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

64 | 65 | `x` parametresine girilen array'in bitleri arasında `not` işlemi yapar. Örnek: 66 | ```py 67 | import numpy as np 68 | 69 | a = np.array([1,2,3,4,5]) 70 | 71 | print(np.invert(a)) 72 | ``` 73 | **Output:** 74 | ``` 75 | [-2 -3 -4 -5 -6] 76 | ``` 77 | 78 |

left_shift(x1, x2, /, out=None, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

79 | 80 | `x1` parametresine girilen array'in bitleri arasında `x2` parametresine girilen değer kadar sola kaydırma işlemi yapar. Örnek: 81 | ```py 82 | import numpy as np 83 | 84 | a = np.array([1,2,3,4,5]) 85 | 86 | print(np.left_shift(a,2)) 87 | ``` 88 | **Output:** 89 | ``` 90 | [4 8 12 16 20] 91 | ``` 92 | 93 |

right_shift(x1, x2, /, out=None, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

94 | 95 | `x1` parametresine girilen array'in bitleri arasında `x2` parametresine girilen değer kadar sağa kaydırma işlemi yapar. Örnek: 96 | ```py 97 | import numpy as np 98 | 99 | a = np.array([1,2,3,4,5]) 100 | 101 | print(np.right_shift(a,2)) 102 | ``` 103 | **Output:** 104 | ``` 105 | [0 0 0 1 1] 106 | ``` 107 | 108 |

Byte Swapping

109 | 110 |

ndarray.byteswap(inplace=False) Methodu

111 | 112 | `ndarray`'in byte'larını değiştirir. Örnek: 113 | ```py 114 | import numpy as np 115 | 116 | x = np.array([1, 256, 8755], dtype=np.int16) 117 | 118 | print(x.byteswap(True)) 119 | ``` 120 | **Output:** 121 | ``` 122 | [ 256 1 22124] 123 | ``` -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/broadcasting.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Broadcasting](#1) 4 | 5 |

Broadcasting

6 | 7 | Array'ler arasında işlem yapma kabiliyetine **broadcasting** denir. Broadcasting'in mümkün olabilmesi için vector ve bir scalar veya uyumlu boyutlardaki arrayler arasında işlem yapılmalıdır. Farklı boyutlardaki arrayler arasında doğrudan işlem yapamazsınız. Farklı boyutlardaki arrayler arasında işlem yapılabilmesi için boyutları uyumlu hale getirilmelidir. Bunun için arraylerin boyutlarından en küçük olanı, diğer arrayin boyutlarına uygun şekilde yayımlanmalıdır (broadcasting). Örnek: 8 | ```py 9 | import numpy as np 10 | 11 | a = np.array([1,2,3,4,5]) 12 | print(a + 1) # Output: [2 3 4 5 6] (vector + scalar) 13 | 14 | a = np.array([[1,2,3],[4,5,6]]) 15 | b = np.array([1,2,3]) 16 | print(a + b) # Output: [[2 4 6] [5 7 9]] (array + vector) 17 | 18 | a = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]]) 19 | b = np.array([[1,2,3],[4,5,6]]) 20 | print(a+b) # Output: [[[ 2 4 6] [ 8 10 12]] [[ 8 10 12] [14 16 18]]] (array + array) 21 | ``` 22 | Gördüğünüz gibi `a` arrayinin boyutu `(2,3)` iken `b` arrayinin boyutu `(3,)` olduğu için daha küçük bir array olan `b`, uyumlu shape'e sahip olmaları için daha büyük array olan `a` boyutuna yayımlanlanmıştır (broadcast to). Ardından `a` ile `b` arrayleri arasında element-to-element işlemi yapmak mümkün olmuştur. Bu yayımlama (broadcast to) işlemini `broadcast_to` fonksiyonu ile de yapabilirsiniz. Örnek: 23 | ```py 24 | import numpy as np 25 | 26 | a = np.array([1,2,3]) 27 | print(np.broadcast_to(a,(2,3))) # Output: [[1 2 3] [1 2 3]] 28 | ``` 29 | Daha fazla bilgi için [tıklayın](https://numpy.org/doc/1.23/user/basics.broadcasting.html). -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/copy_view.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Copy & View](#1) 4 | 5 |

Copy & View

6 | 7 | NumPy'da array'lerin kopyalanması ve görünümü (view) alınması iki farklı işlemdir. Kopyalam işlemi, array'i her şeyiyle birlikte kopyalar. Görünüm almak ise array'in sadece görünümünü alır. Bu işlemler aşağıdaki şekilde gerçekleştirilir: Örnek: 8 | ```py 9 | # view 10 | import numpy as np 11 | arr = np.array([[10,10], [2,3], [4,5]]) 12 | 13 | print('Array arr is:', arr, sep="\n", end="\n\n") 14 | 15 | print('Create a view of arr: b = a.view()') 16 | b = arr.view() 17 | print('Array b is:', b, sep="\n", end="\n\n") 18 | 19 | print('b is arr:', b is arr, end="\n\n") 20 | 21 | print ('Change the contents of b: b[0,0] = 100') 22 | b[0,0] = 100 23 | print('Modified array b:', b, sep="\n") 24 | print('arr remains unchanged:', arr, sep="\n") 25 | ``` 26 | **Output:** 27 | ``` 28 | Array arr is: 29 | [[10 10] 30 | [ 2 3] 31 | [ 4 5]] 32 | 33 | Create a view of arr: b = a.view() 34 | Array b is: 35 | [[10 10] 36 | [ 2 3] 37 | [ 4 5]] 38 | 39 | b is arr: False 40 | 41 | Change the contents of b: b[0,0] = 100 42 | Modified array b: 43 | [[100 10] 44 | [ 2 3] 45 | [ 4 5]] 46 | arr remains unchanged: 47 | [[100 10] 48 | [ 2 3] 49 | [ 4 5]] 50 | ``` 51 | ```py 52 | # Copy 53 | import numpy as np 54 | arr = np.array([[10,10], [2,3], [4,5]]) 55 | 56 | print('Array arr is:', arr, sep="\n", end="\n\n") 57 | 58 | print('Create a deep copy of arr: b = a.copy()') 59 | b = arr.copy() 60 | print('Array b is:', b, sep="\n", end="\n\n") 61 | 62 | print('b is arr:', b is arr, end="\n\n") 63 | 64 | print ('Change the contents of b: b[0,0] = 100') 65 | b[0,0] = 100 66 | print('Modified array b:', b, sep="\n") 67 | print('arr remains unchanged:', arr, sep="\n") 68 | ``` 69 | **Output:** 70 | ``` 71 | Array a is: 72 | [[10 10] 73 | [ 2 3] 74 | [ 4 5]] 75 | 76 | Create a deep copy of a: b = a.copy() 77 | Array b is: 78 | [[10 10] 79 | [ 2 3] 80 | [ 4 5]] 81 | 82 | Can we write b is a False 83 | 84 | Change the contents of b: b[0,0] = 100 85 | Modified array b: 86 | [[100 10] 87 | [ 2 3] 88 | [ 4 5]] 89 | a remains unchanged: 90 | [[10 10] 91 | [ 2 3] 92 | [ 4 5]] 93 | ``` 94 | Gördüğünüz gibi `view` işlemi ile array'in sadece görünümünü alındığı için orjinal array'de yapılan değişiklikler görünüm alınan array'de de görünür. `copy` işlemi ise array'i tamamen kopyalayıp orjinal array'den tamamen bağımsız bir array oluşturur. Bu yüzden orjinal array'de yapılan değişiklikler kopyalanan array'de görünmez. -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/functions_for_rounding.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Functions for Rounding`](#1) 4 | - [`around` Methodu](#1.1) 5 | - [`floor` Methodu](#1.2) 6 | - [`ceil` Methodu](#1.3) 7 | 8 | 9 |

Functions for Rounding

10 | 11 |

around(a, decimals=0, out=None) Methodu

12 | 13 | `a` parametresine girilen array'in tüm değerlerinin belirtilen `decimals` parametresine göre yuvarlanmasını sağlar. Örnek: 14 | ```py 15 | import numpy as np 16 | 17 | x = np.array([1.0, 5.55, 123, 0.567, 25.532]) 18 | 19 | print(np.around(x)) 20 | print(np.around(x, decimals=1)) 21 | print(np.around(x, decimals=-1)) 22 | ``` 23 | **Output:** 24 | ``` 25 | [ 1. 6. 123. 1. 26.] 26 | [ 1. 5.6 123. 0.6 25.5] 27 | [ 0. 10. 120. 0. 30.] 28 | ``` 29 | 30 |

floor(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

31 | 32 | `x` parametresine girilen array'in tüm değerlerinin alt değerini alır. Örnek: 33 | ```py 34 | import numpy as np 35 | 36 | x = np.array([-1.7, 1.5, -0.2, 0.6, 10]) 37 | 38 | print(np.floor(x)) 39 | ``` 40 | **Output:** 41 | ``` 42 | [-2. 1. -1. 0. 10.] 43 | ``` 44 | 45 |

ceil(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

46 | 47 | `x` parametresine girilen array'in tüm değerlerinin üst değerini alır. Örnek: 48 | ```py 49 | import numpy as np 50 | 51 | x = np.array([-1.7, 1.5, -0.2, 0.6, 10]) 52 | 53 | print(np.ceil(x)) 54 | ``` 55 | **Output:** 56 | ``` 57 | [-1. 2. -0. 1. 10.] 58 | ``` -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/i_o_operations.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [](#1) 4 | - [`` Methodu](#1.1) 5 | - [`` Methodu](#1.2) 6 | - [`` Methodu](#1.3) 7 | 8 |

I/O with NumPy

9 | 10 | `ndarray` objeleri disk üzerinde saklanabilir ve tekrar yüklenerek kullanılabilir. Bunun için kullanılan fonksiyonlar şunlardır: 11 | - `save(file, arr, allow_pickle=True, fix_imports=True)`: `arr` parametresine girilen `ndarray` objesini `file` parametresinde belirtilen dosyaya kaydeder. Oluşturulan dosya `.npy` uzantılıdır. 12 | - `savez(file, *args, **kwds)`: `save()` fonksiyonu ile aynı işlevi görür, fakat birden fazla `ndarray` objesi kaydedilebilir. Oluşturulan dosya `.npz` uzantılıdır. 13 | - `savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='', header='', footer='', comments='# ', encoding=None)`: `X` parametresine girilen `ndarray` objesini `fname` parametresinde belirtilen dosyaya kaydeder. Oluşturulan dosya `.csv` ya da `.txt` uzantılıdır. 14 | - `load(file, mmap_mode=None, allow_pickle=False, fix_imports=True, encoding='ASCII')`: `file` parametresinde belirtilen dosyayı yükler ve `ndarray` objesi olarak döndürür. 15 | - `loadtxt(fname, dtype=, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0, encoding='bytes', max_rows=None)`: `fname` parametresinde belirtilen dosyayı yükler ve `ndarray` objesi olarak döndürür. 16 | 17 | ```py 18 | import numpy as np 19 | 20 | a1 = np.array([1, 2, 3]) 21 | a2 = np.array([4, 5, 6]) 22 | a3 = np.array([7, 8, 9]) 23 | np.save("file1", a1) 24 | np.savez("file2",a2,a3) 25 | b1 = np.load("file1.npy") 26 | b2 = np.load("file2.npz") 27 | print(b1) # Output: [1 2 3] 28 | print(b2) # Output: 29 | ``` 30 | ```py 31 | import numpy as np 32 | 33 | a = np.array([1, 2, 3, 4, 5, 6, 7, 8]) 34 | np.savetxt('new_file.csv', a) 35 | np.savetxt('new_file.txt', a) 36 | b1 = np.loadtxt('new_file.csv') 37 | b2 = np.loadtxt('new_file.txt') 38 | print(b1) # Output: [1. 2. 3. 4. 5. 6. 7. 8.] 39 | print(b2) # Output: [1. 2. 3. 4. 5. 6. 7. 8.] 40 | ``` 41 | 42 | **Not:** Metin dosyaları ile uğraşmak ve paylaşmak daha kolay olsa bile `.npy` ve `.npz` dosyaları daha küçük boyuttadır ve daha hızlı okunur. -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/indexing_slicing.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Indexing ve Slicing](#1) 4 | 5 |

Indexing ve Slicing

6 | 7 | Array'in elementlerine aynı Python'ın build-in container objelerindeki gibi index numarası ile erişebilirsiniz. Birden fazla indexleme yöntemi mevcuttur: 8 | - **Integer Indexing**: Array'in elementlerine tek tek index numarası ile erişebilirsiniz. Örnek: 9 | ```py 10 | import numpy as np 11 | 12 | a = np.array([1,2,3,4,5]) 13 | print(a[0]) # Output: 1 14 | print(a[2]) # Output: 3 15 | ``` 16 | Çok boyutlu array'lerde axis'ler dıştan içe anlamına gelecek şekilde soldan sağa doğru dolayı integer indexlemeyi buna göre yapmalısınız. Örnek: 17 | ```py 18 | import numpy as np 19 | 20 | a = np.array([[[1,2,3],[4,5,6],[7,8,9]], 21 | [[10,11,12],[13,14,15],[16,17,18]], 22 | [[19,20,21],[22,23,24],[25,26,27]]]) 23 | print(a, end='\n--------\n') 24 | print(a[0], end='\n--------\n') 25 | print(a[0,], end='\n--------\n') 26 | print(a[0][0], end='\n--------\n') 27 | print(a[0,0], end='\n--------\n') 28 | print(a[0][0][0], end='\n--------\n') 29 | print(a[0,0,0]) 30 | ``` 31 | Output: 32 | ```py 33 | [[[ 1 2 3] 34 | [ 4 5 6] 35 | [ 7 8 9]] 36 | 37 | [[10 11 12] 38 | [13 14 15] 39 | [16 17 18]] 40 | 41 | [[19 20 21] 42 | [22 23 24] 43 | [25 26 27]]] 44 | -------- 45 | [[1 2 3] 46 | [4 5 6] 47 | [7 8 9]] 48 | -------- 49 | [[1 2 3] 50 | [4 5 6] 51 | [7 8 9]] 52 | -------- 53 | [1 2 3] 54 | -------- 55 | [1 2 3] 56 | -------- 57 | 1 58 | -------- 59 | 1 60 | ``` 61 | 62 | - **Boolean Indexing**: Array'in elementlerine tek tek boolean değerler ile erişebilirsiniz. Örnek: 63 | ```py 64 | import numpy as np 65 | 66 | a = np.array([1,2,3,4,5]) 67 | print(a[[True,False,True,False,True]]) # Output: [1 3 5] 68 | 69 | a = np.array([[1,2,3],[4,5,6]]) 70 | print(a[[[True,False,True],[False,True,True]]]) # Output: [1 3 5 6] 71 | ``` 72 | 73 | - **Filter Indexing**: Array'in elementlerine filtreleme yaparak erişebilirsiniz. Örnek: 74 | ```py 75 | import numpy as np 76 | 77 | a = np.array([1,2,3,4,5]) 78 | print(a[a > 3]) # Output: [4 5] 79 | print(a[(a > 3) & (a < 5)]) # Output: [4] 80 | ``` 81 | 82 | - **Fancy Indexing**: Array'in elementlerine tek tek index numarası ile erişebilirsiniz. Örnek: 83 | ```py 84 | import numpy as np 85 | 86 | a = np.array([1,2,3,4,5]) 87 | print(a[[0,2,4]]) # Output: [1 3 5] 88 | ``` 89 | 90 | - **Field Indexing**: Array'in elementlerine tek tek field ismi ile erişebilirsiniz. Örnek: 91 | ```py 92 | import numpy as np 93 | 94 | a = np.array([(1,2,3),(4,5,6)],dtype=[('a','i4'),('b','i4'),('c','i4')]) 95 | print(a['a']) # Output: [1 4] 96 | print(a['b']) # Output: [2 5] 97 | print(a['c']) # Output: [3 6] 98 | ``` 99 | 100 | - **Ellipsis Indexing**: Array'in birden fazla boyutlu olduğu durumlarda, array'in istenilen boyutlarına tek seferde erişmek için kullanılır. Örnek: 101 | ```py 102 | import numpy as np 103 | 104 | a = np.ones((2,2,2,2)) 105 | print(a[:,:,:,0], end='\n----------------\n') 106 | print(a[...,0]) 107 | ``` 108 | Output: 109 | ```py 110 | [[[1. 1.] 111 | [1. 1.]] 112 | 113 | [[1. 1.] 114 | [1. 1.]]] 115 | ---------------- 116 | [[[1. 1.] 117 | [1. 1.]] 118 | 119 | [[1. 1.] 120 | [1. 1.]]] 121 | ``` 122 | Daha fazla bilgi için [tıklayın](https://numpy.org/doc/1.23/reference/arrays.indexing.html#basic-slicing-and-indexing). -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/iterating_over_array.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Array Üzerinde Iterating İşlemi(Iterating Over Array)](#1) 4 | 5 |

Array Üzerinde Iterating İşlemi(Iterating Over Array)

6 | 7 | Array'ler üzerinde döngü oluşturmak için `nditer` fonksiyonunu kullanabilirsiniz. Örnek: 8 | ```py 9 | import numpy as np 10 | 11 | a = np.arange(0,60,5).reshape(3,4) 12 | print("Original array is:\n", a) 13 | b = a.T 14 | print("Transpose of array is:\n", b) 15 | print("Orjinal array'in sıralanması:") 16 | for i in np.nditer(a): 17 | print(i,end=", ") # Output: 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 18 | 19 | print("\nOrjinal array'in Transpose'sinin sıralanması:") 20 | for i in np.nditer(b): 21 | print(i,end=", ") # Output: 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 22 | ``` 23 | **Output:** 24 | ``` 25 | Original array is: 26 | [[ 0 5 10 15] 27 | [20 25 30 35] 28 | [40 45 50 55]] 29 | Transpose of array is: 30 | [[ 0 20 40] 31 | [ 5 25 45] 32 | [10 30 50] 33 | [15 35 55]] 34 | Orjinal array'in yazdırılması: 35 | 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 36 | Orjinal array'in Transpose'sinin yazdırılması: 37 | 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 38 | ``` 39 | Gördüğünüz gibi buradaki yineleme sırası array'in elementlerinin array'deki konumlarına göre değil array'in bellekteki konumlarına göre yapılmışyır. Bu duruma sebep olan şeye Iteration Order (Yineleme Sırası) denir. Yineleme sırasını değiştirmek için `order` parametresini kullanabilirsiniz. Örnek: 40 | ```py 41 | import numpy as np 42 | 43 | a = np.arange(0,60,5).reshape(3,4) 44 | print("Original array is:\n", a) 45 | print("Transpose of array is:\n", a.T) 46 | print("Sorted in C-style order:") 47 | for i in np.nditer(a, order='C'): 48 | print(i,end=", ") 49 | print("\nSorted in F-style order:") 50 | for i in np.nditer(a, order='F'): 51 | print(i,end=", ") 52 | ``` 53 | **Output:** 54 | ``` 55 | Original array is: 56 | [[ 0 5 10 15] 57 | [20 25 30 35] 58 | [40 45 50 55]] 59 | Transpose of array is: 60 | [[ 0 20 40] 61 | [ 5 25 45] 62 | [10 30 50] 63 | [15 35 55]] 64 | Sorted in C-style order: 65 | 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 66 | Sorted in F-style order: 67 | 0, 20, 40, 5, 25, 45, 10, 30, 50, 15, 35, 55, 68 | ``` 69 | Aynı elementler F-style order kullanılarak sıralanırsa, iterator, bir array üzerinde iterating işleminin daha verimli yolunu seçer. 70 | 71 | `nditer` objesinin bir diğer optional parametresi `flags`'dır. Bu parametre, array üzerindeki her bir element için bir flag belirler. Bu flag'ler, elementlerin üzerinde yapılacak işlemleri belirler. 72 | - `'c_index'`: C-order index kullanılır. 73 | - `'f_index'`: Fortran-order index kullanılır. 74 | - `'multi-index'`: Bir multi-index ya da iteration dimension başına bir tuple of indices kullanılır. 75 | - Causes a multi-index, or a tuple of indices with one per iteration dimension, to be tracked. 76 | - `'external_loop'`: Causes the values given to be one-dimensional arrays with multiple values instead of zero-dimensional arrays. Örnek: 77 | ```py 78 | import numpy as np 79 | 80 | a = np.arange(0,60,5).reshape(3,4) 81 | 82 | print("Original array is:\n", a) 83 | 84 | print("\nSorting in C order with c_index flag:") 85 | for i in np.nditer(a, flags=['c_index'], order='C'): 86 | print(i,end=", ") 87 | print("\nSorting in F order with c_index flag:") 88 | for i in np.nditer(a, flags=['c_index'], order='F'): 89 | print(i,end=", ") 90 | 91 | print("\n\nSorting in C order with f_index flag:") 92 | for i in np.nditer(a, flags=['f_index'], order='C'): 93 | print(i,end=", ") 94 | print("\nSorting in F order with f_index flag:") 95 | for i in np.nditer(a, flags=['f_index'], order='F'): 96 | print(i,end=", ") 97 | 98 | print("\n\nSorting in C order with multi_index flag:") 99 | for i in np.nditer(a, flags=['multi_index'], order='C'): 100 | print(i,end=", ") 101 | print("\nSorting in F order with multi_index flag:") 102 | for i in np.nditer(a, flags=['multi_index'], order='F'): 103 | print(i,end=", ") 104 | 105 | print("\n\nSorting in C order with external_loop flag:") 106 | for i in np.nditer(a, flags=['external_loop'], order='C'): 107 | print(i,end=", ") 108 | print("\nSorting in F order with external_loop flag:") 109 | for i in np.nditer(a, flags=['external_loop'], order='F'): 110 | print(i,end=", ") 111 | ``` 112 | **Output:** 113 | ``` 114 | Original array is: 115 | [[ 0 5 10 15] 116 | [20 25 30 35] 117 | [40 45 50 55]] 118 | 119 | Sorting in C order with c_index flag: 120 | 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 121 | Sorting in F order with c_index flag: 122 | 0, 20, 40, 5, 25, 45, 10, 30, 50, 15, 35, 55, 123 | 124 | Sorting in C order with f_index flag: 125 | 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 126 | Sorting in F order with f_index flag: 127 | 0, 20, 40, 5, 25, 45, 10, 30, 50, 15, 35, 55, 128 | 129 | Sorting in C order with multi_index flag: 130 | 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 131 | Sorting in F order with multi_index flag: 132 | 0, 20, 40, 5, 25, 45, 10, 30, 50, 15, 35, 55, 133 | 134 | Sorting in C order with external_loop flag: 135 | [ 0 5 10 15 20 25 30 35 40 45 50 55], 136 | Sorting in F order with external_loop flag: 137 | [ 0 20 40], [ 5 25 45], [10 30 50], [15 35 55], 138 | ``` 139 | 140 | `nditer` objesinin bir diğer optional parametresi `op_flags`'dır. Bu parametre, array üzerindeki her bir element için bir flag belirler. Bu flag'ler, elementlerin üzerinde yapılacak işlemleri belirler. Default değeri `'readonly'`'dır. Bu flag, array üzerindeki elementlerin üzerinde sadece okuma yapılmasını sağlar. `'readwrite'` flag'ini kullanarak array üzerindeki elementlerin üzerinde okuma ve yazma yapılmasını sağlayabilirsiniz. `'writeonly'` flag'ini kullanarak array üzerindeki elementlerin üzerinde sadece yazma yapılmasını sağlayabilirsiniz. Örnek: 141 | ```py 142 | import numpy as np 143 | 144 | a = np.arange(0,60,5).reshape(3,4) 145 | print("Original array is:\n", a) 146 | print("Transpose of array is:\n", a.T) 147 | print("Sorted in C-style order:") 148 | for i in np.nditer(a, order='C', op_flags=['readwrite']): 149 | i[...] = 2*i 150 | print("Modified array is:\n", a) 151 | ``` 152 | **Output:** 153 | ``` 154 | Original array is: 155 | [[ 0 5 10 15] 156 | [20 25 30 35] 157 | [40 45 50 55]] 158 | Modified array is: 159 | [[ 0 10 20 30] 160 | [ 40 50 60 70] 161 | [ 80 90 100 110]] 162 | ``` 163 | 164 | Broadcastable iki array üzerinde aynı anda iterating yapmak için `nditer` objesini kullanabilirsiniz. Örnek: 165 | ```py 166 | import numpy as np 167 | 168 | a = np.arange(0,60,5).reshape(3,4) 169 | b = np.array([1, 2, 3, 4], dtype=int) 170 | for i,j in np.nditer([a,b]): 171 | print(f"{i}:{j}", end=", ") # Output: 0:1, 5:2, 10:3, 15:4, 20:1, 25:2, 30:3, 35:4, 40:1, 45:2, 50:3, 55:4, 172 | ``` 173 | Daha fazla bilgi için [tıklayın](https://numpy.org/doc/1.23/reference/generated/numpy.nditer.html). -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/linear_algebra.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Linear Algebra](#1) 4 | - [`linalg.dot(a, b, out=None)`](#1) 5 | - [`linalg.vdot(a, b)`](#1) 6 | - [`linalg.inner(a, b)`](#1) 7 | - [`linalg.matmul(x1, x2, *args, **kwargs)`](#1) 8 | - [`linalg.determinant(a)`](#1) 9 | - [`linalg.solve(a, b)`](#1) 10 | - [`linalg.inv(a)`](#1) 11 | 12 |

Linear Algebra

13 | 14 | NumPy paketi bir Lineer Cebir kitaplığı (`numpy.linalg`) içerir. Bu modül, matrisler üzerinde çeşitli matematiksel işlemler yapmamızı sağlar. 15 | 16 |

linalg.dot(a, b, out=None) Methodu

17 | 18 | `a` ve `b` parametrelerine girilen matrisleri çarpar. Örnek: 19 | ```py 20 | import numpy as np 21 | 22 | a = np.array([[1, 0], [0, 1]]) 23 | b = np.array([[4, 1], [2, 2]]) 24 | 25 | print(np.dot(a, b)) 26 | ``` 27 | **Output:** 28 | ``` 29 | [[4 1] 30 | [2 2]] 31 | ``` 32 | 33 |

linalg.vdot(a, b) Methodu

34 | 35 | `a` ve `b` parametrelerine girilen vektörleri çarpar. Örnek: 36 | ```py 37 | import numpy as np 38 | 39 | a = np.array([1, 4, 5]) 40 | b = np.array([7, 2, 12]) 41 | 42 | print(np.vdot(a, b)) 43 | ``` 44 | **Output:** 45 | ``` 46 | 61 47 | ``` 48 | 49 |

linalg.inner(a, b) Methodu

50 | 51 | `a` ve `b` parametrelerine girilen matrisleri iç çarpımı yapar. Örnek: 52 | ```py 53 | import numpy as np 54 | 55 | a = np.array([[1, 0], [0, 1]]) 56 | b = np.array([[4, 1], [2, 2]]) 57 | 58 | print(np.inner(a, b)) 59 | ``` 60 | **Output:** 61 | ``` 62 | [[4 1] 63 | [2 2]] 64 | ``` 65 | 66 |

linalg.matmul(x1, x2, *args, **kwargs) Methodu

67 | 68 | `x1` ve `x2` parametrelerine girilen matrisleri çarpar. Örnek: 69 | ```py 70 | import numpy as np 71 | 72 | a = np.array([[1, 0], [0, 1]]) 73 | b = np.array([[4, 1], [2, 2]]) 74 | 75 | print(np.matmul(a, b)) 76 | ``` 77 | **Output:** 78 | ``` 79 | [[4 1] 80 | [2 2]] 81 | ``` 82 | 83 |

linalg.determinant(a) Methodu

84 | 85 | `a` parametresine girilen matrisin determinantını hesaplar. Örnek: 86 | ```py 87 | import numpy as np 88 | 89 | a = np.array([[1, 2], [3, 4]]) 90 | 91 | print(np.linalg.det(a)) 92 | ``` 93 | **Output:** 94 | ``` 95 | -2.0000000000000004 96 | ``` 97 | 98 |

linalg.solve(a, b) Methodu

99 | 100 | `a` parametresine girilen matrisin `b` parametresine girilen vektörü çözmesini sağlar. Örnek: 101 | ```py 102 | import numpy as np 103 | 104 | a = np.array([[1, 1, 1], [0, 2, 5], [2, 5, -1]]) 105 | b = np.array([6, -4, 27]) 106 | 107 | print(np.linalg.solve(a, b)) 108 | ``` 109 | **Output:** 110 | ``` 111 | [ 5. 3. -2.] 112 | ``` 113 | 114 |

linalg.inv(a) Methodu

115 | 116 | `a` parametresine girilen matrisin tersini hesaplar. Örnek: 117 | ```py 118 | import numpy as np 119 | 120 | a = np.array([[1, 2], [3, 4]]) 121 | 122 | print(np.linalg.inv(a)) 123 | ``` 124 | **Output:** 125 | ``` 126 | [[-2. 1. ] 127 | [ 1.5 -0.5]] 128 | ``` -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/matplotlib.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Matplotlib](#1) 4 | - [`plot` Methodu](#1.1) 5 | - [`subplot` Methodu](#1.2) 6 | - [`bar` Methodu](#1.3) 7 | 8 |

Matplotlib

9 | 10 | Matplotlib, Python dilinde veri görselleştirme için kullanılan bir kütüphanedir. Matplotlib, verileri çizgi, nokta, bar, histogram, contour, 3D gibi çeşitli grafiklerle görselleştirmemizi sağlar. MatLab programında kullanılan grafik çizme fonksiyonlarının çoğu Matplotlib kütüphanesinde bulunur. Matplotlib hakkında daha fazla bilgi için [Matplotlib](https://matplotlib.org/) sitesini ziyaret edebilirsiniz. 11 | 12 | Matplotlib kütüphanesini kullanabilmek için `import matplotlib.pyplot as plt` ya da `from matplotlib import pyplot as plt` kodunu kullanabiliriz. 13 | 14 |

plot(x, y) Methodu

15 | 16 | `x` ve `y` parametrelerine girilen verileri çizgi grafiği olarak çizer. Örnek: 17 | ```py 18 | import numpy as np 19 | from matplotlib import pyplot as plt 20 | 21 | x = np.arange(1,11) 22 | y = 2 * x + 5 23 | plt.title("Matplotlib demo") 24 | plt.xlabel("x axis caption") 25 | plt.ylabel("y axis caption") 26 | plt.plot(x,y) 27 | plt.show() 28 | ``` 29 | **Output:** 30 | 31 | ![](./pics/2.png) 32 | 33 | `plot()` fonksiyonuna format string parametresi de verilebilir. Format string parametresi, çizgi grafiğinin rengini, kalınlığını, şeklini ve benzeri özelliklerini belirler. 34 | | Format String | Açıklama | 35 | | --- | --- | 36 | | `color` | Çizgi rengi | 37 | | `linewidth` | Çizgi kalınlığı | 38 | | `linestyle` | Çizgi şekli | 39 | | `marker` | Nokta şekli | 40 | | `markersize` | Nokta boyutu | 41 | | `markeredgecolor` | Nokta kenar rengi | 42 | | `markeredgewidth` | Nokta kenar kalınlığı | 43 | | `markerfacecolor` | Nokta iç rengi | 44 | | `alpha` | Saydamlık | 45 | | `label` | Etiket | 46 | Örnek: 47 | ```py 48 | import numpy as np 49 | from matplotlib import pyplot as plt 50 | 51 | x = np.arange(1,11) 52 | y = 2 * x + 5 53 | plt.title("Matplotlib demo") 54 | plt.xlabel("x axis caption") 55 | plt.ylabel("y axis caption") 56 | plt.plot(x,y, color='red', linewidth=2.5, linestyle=':', marker='o', markersize=10, markeredgecolor='blue', markeredgewidth=3, markerfacecolor='green', alpha=0.5, label='line') 57 | plt.legend() 58 | plt.show() 59 | ``` 60 | **Output:** 61 | 62 | ![](./pics/3.png) 63 | 64 | Daha fazla format string parametresi için [buraya](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html) bakabilirsiniz. 65 | 66 |

subplot(nrows, ncols, index, *args, **kwargs) Methodu

67 | 68 | Çizgi grafiğini `nrows` satır ve `ncols` sütun olacak şekilde `index` numarasına göre parçalara böler. Örnek: 69 | ```py 70 | import numpy as np 71 | from matplotlib import pyplot as plt 72 | 73 | x = np.arange(1,11) 74 | y = 2 * x + 5 75 | plt.subplot(2, 2, 1) 76 | plt.plot(x, y) 77 | plt.subplot(2, 2, 2) 78 | plt.plot(x, y) 79 | plt.subplot(2, 2, 3) 80 | plt.plot(x, y) 81 | plt.subplot(2, 2, 4) 82 | plt.plot(x, y) 83 | plt.show() 84 | ``` 85 | **Output:** 86 | 87 | ![](./pics/4.png) 88 | 89 | ```py 90 | import numpy as np 91 | from matplotlib import pyplot as plt 92 | 93 | x = np.arange(1,11) 94 | y = 2 * x + 5 95 | plt.subplot(4, 1, 1) 96 | plt.plot(x, y) 97 | plt.subplot(4, 1, 2) 98 | plt.plot(x, y) 99 | plt.subplot(4, 1, 3) 100 | plt.plot(x, y) 101 | plt.subplot(4, 1, 4) 102 | plt.plot(x, y) 103 | plt.show() 104 | ``` 105 | **Output:** 106 | 107 | ![](./pics/5.png) 108 | 109 |

bar(x, height, width=0.8, bottom=None, *, align='center', data=None, **kwargs) Methodu

110 | 111 | `x` ve `height` parametrelerine girilen verileri bar grafiği olarak çizer. `width` parametresi bar grafiğinin genişliğini, `bottom` parametresi ise bar grafiğinin başlangıç noktasını belirler. Örnek: 112 | ```py 113 | import numpy as np 114 | from matplotlib import pyplot as plt 115 | 116 | x = np.arange(1,11) 117 | y = 2 * x + 5 118 | plt.bar(x, y) 119 | plt.show() 120 | ``` 121 | **Output:** 122 | 123 | ![](./pics/6.png) 124 | 125 | ```py 126 | import numpy as np 127 | from matplotlib import pyplot as plt 128 | 129 | x = np.arange(1,11) 130 | y = 2 * x + 5 131 | plt.bar(x, y, width=0.5, bottom=10) 132 | plt.show() 133 | ``` 134 | **Output:** 135 | 136 | ![](./pics/7.png) 137 | 138 |

hist(a, bins=10, range=None, normed=None, weights=None, density=None) Methodu

139 | 140 | Histogram, verilerin sıklık dağılımını gösteren bir grafiktir. Histogramı çizmek için NumPy'ın `hist()` fonksiyonu kullanılır. `hist()` fonksiyonu, verileri sınıflara ayırır ve her sınıfın kaç veri içerdiğini hesaplar, sınıfların sıklık değerlerini ve sınıf sınırlarını döndürür. `histogram()` fonksiyonunun syntax'ı `hist(a, bins=10, range=None, normed=None, weights=None, density=None)` şeklindedir. 141 | - `a`: Histogramın çizileceği veriler 142 | - `bins`: Histogramın sınıf sayısı 143 | - `range`: Histogramın sınıf sınırları 144 | - `normed`: Histogramın sıklık değerlerinin toplamının 1 olup olmadığını belirler 145 | - `weights`: Histogramın sıklık değerlerinin ağırlıklarını belirler 146 | - `density`: Histogramın sıklık değerlerinin toplamının 1 olup olmadığını belirler 147 | Örnek: 148 | ```py 149 | import numpy as np 150 | 151 | a = np.array([22, 87, 5, 43, 56, 73, 55, 54, 11, 20, 51, 5, 79, 31, 27]) 152 | hist, bins = np.hist(a, bins=[0, 20, 40, 60, 80, 100]) 153 | print(hist) 154 | print(bins) 155 | ``` 156 | **Output:** 157 | ``` 158 | [3 4 5 2 1] 159 | [ 0 20 40 60 80 100] 160 | ``` -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/matrix_library.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Matrix Library](#1) 4 | - [`matlib.empty`](#1.1) 5 | - [`matlib.zeros`](#1.2) 6 | - [`matlib.ones`](#1.3) 7 | - [`matlib.eye`](#1.4) 8 | - [`matlib.identity`](#1.5) 9 | - [`matlib.rand`](#1.6) 10 | 11 |

Matrix Library

12 | 13 |

matlib.empty(shape, dtype=float, order='C') Methodu

14 | 15 | `shape` parametresine girilen boyutta boş bir array oluşturur. Örnek: 16 | ```py 17 | import numpy.matlib 18 | 19 | print(numpy.matlib.empty((2, 2))) 20 | ``` 21 | **Output:** 22 | ``` 23 | [[1.36162415e-311 1.36162415e-311] 24 | [1.36162415e-311 1.36162415e-311]] 25 | ``` 26 | 27 |

matlib.zeros(shape, dtype=float, order='C') Methodu

28 | 29 | `shape` parametresine girilen boyutta sıfırlardan oluşan bir array oluşturur. Örnek: 30 | ```py 31 | import numpy.matlib 32 | 33 | print(numpy.matlib.zeros((2, 2))) 34 | ``` 35 | **Output:** 36 | ``` 37 | [[0. 0.] 38 | [0. 0.]] 39 | ``` 40 | 41 |

matlib.ones(shape, dtype=None, order='C') Methodu

42 | 43 | `shape` parametresine girilen boyutta birlerden oluşan bir array oluşturur. Örnek: 44 | ```py 45 | import numpy.matlib 46 | 47 | print(numpy.matlib.ones((2, 2))) 48 | ``` 49 | **Output:** 50 | ``` 51 | [[1. 1.] 52 | [1. 1.]] 53 | ``` 54 | 55 |

matlib.eye(n, M=None, k=0, dtype=float, order='C') Methodu

56 | 57 | `n` parametresine girilen boyutta birim matris oluşturur. `M` parametresi girilmezse `n` parametresi ile aynı değer alır (yani kare matris olur). `k` parametresi ise birim matrisin ana köşegeninin sağa veya sola kaydırılmasını sağlar. Örnek: 58 | ```py 59 | import numpy.matlib 60 | 61 | print(numpy.matlib.eye(n=3, M=4, k=0, dtype=float)) 62 | ``` 63 | **Output:** 64 | ``` 65 | [[1. 0. 0. 0.] 66 | [0. 1. 0. 0.] 67 | [0. 0. 1. 0.]] 68 | ``` 69 | 70 |

matlib.identity(n, dtype=None) Methodu

71 | 72 | `n` parametresine girilen boyutta birim matris oluşturur. Örnek: 73 | ```py 74 | import numpy.matlib 75 | 76 | print(numpy.matlib.identity(5, dtype=float)) 77 | ``` 78 | **Output:** 79 | ``` 80 | [[1. 0. 0. 0. 0.] 81 | [0. 1. 0. 0. 0.] 82 | [0. 0. 1. 0. 0.] 83 | [0. 0. 0. 1. 0.] 84 | [0. 0. 0. 0. 1.]] 85 | ``` 86 | 87 |

matlib.rand(*args, **kwargs) Methodu

88 | 89 | `matlib.rand(d0, d1, ..., dn)` şek `d0`, `d1`, ..., `dn` parametrelerine girilen boyutta rastgele değerlerden oluşan bir array oluşturur. Örnek: 90 | ```py 91 | import numpy.matlib 92 | 93 | print(numpy.matlib.rand(3, 3)) 94 | ``` 95 | **Output:** 96 | ``` 97 | [[0.59066705 0.50517741 0.55721634] 98 | [0.82512513 0.54510793 0.6141953 ] 99 | [0.18272202 0.66594261 0.66823337]] 100 | ``` -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/ndarray_attributes.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [`ndarray` Attribute'ları](#1) 4 | - [`shape` Attribute'u](#1.1) 5 | - [`ndim` Attribute'u](#1.2) 6 | - [`itemsize` Attribute'u](#1.3) 7 | - [`size` Attribute'u](#1.4) 8 | - [`dtype` Attribute'u](#1.5) 9 | - [`flags` Attribute'u](#1.6) 10 | 11 |

ndarray Attribute'ları

12 | 13 |

shape Attribute'u

14 | 15 | `ndarray.shape` ya da `numpy.shape(a)` şeklinde kullanılabilir. Uygulandığı/`a` parametresine argüman olarak girilen array'in dimension ve her dimension'ındaki element sayısı bilgisini içeren bir tuple döndürür. Örnek: 16 | ```py 17 | import numpy as np 18 | 19 | a = np.ones((4)) 20 | b = np.ones((4, 3)) 21 | c = np.ones((4, 3, 2)) 22 | 23 | print(a, np.shape(a), end="\n-------\n") 24 | print(b, np.shape(b), end="\n-------\n") 25 | print(c, np.shape(c)) 26 | ``` 27 | **Output:** 28 | ``` 29 | [1. 1. 1. 1.] (4,) 30 | ------- 31 | [[1. 1. 1.] 32 | [1. 1. 1.] 33 | [1. 1. 1.] 34 | [1. 1. 1.]] (4, 3) 35 | ------- 36 | [[[1. 1.] 37 | [1. 1.] 38 | [1. 1.]] 39 | 40 | [[1. 1.] 41 | [1. 1.] 42 | [1. 1.]] 43 | 44 | [[1. 1.] 45 | [1. 1.] 46 | [1. 1.]] 47 | 48 | [[1. 1.] 49 | [1. 1.] 50 | [1. 1.]]] (4, 3, 2) 51 | ``` 52 | `shape` attribute'u ilgili array'i yeniden şekillendirmek (reshape) için de kullanılabilir. Örnek: 53 | ```py 54 | import numpy as np 55 | 56 | a = np.ones((4, 3, 2)) 57 | 58 | print(a, np.shape(a), end="\n-------\n") 59 | a.shape = (4, 6) 60 | print(a, np.shape(a), a.shape) 61 | ``` 62 | **Output:** 63 | ``` 64 | [[[1. 1.] 65 | [1. 1.] 66 | [1. 1.]] 67 | 68 | [[1. 1.] 69 | [1. 1.] 70 | [1. 1.]] 71 | 72 | [[1. 1.] 73 | [1. 1.] 74 | [1. 1.]] 75 | 76 | [[1. 1.] 77 | [1. 1.] 78 | [1. 1.]]] (4, 3, 2) 79 | ------- 80 | [[1. 1. 1. 1. 1. 1.] 81 | [1. 1. 1. 1. 1. 1.] 82 | [1. 1. 1. 1. 1. 1.] 83 | [1. 1. 1. 1. 1. 1.]] (4, 6) (4, 6) 84 | ``` 85 | **Not:** Bu işlemin yapılabilmesi için ilgili array'in eski ve yeni shape'i aynı sayıda elemente sahip olmalıdır aksi halde `ValueError: cannot reshape array of size 24 into shape (4,5)` örneğindeki gibi bir hata döndürür. 86 | 87 |

ndim Attribute'u

88 | 89 | `ndarray.ndim` ya da `numpy.ndim(a)` şeklinde kullanılabilir. Uygulandığı/`a` parametresine argüman olarak girilen array'in dimension sayısını döndürür. Örnek: 90 | ```py 91 | import numpy as np 92 | 93 | a = np.ones((4, 3, 2)) 94 | 95 | print(np.ndim(a)) # Output: 3 96 | a.shape = (4, 6) 97 | print(np.ndim(a),a.ndim) # Output: 2 2 98 | ``` 99 | 100 |

itemsize Attribute'u

101 | 102 | `ndarray.itemsize` şeklinde kullanılabilir. Uygulandığı array'in her elementinin bellekte kapladığı alanı byte cinsinden döndürür. Örnek: 103 | ```py 104 | import numpy as np 105 | 106 | a1 = np.ones((5,), dtype=np.int8) 107 | a2 = np.ones((5,), dtype=np.int32) 108 | a3 = np.ones((5,), dtype=np.float16) 109 | 110 | print(a1.itemsize) # Output: 1 111 | print(a2.itemsize) # Output: 4 112 | print(a3.itemsize) # Output: 2 113 | ``` 114 | 115 |

size Attribute'u

116 | 117 | `ndarray.size` ya da `numpy.size(a)` şeklinde kullanılabilir. Uygulandığı/`a` parametresine argüman olarak girilen array'in toplam element sayısını döndürür. Örnek: 118 | ```py 119 | import numpy as np 120 | a = np.array([[4,2,3,1],[8,5,7,6]]) 121 | b = np.array([11,9,12,10]) 122 | print(np.size(a)) # Output: 8 123 | print(np.size(b)) # Output: 4 124 | ``` 125 | 126 |

dtype Attribute'u

127 | 128 | `ndarray.dtype` ya da `numpy.dtype(a)` şeklinde kullanılabilir. Uygulandığı/`a` parametresine argüman olarak girilen array'in elementlerinin veri tipini döndürür. Örnek: 129 | ```py 130 | import numpy as np 131 | 132 | a1 = np.ones((5,), dtype=np.int8) 133 | a2 = np.ones((5,), dtype=np.int32) 134 | a3 = np.ones((5,), dtype=np.float16) 135 | 136 | print(a1.dtype) # Output: int8 137 | print(a2.dtype) # Output: int32 138 | print(a3.dtype) # Output: float16 139 | ``` 140 | 141 |

flags Attribute'u

142 | 143 | Bir array'in bellekte nasıl saklandığını gösteren bir özellik objesi (``) döndürür. Örnek: 144 | ```py 145 | import numpy as np 146 | 147 | a = np.array([1,2,3,4,5,6,7,8,9,10]) 148 | print(a.flags) 149 | ``` 150 | **Output:** 151 | ``` 152 | C_CONTIGUOUS : True 153 | F_CONTIGUOUS : True 154 | OWNDATA : True 155 | WRITEABLE : True 156 | ALIGNED : True 157 | WRITEBACKIFCOPY : False 158 | ``` 159 | Buradaki özelliklerin anlamları şu şekildedir: 160 | - `C_CONTIGUOUS` (C): True ise array'in bellekte C dilindeki gibi sıralandığı anlamına gelir (C-style contiguous segment). 161 | - `F_CONTIGUOUS` (F): True ise array'in bellekte Fortran dilindeki gibi sıralandığı anlamına gelir (Fortran-style contiguous segment). 162 | - `OWNDATA` (O): True ise array'in bellekteki verilerini kendi sakladığı (yani dizi, kullandığı belleğin sahibi) ya da başka bir objeden ödünç aldığı anlamına gelir. 163 | - `WRITEABLE` (W): True ise array'in bellekteki verilerini değiştirebilir (yani array'in immutable olmadığı) anlamına gelir. Bunu False olarak ayarlamak verileri kilitler ve salt okunur (read-only) yapar. 164 | - `ALIGNED` (A): True ise array'in verilerini ve tüm elementleri, donanım için uygun şekilde hizalanmış anlamına gelir. 165 | - `UPDATEIFCOPY` (U): True ise array'in bellekteki verilerini değiştirdiğinizde, değişikliklerin başka bir array'e yazılacağı (yani temel dizi bu dizinin içeriğiyle güncelleneceği) anlamına gelir. Bu özellik, array'in bellekteki verilerini kopyaladığından dolayı performansı düşürür. -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/ndarray_object.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [`ndarray` Object](#1) 4 | - [Array'lerde Boyut (Dimension) ve Indexing](#2) 5 | 6 |

ndarray Object

7 | 8 | NumPy'da tanımlanan en önemli obje, `ndarray` adı verilen N boyutlu bir array türüdür. `ndarray`, aynı type data'ların (bunlara element veya item denir ama ben element olarak bahsedeceğim) toplandığı bir koleksiyonudur (grid of value, collection). Bu elementlere erişmek için zero-based index'leme kullanılır (yani ilk elementin index'i `0` olarak ifade edilir). Bir `ndarray`'deki her bir element bellekte aynı boyutta yer kaplar ve `data-type` objesinin bir objesidir (`data-type` = `dtype`). 9 | 10 | Bir ndarray'i slicing yoluyla (daha sonra anlatılacak) parçalarsan bir array scalar elde edersin. 11 | 12 | ![](./pics/1.jpg) 13 | 14 | Görseldeki ndarray diyagramı, dtype ve array scalar arasındaki ilişkiyi gösteriyor. Örnek: 15 | ```py 16 | import numpy as np 17 | 18 | a = np.array([1,2,3,4,5]) 19 | b = a[0:2] 20 | c = a[4] 21 | print(type(b), b.dtype, b) # Output: int32 [1 2] 22 | print(type(c), c.dtype, c) # Output: int32 5 23 | ``` 24 | Yani yukarıda anlattığım bütün olay, `c`'nin `'numpy.int32'` type bir obje olması için yaptığımız şeyin açıklaması. 25 | 26 | **Not:** The ndarray object consists of contiguous one-dimensional segment of computer memory, combined with an indexing scheme that maps each item to a location in the memory block. The memory block holds the elements in a row-major order (C style) or a column-major order (FORTRAN or MatLab style). 27 | 28 |

Array'lerde Boyut (Dimension) ve Indexing

29 | 30 | Array'leri indexlemek normal python'daki sequence'ları indexlemek gibidir. Örnek: 31 | ```py 32 | import numpy as np 33 | 34 | a = np.array([[1,2,3],[4,5,6],[7,8,9]]) 35 | print(a,end="\n-------\n") 36 | print(a[0],end="\n-------\n") 37 | print(a[0][0]) 38 | ``` 39 | **Output:** 40 | ``` 41 | [[1 2 3] 42 | [4 5 6] 43 | [7 8 9]] 44 | ------- 45 | [1 2 3] 46 | ------- 47 | 1 48 | ``` 49 | 50 | Bir array'in **rank**'ı, o dizinin dimension sayısını ifade eden bir integer'dır. İki ya da daha fazla dimension'ı bulunan NumPy array'ler initialize (başlatmak) edebilmek için (kısaca oluşturabilmek için) nested listeler kullanılır. Örnek: 51 | ```py 52 | import numpy as np 53 | print(np.array([[1,2,3],[4,5,6],[7,8,9]])) 54 | ``` 55 | **Output:** 56 | ``` 57 | [[1 2 3] 58 | [4 5 6] 59 | [7 8 9]] 60 | ``` 61 | NumPy'da dimension'lar **axis** olarak isimlendirilir (birden fazla dimension'dan bahsediyorsak **axes**). 2D array'lerle uğraşırken column ve row kavramlarıyla karşılaşmışsınızdır. Column ve row kavramları sadece 2D array'lerde geçerli olduğu için genel olarak axis (eksen) terimi kullanılır. Çok dimention'lu array'lerde axis'ler dıştan içe anlamına gelecek şekilde soldan sağa doğru sıralanır. Örnek: 62 | ``` 63 | [[[1 2 3] 64 | [4 5 6] 65 | [7 8 9]] 66 | 67 | [[1 2 3] 68 | [4 5 6] 69 | [7 8 9]]] 70 | 71 | a[first axis, second axis, third axis, ...] 72 | ``` 73 | ```py 74 | import numpy as np 75 | 76 | a = np.zeros((2,3,4)) 77 | print(a,end="\n-------\n") 78 | a[:,0,0] = 1 79 | print(a,end="\n-------\n") 80 | a = np.zeros((2,3,4)) 81 | a[0,:,0] = 2 82 | print(a,end="\n-------\n") 83 | a = np.zeros((2,3,4)) 84 | a[0,0,:] = 3 85 | print(a) 86 | ``` 87 | **Output:** 88 | ``` 89 | [[[0. 0. 0. 0.] 90 | [0. 0. 0. 0.] 91 | [0. 0. 0. 0.]] 92 | 93 | [[0. 0. 0. 0.] 94 | [0. 0. 0. 0.] 95 | [0. 0. 0. 0.]]] 96 | ------- 97 | [[[1. 0. 0. 0.] 98 | [0. 0. 0. 0.] 99 | [0. 0. 0. 0.]] 100 | 101 | [[1. 0. 0. 0.] 102 | [0. 0. 0. 0.] 103 | [0. 0. 0. 0.]]] 104 | ------- 105 | [[[2. 0. 0. 0.] 106 | [2. 0. 0. 0.] 107 | [2. 0. 0. 0.]] 108 | 109 | [[0. 0. 0. 0.] 110 | [0. 0. 0. 0.] 111 | [0. 0. 0. 0.]]] 112 | ------- 113 | [[[3. 3. 3. 3.] 114 | [0. 0. 0. 0.] 115 | [0. 0. 0. 0.]] 116 | 117 | [[0. 0. 0. 0.] 118 | [0. 0. 0. 0.] 119 | [0. 0. 0. 0.]]] 120 | ``` 121 | **Not:** Farklı array'ler aynı verileri içeriyor olabilir. Bu durumda array'lerin birinde yaptığınız değişiklikler diğer array'i de etkiler. 122 | 123 | [Array attributes](https://numpy.org/doc/stable/reference/arrays.ndarray.html#arrays-ndarray) ve [array object](https://numpy.org/doc/stable/reference/arrays.html#arrays) hakkında daha fazla bilgi tıklayınız. -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/numpy_data_types.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [NumPy'ın Desteklediği Veri Türleri (`dtype`)](#1) 4 | 5 |

NumPy'ın Desteklediği Veri Türleri (dtype)

6 | 7 | Bir `dtype`, 8 | - Data'nın type'ına (integer, float ya da Python object), 9 | - Data'nın size'ına, 10 | - Byte order (little-endian or big-endian), 11 | - Structured type olması durumunda, field'lerin adları (name), her field'ın data type'ı ve her filed tarafından alınan memory block parçasına ()part of memory block), 12 | - Data dype bir subarray ise, shape ve data type'ına 13 | 14 | bağlı olarak bir array'e karşılık gelen sabit bellek bloğunun (fixed block of memory) yorumlanmasını (interpretation) açıklar. 15 | 16 | **Not:** Byte order'a data type'a prefix olarak `<` ya da `>` eklenerek karar verilir. `<` encoding'in little-endian olduğu anlamına gelir (en önemsizi (least significant) en küçük adreste saklanır). `>` encoding'in big-endian olduğu anlamına gelir (en önemli (most significant) byte en küçük adreste saklanır). 17 | 18 | | Type | Description | 19 | | :----------: | :------------------------------------------------------------------------------------------------------------------ | 20 | | `bool_` | Byte olarak depolanan boolean (`True` ya da `False`) | 21 | | `int_` | Default integer type (C'deki `long` ile neredeyse aynı (same as), normalde ya `int32` ya da `int64`) | 22 | | `intc` | C'deki `int` ile birebir aynı (identical)(normalde ya `int32` ya da `int64`) | 23 | | `intp` | Indexing için kullanılan integer (C'deki `ssize_t` ile neredeyse aynı (same as), normalde ya `int32` ya da `int64`) | 24 | | `int8` | Byte (-128 to 127) | 25 | | `int16` | Integer (-32768 to 32767) | 26 | | `int32` | Integer (-2147483648 to 2147483647) | 27 | | `int64` | Integer (-9223372036854775808 to 9223372036854775807) | 28 | | `uint8` | Unsigned integer (0 to 255) | 29 | | `uint16` | Unsigned integer (0 to 65535) | 30 | | `uint32` | Unsigned integer (0 to 4294967295) | 31 | | `uint64` | Unsigned integer (0 to 18446744073709551615) | 32 | | `float_` | `float64` için kısaltma (shorthand) | 33 | | `float16` | Half precision float: sign bit, 5 bits exponent, 10 bits mantissa | 34 | | `float32` | Single precision float: sign bit, 8 bits exponent, 23 bits mantissa | 35 | | `float64` | Double precision float: sign bit, 11 bits exponent, 52 bits mantissa | 36 | | `complex_` | `complex128` için kısaltma (shorthand) | 37 | | `complex64` | İki 32-bit ile temsil edilen complex sayı (real and imaginary components) | 38 | | `complex128` | İki 64-bit ile temsil edilen complex sayı (real and imaginary components) | 39 | 40 | Bir `dtype` objesi oluşturmak için `dtype(object, align, copy)` methodu kullanılır. 41 | - **`object`**: Argüman olarak bir data type objesine dönüştürülecek objeyi kabul eder. 42 | - **`align:bool` (optional)**: Bilgi için [tıklayın](https://numpy.org/doc/stable/reference/generated/numpy.dtype.html?highlight=numpy%20dtype#numpy.dtype). 43 | - **`copy:bool` (optional)**: Bilgi için [tıklayın](https://numpy.org/doc/stable/reference/generated/numpy.dtype.html?highlight=numpy%20dtype#numpy.dtype). 44 | 45 | `dtype` ile ilgili daha fazla bilgi ve kullanımıyla ilgili örnekler için [tıklayınız](https://numpy.org/doc/stable/reference/generated/numpy.dtype.html?highlight=numpy%20dtype#numpy.dtype). -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/pics/1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/modules/numpy/pics/1.jpg -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/pics/2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/modules/numpy/pics/2.png -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/pics/3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/modules/numpy/pics/3.png -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/pics/4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/modules/numpy/pics/4.png -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/pics/5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/modules/numpy/pics/5.png -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/pics/6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/modules/numpy/pics/6.png -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/pics/7.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/modules/numpy/pics/7.png -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/sort_search_counting_functions.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Sort, Search & Counting Functions](#1) 4 | - [sort](#1.1) 5 | - [argsort](#1.2) 6 | - [lexsort](#1.3) 7 | - [argmax](#1.4) 8 | - [argmin](#1.5) 9 | - [nonzero](#1.6) 10 | - [where](#1.7) 11 | - [extract](#1.8) 12 | 13 |

Sort, Search & Counting Functions

14 | 15 | NumPy'da çeşitli sorting fonksiyonları bulunmaktadır. Bu fonksiyonlar speed of execution, worst case performance, workspace required, stability of algorithms ile karakterize edilen farklı sorting algoritmaları uygular. 4 sıralama algoritması bulunmaktadır: 16 | | **kind** | **speed** | **worst case** | **work space** | **stable** | 17 | | :-----------: | :-------: | :------------: | :------------: | :--------: | 18 | | `'quicksort'` | 1 | O(n^2) | 0 | no | 19 | | `'mergesort'` | 2 | O(n*log(n)) | ~n/2 | yes | 20 | | `'timsort'` | 2 | O(n*log(n)) | ~n/2 | yes | 21 | | `'heapsort'` | 3 | O(n*log(n)) | 0 | no | 22 | 23 |

sort(a, /, axis=-1, kind='quicksort', order=None) Methodu

24 | 25 | `a` parametresine girilen array'i sıralar. Örnek: 26 | ```py 27 | import numpy as np 28 | 29 | a = np.array([[3, 7], [9, 1]]) 30 | 31 | print(np.sort(a)) 32 | ``` 33 | **Output:** 34 | ``` 35 | [[3 7] 36 | [1 9]] 37 | ``` 38 | 39 |

argsort(a, /, axis=-1, kind='quicksort', order=None) Methodu

40 | 41 | `a` parametresine girilen array'in sıralanmış haliyle aynı boyutlu bir array döndürür. Örnek: 42 | ```py 43 | import numpy as np 44 | 45 | a = np.array([[3, 7], [9, 1]]) 46 | 47 | print(np.argsort(a)) 48 | ``` 49 | **Output:** 50 | ``` 51 | [[0 1] 52 | [1 0]] 53 | ``` 54 | 55 |

lexsort(keys, /, axis=-1) Methodu

56 | 57 | `keys` parametresine girilen array'in sıralanmış haliyle aynı boyutlu bir array döndürür. Örnek: 58 | ```py 59 | import numpy as np 60 | 61 | x = np.array([3, 1, 2]) 62 | y = np.array([2, 3, 1]) 63 | 64 | print(np.lexsort((x, y))) 65 | ``` 66 | **Output:** 67 | ``` 68 | [1 2 0] 69 | ``` 70 | 71 |

argmax(a, /, axis=None, out=None) Methodu

72 | 73 | `a` parametresine girilen array'in en büyük değerini döndürür. Örnek: 74 | ```py 75 | import numpy as np 76 | 77 | a = np.array([1, 2, 3, 4]) 78 | 79 | print(np.argmax(a)) 80 | ``` 81 | **Output:** 82 | ``` 83 | 3 84 | ``` 85 | 86 |

argmin(a, /, axis=None, out=None) Methodu

87 | 88 | `a` parametresine girilen array'in en küçük değerini döndürür. Örnek: 89 | ```py 90 | import numpy as np 91 | 92 | a = np.array([1, 2, 3, 4]) 93 | 94 | print(np.argmin(a)) 95 | ``` 96 | **Output:** 97 | ``` 98 | 0 99 | ``` 100 | 101 |

nonzero(a) Methodu

102 | 103 | `a` parametresine girilen array'de 0 olmayan değerlerin indexlerini döndürür. Örnek: 104 | ```py 105 | import numpy as np 106 | 107 | a = np.array([[1, 2, 3], [0, 0, 0], [4, 5, 6]]) 108 | 109 | print(np.nonzero(a)) 110 | ``` 111 | **Output:** 112 | ``` 113 | (array([0, 0, 0, 2, 2, 2]), array([0, 1, 2, 0, 1, 2])) 114 | ``` 115 | 116 |

where(condition, /, x=None, y=None) Methodu

117 | 118 | `condition` parametresine girilen array'de `True` olan (yani `0` olmayan) değerlerin indexlerini döndürür. Örnek: 119 | ```py 120 | import numpy as np 121 | 122 | a = np.array([[1, 2, 3], [0, 0, 0], [4, 5, 6]]) 123 | 124 | print(np.where(a > 2)) 125 | ``` 126 | **Output:** 127 | ``` 128 | (array([0, 2, 2, 2]), array([2, 0, 1, 2])) 129 | ``` 130 | 131 |

extract(condition, arr) Methodu

132 | 133 | `condition` parametresine girilen array'de 0 olmayan değerlerin indexlerini `arr` parametresine girilen array'den alır. Örnek: 134 | ```py 135 | import numpy as np 136 | 137 | a = np.array([[1, 2, 3], [0, 0, 0], [4, 5, 6]]) 138 | 139 | print(np.extract(a > 2, a)) 140 | ``` 141 | **Output:** 142 | ``` 143 | [3 4 5 6] 144 | ``` -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/statistical_functions.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Statistical Functions](#1) 4 | - [`amin` Methodu](#1.1) 5 | - [`amax` Methodu](#1.2) 6 | - [`ptp` Methodu](#1.3) 7 | - [`percentile` Methodu](#1.4) 8 | - [`median` Methodu](#1.5) 9 | - [`mean` Methodu](#1.6) 10 | - [`average` Methodu](#1.7) 11 | - [`std` Methodu](#1.8) 12 | - [`var` Methodu](#1.9) 13 | 14 |

Statistical Functions

15 | 16 |

amin Methodu

17 | 18 | `amin(a, /, axis=None, out=None, keepdims=, initial=, where=True)` syntax'ına sahiptir. `a` parametresine girilen array'in tüm değerlerinin en küçüğünü alır. Örnek: 19 | ```py 20 | import numpy as np 21 | 22 | a = np.array([[3, 7, 5], [8, 4, 3], [2, 4, 9]]) 23 | 24 | print(np.amin(a)) 25 | ``` 26 | **Output:** 27 | ``` 28 | 2 29 | ``` 30 | 31 |

amax Methodu

32 | 33 | `amax(a, /, axis=None, out=None, keepdims=, initial=, where=True)` syntax'ına sahiptir. `a` parametresine girilen array'in tüm değerlerinin en büyüğünü alır. Örnek: 34 | ```py 35 | import numpy as np 36 | 37 | a = np.array([[3, 7, 5], [8, 4, 3], [2, 4, 9]]) 38 | 39 | print(np.amax(a)) 40 | ``` 41 | **Output:** 42 | ``` 43 | 9 44 | ``` 45 | 46 |

ptp Methodu

47 | 48 | `ptp(a, /, axis=None, out=None, keepdims=)` syntax'ına sahiptir. `a` parametresine girilen array'in tüm değerlerinin en büyük ve en küçük farkını alır. Örnek: 49 | ```py 50 | import numpy as np 51 | 52 | a = np.array([[3, 7, 5], [8, 4, 3], [2, 4, 9]]) 53 | 54 | print(np.ptp(a)) 55 | ``` 56 | **Output:** 57 | ``` 58 | 7 59 | ``` 60 | 61 |

percentile(a, q, /, axis=None, out=None, overwrite_input=False, interpolation='linear', keepdims=False) Methodu

62 | 63 | `a` parametresine girilen array'in tüm değerlerinin `q` parametresine girilen yüzdelik değerine göre yüzdelik değerini alır. Örnek: 64 | ```py 65 | import numpy as np 66 | 67 | a = np.array([[10, 7, 4], [3, 2, 1]]) 68 | 69 | print(np.percentile(a, 50)) 70 | ``` 71 | **Output:** 72 | ``` 73 | 3.5 74 | ``` 75 | 76 |

median(a, /, axis=None, out=None, overwrite_input=False, keepdims=False) Methodu

77 | 78 | `a` parametresine girilen array'in tüm değerlerinin ortalamasını alır. Örnek: 79 | ```py 80 | import numpy as np 81 | 82 | a = np.array([[30, 65, 70], [80, 95, 10], [50, 90, 60]]) 83 | 84 | print(np.median(a)) 85 | ``` 86 | **Output:** 87 | ``` 88 | 65.0 89 | ``` 90 | 91 |

mean Methodu

92 | 93 | `mean(a, /, axis=None, dtype=None, out=None, keepdims=)` syntax'ına sahiptir. `a` parametresine girilen array'in tüm değerlerinin ortalamasını alır. Örnek: 94 | ```py 95 | import numpy as np 96 | 97 | a = np.array([[1, 2, 3], [3, 4, 5], [4, 5, 6]]) 98 | 99 | print(np.mean(a)) 100 | ``` 101 | **Output:** 102 | ``` 103 | 3.6666666666666665 104 | ``` 105 | 106 |

average(a, /, axis=None, weights=None, returned=False) Methodu

107 | 108 | `a` parametresine girilen array'in tüm değerlerinin ağırlıklı ortalamasını alır. Örnek: 109 | ```py 110 | import numpy as np 111 | 112 | a = np.array([1, 2, 3, 4]) 113 | 114 | print(np.average(a)) 115 | ``` 116 | **Output:** 117 | ``` 118 | 2.5 119 | ``` 120 | 121 |

std Methodu

122 | 123 | `std(a, /, axis=None, dtype=None, out=None, ddof=0, keepdims=)` syntax'ına sahiptir. `a` parametresine girilen array'in tüm değerlerinin standart sapmasını alır. Örnek: 124 | ```py 125 | import numpy as np 126 | 127 | a = np.array([1, 2, 3, 4]) 128 | 129 | print(np.std(a)) 130 | ``` 131 | **Output:** 132 | ``` 133 | 1.118033988749895 134 | ``` 135 | 136 |

var Methodu

137 | 138 | `var(a, /, axis=None, dtype=None, out=None, ddof=0, keepdims=)` syntax'ına sahiptir. `a` parametresine girilen array'in tüm değerlerinin varyansını alır. Örnek: 139 | ```py 140 | import numpy as np 141 | 142 | a = np.array([1, 2, 3, 4]) 143 | 144 | print(np.var(a)) 145 | ``` 146 | **Output:** 147 | ``` 148 | 1.25 149 | ``` -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/string_functions.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [String Functions](#1) 4 | - [`add` Methodu](#1.1) 5 | - [`multiply` Methodu](#1.2) 6 | - [`center` Methodu](#1.3) 7 | - [`capitalize` Methodu](#1.4) 8 | - [`title` Methodu](#1.5) 9 | - [`lower` Methodu](#1.6) 10 | - [`upper` Methodu](#1.7) 11 | - [`split` Methodu](#1.8) 12 | - [`splitlines` Methodu](#1.9) 13 | - [`strip` Methodu](#1.10) 14 | - [`join` Methodu](#1.11) 15 | - [`replace` Methodu](#1.12) 16 | - [`decode` Methodu](#1.13) 17 | - [`encode` Methodu](#1.14) 18 | 19 |

String Functions

20 | 21 |

add(x1, x2, /[, out, casting, order, dtype, subok]) Methodu

22 | 23 | `x1` ve `x2` parametrelerine girilen array'lerin string değerlerini birleştirir. Örnek: 24 | ```py 25 | import numpy as np 26 | 27 | a = np.array(['a','b','c']) 28 | b = np.array(['d','e','f']) 29 | 30 | print(np.add(a,b)) 31 | ``` 32 | **Output:** 33 | ``` 34 | ['ad' 'be' 'cf'] 35 | ``` 36 | 37 |

multiply(x1, x2, /[, out, casting, order, dtype, subok]) Methodu

38 | 39 | `x1` parametresine girilen array'in string değerlerini `x2` parametresine girilen değer kadar tekrar eder. Örnek: 40 | ```py 41 | import numpy as np 42 | 43 | a = np.array(['a','b','c']) 44 | 45 | print(np.multiply(a,3)) 46 | ``` 47 | **Output:** 48 | ``` 49 | ['aaa' 'bbb' 'ccc'] 50 | ``` 51 | 52 |

center(a, width, fillchar=' ', /) Methodu

53 | 54 | `a` parametresine girilen array'in string değerlerini `width` parametresine girilen değer kadar ortalar. `fillchar` parametresine girilen değer ile boşlukları doldurur. Örnek: 55 | ```py 56 | import numpy as np 57 | 58 | a = np.array(['a','b','c']) 59 | 60 | print(np.center(a,10,'-')) 61 | ``` 62 | **Output:** 63 | ``` 64 | ['---a----' '---b----' '---c----'] 65 | ``` 66 | 67 |

capitalize(a, /) Methodu

68 | 69 | `a` parametresine girilen array'in string değerlerinin ilk harflerini büyük yapar. Örnek: 70 | ```py 71 | import numpy as np 72 | 73 | a = np.array(['a','b','c']) 74 | 75 | print(np.capitalize(a)) 76 | ``` 77 | **Output:** 78 | ``` 79 | ['A' 'B' 'C'] 80 | ``` 81 | 82 |

title(a, /) Methodu

83 | 84 | `a` parametresine girilen array'in string değerlerinin tüm harflerini büyük yapar. Örnek: 85 | ```py 86 | import numpy as np 87 | 88 | a = np.array(['a','b','c']) 89 | 90 | print(np.title(a)) 91 | ``` 92 | **Output:** 93 | ``` 94 | ['A' 'B' 'C'] 95 | ``` 96 | 97 |

lower(a, /) Methodu

98 | 99 | `a` parametresine girilen array'in string değerlerinin tüm harflerini küçük yapar. Örnek: 100 | ```py 101 | import numpy as np 102 | 103 | a = np.array(['A','B','C']) 104 | 105 | print(np.lower(a)) 106 | ``` 107 | **Output:** 108 | ``` 109 | ['a' 'b' 'c'] 110 | ``` 111 | 112 |

upper(a, /) Methodu

113 | 114 | `a` parametresine girilen array'in string değerlerinin tüm harflerini büyük yapar. Örnek: 115 | ```py 116 | import numpy as np 117 | 118 | a = np.array(['a','b','c']) 119 | 120 | print(np.upper(a)) 121 | ``` 122 | **Output:** 123 | ``` 124 | ['A' 'B' 'C'] 125 | ``` 126 | 127 |

split(a, /[, sep, maxsplit]) Methodu

128 | 129 | `a` parametresine girilen array'in string değerlerini `sep` parametresine girilen değer ile ayırır. `maxsplit` parametresine girilen değer kadar ayırma işlemi yapar. Örnek: 130 | ```py 131 | import numpy as np 132 | 133 | a = np.array(['a b c','d e f','g h i']) 134 | 135 | print(np.split(a,' ')) 136 | ``` 137 | **Output:** 138 | ``` 139 | [array(['a', 'b', 'c'], dtype='splitlines(a, /[, keepends]) Methodu 145 | 146 | `a` parametresine girilen array'in string değerlerini satır sonlarına göre ayırır. `keepends` parametresine `True` girilirse satır sonlarını da ayırır. Örnek: 147 | ```py 148 | import numpy as np 149 | 150 | a = np.array(['a\nb\nc','d\ne\nf','g\nh\ni']) 151 | 152 | print(np.splitlines(a)) 153 | ``` 154 | **Output:** 155 | ``` 156 | [array(['a', 'b', 'c'], dtype='strip(a, /[, chars]) Methodu 162 | 163 | `a` parametresine girilen array'in string değerlerinin başındaki ve sonundaki boşlukları siler. `chars` parametresine girilen değerlerin başındaki ve sonundaki boşlukları siler. Örnek: 164 | ```py 165 | import numpy as np 166 | 167 | a = np.array([' a ',' b ',' c ']) 168 | 169 | print(np.strip(a)) 170 | ``` 171 | **Output:** 172 | ``` 173 | ['a' 'b' 'c'] 174 | ``` 175 | 176 |

join(a, sep, /) Methodu

177 | 178 | `a` parametresine girilen array'in string değerlerini `sep` parametresine girilen değer ile birleştirir. Örnek: 179 | ```py 180 | import numpy as np 181 | 182 | a = np.array(['a','b','c']) 183 | 184 | print(np.join(a,'-')) 185 | ``` 186 | **Output:** 187 | ``` 188 | a-b-c 189 | ``` 190 | 191 |

replace(a, old, new, /[, count]) Methodu

192 | 193 | `a` parametresine girilen array'in string değerlerinde `old` parametresine girilen değeri `new` parametresine girilen değer ile değiştirir. `count` parametresine girilen değer kadar değiştirme işlemi yapar. Örnek: 194 | ```py 195 | import numpy as np 196 | 197 | a = np.array(['a','b','c']) 198 | 199 | print(np.replace(a,'a','d')) 200 | ``` 201 | **Output:** 202 | ``` 203 | ['d' 'b' 'c'] 204 | ``` 205 | 206 |

decode(a, /[, encoding, errors]) Methodu

207 | 208 | `a` parametresine girilen array'in string değerlerini `encoding` parametresine girilen değer ile kodlar. `errors` parametresine girilen değer ile hata ayıklaması yapar. Örnek: 209 | ```py 210 | import numpy as np 211 | 212 | a = np.array(['a','b','c']) 213 | 214 | print(np.decode(a,'utf-8')) 215 | ``` 216 | **Output:** 217 | ``` 218 | [b'a' b'b' b'c'] 219 | ``` 220 | 221 |

encode(a, /[, encoding, errors]) Methodu

222 | 223 | `a` parametresine girilen array'in string değerlerini `encoding` parametresine girilen değer ile kodlar. `errors` parametresine girilen değer ile hata ayıklaması yapar. Örnek: 224 | ```py 225 | import numpy as np 226 | 227 | a = np.array([b'a',b'b',b'c']) 228 | 229 | print(np.encode(a,'utf-8')) 230 | ``` 231 | **Output:** 232 | ``` 233 | ['a' 'b' 'c'] 234 | ``` -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/trigonometric_functions.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Trigonometric Functions](#1) 4 | - [`sin` Methodu](#1.1) 5 | - [`cos` Methodu](#1.2) 6 | - [`tan` Methodu](#1.3) 7 | - [`arcsin` Methodu](#1.4) 8 | - [`arccos` Methodu](#1.5) 9 | - [`arctan` Methodu](#1.6) 10 | - [`degrees` Methodu](#1.7) 11 | - [`radians` Methodu](#1.8) 12 | - [`deg2rad` Methodu](#1.9) 13 | - [`rad2deg` Methodu](#1.10) 14 | - [`unwrap` Methodu](#1.11) 15 | 16 |

Trigonometric Functions

17 | 18 |

sin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

19 | 20 | `x` parametresine girilen array'in tüm değerlerinin sinüsünü alır ve radians cinsinden döndürür. Örnek: 21 | ```py 22 | import numpy as np 23 | 24 | x = np.array([0, np.pi/2, np.pi]) 25 | 26 | print(np.sin(x)) 27 | ``` 28 | **Output:** 29 | ``` 30 | [0.0000000e+00 1.0000000e+00 1.2246468e-16] 31 | ``` 32 | 33 |

cos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

34 | 35 | `x` parametresine girilen array'in tüm değerlerinin kosinüsünü alır ve radians cinsinden döndürür. Örnek: 36 | ```py 37 | import numpy as np 38 | 39 | x = np.array([0, np.pi/2, np.pi]) 40 | 41 | print(np.cos(x)) 42 | ``` 43 | **Output:** 44 | ``` 45 | [ 1.0000000e+00 6.1232340e-17 -1.0000000e+00] 46 | ``` 47 | 48 |

tan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

49 | 50 | `x` parametresine girilen array'in tüm değerlerinin tanjantını alır ve radians cinsinden döndürür. Örnek: 51 | ```py 52 | import numpy as np 53 | 54 | x = np.array([0, np.pi/2, np.pi]) 55 | 56 | print(np.tan(x)) 57 | ``` 58 | **Output:** 59 | ``` 60 | [ 0.0000000e+00 1.6331239e+16 -1.2246468e-16] 61 | ``` 62 | 63 |

arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

64 | 65 | `x` parametresine girilen array'in tüm değerlerinin ters sinüsünü alır ve radians cinsinden döndürür. Örnek: 66 | ```py 67 | import numpy as np 68 | 69 | x = np.array([0, 1, -1]) 70 | 71 | print(np.arcsin(x)) 72 | ``` 73 | **Output:** 74 | ``` 75 | [0. 1.57079633 1.57079633] 76 | ``` 77 | 78 |

arccos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

79 | 80 | `x` parametresine girilen array'in tüm değerlerinin ters kosinüsünü alır ve radians cinsinden döndürür. Örnek: 81 | ```py 82 | import numpy as np 83 | 84 | x = np.array([0, 1, -1]) 85 | 86 | print(np.arccos(x)) 87 | ``` 88 | **Output:** 89 | ``` 90 | [1.57079633 0. 3.14159265] 91 | ``` 92 | 93 |

arctan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

94 | 95 | `x` parametresine girilen array'in tüm değerlerinin ters tanjantını alır ve radians cinsinden döndürür. Örnek: 96 | ```py 97 | import numpy as np 98 | 99 | x = np.array([0, 1, -1]) 100 | 101 | print(np.arctan(x)) 102 | ``` 103 | **Output:** 104 | ``` 105 | [0. 0.78539816 0.78539816] 106 | ``` 107 | 108 |

degrees(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

109 | 110 | `x` parametresine girilen array'in tüm değerlerinin derece cinsinden karşılığını alır. Örnek: 111 | ```py 112 | import numpy as np 113 | 114 | x = np.array([0, np.pi/2, np.pi]) 115 | 116 | print(np.degrees(x)) 117 | ``` 118 | **Output:** 119 | ``` 120 | [ 0. 90. 180.] 121 | ``` 122 | 123 |

radians(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

124 | 125 | `x` parametresine girilen array'in tüm değerlerinin radyan cinsinden karşılığını alır. Örnek: 126 | ```py 127 | import numpy as np 128 | 129 | x = np.array([0, 90, 180]) 130 | 131 | print(np.radians(x)) 132 | ``` 133 | **Output:** 134 | ``` 135 | [0. 1.57079633 3.14159265] 136 | ``` 137 | 138 |

deg2rad(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

139 | 140 | `x` parametresine girilen array'in tüm değerlerinin radyan cinsinden karşılığını alır. Örnek: 141 | ```py 142 | import numpy as np 143 | 144 | x = np.array([0, 90, 180]) 145 | 146 | print(np.deg2rad(x)) 147 | ``` 148 | **Output:** 149 | ``` 150 | [0. 1.57079633 3.14159265] 151 | ``` 152 | 153 |

rad2deg(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj]) Methodu

154 | 155 | `x` parametresine girilen array'in tüm değerlerinin derece cinsinden karşılığını alır. Örnek: 156 | ```py 157 | import numpy as np 158 | 159 | x = np.array([0, np.pi/2, np.pi]) 160 | 161 | print(np.rad2deg(x)) 162 | ``` 163 | **Output:** 164 | ``` 165 | [ 0. 90. 180.] 166 | ``` 167 | 168 |

unwrap(p, discont=None, axis=- 1, *, period=6.283185307179586) Methodu

169 | 170 | `p` parametresine girilen array'in tüm değerlerinin ters sinüsünü alır ve radians cinsinden döndürür. Örnek: 171 | ```py 172 | import numpy as np 173 | 174 | x = np.array([0, 1, -1]) 175 | 176 | print(np.unwrap(x)) 177 | ``` 178 | **Output:** 179 | ``` 180 | [0. 1.57079633 1.57079633] 181 | ``` -------------------------------------------------------------------------------- /python_tutorial/modules/numpy/what_is_numpy.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [NumPy Nedir](#1) 4 | - [Numpy Installing ve Importing](#2) 5 | 6 |

NumPy Nedir?

7 | 8 | Numerical Python'un kısaltması olan NumPy, multidimensional array objeleri üretmek ve bunlar üzerinde mathematical ve logical işlemler yapmak için çeşitli yöntemler sunan, science ve engineering alanlarında sıkça kullanılan open source library'dir. 9 | 10 | Numerical data'lar ile çalışmak için evrensel bir standarttır. Kendi başına bir işe yaramaz ama Pandas, SciPy, Matplotlib, scikit-learn, scikit-image ve diğer birçok data science ve scientific gibi birçok Python paketinde; veri manipülasyonu, veri bilimi, yapay zeka gibi birçok alanda kullanılmaktadır. 11 | 12 | Multidimensional array ve matrix data structure'ları içerir. n-dimensional array object olan `ndarray` ve methodlar barındırır. `ndarray`'ler hem vector'leri (1D array) hem matrix'leri (2D array) hem de tensor'leri (+3D array) temsil etmek için kullanılır. 13 | 14 | [**vectorization**](https://stackoverflow.com/a/1422181/15170972 "https://stackoverflow.com/a/1422181/15170972")'ı desteklediği ve Python listelerinden farklı olarak homojen bir yapıya sahip olduğu için daha hızlıdır, compact'tır, daha az bellek tüketir, daha optimize ve verimlidir. Örnek: 15 | ```py 16 | import numpy as np 17 | import time 18 | 19 | start_time_1 = time.time() 20 | A = np.arange(1000000) 21 | A**2 22 | time_1 = time.time() - start_time_1 23 | 24 | start_time_2 = time.time() 25 | B = range(1000000) 26 | [i**2 for i in B] 27 | time_2 = time.time() - start_time_2 28 | 29 | print(f"time_1: {time_1}", 30 | f"time_2: {time_2}", 31 | f"Bu işlemde arange, range'den {time_2/time_1} kat daha hızlı çalıştı.", sep="\n") 32 | ``` 33 | **Output:** 34 | ``` 35 | time_1: 0.0020034313201904297 36 | time_2: 0.2800407409667969 37 | Bu işlemde arange, range'den 139.78055456384624 kat daha hızlı çalıştı. 38 | ``` 39 | 40 |

Numpy Installing ve Importing

41 | 42 | Windows ve `pip` kullanıyorsanız CMD'ye `pip install numpy` yazarak Numpy yükleyebilirsiniz. 43 | 44 | Python programınızıda Numpy'ı kullanmak için önce import etmelisiniz: 45 | ```py 46 | import numpy as np 47 | ``` 48 | Sürekli numpy yazmak yerine np kullanmak daha pratik olduğu için böyle tercih etmeniz sizin yararınıza olur. -------------------------------------------------------------------------------- /python_tutorial/opp/abstract.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Abstract Class](#1) 4 | - [Abstract Class Özellikleri](#1.1) 5 | - [Abstraction](#1.2) 6 | 7 |

Abstract Class

8 | 9 | Abstract Class'lar, aynı özellikleri taşıyan objeleri aynı çatı altında toplayıp, bu objelere bir şablon (template) görevi gören class'lardır. 10 | 11 |

Abstract Class Özellikleri

12 | 13 | - Python, abstract class'ları doğrudan desteklemez. Bu yüzden `from abc import ABC, abstractmethod` şeklinde `ABC` (Abstract Base Class) ve `abstractmethod` decorator'ını programınıza import ederek başlamalısınız. 14 | 15 | - `ABC`'den miras almış class'lardan instance türetemezsiniz. Aksi halde `TypeError: Can't instantiate abstract class abstract_class_exp with abstract method process` örneğindeki gibi bir hatası alırsınız. Örnek: 16 | ```py 17 | from abc import ABC, abstractmethod 18 | 19 | class A(ABC): 20 | @abstractmethod 21 | def func(self): pass 22 | 23 | var = A() # TypeError: Can't instantiate abstract class abstract_class_exp with abstract method process 24 | ``` 25 | `ABC`'dan (Abstract Base Class'dan) instance türetince aynı şey yaşanmaz çünkü `ABC` ve `ABCMeta` class'larının methodları abstract method değildir. 26 | 27 | - Abstract class'lar en az bir tane `@abstractmethod` decoratoru ile decore edilerek abstract method'a dönüştürülmüş method'a sahip olmalıdır. Aksi halde abstract class olarak kabul edilmezler. 28 | 29 | - Bir abstract class'ı (`ABC` class'ını miras almış class'lar abstract class oluyor) miras alan subclass'lara, miras aldığı abstract class'da bildirilmiş (declaration) ya da tanımlanmış (definition) abstract methodları tanımlamak (definition) zorundasınız. Aksi halde `TypeError: Can't instantiate abstract class abstract_subclass_exp with abstract method process` örneğindeki gibi bir hatası alırsınız. Örnek: 30 | ```py 31 | from abc import ABC, abstractmethod 32 | 33 | class A(ABC): 34 | def __init__(self): 35 | print("Çalıştı...") 36 | 37 | @abstractmethod 38 | def func(self): 39 | pass 40 | 41 | class B(A): 42 | pass 43 | 44 | class C(A): 45 | def func(self): 46 | pass 47 | 48 | var1 = B() # TypeError: Can't instantiate abstract class B with abstract method func 49 | var2 = C() # Output: Çalıştı... 50 | ``` 51 | 52 |

Abstraction

53 | 54 | Abstraction (soyutlama) işlemine örnek: 55 | ```py 56 | from abc import ABC, abstractmethod 57 | 58 | class A(ABC): # A artık bir abstract class. 59 | 60 | @abstractmethod 61 | def func1(self): 62 | print("func1 A Class'ında çalıştı.", end=" ") 63 | 64 | class B(A): 65 | def func1(self): 66 | print("func1 B Class'ında çalıştı.") 67 | 68 | class C(A): 69 | def func1(self): 70 | super().func1() 71 | print("func1 C Class'ında çalıştı.") 72 | 73 | class D: 74 | def func2(self): 75 | print("func2 D Class'ında çalıştı.") 76 | 77 | class E(A): 78 | def func2(self): 79 | print("func2 E Class'ında çalıştı.") 80 | 81 | var1 = A() # TypeError: Can't instantiate abstract class A with abstract method func1 82 | var2 = B() 83 | var3 = C() 84 | var4 = D() 85 | var5 = E() # TypeError: Can't instantiate abstract class E with abstract method func1 86 | 87 | var2.func1() # Output: func1 B Class'ında çalıştı. 88 | var3.func1() # Output: func1 A Class'ında çalıştı. func1 C Class'ında çalıştı. 89 | var4.func1() # AttributeError: 'D' object has no attribute 'func1' 90 | var4.func2() # Output: func2 D Class'ında çalıştı. 91 | ``` 92 | Bu örneği parça parça açıklayalım: 93 | - `A` class'ı `ABC` abstract base class'dan miras alarak bir abstract class'a olmuştur. Bu yüzden `A` class'ından instance türetemezsiniz. Türetmeye çalışırsanız yukarıdaki gibi `TypeError: Can't instantiate abstract class A with abstract method func1` hatası yükseltilir. 94 | - `A` abstract class'ındaki `func1` methodu `@abstractmethod` decorator'ı ile decore edildiği için bu method artık bir abstract method olur. Bu yüzden `A` abstract class'ından miras alan class'larda (`B`, `C` ve `E` class'ları) `func1` abstract methodunu tanımlamak zorundasınız. Aksi halde `var5 = E()` kodundaki gibi `TypeError: Can't instantiate abstract class BlackBoard with abstract method func1` hatası yükseltilir (çünkü `E` class'ından `func1` abstract methodu tanımlı değil). 95 | 96 | **Not:** Yukarıdaki örnekte `B` ve `C` class'larında gördüğünüz gibi, bu class'ların `func1` methodunun içeriğini, bu class'ların miras aldığı `A` abstract class'ındaki `func1` abstract methodunun içeriğinin aynısı olacak şekilde tanımlamak zorunda değilsiniz. `B` ve `C` class'larında `func1` identifier'ına sahip bir fonksiyonun tanımlı olması yeterlidir. İçeriğini istediğiniz gibi değiştirebilirsiniz. 97 | 98 | **Not:** Normal bir class'ın instance-class-static methodları ve property objeleri olduğu gibi, abstract class'ların da bunlar gibi objeleri vardır: 99 | ```py 100 | import abc 101 | 102 | print(dir(abc)) 103 | ``` 104 | **Output:** 105 | ```py 106 | ['ABC', 'ABCMeta', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_abc_init', '_abc_instancecheck', '_abc_register', '_abc_subclasscheck', '_get_dump', '_reset_caches', '_reset_registry', 'abstractclassmethod', 'abstractmethod', 'abstractproperty', 'abstractstaticmethod', 'get_cache_token'] 107 | ``` 108 | **Karşılıkları:** 109 | ``` 110 | ABCMeta : ABC tanımlamak için kullanılan meta class 111 | ABC : Abstract class oluşturmak için miras alınan class 112 | abstractmethod : Instance methodun abstract olanı 113 | abstractclassmethod : Class methodun abstract olanı 114 | abstractstaticmethod : Static methodun abstract olanı 115 | abstractproperty : Property'nin abstract olanı 116 | ``` 117 | Bunları kullanacaksanız, Python ile baya kapsamlı bir proje geliştiriyorsunuz demektir. Böyle bir proje geliştirebilen birisi ingilizce de biliyordur. Bu yüzden ingilizce kaynaklardan kendiniz araştırabilirsiniz. 118 | 119 | Daha fazla bilgi için [tıklayınız](https://docs.python.org/3/library/abc.html?highlight=abstract "https://docs.python.org/3/library/abc.html?highlight=abstract") -------------------------------------------------------------------------------- /python_tutorial/opp/class_members.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Class Members](#1) 4 | - [Public Members (Aleni Üyeler)](#1.1) 5 | - [Private Members (Gizli Üyeler)](#1.2) 6 | - [Semi-private Members (Yarı-gizli Üyeler)](#1.3) 7 | 8 |

Class Members

9 | 10 | Bir class'ın içindeki attribute'lar, variable'lar, method'lar vb. diğer öğelerin her biri bir class member'dır (sınıf üyesidir). Class member'lar üçe ayrılır: 11 | - Aleni Üyeler (Public Members) 12 | - Gizli Üyeler (Private Members) 13 | - Yarı-Gizli Üyeler (Semi-Private Members) 14 | 15 |

Public Members (Aleni Üyeler)

16 | 17 | Bir class member'a class dışından normal yöntemlerle erişilebiliyorsa, bu class member'a **public member** denir. Örnek: 18 | ```py 19 | class A(): 20 | c_attri = 'Class Attribute' 21 | 22 | def __init__(self),: 23 | self.i_attri = 'Instance Attribute' 24 | 25 | def instance_method(self): 26 | print(f"instance_method() Çalıştı! | {self.i_attri}") 27 | 28 | @classmethod 29 | def class_method(cls): 30 | print(f"class_method() Çalıştı! | {cls.c_attri}") 31 | 32 | @staticmethod 33 | def static_method(): 34 | s_attri = 'Static Attribute' 35 | print(f"static_method() Çalıştı! | {s_attri}") 36 | 37 | var = A() 38 | print(dir(var)) # Output: ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'c_attri', 'class_method', 'i_attri', 'instance_method', 'static_method'] 39 | 40 | # Normal yöntemlerden kasıt: 41 | print(A.c_attri) # Output: Class Attribute 42 | var.instance_method() # Output: instance_method() Çalıştı! | Instance Attribute 43 | var.class_method() # Output: class_method() Çalıştı! | Class Attribute 44 | var.static_method() # Output: static_method() Çalıştı! | Static Attribute 45 | ``` 46 | `dir(A)` fonksiyonu bize `A` class'ı içindeki bütün class member'ları verir. Bu class member'lara yukarıdaki gibi **normal yöntemlerle doğrudan** erişebildiği için bu öğeler public member'dır. Gördüğünüz gibi buradaki `c_attri`, `i_attri`, `instance_method`, `class_method`, `static_method` ve diğer method ve attribute'lar public member'dır. 47 | 48 | **Not:** Private member olarak tanımlanmamış bütün class member'lar (semi-private ve public member'lardan bahsediyorum), Python tarafından otomatik olarak public member olarak kabul edilir. 49 | 50 |

Private Members (Gizli Üyeler)

51 | 52 | Class'ın iç işlerini ilgilendirdiği için dışarıdan erişimine gerek olmayan ya da dışarıdan erişilirse programda sorunlara neden olabilecek (dışarıdan erişilmesi istenmeyen) class member'ların isimlerinin önüne (yani en soluna) **en az 2** tane, sonuna (yani en sağına) **en fazla 1** tane alt çizgi (`_` underscore) koyarak bu class member'ları **private member**'lar haline getirebilirsiniz. Private member'lara normal yöntemlerle doğrudan erişilemez. Örnekler: 53 | ```py 54 | class A(): 55 | # Attribute Attribute Class Member 56 | # Name Value Type 57 | gizli = "gizli" # Public Member 58 | _gizli = "_gizli" # Public Member 59 | _gizli_ = "_gizli_" # Public Member 60 | _gizli__ = "_gizli__" # Public Member 61 | _gizli___ = "_gizli___" # Public Member 62 | __gizli = "__gizli" # Private Member 63 | __gizli_ = "__gizli_" # Private Member 64 | __gizli__ = "__gizli__" # Public Member 65 | __gizli___ = "__gizli___" # Public Member 66 | __gizli_gizli = "__gizli_gizli" # Private Member 67 | __gizli_gizli_ = "__gizli_gizli_" # Private Member 68 | __gizli_gizli__ = "__gizli_gizli__" # Public Member 69 | __gizli_gizli___ = "__gizli_gizli___" # Public Member 70 | ___gizli = "___gizli" # Private Member 71 | ___gizli_ = "___gizli_" # Private Member 72 | ___gizli__ = "___gizli__" # Public Member 73 | ___gizli___ = "___gizli___" # Public Member 74 | 75 | print(A().gizli) # Output: gizli 76 | print(A().__gizli) # AttributeError: 'A' object has no attribute '__gizli' 77 | ``` 78 | Gördüğünüz gibi private member oluşturma kuralına uyan isimleri (identifier) Python private member olarak kabul ederken, bu kurala uymayanları public member olarak kabul ediyor. 79 | 80 | Herhangi bir class objesi (method, attribute, property vs.) private member olarak tanımlanabilir. Örnekler: 81 | ```py 82 | class A(): 83 | __c_attri = 'Class Attribute' 84 | 85 | def __init__(self): 86 | self.__i_attri = 'Instance Attribute' 87 | 88 | def __instance_method(self): 89 | print(f"instance_method() Çalıştı! | {self.__i_attri}") 90 | 91 | @classmethod 92 | def __class_method(cls): 93 | print(f"class_method() Çalıştı! | {cls.__c_attri}") 94 | 95 | @staticmethod 96 | def __static_method(): 97 | s_attri = 'Static Attribute' 98 | print(f"static_method() Çalıştı! | {s_attri}") 99 | 100 | __property_exp = property() 101 | 102 | var = A() 103 | for i in dir(var): 104 | if "_A" in i: 105 | print(i) 106 | ``` 107 | **Output:** 108 | ``` 109 | _A__c_attri 110 | _A__class_method 111 | _A__i_attri 112 | _A__instance_method 113 | _A__property_exp 114 | _A__static_method 115 | ``` 116 | 117 | Private member'ları tanımlandıkları isimlerle (identifier) doğrudan çağıramazsınız çünkü bellekte tanımlandıkları isimlerle depolanmazlar. Yani private olarak tanımlanmış bir class member, class dışından tamamen erişilemez değildir. Bu durum Python'ın, private member'ları **Name Mangling** kullanarak farklı bir isimle (identifier) belleğe kaydetmesinden kaynaklanır. Python private member'ları `_{class_name}{private_class_member_name}` formatında oluşturulmuş isimlerle (identifier) belleğe kaydeder. Buna **Name Mangling (isim bulandırma)** denir. Örnekler: 118 | ```py 119 | class A(): 120 | # Attribute Attribute Class Member | Bellekteki 121 | # Name Value Type | İsmi 122 | gizli = "gizli" # Public Member | gizli 123 | _gizli = "_gizli" # Public Member | _gizli 124 | _gizli_ = "_gizli_" # Public Member | _gizli_ 125 | _gizli__ = "_gizli__" # Public Member | _gizli__ 126 | _gizli___ = "_gizli___" # Public Member | _gizli___ 127 | __gizli = "__gizli" # Private Member | _A__gizli 128 | __gizli_ = "__gizli_" # Private Member | _A__gizli_ 129 | __gizli__ = "__gizli__" # Public Member | __gizli__ 130 | __gizli___ = "__gizli___" # Public Member | __gizli___ 131 | __gizli_gizli = "__gizli_gizli" # Private Member | _A__gizli_gizli 132 | __gizli_gizli_ = "__gizli_gizli_" # Private Member | _A__gizli_gizli_ 133 | __gizli_gizli__ = "__gizli_gizli__" # Public Member | __gizli_gizli__ 134 | __gizli_gizli___ = "__gizli_gizli___" # Public Member | __gizli_gizli___ 135 | ___gizli = "___gizli" # Private Member | _A___gizli 136 | ___gizli_ = "___gizli_" # Private Member | _A___gizli_ 137 | ___gizli__ = "___gizli__" # Public Member | ___gizli__ 138 | ___gizli___ = "___gizli___" # Public Member | ___gizli___ 139 | 140 | print(A().gizli) # Output: gizli 141 | print(A()._A__gizli) # Output: __gizli 142 | print(A().__gizli) # AttributeError: 'A' object has no attribute '__gizli' 143 | ``` 144 | Gördüğünüz gibi private member'lara `A().__gizli` örneğindeki gibi erişemezsiniz çünkü bellekte bu isimde bir attribute yok. 145 | 146 | **Not:** Private member'lara bu şekilde erişebilmemiz, private member'ları teknik olarak private yapmaz. Bu yüzden private member'ların doğru kullanımı name mangling ile bir nebze güvenceye alınmış ve kullanıcıların inisiyatifine bırakılmıştır. 147 | 148 | Private member'lara class dışından normal yollarla doğrudan erişemesek bile, class'ın içinde kullanabiliriz. Örnek: 149 | ```py 150 | class A(): 151 | __gizli1 = "Private Member 1" 152 | __gizli2 = "Private Member 2" 153 | 154 | def yazdir1(self): 155 | print(self.__gizli1) 156 | 157 | def yazdir2(self): 158 | return self.__gizli2 159 | 160 | A().yazdir1() # Output: Private Member 1 161 | print(A().yazdir2()) # Output: Private Member 2 162 | ``` 163 | `A().yazdir1()` ve `print(A().yazdir2())` kodlarıyla bu private member'ların value'larına class dışından ulaşabilsek bile bu normal yollarla doğrudan bir erişim olmadığından, dolaylı yoldan (method aracılığıyla) bir erişim olduğundan bu class member'lar public member olarak kabul edilmez. 164 | 165 |

Semi-private Members (Yarı-gizli Üyeler)

166 | 167 | Önüne (yani en soluna) bir tane alt çizgi (`_`) konularak oluşturulan isimlere (identifier) sahip class member'lara **Semi-Private Member**'lar denir. Semi-private member teknik olarak public member'dır. Yeni semi-private member'lar, Python kullanıcıların uydurduğu bir şeydir. Python kullanıcıları semi-private member'ları, bir class member'ın bellekteki ismini (identifier) değiştirmeden private member gibi kullanmak istediklerinde kullanmayı tercih eder. 168 | ```py 169 | class A(): 170 | # Attribute Attribute Class Member | Bellekteki 171 | # Name Value Type | İsmi 172 | gizli = "gizli" # Public Member | gizli 173 | _gizli = "_gizli" # Public Member | _gizli 174 | __gizli = "__gizli" # Private Member | _A__gizli 175 | 176 | print(A().gizli) # Output: gizli 177 | print(A()._gizli) # Output: _gizli 178 | print(A()._A__gizli) # Output: __gizli 179 | print(A().__gizli) # AttributeError: 'A' object has no attribute '__gizli' 180 | ``` -------------------------------------------------------------------------------- /python_tutorial/opp/composition.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Composition (Dahil Etme)](#1) 4 | 5 |

Composition (Dahil Etme)

6 | 7 | Bir class'ın görevini/sorumluluklarını başka bir class'a devretmeye (delegated) **Composition** denir. Örnek: 8 | ```py 9 | class Gelir: 10 | def __init__(self, maaş, bonus): 11 | self.maaş = maaş 12 | self.bonus = bonus 13 | 14 | def yıllık_gelir(self): 15 | return (self.maaş*12) + self.bonus 16 | 17 | class Çalışan: 18 | def __init__(self, isim, yaş, maaş, bonus): 19 | self.isim=isim 20 | self.yaş=yaş 21 | self.obj_Gelir = Gelir(maaş, bonus) 22 | 23 | def toplam_gelir(self): 24 | return self.obj_Gelir.yıllık_gelir() 25 | 26 | var = Çalışan('Ali', 25, 2825, 250) 27 | print(var.isim, var.yaş, var.obj_Gelir.maaş, var.obj_Gelir.bonus, sep=", ") # Output: Ali, 25, 2825, 250 28 | print(var.toplam_gelir()) # Output: 34150 29 | ``` 30 | İçinde diğer class'lardan türetilmiş instance'ları barındıran class'lara (yani buradaki `Çalışan` class'ına) **Composite Class**, barındırdığı instance'lara (yani buradaki `obj_Gelir` variable'ına atanmış `Gelir` class'ından türetilmiş instance'a) **Component** denir. 31 | 32 | Composition kavramının Inheritance kavramı ile yakından ilişkisi vardır. Her ikisi de iki class arasındaki ilişkiyi tanımlayarak, kodun yeniden kullanılabilmesini (aynı kodu tekrar tekrar yazmamaktan bahsediyor) sağlarlar fakat bunu farklı şekillerde yaparlar. 33 | 34 | Composition, herhangi bir class'daki objeleri miras almak yerine, herhangi bir class'dan türetilen instance'ı (component) composite class içinde başka bir objeye atayarak kullanmamıza olanak tanır. Bu sayede farklı tür objeleri birleştirerek kompleks class'lar oluşturabiliriz. 35 | 36 | İki class arasındaki Composition ilişkisinin gevşek bir şekilde bağlı olduğu kabul edilir. Bu, component'ların nadiren composite class'ları etkilediği, composite class'ın ise component'ları hiçbir zaman etkilemediği anlamına gelir. Bu durum, mevcut kodu etkilemeden yeni gereksinimlere uygun bir şekilde programın değiştirilmesine daha iyi uyum sağlar. Aynı zamanda composite class'ı sildiğimizde, composite class'ın component'larını da silmiş olacağımız için herhangi bir sorun yaşamayız. 37 | 38 | Daha fazla bilgi için [tıklayınız](https://realpython.com/inheritance-composition-python/ "https://realpython.com/inheritance-composition-python/"). -------------------------------------------------------------------------------- /python_tutorial/opp/pics/1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/opp/pics/1.png -------------------------------------------------------------------------------- /python_tutorial/opp/pics/10.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/opp/pics/10.png -------------------------------------------------------------------------------- /python_tutorial/opp/pics/11.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/opp/pics/11.png -------------------------------------------------------------------------------- /python_tutorial/opp/pics/12.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/opp/pics/12.png -------------------------------------------------------------------------------- /python_tutorial/opp/pics/2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/opp/pics/2.png -------------------------------------------------------------------------------- /python_tutorial/opp/pics/3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/opp/pics/3.png -------------------------------------------------------------------------------- /python_tutorial/opp/pics/4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/opp/pics/4.png -------------------------------------------------------------------------------- /python_tutorial/opp/pics/5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/opp/pics/5.png -------------------------------------------------------------------------------- /python_tutorial/opp/pics/6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/opp/pics/6.png -------------------------------------------------------------------------------- /python_tutorial/opp/pics/7.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/opp/pics/7.png -------------------------------------------------------------------------------- /python_tutorial/opp/pics/8.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/opp/pics/8.png -------------------------------------------------------------------------------- /python_tutorial/opp/pics/9.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/opp/pics/9.png -------------------------------------------------------------------------------- /python_tutorial/opp/what_is_object.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | 3 | - [Nesne/Obje Nedir?](#1) 4 | - [First Class Objects](#1.1) 5 | 6 |

Nesne/Obje Nedir?

7 | 8 | Python'da belli birtakım methodlara ve/veya attribute'lara sahip olan şeylere nesne/obje adı verilir. Yani 'nesne' kelimesi, içinde birtakım method ve/veya attribute'lar barındıran şeyleri tanımlamak için kullanılan bir tabirden, basit bir isimlendirmeden ibarettir. İngilizcesi **object**'dir. Örnek: 9 | ```py 10 | class A(): 11 | pass 12 | 13 | print(dir(A())) 14 | ``` 15 | **Output:** 16 | ``` 17 | ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__'] 18 | ``` 19 | Gördüğünüz gibi kod block'una hiçbir şey tanımlamadığımız bir class bile içerisinde birçok fonksiyon ve attribute'e sahiptir. İşte nesne/obje tam olarak budur. 20 | 21 | **Not:** Python'da keyword'ler, statement'lar ve operator'lar hariç her şey bir objedir. Bunlara ulaşmak için [tıklayınız](./python_tutorial/blob/main/python_tutorial/temel_bilgiler/statements_expressions_keywords.md). 22 | 23 |

First Class Objects

24 | 25 | Python'un yaratıcısı Guido van Rossum şöyle bir şey söylemiş: 26 | 27 | > "Python'a ilişkin hedeflerimden bir tanesi de, bu dili, bütün nesneler 'birinci sınıf' olacak şekilde tasarlamaktı. Bununla kastettiğim, dil içinde kendisine bir isim verilebilen bütün nesnelerin (örn. tam sayılar, karakter dizileri, fonksiyonlar, sınıflar, modüller, methodlar, vb.) eşit statüye sahip olmasıdır. Yani, bütün nesnelerin değişkenlere atanabilmesi, listelerin içine yerleştirilebilmesi, sözlükler içinde depolanabilmesi, argüman olarak atanabilmesi vesaire…" 28 | 29 | Buradan anlamamız gereken şey, Python'un asıl amacının bütün nesnelerin eşit statüde olması ve bu sayede birbiriyle kolayca etkileşime geçebilmesidir. Örneğin: 30 | - Başka bir fonksiyona veya class'a parametre olarak verilebilirler: 31 | ```py 32 | class Class1(): 33 | def __init__(self): 34 | print("Başarılı!!!") 35 | 36 | class Class2(Class1): # Class'a parametre olarak verilebilmesi (Buna parametre olarak verilmekten ziyade miras alma deniyor. Daha sonra anlatılacak) 37 | def __init__(self): 38 | print("Başarılı!!!") 39 | 40 | print(Class2()) # fonksiyona parametre olarak verilebilmesi 41 | ``` 42 | **Output:** 43 | ``` 44 | Başarılı!!! 45 | <__main__.Class2 object at 0x000001677129DFD0> 46 | ``` 47 | - Bir fonksiyondan döndürülebilirler. 48 | ```py 49 | class Class(): 50 | def __init__(self): 51 | print("Başarılı!!!") 52 | 53 | def func(): 54 | return Class() 55 | 56 | func() # Output: Başarılı!!! 57 | ``` 58 | - Bir variable'a atanabilirler. 59 | ```py 60 | class Class(): 61 | def __init__(self): 62 | print("Başarılı!!!") 63 | 64 | değişken = Class() # Output: Başarılı!!! 65 | ``` 66 | First Class Object özelliğine sahip olmayan Python dışındaki dillerin şöyle sıkıntıları vardır: 67 | |Python|Diğer| 68 | |:--:|:--:| 69 | |Her nesneyi her nesneyle beraber kullanabilirsiniz.|Öğelerin kullanımına ilişkin çeşitli kısıtlamalar vardır.| 70 | |Bütün öğeler aynı haklara sahiptir.|Yeni öğeler arasında ayrım yapılır.| 71 | |Her şey bir nesnedir ve her nesne aynı haklara sahiptir.|Variable'lar, fonksiyonlar ve class'lar aynı haklara sahip değildir.| 72 | |Her şey bir nesnedir ve her nesne her yerde eşit muamele görür.|Bir variable'ı ya da value'yu kullanabildiğiniz her yerde fonksiyon ya da class kullanamazsınız.| -------------------------------------------------------------------------------- /python_tutorial/temel_bilgiler/if-elif-else.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | - [`if` Statement](#1) 3 | - [`elif` Statement](#2) 4 | - [`else` Statement](#3) 5 | - [Tek satırda `if` - `else` tanımlamak](#4) 6 | 7 |

if Statement

8 | 9 | "Eğer ..." anlamına gelmektedir. Syntax'ı: 10 | ```py 11 | if (condition): 12 | # Expression 13 | ``` 14 | `condition`'a girilen koşul sağlanıyorsa (`True`) Python, `if` statement kod block'unu okur ve çalıştırır; sağlanmıyorsa (`False`) okunmaz ve bir sonraki statement'a geçer. Örnek: 15 | ```py 16 | sayı = int(input("Sayı gir: ")) 17 | if sayı == 0: 18 | print("Girdiğiniz sayı 0'dır.") 19 | if sayı < 0: 20 | print("Girdiğiniz sayı 0'dan küçüktür.") 21 | if sayı > 0: 22 | print("Girdiğiniz sayı 0'dan büyüktür.") 23 | ``` 24 | **Outputs:** 25 | ``` 26 | Sayı gir: 0 27 | Girdiğiniz sayı 0'dır. 28 | ``` 29 | ``` 30 | Sayı gir: 1 31 | Girdiğiniz sayı 0'dan büyüktür. 32 | ``` 33 | ``` 34 | Sayı gir: -1 35 | Girdiğiniz sayı 0'dan küçüktür. 36 | ``` 37 | 38 | **Not:** Bir `if` statement'ın çalışması diğer `if` statement'ları etkilemez. Yani her `if` statement bağımsızdır. Örnek: 39 | ```py 40 | sayı = int(input("Sayı gir: ")) 41 | if sayı == 0: 42 | print("Girdiğiniz sayı 0'dır.") 43 | if sayı < 10: 44 | print("Girdiğiniz sayı 10'dan küçüktür.") 45 | if sayı > -10: 46 | print("Girdiğiniz sayı -10'dan büyüktür.") 47 | ``` 48 | **Output:** 49 | ``` 50 | Sayı gir: 0 51 | Girdiğiniz sayı sıfırdır. 52 | Girdiğiniz sayı 10'dan küçüktür. 53 | Girdiğiniz sayı -10'dan büyüktür. 54 | ``` 55 | Gördüğünüz gibi `condition`'a girilen koşulu sağlayan bütün `if` statement'lar çalıştı. 56 | 57 |

elif Statement

58 | 59 | `else if`'den türemiştir. "... değilse, eğer ..." anlamına gelmektedir. Syntax: 60 | ```py 61 | # else if syntax: 62 | else: # daha sonra anlatılacak 63 | if (condition): 64 | # Expression 65 | ``` 66 | ```py 67 | # elif statement 68 | elif (condition): 69 | # Expression 70 | ``` 71 | `elif` statement kendisinden önceki `elif` ya da `if` statement'a bağımlıdır. Sadece kendinden önceki `if` ya da `elif` statement çalışmazsa ve `condition`'a girilen koşul sağlanıyorsa çalışır. Örnek: 72 | ```py 73 | sayı = int(input("Sayı gir: ")) 74 | if sayı == 0: 75 | print("Girdiğiniz sayı 0'dır.") 76 | elif sayı < 0: 77 | print("Girdiğiniz sayı 0'dan küçüktür.") 78 | elif sayı > 0: 79 | print("Girdiğiniz sayı 0'dan Büyüktür.") 80 | ``` 81 | **Outputs:** 82 | ``` 83 | Sayı gir: 0 84 | Girdiğiniz sayı 0'dır. 85 | ``` 86 | ``` 87 | Sayı gir: 1 88 | Girdiğiniz sayı 0'dan Büyüktür. 89 | ``` 90 | ``` 91 | Sayı gir: -1 92 | Girdiğiniz sayı 0'dan küçüktür. 93 | ``` 94 | Bu kısmın, `elif` yerine `if` statement kullandığımız seferkinden output olarak farkı yok gibi gözüküyor. Başka bir örnek: 95 | ```py 96 | sayı = int(input("Sayı gir: ")) 97 | if sayı == 0: 98 | print("Girdiğiniz sayı 0'dır.") 99 | elif sayı < 10: 100 | print("Girdiğiniz sayı 10'dan küçüktür.") 101 | elif sayı > -10: 102 | print("Girdiğiniz sayı -10'dan büyüktür.") 103 | ``` 104 | **Outputs:** 105 | ``` 106 | Sayı gir: 0 107 | Girdiğiniz sayı 0'dır. 108 | ``` 109 | ``` 110 | Sayı gir: 9 111 | Girdiğiniz sayı 10'dan küçüktür. 112 | ``` 113 | ``` 114 | Sayı gir: 11 115 | Girdiğiniz sayı -10'dan büyüktür. 116 | ``` 117 | `sayı` variable'ına input olarak `0` value'sunu girdiğimizde, `0` sayısı `10`'dan küçük ve `-10`'dan büyük olmasına rağmen sadece `if` statement çalıştı. Benzer şey `9` value'sunda da oldu. `9` sayısı `10`'dan küçük ve `-10`'dan büyük olmasına rağmen sadece ilk `elif` statement çalıştı. Çünkü `elif` statement sadece kendinden önceki `if` ya da `elif` statement çalışmazsa ve `condition`'a girilen koşul sağlanıyorsa çalışır. 118 | 119 | **Not:** `if` ve `elif` statement'ların `condition` kısmına yazacağınız koşulları parantez içine almakla almamak arasında bir fark yoktur. örnek: 120 | ```py 121 | if True: 122 | print("Hello") 123 | 124 | if (False): 125 | pass 126 | elif (True): 127 | print("World") 128 | ``` 129 | **Output:** 130 | ``` 131 | Hello 132 | World 133 | ``` 134 | 135 |

else Statement

136 | 137 | "... değilse ..." anlamına gelmektedir. Syntax: 138 | ```py 139 | else: 140 | # Expression 141 | ``` 142 | 143 | `else` statement kendisinden önceki `elif` ya da `if` statement'a bağımlıdır. Sadece kendinden önceki `if` ya da `elif` statement çalışmazsa çalışır. Örnek: 144 | ```py 145 | sayı = int(input("Sayı gir: ")) 146 | if sayı == 0: 147 | print("Girdiğiniz sayı 0'dır.") 148 | else: 149 | print("Girdiğiniz sayı 0 değildir.") 150 | ``` 151 | **Outputs:** 152 | ``` 153 | Sayı gir: 0 154 | Girdiğiniz sayı 0'dır. 155 | ``` 156 | ``` 157 | Sayı gir: 1 158 | Girdiğiniz sayı 0 değildir. 159 | ``` 160 | 161 | Başka bir örnek: 162 | ```py 163 | sayı = int(input("Sayı gir: ")) 164 | if sayı == 0: 165 | print("Girdiğiniz sayı 0'dır.") 166 | elif sayı == 1: 167 | print("Girdiğiniz sayı 1'dir.") 168 | else: 169 | print("Girdiğiniz sayı 0 ya da 1 değildir.") 170 | ``` 171 | **Outputs:** 172 | ``` 173 | Sayı gir: 0 174 | Girdiğiniz sayı 0'dır. 175 | ``` 176 | ``` 177 | Sayı gir: 1 178 | Girdiğiniz sayı 1'dir. 179 | ``` 180 | ``` 181 | Sayı gir: 2 182 | Girdiğiniz sayı 0 ya da 1 değildir. 183 | ``` 184 | 185 | **Not:** Herhangi bir `if` veya `if` - `elif` statement, `else` statement olmadan da kullanılabilir. Gördüğünüz gibi `else` statement'ın tek çalışma koşulu kendinden önceki `if` ya da `elif` statement çalışmaması. 186 | 187 | **Not:** Her `else` statement, kendinden önceki `if` ya da `elif` statement'ı dikkate alır. Örnek: 188 | ```py 189 | if False: # 1. `if` statement 190 | pass 191 | else: 192 | print("1. `else` çalıştı.") 193 | 194 | if False: # 2. `if` statement 195 | pass 196 | else: 197 | print("2. `else` çalıştı.") 198 | 199 | if False: 200 | pass 201 | elif False: 202 | pass 203 | else: 204 | print("3. `else` çalıştı.") 205 | ``` 206 | **Output:** 207 | ``` 208 | 1. `else` çalıştı. 209 | 2. `else` çalıştı. 210 | 3. `else` çalıştı. 211 | ``` 212 | Gördüğünüz gibi her `else` statement, kendinden hemen önceki ilk `if` ya da `elif` statement'ı dikkate alır. Yukarıdaki kodda tanımlanmış 2. `else` statement'ın 1. `if` statement'ı değil 2. `if` statement'ı dikkate alması bunun kanıtıdır. 213 | 214 |

Tek satırda if - else tanımlamak

215 | 216 | `(Expression) if (condition) else (Expression)` yapısını kullanarak tek satırda `if` - `else` yapısı oluşturabilirsiniz. Örnek: 217 | ```py 218 | (print(1)) if True else (print(2)) # Output: 1 219 | print(1) if True else print(2) # Output: 1 220 | 221 | (print(1)) if False else (print(2)) # Output: 2 222 | print(1) if False else print(2) # Output: 2 223 | ``` 224 | `Expression` kısımlarını parantez içine almakla almamak arasında işlevsel olarak bir fark yoktur. Parantezler sadece, kullanıcının kodu anlamasını kolaylaştırır. Daha karmaşık bir örnek: 225 | ```py 226 | ((print(1)) if True else (print(2))) if True else ((print(3)) if True else print(4)) # Output: 1 227 | ((print(1)) if False else (print(2))) if True else ((print(3)) if True else print(4)) # Output: 2 228 | ((print(1)) if False else (print(2))) if False else ((print(3)) if True else print(4)) # Output: 3 229 | ((print(1)) if False else (print(2))) if False else ((print(3)) if False else print(4)) # Output: 4 230 | ``` 231 | -------------------------------------------------------------------------------- /python_tutorial/temel_bilgiler/pics/1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/temel_bilgiler/pics/1.png -------------------------------------------------------------------------------- /python_tutorial/temel_bilgiler/pics/2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/temel_bilgiler/pics/2.png -------------------------------------------------------------------------------- /python_tutorial/temel_bilgiler/pics/3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/temel_bilgiler/pics/3.png -------------------------------------------------------------------------------- /python_tutorial/temel_bilgiler/pics/4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/temel_bilgiler/pics/4.png -------------------------------------------------------------------------------- /python_tutorial/temel_bilgiler/pics/5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/temel_bilgiler/pics/5.png -------------------------------------------------------------------------------- /python_tutorial/temel_bilgiler/pics/6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/eyupkaganeyupoglu/python_tutorial_tr/118b2e11dcea7a5ce50db6ce4ecbe747a176ab45/python_tutorial/temel_bilgiler/pics/6.png -------------------------------------------------------------------------------- /python_tutorial/temel_bilgiler/print_and_input.md: -------------------------------------------------------------------------------- 1 | # İçindekiler 2 | - [Print-Input İşlemleri](#1) 3 | - [`print()` Fonksiyonu](#2) 4 | - [`*values` Parametresi](#2.1) 5 | - [`sep` Parametresi](#2.2) 6 | - [`end` Parametresi](#2.3) 7 | - [`file` Parametresi](#2.4) 8 | - [`flush` Parametresi](#2.5) 9 | - [`input()` Fonksiyonu](#3) 10 | 11 |

Print-Input İşlemleri

12 | 13 | Programınıza girdi (input) almak için `input()`, çıktı (output) almak için `print()` adlı build-in fonksiyonlardan faydalanılır. 14 | 15 |

print() Fonksiyonu

16 | 17 | `print()` build-in fonksiyonu, `print(*values, sep=' ', end='\n', file=sys.stdout, flush=False)` syntax'ına sahiptir. `print()` fonksiyonu `file` parametresinde belirtilen, default değeri `sys.stdout` olan yere bir şeyler yazdırmak için kullanılan bir build-in (gömülü) fonksiyondur. Örnek: 18 | ```py 19 | print(35) 20 | print("Merhaba") 21 | print(""" 22 | [H]=========PYTHON========[-][o][x] 23 | | | 24 | | Programa Hoşgeldiniz! | 25 | | Sürüm 0.8 | 26 | | Devam etmek için herhangi | 27 | | bir düğmeye basın. | 28 | | | 29 | |=================================| 30 | """) 31 | ``` 32 | **Output:** 33 | ``` 34 | 35 35 | Merhaba 36 | 37 | [H]=========PYTHON========[-][o][x] 38 | | | 39 | | Programa Hoşgeldiniz! | 40 | | Sürüm 3.9.2 | 41 | | Devam etmek için herhangi | 42 | | bir düğmeye basın. | 43 | | | 44 | |=================================| 45 | 46 | ``` 47 | 48 |

*values Parametresi

49 | 50 | `*values` parametresi bir yıldızlı parametredir. Yıldızlı parametrelerin tam olarak ne olduğunu daha sonra [burada](./python_tutorial/blob/main/python_tutorial/functions/functions.md#1.1.3) açıklanacak. `print()` fonksiyonu, `*values` parametresine girilen normal ya da yıldızlı argümanları yazdırır. Örnek: 51 | ```py 52 | print("T" , "B" , "M" , "M") # Output: T B M M 53 | print(*"TBMM") # Output: T B M M 54 | ``` 55 | 56 | **Not:** Daha sonra göreceğiniz `len()` gibi fonksiyonlar `len(*"Python")` gibi argümanlar kabul etmezler. Bu fonksiyonun nasıl tanımlandığıyla (definition) alakalıdır. Bu notu anlamadıysanız takılmayın, tutorial'a devam edin. 57 | 58 |

sep Parametresi

59 | 60 | `sep` parametresi, `*values` parametresine girilen argümanlar arasına gelecek string'i belirlediğimiz parametredir. Default değeri (yani bu parametreye argüman girmediğiniz taktirde kullandığı argüman) bir adet boşluk (space) `" "` karakteridir. Örnek: 61 | ```py 62 | print(1 , 2 , 3 , 4 , 5 , 6 , sep = "/") # Output: 1/2/3/4/5/6 63 | print(1 , 2 , 3 , 4 , 5 , 6 , sep = "+") # Output: 1+2+3+4+5+6 64 | print(1 , 2 , 3 , 4 , 5 , 6 , sep = "Q") # Output: 1Q2Q3Q4Q5Q6 65 | print(1 , 2 , 3 , 4 , 5 , 6 , sep = "%") # Output: 1%2%3%4%5%6 66 | ``` 67 | `sep` parametresine argüman olarak `\n` ya da `\t` gibi kaçış dizileri de (Escape Sequences) girebilirsiniz. 68 | ```py 69 | print("Selam" , "Ben" , "Python!" , sep = "\n", end="\n\n") 70 | print("Selam" , "Ben" , "Python!" , sep = "\t") 71 | ``` 72 | **Output:** 73 | ``` 74 | Selam 75 | Ben 76 | Python! 77 | 78 | Selam Ben Python! 79 | ``` 80 | Bu parametreye sadece string type (karakter dizisi türü) argümanlar girebilirsiniz. Aksi halde `TypeError` hatası yükseltilir. Örnek: 81 | ```py 82 | print(1 , 2 , 3 , 4 , 5 , 6 , sep = 1) # TypeError: sep must be None or a string, not int 83 | ``` 84 | **Not:** `sep` parametresine argüman olarak `None` verirseniz, default değeri geçerli olur. Örnek: 85 | ```py 86 | print(1 , 2 , 3 , 4 , 5 , 6 , sep = None) # Output: 1 2 3 4 5 6 87 | ``` 88 | 89 |

end Parametresi

90 | 91 | `end` parametresi, `*values` parametresine girilen argümanların sonuncusu yazdırıldıktan sonra yazdırılacak string'i belirlediğimiz parametredir. Default değeri `\n` kaçış dizisidir (Escape Sequences). 92 | ```py 93 | print(1 , 2 , 3 , 4 , 5 , 6 , sep=", ", end = ", 7\n") 94 | print(1 , 2 , 3 , 4 , 5 , 6, sep=", ") 95 | ``` 96 | **Output:** 97 | ``` 98 | 1, 2, 3, 4, 5, 6, 7 99 | 1, 2, 3, 4, 5, 6 100 | ``` 101 | Bu parametreye sadece string type (karakter dizisi türü) argümanlar girebilirsiniz. Aksi halde `TypeError` hatası yükseltilir. Örnek: 102 | ```py 103 | print(1 , 2 , 3 , 4 , 5 , 6 , sep=", ", end = 1) # TypeError: end must be None or a string, not int 104 | ``` 105 | **Not:** `end` parametresine argüman olarak `None` verirseniz, default değeri geçerli olur. Örnek: 106 | ```py 107 | print(1 , 2 , 3 , 4 , 5 , 6 , end = None) 108 | print(1 , 2 , 3 , 4 , 5 , 6 , end = None) 109 | ``` 110 | **Output:** 111 | ``` 112 | 1, 2, 3, 4, 5, 6 113 | 1, 2, 3, 4, 5, 6 114 | 115 | ``` 116 | 117 |

file Parametresi

118 | 119 | `print()` fonksiyonu, outputlarını default olarak `sys.stdout`'a yani **standart çıktı konumu**'na yazdırır. `sys.stdout` VSCode'da terminalken, başka bir yerde başka bir şey olarak ayarlı olabilir. `file` parametresine girdiğimiz argüman ile `print()` fonksiyonunun outputlarını nereye yazdıracağını belirleyebiliriz. Örnek: 120 | ```py 121 | dosya = open("deneme.txt", "w") 122 | print("Merhaba Ben Python!", file = dosya) 123 | dosya.close() 124 | ``` 125 | **deneme.txt:** 126 | ``` 127 | Merhaba Ben Python! 128 | 129 | ``` 130 | 131 | `stdout`, kodlarımızın çıktılarının gönderildiği yerdir. Örnek: 132 | ```py 133 | import sys 134 | print(sys.stdout, flush=True) 135 | ``` 136 | Bu kod bize `sys.stdout` ile ilgili bilgiler verir: `<_io.TextIOWrapper name='' mode='w' encoding='utf-8'>` 137 | - `name`, `sys.stdout`'un o anki adını verir. 138 | - `mode`, `sys.stdout`'un hangi kipe sahip olduğunu gösterir. `sys.stdout`'u genellikle yazma kipinde (`w`) bulunur. 139 | - `encoding` `sys.stdout`'un sahip olduğu kodlama biçimini gösterir. Kodlama biçimleri uyuşmazsa, bazı karakterler hatalı gösterilebilir. 140 | 141 | `sys.stdout`'a kalıcı olarak bir dosya atarsanız, bundan sonra programınızın bütün çıktıları o dosyaya aktarılır. Örnek: 142 | ```py 143 | dosya = open("deneme.txt", "w") 144 | sys.stdout = dosya 145 | print("Merhaba Ben Python!", flush=True) 146 | ``` 147 | **deneme.txt:** 148 | ``` 149 | Merhaba Ben Python! 150 | 151 | ``` 152 | Bu şekilde yaparsanız, `sys.stdout` methodunun atıfta bulunduğu değeri tamamen kaybedeceğiniz için (çünkü `sys.stdout` methoduna `dosya` variable'ının value'sunu atıyorsunuz) geri döndürme şansınız kalmıyor. Bunu çözümü: 153 | ```py 154 | dosya = open("deneme.txt", "w") 155 | sys.stdout, dosya = dosya, sys.stdout 156 | print("Kalıcı dosya işlemi başarılı!", flush=True) 157 | ``` 158 | **deneme.txt:** 159 | ``` 160 | Merhaba Ben Python! 161 | 162 | ``` 163 | Bu şekilde yaparsanız, `sys.stdout` methodunun value'su ile `dosya` variable'ının value'sunu birbiriyle değiştirdiğiniz için (swap) tekrar aynı kodu (`sys.stdout, dosya = dosya, sys.stdout`) çalıştırdığınızda `sys.stdout` methodu ile `dosya` variable'ı eski haline geri dönmüş olur. Bunun mantığını daha önce anlattım. Bunu yapmak yerine `sys.stdout` methodunun value'sunu herhangi bir variable'a atayıp da saklayabilirsiniz. 164 | 165 |

flush Parametresi

166 | 167 | Python'da `open()` build-in fonksiyonu ile bir dosya açtığımızda, o dosyayı kapatmadığımız sürece `print()` fonksiyonunun dosyaya yazdırdığı şeyler dosyada görünmez (dosyaya işlenmez/yazılmaz). Çünkü dosyayı kapatmadığımız sürece işlenen bilgiler buffer (tampon) adı verilen bir bölgede bekletiliyor ve dosyayı kapattığımızda da dosyaya işleniyor/yazılıyor. `flush` parametresinin default değeri `False`'dır. `flush` parametresi `False` ise bahsettiğim durum geçerlidir. Ama `flush` parametresi `True` ise, `print()` fonksiyonunun dosyaya yazdırdığı şeyler anında dosyaya işlenir/yazılır. 168 | 169 | **Not:** `flush` parametresinin `True` olması, `print()` fonksiyonunun dosyaya bir şeyler yazdırdıktan sonra dosyayı kapattığı anlamına gelmiyor. Dosyayı kapatmak için `close()` methodunu kullanmanız gerekiyor. Kanıtı: 170 | ```py 171 | dosya = open("deneme.txt", "w") 172 | print("Merhaba Ben Python!", file=dosya, flush=True) 173 | print(dosya.closed) # Output: False (Yani dosya açık) 174 | dosya.close() 175 | print(dosya.closed) # Output: True (Yani dosya kapalı) 176 | ``` 177 | **deneme.txt:** 178 | ``` 179 | Merhaba Ben Python! 180 | 181 | ``` 182 | 183 | **Not:** Dosya işlemleri konusunu öğrendikten sonra bu kısımları daha iyi anlayacaksınız. 184 | 185 | `print()` build-in fonksiyonu ile ilgili daha fazla Bilgi için [tıklayınız](https://docs.python.org/3/library/functions.html#print "https://docs.python.org/3/library/functions.html#print"). 186 | 187 |

input() Fonksiyonu

188 | 189 | `input()` build-in fonksiyonu, `input(prompt)` syntax'ına sahiptir. Bu fonksiyon, kullanıcıdan girdi (input) almanı sağlayan bir build-in (gömülü) fonksiyondur. `prompt` parametresi, `input()` fonksiyonu çağırıldığında (call) argüman olarak `stdout`'a yazdırılacak string'i alır. Bu fonksiyon ile kullanıcıdan alınan verileri kullanabilmek için bu fonksiyonu bir variable'a atayarak kullanabilirsiniz. Örnek: 190 | ```py 191 | var = input("Bir sayı giriniz: ") 192 | print("Girdiğiniz sayı:", var) 193 | ``` 194 | **Output:** 195 | ``` 196 | Bir sayı giriniz: 15 197 | Girdiğiniz sayı: 15 198 | ``` 199 | `input()` fonksiyonu, kullanıcının girdiği verileri string type olarak programa verir. Örnek: 200 | ```py 201 | var = input("Bir veri giriniz: ") 202 | print("Girdiğiniz verinin türü:", type(var)) 203 | ``` 204 | **Output:** 205 | ``` 206 | Bir veri giriniz: 15 207 | Girdiğiniz verinin türü: 208 | ``` 209 | Gördüğünüz gibi integer bir veri girsek bile `input()` fonksiyonunun programam verdiği verinin string type bir veri olduğunu görüyoruz. Kullanıcıdan aldığınız verinin integer type olmasını istiyorsanız, `input()` fonksiyonunun programa verdiği verinin türünü (type) değiştirmelisiniz. Örnek: 210 | ```py 211 | var = input("Bir veri giriniz: ") 212 | var = int(var) 213 | print("Girdiğiniz verinin türü:", type(var)) 214 | ``` 215 | **Output:** 216 | ``` 217 | Bir veri giriniz: 15 218 | Girdiğiniz verinin türü: 219 | ``` 220 | Ama şimdi de kullanıcı harflerden oluşan bir veri girerse, harfleri integer'a dönüştüremeyeceğimiz için hata yükseltilecek. Örnek: 221 | ```py 222 | var = input("Bir veri giriniz: ") 223 | var = int(var) # ValueError: invalid literal for int() with base 10: 'selam' 224 | print("Girdiğiniz verinin türü:", type(var)) 225 | ``` 226 | Bunun gibi tip dönüşümlerini (type conversions) daha sonra anlatacağım. `var = int(var)` gibi fazladan bir statement tanımlamak yerine `var = int(input("Bir veri giriniz: "))` şeklinde tek statementte de halledebilirsiniz. 227 | 228 | Daha fazla bilgi için [tıklayınız](https://docs.python.org/3/library/functions.html#input "https://docs.python.org/3/library/functions.html#input"). --------------------------------------------------------------------------------