5-lambda_filter_mab.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* lambda \n",
    "* filter\n",
    "* map\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**lambda arguments: expression**\n",
    "\n",
    "Syntax olarak sadece bir ifade(expression) ve birden fazla parametre(arguments) alabilir. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "double = lambda x: x * 2 #x--> arguments x*2--> espresion\n",
    "print(double(15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "def double(x):\n",
    "    return x*2\n",
    "print(double(15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "# default değer verme\n",
    "\n",
    "double = lambda x = 2: x * 2\n",
    "\n",
    "print(double())\n",
    "print(double(15))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "Min = lambda x, y : x  if x < y else y #ikinci x if in içi gibi düşün\n",
    "print(Min(9,7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3, 6, 8], [1, 2, 4, 6, 9], [0, 1, 3, 5, 7]]\n"
     ]
    }
   ],
   "source": [
    "# iç içe yer alan listeleri lamda fonksiyonu ile sıralayalım. \n",
    "\n",
    "my_list = [[2,6,8,3,1], [2,6,4,1,9], [0,7,3,5,1]]\n",
    "\n",
    "sortedList = lambda use_list: (sorted(i) for i in use_list)\n",
    "print(list(sortedList(my_list)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "my_list = [[2,6,8,3,1], [2,6,4,1,9], [0,7,3,5,1]]\n",
    "def sortedList(liste):\n",
    "    for i, item in enumerate(my_list): #enumerate i ve item değerini aynı anda almak için kullanılır. \n",
    "        my_list[i]=sorted(item)\n",
    "    return\n",
    "\n",
    "print(sortedList(my_list))\n",
    "\n",
    "\n",
    "print(sortedList(my_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 70, 90, 40, 30]\n"
     ]
    }
   ],
   "source": [
    "multply_list = lambda x: (i * 10 for i in x) \n",
    "print(list(multply_list([1,7,9,4,3])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**filter( )** --> parametre olarak bir lamda yani isimsiz bir fonksiyon ve bir liste alır. Verilen ifadeye uygun işlemleri ele alır ve yeni bir liste döner.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 43, 5, 7, 77]\n"
     ]
    }
   ],
   "source": [
    "#liste içerisindeki tek sayıları alma\n",
    "my_list= [1,2,43,5,6,7,34,0,77]\n",
    "\n",
    "print(list(filter(lambda x: x % 2 != 0, my_list)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "map ( ) --> paramtre olarak bir lamda yani isimsiz bir fonksiyon ve bir liste alır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[True, False, True, True, False, True, False, False, True]\n"
     ]
    }
   ],
   "source": [
    "my_list= [1,2,43,5,6,7,34,0,77]\n",
    "print(list(map(lambda x: x % 2 != 0, my_list)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 16, 25, 36, 49, 9, 0, 49]\n"
     ]
    }
   ],
   "source": [
    "# map ile her elamanın karesini alan kodu yazalım. \n",
    "my_list= [1,2,4,5,6,7,3,0,7]\n",
    "print(list(map(lambda x: x ** 2, my_list)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 21, 0]\n"
     ]
    }
   ],
   "source": [
    "# map ile liste içerisindeki her listenin ilk elamanının 3 katını döndüren kod.\n",
    "my_list = [[2,6,8,3,1], [7,6,4,1,9], [0,7,3,5,1]]\n",
    "\n",
    "print(list(map(lambda x: x[0]*3, my_list))) # mantık olarak map listenin içinde gez demek. For'a gerek kalmıyor. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20, 30, 50, 40]\n",
      "[2, 3, 5, 4]\n"
     ]
    }
   ],
   "source": [
    "# filter ile [20, 30, 15, 10, 13, 50, 40] listesi içerisinde olanları >=20 olanları bulup, \n",
    "# map ile yeni listedeki değerleri integer bölme ile 10'a bölelim ve oluşan listeyi ekrana basalım.\n",
    "\n",
    "\n",
    "print(list(filter(lambda x: x >=20, [20, 30, 15, 10, 13, 50, 40] )))\n",
    "\n",
    "print(list(map(lambda x: x //10,filter(lambda x: x >=20, [20, 30, 15, 10, 13, 50, 40]))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Beyza', 34, 2, 89.6, True, 'a']\n"
     ]
    }
   ],
   "source": [
    "# listenin içerisinde yer alan integer tipindeki elemanları bulalım.\n",
    "my_list= [\"Beyza\", 34, 2, 89.6, True, 'a']\n",
    "\n",
    "print(list(filter(lambda x: type(x), my_list)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['EMRE', 'CEYDA', 'CEREN', 'İLKAY', 'BUKET', 'AYŞE', 'NURCAN']\n",
      "['emre', 'ceyda', 'ceren', 'i̇lkay', 'buket', 'ayşe', 'nurcan']\n"
     ]
    }
   ],
   "source": [
    "# liste içerisindeki isimleri büyük harfe çevirelim.\n",
    "my_list= [\"Emre\", \"Ceyda\", \"Ceren\", \"İlkay\", \"Buket\", \"Ayşe\", \"Nurcan\"]\n",
    "\n",
    "print(list(map(lambda x: x.upper(), my_list)))\n",
    "print(list(map(lambda x: x.lower(), my_list)))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.7 64-bit",
   "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.7"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "1d8047cf9a3fb5d39b90451c85057b3ab99e4664a0128e29f03111a30f920c3d"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}