# Numpy Dizilerinin Dilimlenmesi (Slicing)

Numpy dizilerinin dilimlenmesi python dizilerinin dilimlenmesine benzer. Farklı olarak her bir boyutta ayrı olarak dilimleme işlemini yapmamız gerekmektedir. Hatırlayacağınız üzere dilimleme yaparken önce satır, sonra sütun seçiyoruz.

```python
a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])  # matris oluşturduk

print a   #    "[[ 1,  2,  3],
          #      [ 4,  5,  6],
          #      [ 7,  8,  9],
          #      [10, 11, 12]])"  yazdırır
```

## Tek boyutta dilimleme

a matrisi üzerinde dilimleme yaparak bir satırı veya sütunu seçebiliriz. Bu kısımlar yabancı geliyorsa Python'da dilimleme konularına bakabilirsiniz.

Belli bir satırdaki tüm elemanlar şu şekilde alınabilir.

```python
b = a[1, :]
print b       # [4 5 6]

# ilk parametre ile ikinci satırı, ikinci parametre ile de o satırdaki tüm elemanları aldık
```

Ya da belli bir sütundan seçim yapabiliriz.

```python
b = a[:, 2]
print b       # [ 3  6  9 12]

# ilk parametre ile tüm değerlerin seçileceğini, ikinci parametre ile de o sütunu seçtik
```

## İki boyutta dilimleme

a matrisi üzerinde dilimleme yaparak alt bir matris oluşturabiliriz. Örneğin ilk 2 satırı ve sütunlardan da 1. ve 2. sütunu seçelim. Bu kısımlar yabancı geliyorsa Python'da dilimleme konularına bakabilirsiniz.

```python
b = a[:2, 1:3]
print b         # [[2 3]
                #  [5 6]]
```

#### Önemli bir nokta:

√ Burada dikkat edilmesi gereken nokta şudur: Dilimleme sonucunda oluşan yeni **b** matrisimiz aslında bellekte a matrisini referans etmektedir, yani **b** matrisi kendi başına yeni bir matris değildir. Dolayısıyla gerçek matristeki bir değişiklik b matrisini de bozacaktır.

Bunu isterseniz gözlemleyebilirsiniz. **a** matrisindeki bahsi geçen aralığa giren bir elemanın değerini değiştirelim ve **b** nin içeriğini gözlemleyelim. Sonucun değiştiğini göreceğiz.

```python
a[0,1] = 99
print b     # [[99  3]
            #  [ 5  6]]
```

## Aralardan eleman seçme

Yeni bir matris oluşturalım. Bu matris 3x3 boyutlarında kare matris olsun ve köşegen değerlerine erişmek isteyelim. Bu durumda aralardan eleman seçebiliriz. Önce matrisimizi oluşturalım:

```python
a = np.array([[1,2,3], [4,5,6], [7,8,9]]) # matris oluşturduk

print a   # " [[ 1, 2, 3],
          #    [ 4, 5, 6],
          #    [ 7, 8, 9]] "  yazdırır
```

Örneğin sırasıyla \[0,0], \[1,1], \[2,2] üzerindeki elemanlara erişmek istiyoruz. Dizi veya ~~tuple~~ parametre vererek bunu iki şekilde yapabiliriz. İlk parametre satırları, ikinci parametre ise sütunları seçmeye yarar.

```python
print a[[0, 1, 2], [0, 1, 2]]   # [1 5 9]
```

veya

```python
print a[(0, 1, 2), (0, 1, 2)]   # [1 5 9]
```

### Dilimlenmiş kısımlar değiştirilebilir!

Yukarıdaki herhangi bir metodla dilimleme yapılmış kısımların tek bir komutla değiştirilmesi mümkündür. Örneğin köşegenleri seçtiğimiz son örnekte olduğu gibi, seçilen bu kısımlara 99 değeri atanmıştır.

```python
a[[0, 1, 2), (0, 1, 2]] = 99

print a    # " [[99,  2,  3],
           #    [ 4, 99,  6],
           #    [ 7,  8, 99]] " yazdırır
```

