numpy_tutorial_turkish.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FSPDQrlU674-"
   },
   "source": [
    "# Numpy Türkçe Başlangıç"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [GOOGLE COLAB ÜZERİNDE ÇALIŞTIR!](http://colab.research.google.com/github/fuatbeser/python-notlarim/blob/master/numpy_tutorial_turkish.ipynb)\n",
    "\n",
    "- [Github](https://github.com/fuatbeser/python-notlarim) (Daha fazla kişiye ulaşması için yıldız verebilirsiniz.)\n",
    "- [Jupyter Notebook Viewer](http://nbviewer.jupyter.org/github/fuatbeser/python-notlarim/blob/master/numpy_tutorial_turkish.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3tyVUT0s679P"
   },
   "source": [
    "## Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BlStqyyR679P"
   },
   "source": [
    "Numpy bilimsel hesaplamalarda sıklıkla kullanılan Python'un temel kütüphanelerinden bir tanesidir."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6pe8151F679P"
   },
   "source": [
    "`Numpy` kütüphanesini kullanabilmek için öncelikle `import` kullanarak çağırmamız gerekir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "bhhKXC0O679Q"
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "pBw0NtmC679Q"
   },
   "source": [
    "### Diziler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qyh89byi679R",
    "outputId": "16ccb575-35dc-454a-91dc-b1b956db289c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'> (3,)\n",
      "1 2 3\n",
      "[5 2 3]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3])  # Birinci dereceden dizi tanımlayalım\n",
    "\n",
    "print (type(a), a.shape) # Dizinin veri tipini ve boyutunu yazdıralım\n",
    "print(a[0], a[1], a[2])  # Dizinin her bir elemanını ayrı ayrı yazdıralım\n",
    "\n",
    "a[0] = 5                 # Dizinin ilk elamanını 5 ile değiştirelim\n",
    "print (a)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7RJq5boB679U",
    "outputId": "7326f6a5-4fba-4aa2-f593-b9ed29367fc4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "b = np.array([[1,2,3],[4,5,6]])   # İkinci dereceden dizi tanımlayalım\n",
    "print (b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**İPUCU**: Yukarıda köşeli parantez sayısının dereceyi (rank) verdiğine dikkat edin.\n",
    "\n",
    "Bir dizinin derecesini `.ndim` ile görebiliriz. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Dq6MueDU679X",
    "outputId": "ded528b0-d531-4f39-ee12-a7d0087b89fe"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n",
      "1 2 4\n"
     ]
    }
   ],
   "source": [
    "print (b.shape)                   \n",
    "print (b[0, 0], b[0, 1], b[1, 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MB0NUUzk679Z"
   },
   "source": [
    "**Sıfırlardan** oluşan bir dizi için `np.zeros()` kullanılır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XrnnqJCj679Z",
    "outputId": "38a20b55-f857-47a6-9556-825a41bf9690"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0.]\n",
      " [0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "a = np.zeros((2,2))  # Tüm elemanları \"sıfır\" olan 2 x 2 boyutlu dizi\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Birlerden** oluşan bir dizi için `np.ones()` kullanılır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ooJNhDeT679e",
    "outputId": "d074623a-e43b-4fb1-e24a-d8d261b0ca03"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "b = np.ones((1,2))   # Tüm elemanları \"bir\" olan 1 x 2 boyutlu dizi\n",
    "print (b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**İstediğimiz bir değerden** oluşan bir dizi için `np.full()` kullanılır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "w2JY1I_s679g",
    "outputId": "04e905d4-1334-4787-9b1a-743c81673eec"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7 7]\n",
      " [7 7]]\n"
     ]
    }
   ],
   "source": [
    "c = np.full((2,2), 7) # Tüm elemanları \"yedi\" olan 2 x 2 boyutlu dizi\n",
    "print (c) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Boş matris** oluşturmak için `np.empty()` kullanılır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.49166815e-154 1.49166815e-154 4.94065646e-323 0.00000000e+000\n",
      "  0.00000000e+000]\n",
      " [0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000\n",
      "  0.00000000e+000]\n",
      " [0.00000000e+000 0.00000000e+000 0.00000000e+000 0.00000000e+000\n",
      "  1.49166815e-154]\n",
      " [1.29073595e-231 1.48219694e-323 0.00000000e+000 0.00000000e+000\n",
      "  1.39067116e-308]]\n"
     ]
    }
   ],
   "source": [
    "d = np.empty((4,5))\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Birim matris** oluşturmak için `np.eye()` kullanılır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "mEq6W3DE679i",
    "outputId": "ce9c47e2-5f7c-425f-ab04-77f173417065"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0. 0.]\n",
      " [0. 1. 0. 0.]\n",
      " [0. 0. 1. 0.]\n",
      " [0. 0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "e = np.eye(4)        # 2 x 2 boyutlu birim matris\n",
    "print (e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Rastgele matris** oluşturmak için `np.random.random()` kullanılır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ZLCxF4qP679m",
    "outputId": "e5d56199-d2be-4bb9-9083-f2ad9ac17ce8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.39563252 0.61736094 0.10952616 0.31257607 0.69795189]\n",
      " [0.76800638 0.44738347 0.22151628 0.91598655 0.50837659]\n",
      " [0.59224484 0.48875911 0.6420558  0.65609772 0.7622266 ]\n",
      " [0.17429605 0.57955237 0.10740249 0.66641907 0.01363425]\n",
      " [0.31126941 0.33090077 0.08159594 0.99136013 0.03020277]]\n"
     ]
    }
   ],
   "source": [
    "f = np.random.random((5,5)) # 5 x 5 boyutlu rastgele değerlerden oluşan matris\n",
    "print (f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Belirli bir aralıklı sayılardan oluşan bir dizi oluşturmak için `.arange()` kullanırız."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "g = np.arange(0,10,1) # 0'dan 10'a (hariç) aralarında 1 olan\n",
    "print(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]\n"
     ]
    }
   ],
   "source": [
    "h = np.linspace(0,9,10) # 0'dan 9'a (dahil) 10 adet sayı \n",
    "print(h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "dizim = np.array([11,22,23,14,5,36,7,3,9,5,11,133,13,5,66])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bir dizinin boyutu `.shape` ile görülür."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(15,)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dizim.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diziyi yeniden boyutlandırmak için `.reshape` kullanılır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 11,  22,  23],\n",
       "       [ 14,   5,  36],\n",
       "       [  7,   3,   9],\n",
       "       [  5,  11, 133],\n",
       "       [ 13,   5,  66]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dizim.reshape(5,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 11,  22,  23,  14,   5,  36,   7,   3,   9,   5,  11, 133,  13,\n",
       "         5,  66])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dizim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fakat yukarıda da görebileceğiniz üzere yalnızca `.reshape()` kullandığınızda dizinin boyutu değişmez. Bunun için ya `.resize()` fonksiyonunu kullanmak ya da diziye atama yapmak gerekir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 11  22  23]\n",
      " [ 14   5  36]\n",
      " [  7   3   9]\n",
      " [  5  11 133]\n",
      " [ 13   5  66]]\n"
     ]
    }
   ],
   "source": [
    "dizim.resize(5,3)\n",
    "print(dizim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 11  22  23  14   5]\n",
      " [ 36   7   3   9   5]\n",
      " [ 11 133  13   5  66]]\n"
     ]
    }
   ],
   "source": [
    "dizim = dizim.reshape(3,5)\n",
    "print(dizim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diziyi tek boyutlu bir vektör haline getirmek için `.ravel()` fonksiyonunu kullanabiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 11  22  23  14   5  36   7   3   9   5  11 133  13   5  66]\n"
     ]
    }
   ],
   "source": [
    "dizim = dizim.ravel()\n",
    "print(dizim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dizinin uzunluğunu `.size` ile görürüz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dizim.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dizi elemanlarının veri tiplerine `.dtype` ile bakarız."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dizim.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dizinin en büyük elemanını `max()` ile bulabiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "133"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dizim.max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dizinin en küçük elemanını `min()` ile bulabiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dizim.min()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dizinin tersini almak için `dizi[::-1]` kullanıyoruz. Listelerde `reverse()` fonksiyonu vardı hatırlarsanız. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 66,   5,  13, 133,  11,   5,   9,   3,   7,  36,   5,  14,  23,\n",
       "        22,  11])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dizim[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[1,2],[3,4]])\n",
    "b = np.array([[5,6],[7,8]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "İki diziyi **dikey** olarak art arda eklemek (_stack_) için `.vstack()` kullanırız."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6],\n",
       "       [7, 8]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((a,b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "İki diziyi **yatay** olarak art arda eklemek (_stack_) için ise `.hstack()` kullanırız."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 5, 6],\n",
       "       [3, 4, 7, 8]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hstack((a,b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qN3x1ulv679o"
   },
   "source": [
    "### Dizi İndeksleme"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "laez-d6T679p"
   },
   "source": [
    "Numpy dizilerde indeksleme yapmak için farklı seçenekler sunmaktadır."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Za0yPj1X679p"
   },
   "source": [
    "Dilimleme (Slicing): Python listelerine de dilimlenebilir. Diziler çok boyutlu olduğu için her bir boyut için dilimi belirlemek gerekmektedir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "iI-f9hgk679q",
    "outputId": "7f2e4946-24fe-44ce-c0de-bd5eb756060b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 3]\n",
      " [6 7]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# 2. dereceden (rank) boyutu (3, 4) olan dizi tanımlayalım.\n",
    "\n",
    "# [[ 1  2  3  4]\n",
    "#  [ 5  6  7  8]\n",
    "#  [ 9 10 11 12]]\n",
    "\n",
    "a = np.array([[1,2,3,4], \n",
    "              [5,6,7,8], \n",
    "              [9,10,11,12]])\n",
    "\n",
    "# Dilimleme kullanarak ilk iki satırı ve \n",
    "# 1. ve 2. sütunları içeren alt-dizi oluşturalım.\n",
    "# Alt-dizinin boyutu (2, 2) olacaktır.\n",
    "\n",
    "# [[2 3]\n",
    "#  [6 7]]\n",
    "\n",
    "b = a[:2, 1:3] # 0. ve 1. satır / 1. ve 2. sütun\n",
    "print (b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4],\n",
       "       [ 5,  6,  7,  8],\n",
       "       [ 9, 10, 11, 12]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "oPuQtPXN679s"
   },
   "source": [
    "**İPUCU**: Dilimi, orijinal veriden aldığımız için dilim üzerinde yaptığımız değişik orijinal veriye etki eder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jqcOi0P7679t",
    "outputId": "c55dfe5d-3628-4934-9ed9-20cebc5cd9af"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "77\n"
     ]
    }
   ],
   "source": [
    "print (a[0, 1])  \n",
    "b[0, 0] = 77    # b[0, 0] ile aslında a[0, 1]'yı işaret ediyoruz\n",
    "print (a[0, 1]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "BLWI50ET679v",
    "outputId": "98d6b2cf-1509-4c50-daac-7e06589d6ae0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "# 3 x 4 boyutunda 2. dereceden bir dizi oluşturalım\n",
    "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oluşturduğumuz dizinin ortadaki (ikinci) satırına nasıl ulaşabiliriz? Dereceler farklı olmak üzere üç farklı yöntem vardır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "2Jyy07rc679x",
    "outputId": "d18b7d99-243d-4325-ea27-9a6e5107df57"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 6 7 8] (4,)\n",
      "[[5 6 7 8]] (1, 4)\n",
      "[[5 6 7 8]] (1, 4)\n"
     ]
    }
   ],
   "source": [
    "satir_v1 = a[1, :]    # İkinci satırın 1. dereceden görünüşü  \n",
    "satir_v2 = a[1:2, :]  # İkinci satırın 2. dereceden görünüşü  \n",
    "satir_v3 = a[[1], :]  # İkinci satırın 2. dereceden görünüşü  \n",
    "\n",
    "print (satir_v1, satir_v1.shape) \n",
    "print (satir_v2, satir_v2.shape)\n",
    "print (satir_v3, satir_v3.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aynı yöntem sütunlar için de geçerlidir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "iR1_tZNf6790",
    "outputId": "0f67a15a-44e2-4a7b-a528-16b01d6c9ba4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2  6 10] (3,)\n",
      "[[ 2]\n",
      " [ 6]\n",
      " [10]] (3, 1)\n"
     ]
    }
   ],
   "source": [
    "sutun_v1 = a[:, 1]\n",
    "sutun_v2 = a[:, 1:2]\n",
    "\n",
    "print (sutun_v1, sutun_v1.shape) # 1. derece\n",
    "print (sutun_v2, sutun_v2.shape) # 2. derece"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**İPUCU**: Yukarıdaki örnekte gördüğünüz gibi normalde dikey olan sütun dizisi 1. dereceden olduğu zaman satır ya da sütun olabilmektedir. İndekslemede problemle karşılaşmamak için tavsiyem 1. dereceden dizileri kullanmaktan mümkün olduğunca kaçınmanız."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1NJFB0Sm6792"
   },
   "source": [
    "Dizilerde önce satırları sonra da sütunları indeksleyebileceğimiz gibi ayrı ayrı da indeksleme yapabiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jEoxS9QB6792",
    "outputId": "bd1ff059-ec99-4483-c794-71d6c3d28169"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 4 5]\n",
      "[1 4 5]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
    "\n",
    "# a[0,0], a[1,1] ve a[2,0]'ı indekslemek için  \n",
    "print (a[[0, 1, 2], [0, 1, 0]])\n",
    "\n",
    "# Ayrı ayrı indeksleme yapalım\n",
    "print (np.array([a[0, 0], a[1, 1], a[2, 0]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MnRBMkEk679_",
    "outputId": "1ae15d20-91ad-4272-f574-00f8cc8aabec"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "mrx4ydsK67-A",
    "outputId": "eaab8fd2-aaf0-44d0-caf4-27ee6658c982"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  6  7 11]\n"
     ]
    }
   ],
   "source": [
    "# İndis dizisi oluşturalım\n",
    "indis = np.array([0, 2, 0, 1])\n",
    "\n",
    "# Her satırdan sırasıyla indis dizisini kullanarak değerleri seçelim \n",
    "print (a[np.arange(4), indis])  # \"[ 1  6  7 11]\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "O_NBDN5667-C",
    "outputId": "e6013731-b858-4855-8860-8d6f2ca9afbc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[11  2  3]\n",
      " [ 4  5 16]\n",
      " [17  8  9]\n",
      " [10 21 12]]\n"
     ]
    }
   ],
   "source": [
    "# İndis dizisini kullanarak elemanlara 10 ekleyelim.\n",
    "a[np.arange(4), indis] += 10\n",
    "\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "EMM7fRu067-E"
   },
   "source": [
    "Boolean dizi indeksleme: Belirtilen koşulu sağlayan elemanları bulmak için Boolean dizi indeksleme kullanılır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "rv6txP5667-E",
    "outputId": "d0d53a36-cf04-42f5-a390-3a0bee8196a2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n",
      "[[False False]\n",
      " [ True  True]\n",
      " [ True  True]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
    "\n",
    "print(a)\n",
    "\n",
    "ikidenBuyuk = (a > 2)  # 2'den büyük olanları seçelim\n",
    "                    # a dizisi ile aynı boyuttu yeni bir dizis oluşturur\n",
    "                    # 2'den büyük ise True, küçük ise False döndürür\n",
    "\n",
    "print (ikidenBuyuk)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "B2E9Kp8_67-H",
    "outputId": "6e4083cd-90c4-4109-87c6-1721689ba0f2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 4 5 6]\n",
      "[3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "# Boolean indeksleme kullanarak bulduğumuz değerleri yazdıralım\n",
    "print (a[ikidenBuyuk])\n",
    "\n",
    "# 2'den büyük olanları şu şekilde de bulabiliriz.\n",
    "print (a[a > 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UheI9Iau67-K"
   },
   "source": [
    "### Numpy Veri Tipleri\n",
    "\n",
    "Numpy ile bir dizi oluşturduğunuzda veri tipi tahmin edilmeye çalışılır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "TpRtBqkq67-L",
    "outputId": "619c378a-80f5-4d23-979e-94bb6f4937ae"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int64 float64 int64\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 2])  # Veri tipini Numpy seçsin\n",
    "y = np.array([1.0, 2.0])  # Veri tipini Numpy seçsin\n",
    "z = np.array([1, 2], dtype=np.int64)  # Veri tipini BİZ belirleyelim\n",
    "\n",
    "# Veri tiplerini ekrana yazdıralım\n",
    "print (x.dtype, y.dtype, z.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "e5XtmK8U67-N"
   },
   "source": [
    "Diğer Numpy veri tiplerine [orijinal dokümanından](http://docs.scipy.org/doc/numpy/reference/arrays.dtypes.html) bakabilirsiniz."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "blV4fLzx67-N"
   },
   "source": [
    "### Dizilerde Matematiksel İşlemler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
    "y = np.array([[5,6],[7,8]], dtype=np.float64)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ENt83Yu667-O"
   },
   "source": [
    "Dizilerde temel matematiksel işlemler şu şekilde yapılır."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Toplama"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "VaJIIyJB67-O",
    "outputId": "eb1c0b4f-8787-4433-9299-fff26ec8fe10"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6.  8.]\n",
      " [10. 12.]]\n",
      "[[ 6.  8.]\n",
      " [10. 12.]]\n"
     ]
    }
   ],
   "source": [
    "print (x + y)\n",
    "print (np.add(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**İPUCU**: `np.add()` ile `x + y` aynı sonucu verir!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Çıkarma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RLvyzh7M67-R",
    "outputId": "bbaf9083-48f8-4686-c09f-ec6c810b79a3"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-4. -4.]\n",
      " [-4. -4.]]\n",
      "[[-4. -4.]\n",
      " [-4. -4.]]\n"
     ]
    }
   ],
   "source": [
    "print (x - y)\n",
    "print (np.subtract(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**İPUCU**: `np.subtract()` ile `x - y` aynı sonucu verir!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Çarpma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "thMJ8lUH67-U",
    "outputId": "33f98e85-8894-4f4d-9776-0d0e7d58c7fa"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 5. 12.]\n",
      " [21. 32.]]\n",
      "[[ 5. 12.]\n",
      " [21. 32.]]\n"
     ]
    }
   ],
   "source": [
    "print (x * y)\n",
    "print (np.multiply(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**İPUCU**: `np.multiply()` ile `x * y` aynı sonucu verir!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tXA82gMH67-a"
   },
   "source": [
    "**İPUCU**: Her bir matris elemanının, diğer matriste o elemanın konumunda bulunan elemanla çarpılmasını istiyorsak `*` kullanırız. Matris çarpımı yapmak istiyorsak `dot` kullanmak gerekiyor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Bölme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "yVaF1spU67-V",
    "outputId": "fb892c62-77ac-4a33-db6a-f974ccfe219d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]]\n",
      "[[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]]\n"
     ]
    }
   ],
   "source": [
    "print (x / y)\n",
    "print (np.divide(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**İPUCU**: `np.divide()` ile `x / y` aynı sonucu verir!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Kök Alma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "z30SOixk67-Y",
    "outputId": "2a91c724-36e9-4521-b597-1fd1ece65694"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         1.41421356]\n",
      " [1.73205081 2.        ]]\n"
     ]
    }
   ],
   "source": [
    "print (np.sqrt(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Kare Alma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  4.]\n",
      " [ 9. 16.]]\n"
     ]
    }
   ],
   "source": [
    "print (np.square(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### $ e^x $ 'i Bulmak"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  2.71828183   7.3890561 ]\n",
      " [ 20.08553692  54.59815003]\n",
      " [148.4131591  403.42879349]]\n"
     ]
    }
   ],
   "source": [
    "print(np.exp(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Matris Çarpımı (Vektörel Çarpım)\n",
    "\n",
    "Öncelikle matrislerde çarpım işleminin nasıl yapıldığını bilmiyorsanız ya da unuttuysanız [şu videoyu](https://www.youtube.com/watch?v=8gDh7MO7yo8) izlemenizi tavsiye ederim."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kzhj16Q-67-a",
    "outputId": "b538af51-fb43-47f3-8a34-c44dc3231149"
   },
   "outputs": [],
   "source": [
    "x = np.array([[1, 2],[3, 4]])\n",
    "y = np.array([[5, 6],[7, 8]])\n",
    "\n",
    "v = np.array([9, 10])\n",
    "w = np.array([11, 12])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "219\n",
      "219\n"
     ]
    }
   ],
   "source": [
    "# v ve w vektörlerini çarpmak için\n",
    "print (v.dot(w))\n",
    "print (np.dot(v, w))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pvI6z2OV67-c",
    "outputId": "51f50232-9a52-43ed-ecd9-f239ca7ea08d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[29 67]\n",
      "[29 67]\n"
     ]
    }
   ],
   "source": [
    "# x matrisi ile v vektörünü çarpmak için\n",
    "print (x.dot(v))\n",
    "print (np.dot(x, v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "EF-vZJsW67-f",
    "outputId": "fce219b0-9822-4a30-ba34-7d3fd1508a07"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[19 22]\n",
      " [43 50]]\n",
      "[[19 22]\n",
      " [43 50]]\n"
     ]
    }
   ],
   "source": [
    "# x ve y matrislerini çarpmak için\n",
    "print (x.dot(y))\n",
    "print (np.dot(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Matris Elemanlarını Toplama "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6CcY5LPt67-h"
   },
   "source": [
    "Numpy'da yer alan `np.sum()` ile belirli bir eksende toplama işlemleri gerçekleştirebiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "fgE8AwzO67-h",
    "outputId": "c954baf8-8e6a-4adf-fe2e-a3965f8a31f1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "[4 6]\n",
      "[3 7]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2],[3,4]])\n",
    "\n",
    "print (np.sum(x))          # Tüm matris elemanlarının toplamını ekrana yazdırır.\n",
    "print (np.sum(x, axis=0))  # Sütun toplamlarını ekrana yazdırır\n",
    "print (np.sum(x, axis=1))  # Satır toplamlarını ekrana yazdırır"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "oWyS3TTP67-j"
   },
   "source": [
    "Tüm matematiksel işlemlere [dokümandan](http://docs.scipy.org/doc/numpy/reference/routines.math.html) ulaşabilirsiniz."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Matris Transpozu Alma\n",
    "\n",
    "Matris transpozunun nasıl alındığını merak ediyorsanız [şu videoyu](https://www.youtube.com/watch?v=0sc8y60Jq04) izlemenizi tavsiye ediyorum. Transpoz almak için `.T` eklemeniz yeterli olacaktır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Yp5H9-5D67-k",
    "outputId": "d3eb63f2-4a66-4ea0-8c2c-82a91b90bd15"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n",
      "[[1 3]\n",
      " [2 4]]\n"
     ]
    }
   ],
   "source": [
    "print (x)\n",
    "print (x.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "VMpZxuod67-m",
    "outputId": "d91b58a8-31f8-49e3-9b7d-46343f48b753"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]]\n",
      "[[1]\n",
      " [2]\n",
      " [3]]\n"
     ]
    }
   ],
   "source": [
    "v = np.array([[1,2,3]])\n",
    "print (v) \n",
    "print (v.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "drTuqVch67-o"
   },
   "source": [
    "### Broadcasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Leix550M67-o"
   },
   "source": [
    "Numpy'ın en önemli özelliklerinden bir tanesi de `broadcasting`dir. Bu işlem, küçük boyutlu bir dizi ile büyük boyutlu bir dizi arasında işlem yapılacağı zaman kolaylık sağlamaktadır. Örneğin büyük bir matrisin her bir satırına sabit sayılardan oluşan bir vektör eklemek isteyelim."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vPARS7kr67-o",
    "outputId": "bfdee846-4108-4f9b-8edf-6fb21b8759de"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "# v vektörünü x matrisinin her bir satırına eklemek isteyelim\n",
    "# sonuçları y matrisinde tutalım\n",
    "\n",
    "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "v = np.array([1, 0, 1])\n",
    "y = np.empty_like(x)   # x ile aynı boyuta sahip bir matris oluşturalım\n",
    "\n",
    "print(x) # x matrisini ekrana yazdıralım"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "# v vektörünü x matrisinin her bir satırına for döngüsü kullanarak ekleyelim\n",
    "for i in range(4):\n",
    "    y[i, :] = x[i, :] + v\n",
    "\n",
    "print (y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1iLogC_i67-r"
   },
   "source": [
    "Bu işlemde herhangi bir sorun görünmüyor. Fakat `x` matrisi çok büyük olursa (örneğin bir görüntü) for döngüsü kullanarak bu işlemi yapmamız çok uzun sürer.   \n",
    "\n",
    "Her bir satırında `v` vektörünün olduğu `vv` adında yeni bir matris oluşturup, bunu `x` matrisi ile toplarsak aynı işlemi yapmış olur muyuz? Deneyelim:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bir matrise tekrarlayan değerler atamak için [`np.tile`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.tile.html) fonksiyonunu kullanabiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Wp1hIZSK67-r",
    "outputId": "ca4981e4-45a7-4cfd-e4ef-2988a230cd02"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 1]\n",
      " [1 0 1]\n",
      " [1 0 1]\n",
      " [1 0 1]]\n"
     ]
    }
   ],
   "source": [
    "vv = np.tile(v, (4, 1))  # 4 satırda 1'er kere v vektörünü kullanacağız.\n",
    "\n",
    "print (vv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4u5c3AmL67-t",
    "outputId": "41b87ec5-a9cc-43ea-ff7f-1cc25e59fd75"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "y = x + vv  # x vv matrislerini toplayalım\n",
    "\n",
    "print (y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VUC63_bi67-v"
   },
   "source": [
    "Evet aynı sonucu bulduk yine. Numpy `broadcasting` ile bu şekilde kopya oluşturmadan bu işlemi yapabiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "LdOYpXWH67-v",
    "outputId": "db8cd042-0ecc-4ca3-cfb1-5d81dd13d647"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# v vektörünü x matrisinin her bir satırına eklemek isteyelim\n",
    "# sonuçları y matrisinde tutalım\n",
    "\n",
    "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "v = np.array([1, 0, 1])\n",
    "y = (x + v)  # x matrisinin her satırına v vektörünü broadcasting kullanarak ekleyelim\n",
    "\n",
    "print (y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bscns3jP67-y"
   },
   "source": [
    "`x`'in boyutu `(4, 3)` ve `v`'nin boyutu `(3,)` olmasına rağmen `y = x + v` satırı çalışmaktadır.\n",
    "\n",
    "Daha fazla `broadcasting` örneği:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "OqbjW15L67-z",
    "outputId": "33e895a2-6e8b-44fa-d853-b63da251810f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 4  5]\n",
      " [ 8 10]\n",
      " [12 15]]\n"
     ]
    }
   ],
   "source": [
    "# v ile w'nin vektörel çarpımını hesaplayalım\n",
    "\n",
    "v = np.array([1,2,3])  # v'nin boyutu (3,)\n",
    "w = np.array([4,5])    # w'nin boyutu (2,)\n",
    "\n",
    "# Vektörel çarpımı yapmak için v'yi sütun vektörü haline getirmemiz gerekir\n",
    "# Sütun vektörü yaptıktan sonra broadcasting uygulayabiliriz\n",
    "# Çıktı matrisinin boyutu (3,2) olacak\n",
    "\n",
    "print (np.reshape(v, (3, 1)) * w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RXudDJUa67-0",
    "outputId": "3d8d58d3-7b4a-4a76-af6a-53c5132fe998"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 4 6]\n",
      " [5 7 9]]\n"
     ]
    }
   ],
   "source": [
    "# Matrisin her satırına vektör ekleyelim\n",
    "x = np.array([[1,2,3], [4,5,6]])\n",
    "# x'in boyutu (2, 3) ve v'nin boyutu (3,) \n",
    "# (2, 3) boyutunda bir matris verecek şekilde broadcasting yapalım\n",
    "\n",
    "print (x + v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "nIfaU5Bh67-2",
    "outputId": "f452a3f0-2dab-4aaf-a866-942354845c83"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 5  6  7]\n",
      " [ 9 10 11]]\n",
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "# Matrisin her sütununa vektör ekleyelim\n",
    "# x'in boyutu (2, 3) ve w'nin boyutu (2,).\n",
    "# Transpozunu alırsak x'in yeni boyutu (3, 2) olur\n",
    "# (3, 2) ile (2,) broadcasting işlemi sonucunda (3, 2) boyutlu matris oluşturur.\n",
    "# Sonucun transpozunu alırız.\n",
    "\n",
    "sonuc = (x.T + w).T\n",
    "\n",
    "print (sonuc)\n",
    "print(sonuc.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "joch7WTf67-4",
    "outputId": "12bcb3a1-f8dd-4c46-afc9-1432113192a7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 5  6  7]\n",
      " [ 9 10 11]]\n"
     ]
    }
   ],
   "source": [
    "# Bir diğer yöntem de w'yi sütun vektörü haline getirmektir.\n",
    "\n",
    "sonuc = x + np.reshape(w, (2, 1)) \n",
    "\n",
    "print (sonuc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(2, 3) boyutundaki `x` matrisi sabit bir sayıyla (örneğin 2) çarparsak yine (2, 3) boyutunda bir matris elde ederiz. Sabit sayıların boyutu () olarak tanımlıdır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "U5W1SnSz67-5",
    "outputId": "7a42d2bf-d7f3-498d-d598-248ab97a6eb4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  4  6]\n",
      " [ 8 10 12]]\n"
     ]
    }
   ],
   "source": [
    "print (x * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fWif8jh967-7"
   },
   "source": [
    "`broadcasting`, `for` döngüsünden kurtardığı gibi kodun daha hızlı çalışmasını sağlar. Daha fazla bilgi için [dokümana](https://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) bakabilirsiniz."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "0C-lKRNi67-7"
   },
   "source": [
    "Numpy'la ilgili daha fazla bilgi için [dokümanına](http://docs.scipy.org/doc/numpy/reference/) bakabilirsiniz."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [
    "PTAHQLZT676R",
    "NNuBO6bO676k",
    "nwS9wFGQ677T",
    "DuAK2VqV677V",
    "mGpcOZPC677p",
    "e7kQtwzD677t",
    "UtYuRtNI6772",
    "LaNwQCYW678K",
    "ct0A73Vz678p",
    "SzvCeQ3P6786",
    "zRSvC60r679G",
    "Bm13r-al679M",
    "pBw0NtmC679Q",
    "qN3x1ulv679o",
    "UheI9Iau67-K",
    "blV4fLzx67-N",
    "drTuqVch67-o",
    "BW_9crWx67-9",
    "Ykk1Ld9S67_C"
   ],
   "name": "Numpy Türkçe Başlangıç",
   "provenance": [],
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}