strategyDesignPattern.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strategy Design Pattern"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Super havalı bir projen olduğunu düşünelim. Mesela evindeki malzemelere göre yemek tarifi veren  bir uygulama. \n",
    "\n",
    "Ancak bir süre sonra kullanıclar süre sınırından bahsetmeye başlıyor. Tek kısıt evdeki malzemeler değil bazen süre sınırı da olabiliyor. Bu yüzden artık süre limitine göre de filitreleme yapan bir özellik ekliyorsun.  \n",
    "\n",
    "\n",
    "Kullanıcılar çok mutlu ama bir süre sonra yeni bir istek daha geliyor. Tarifleri imkanlara gre filitreleme. Herkesin çelik bir wok ya fa döküm tava olmayabilir.  \n",
    "\n",
    "Git gide özellikler artıyor. Yeni özellikler kullanıcıları çok mutlu etsede teknik ekip düzenli olarak ağlamaktan ciddi su kaybı yaşamaya başladı. İşler karıştıkça teknik problemler artacak.  \n",
    "\n",
    "Eğer bir geliştirii olacak çalışacaksan mutlaka beklenmedik özellikler eklemek zorunda kalacaksın.\n",
    "\n",
    "Bunun için tek çözüm beklenmedik özelliklere hazır temiz kodlar yazmaktır."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bu örnekteki problemi çözmek için strategy design patterni uygulayabiliriz.   \n",
    "Strategy design pattern bir amaca ulaşmak için farklı stratejileri kullanıma hazır hale getiriyoruz. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basit bir örnekle sistemi anlayalım ve sonrasında problemimize geri döneceğiz."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Farklı indirim stratejilerini alabilen bir item sınıfı oluşturark başlayalım"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Uygulamamız içi özel bir item\"\"\"\n",
    "class Item:\n",
    "\n",
    "    \"\"\"Fiyat ve indirim metodunu alan bir init \"\"\"\n",
    "\n",
    "    def __init__(self, price, discount_strategy = None):\n",
    "        self.price = price\n",
    "        self.discount_strategy = discount_strategy\n",
    "        \n",
    "    \"\"\" init sırasında verilen stratejiye göre fiyat ayarlayan method\"\"\"\n",
    "    def price_after_discount(self):\n",
    "        \n",
    "        if self.discount_strategy:\n",
    "            discount = self.discount_strategy(self)\n",
    "        else:\n",
    "            discount = 0\n",
    "            \n",
    "        return self.price - discount\n",
    "#dunder method ile özel print yapısı\n",
    "    def __repr__(self):\n",
    "        \n",
    "        statement = \"Price: {}, price after discount: {}\"\n",
    "        return statement.format(self.price, self.price_after_discount())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "artık stratejilere ihtiyacımız var, hadi bunları yazalım"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\"\"\" yüzde yirmi beş indirim yapan ve üzerine birde yirmi  indirim eklesin \"\"\"\n",
    "def on_sale_discount(order):\n",
    "    \n",
    "    return order.price * 0.25 + 20\n",
    "\n",
    "\"\"\"  sadece yüzde yirmi indirim \"\"\"\n",
    "def twenty_percent_discount(order):\n",
    "    \n",
    "    return order.price * 0.20\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "artk ugulanabilir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Price: 2000, price after discount: 2000\n"
     ]
    }
   ],
   "source": [
    "test_item=Item(2000) # fiyat var ama strateji none\n",
    "\n",
    "print(test_item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Price: 2000, price after discount: 1600.0\n"
     ]
    }
   ],
   "source": [
    "test_item.discount_strategy = twenty_percent_discount\n",
    "print(test_item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Price: 2000, price after discount: 1480.0\n"
     ]
    }
   ],
   "source": [
    "test_item.discount_strategy = on_sale_discount\n",
    "print(test_item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Artık objemiz için bir strateji seçebiliyoruz ve objemiz buna göre davranış segiliyor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Şimdi filitreleme problemine dönelim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tarif objeleri ve detaylarını oluşturduk bunlarıda tarif databaseimize ekledik"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Recipe:\n",
    "    def __init__(self, ingredients=None, time=0, requires=None,name=\"recipe\"):\n",
    "        self.ingredients = ingredients\n",
    "        self.time = time\n",
    "        self.requires = requires\n",
    "        self.name=name\n",
    "\n",
    "    def __str__(self):  ## print ile kullanınca çıkan bu \n",
    "        return self.name\n",
    "    def __repr__(self):  ## print ve repr ile ya da list içi printte çıkan bu \n",
    "        return self.name\n",
    "recipe1 = Recipe(ingredients=[\"ing1\",\"ing2\"],time=10,requires=[\"steel wok\"],name=\"Recipe1\")\n",
    "recipe2 = Recipe(ingredients=[\"ing2\",\"ing3\"],time=20,requires=[\"cast iron pan\"],name=\"Recipe2\")\n",
    "recipe3 = Recipe(ingredients=[\"ing1\",\"ing3\"],time=15,requires=None ,name=\"Recipe3\" )\n",
    "recipe4 = Recipe(ingredients=[\"ing3\",\"ing2\"],time=20,requires=None ,name=\"Recipe4\")\n",
    "recipe5 = Recipe(ingredients=[\"ing1\",\"ing2\",\"ing3\"],time=10,requires=[\"steel wok\"] ,name=\"Recipe5\")\n",
    "\n",
    "recipesDataBase=[recipe1,recipe2,recipe3,recipe4,recipe5]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ingredientFilter(availableIngredients:list, recipesList:list) -> list:\n",
    "    filteredList=[]\n",
    "    for i in recipesList:\n",
    "        if all(a  in availableIngredients for a in i.ingredients):   ### list comprehension ve all fonksiyonu ile pythonic bir yaklaşım.\n",
    "            filteredList.append(i)\n",
    "    return filteredList\n",
    "\n",
    "\n",
    "### list comprehension ve all fonksiyonu ile pythonic bir yaklaşım.\n",
    "### Eğer aşina değilseniz basitçe : list comprehension listenizi bir ifade olarak yazmayı sağlar \n",
    "### a in available ingredients kısmı listenin elamanları olacak true yada false \n",
    "### bu listeyi for ile yapılan bir iterasyon ile oluşturduk  for a in i.ingredients\n",
    "### bu alttaki ifadeye benzer\n",
    "### \n",
    "### list=[]\n",
    "### for a in i.ingredients:\n",
    "###     list.append(a  in availableIngredients)\n",
    "### all() basitçe eğer içi hep true ise true döndürür bir false bile durumu bozar\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "filtremizi test edelim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Receipe1, Receipe2, Receipe3, Receipe4, Receipe5]\n"
     ]
    }
   ],
   "source": [
    "print( ingredientFilter(availableIngredients=[\"ing1\",\"ing2\",\"ing3\"], recipesList=recipesDataBase))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Receipe2, Receipe4]\n"
     ]
    }
   ],
   "source": [
    "print( ingredientFilter(availableIngredients=[\"ing2\",\"ing3\"], recipesList=recipesDataBase))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "şimdi malzemeler ve süre için de filitreleyen stratejiler yazalım"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def itemFilter(availableItems:list, recipesList:list) -> list:\n",
    "    filteredList=[]\n",
    "    for i in recipesList:\n",
    "        if i.requires is None or  all(a  in availableItems for a in i.requires):  ###eğer requires none ise de if  çalışır \n",
    "            filteredList.append(i)\n",
    "    return filteredList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Receipe1, Receipe3, Receipe4, Receipe5]\n"
     ]
    }
   ],
   "source": [
    "print( itemFilter(availableItems=[\"steel wok\"], recipesList=recipesDataBase))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def timeFilter(availableTime:int, recipesList:list) -> list:\n",
    "    filteredList=[]\n",
    "    for i in recipesList:\n",
    "        if availableTime >= i.time:\n",
    "            filteredList.append(i)\n",
    "    return filteredList"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Receipe1, Receipe5]\n"
     ]
    }
   ],
   "source": [
    "print( timeFilter(availableTime=10, recipesList=recipesDataBase))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Artık stratejileri uygulayacak bi listeleme sistemine ihtiyacımız var, Listenizin içinde bir objeniz olsun"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RecipeList():\n",
    "    def __init__(self, recipesList=None, strategy=None):\n",
    "        self.recipes=[]\n",
    "        self.filteredRecipes=[]\n",
    "        self.recipes.extend(recipesList)\n",
    "        self.strategy=strategy\n",
    "\n",
    "    def applyFilter(self,filterElement)-> None:\n",
    "        self.filteredRecipes=self.strategy(filterElement,self.recipes)        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Receipe2, Receipe4]\n"
     ]
    }
   ],
   "source": [
    "test_recipe_app = RecipeList(recipesList=recipesDataBase,strategy=ingredientFilter)\n",
    "test_recipe_app.applyFilter(filterElement=[\"ing2\",\"ing3\"])\n",
    "print(test_recipe_app.filteredRecipes)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Receipe1, Receipe5]\n"
     ]
    }
   ],
   "source": [
    "test_recipe_app.strategy=timeFilter\n",
    "test_recipe_app.applyFilter(filterElement=10)\n",
    "print(test_recipe_app.filteredRecipes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Artık farklı filtreleme stratejilerini uygulayan bir yapımız var\n",
    "\n",
    "Bu sistem hakkında konuşmaya devam edeceğiz ama öncesinde biraz beyin fırtınası yapalım   \n",
    "\n",
    "Farklı stratejilere sahip bir trading botu yapabilirsin.  \n",
    "\n",
    "Farklı eşleşme stratejilerine sahip bir oyun \n",
    "\n",
    "Ya da farklı rota arama mekanizmalarına sahip bir haritalar uyulması   \n",
    "\n",
    "\n",
    "Bunu güzel kılan şey ise ana sisteminde bir strateji slotu yaratmış olman. Buraya belli girdi vve çıktı kurallarına uygun bir strateji vermen yeterli. Yeni bir strateji geldiğinde sadece ismi değiştireceksin. Ana sistem içinde hardcoded bir filtre algoritması yok. Silmen gereken bloklar ve ya zombi kodlar olmayacak. Gelecekte yeni stratejiler eklemek istersen sadece yeni bir filtrede dosyasında fitreni yazıp importlayacaksın.  Avantajlar bununla sınırlı değil elbette.\n",
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "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.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}