İçinizden şöyle bir şey geçirdiğinizi duyar gibiyim. 3x3 boyutlu matriste köşegen değerleri belirlemek kolay, peki matrisimiz daha büyük boyutlu olsaydı. Örnegin 10x10 büyüklüğündeki rastgele tamsayı değerlerinden oluşan bir matrisin köşegen değerlerine 0 atamak isteseydik.

```python
a = np.random.random([10,10])*10  # 0-10 arası rastgele tamsayı değerlerinden oluşan bir matris
a = a.astype(int)
print a

[[9 5 3 0 3 7 8 4 1 0]
 [4 5 4 7 0 5 4 1 7 4]
 [2 2 6 0 6 3 3 6 8 0]
 [4 4 7 5 8 9 9 4 3 9]
 [1 1 9 9 2 2 0 6 5 9]
 [4 9 8 8 0 1 2 0 5 3]
 [5 7 3 7 7 5 0 1 0 3]
 [4 0 6 1 2 2 0 5 3 4]
 [9 8 8 4 4 5 1 7 6 1]
 [1 1 3 9 8 1 2 4 1 9]]
```

Önce bu matrisi nasıl oluşturduğumuzun üzerinden kısaca geçelim. Bir önceki özel numpy matrisleri kısmında bahsedildiği üzere **random** metodu bize 10x10 boyutlarında içerisinde 0-1 arası noktalı sayılardan oluşmuş bir matris üretti, sonrasında bunu 10 ile genişleterek 0-10 arası değerler içermesini sağladık. Sonra tamsayı değerlerini elde etmek üzere matrisi noktalı sayılardan tamsayı formatına çevirdik.

Şimdi köşegen değerleri bildiğimiz üzere \[0, 0], \[1, 1], .... , \[n-1, n-1], \[n, n] ikili değerlerinden oluşmaktadır. Bunun tek sayı değeri içeren halini np.arange( ) metodu ile elde edebiliriz. Bunu öğrenmiştik.

```python
noktalar = np.arange(10)     #   [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
kosegenler_noktalar = [noktalar, noktalar]  # köşegen nokta ikilileri elde ettik
a[kosegenler_noktalar] = 0
print a

[[0 5 3 0 3 7 8 4 1 0]
 [4 0 4 7 0 5 4 1 7 4]
 [2 2 0 0 6 3 3 6 8 0]
 [4 4 7 0 8 9 9 4 3 9]
 [1 1 9 9 0 2 0 6 5 9]
 [4 9 8 8 0 0 2 0 5 3]
 [5 7 3 7 7 5 0 1 0 3]
 [4 0 6 1 2 2 0 0 3 4]
 [9 8 8 4 4 5 1 7 0 1]
 [1 1 3 9 8 1 2 4 1 0]]   # köşegenleri 0 yapılmış 10x10 matrisi
```

## Şarta bağlı seçim yapma

Seçim yaptığımız dizi ya da matris elemanlarını belirli bir şartı sağlayıp sağlamamasına göre seçebiliriz. Örneğin basit bir matris oluşturalım ve içerisinde 3'e tam bölünebilen elemanları bulmaya çalışalım. Sonrasında bunları 10 ile genişletelim. Örneğin 3,6 gibi tam bölünen elemanlar 30, 60 gibi değerlere sahip olsun.

```python
a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]]) # matris oluşturduk
a % 3 == 0

[[False False  True False]
 [False  True False False]
 [ True False False  True]]   # gördüğünüz gibi 3'e tam bölünen yerler True, diğerleri False

bolunenler = a % 3 == 0      # bunu bir değişkende saklayalım
a[bolunenler] *= 10          # bu matrisi kullanarak True olan yerleri değiştirelim, 10 ile çarpalım
```

Sonuçta başlangıçtaki matrisimiz 3'e bölünenlerin olduğu kısımda genişlemiş olarak şu şekilde değişecektir.

```python
print a       #  [[   1,   2,   30,   4],
              #   [   5,  60,    7,   8],
              #   [  90,  10,   11, 120]]
```

```python
```

```python
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://mehmet-akif-akkus.gitbook.io/numpy-ile-veri-bilimi/numpy-dizilerinin-dilimlenmesi-slicing.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
