8 - String metodları.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "**Dize**, bir veya daha fazla karakterden bir araya gelmiş bir sıralı veri tipidir. Dizelerle düz metin halindeki veriler alınıp işlenebilir. Veriler pek çok zaman düz metin dosyaları halinde bulunur. HTML, XML, JSON veya CSV gibi standartlardaki veriler de düz metinden oluşur. Bir metin verisini dize halinde aldığımızda, dize metodlarını kullanarak bu verileri işleyebilir, biçimlerini değiştirebilir, parçalayabilir, birleştirebilir, sıralayabilir, değişiklik yapabiliriz.\n",
    "\n",
    "Temel işlemler\n",
    "=============\n",
    "Sıralı nesnelerle kullanılan `len`, `in`, `not in`, `+`, `*` gibi işlemler dizelerde de aynı şekilde çalışır:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print( \"Def\" in \"Abcç Defg\" )\n",
    "print( \"def\" in \"ABcç Defg\" )\n",
    "print( \"def\" not in \"ABcç Defg\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(\"Abcç Defg\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'AbcçDefg'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Abcç\" + \"Defg\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'AbcçAbcçAbcçAbcçAbcç'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Abcç\" * 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bir nesnenin dize biçimini elde etmek için `str` fonksiyonu kullanılabilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'12345'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(12345)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'[1, 2, 3]'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str([1,2,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tek tırnak, çift tırnak, üçlü tırnak\n",
    "==========\n",
    "Python'da diziler istenirse tek tırnakla, istenirse çift tırnakla sınırlandırarak kullanılabilirler. İkisi de aynı nesneyi üretir; yani `\"abc\"` ile `'abc'` aynı dizedir.\n",
    "\n",
    "Bu esneklik, dizenin içinde bir çeşit tırnak varsa, dizenin çevresinde öbür çeşit tırnağı kullanma imkânı verir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ali'nin kalemini ver.\n"
     ]
    }
   ],
   "source": [
    "print(\"Ali'nin kalemini ver.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dedim ki: \"Gel!\"\n"
     ]
    }
   ],
   "source": [
    "print( 'Dedim ki: \"Gel!\"' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eğer dizenin içindeki metinde her iki tırnak çeşidine de ihtiyaç duyarsak, _kaçış karakterleri_  `\\’` ve `\\\"` kullanabiliriz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ali'ye dedim ki: \"Gel!\"\n"
     ]
    }
   ],
   "source": [
    "print(\"Ali'ye dedim ki: \\\"Gel!\\\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Üç tırnak (`\"\"\"` veya `'''`) kullanarak birkaç satıra yayılan bir dize yaratabiliriz. Yaptığımız kaydırmalar, satırbaşları, boş satırlar dizenin parçası olarak kaydedilir. Bu tür dizeler özellikle fonksiyonlardaki belge dizelerinde (docstring) çok kullanılır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcç\n",
      "    def\n",
      "gğhıi\n"
     ]
    }
   ],
   "source": [
    "s = \"\"\"abcç\n",
    "    def\n",
    "gğhıi\"\"\"\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dize metodları\n",
    "=========\n",
    "Dize sınıfı içinde tanımlanmış pek çok metod mevcut. Bunların tam bir listesini görmek için `dir(str)` komutunu verebilirsiniz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__getnewargs__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mod__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rmod__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'capitalize',\n",
       " 'casefold',\n",
       " 'center',\n",
       " 'count',\n",
       " 'encode',\n",
       " 'endswith',\n",
       " 'expandtabs',\n",
       " 'find',\n",
       " 'format',\n",
       " 'format_map',\n",
       " 'index',\n",
       " 'isalnum',\n",
       " 'isalpha',\n",
       " 'isdecimal',\n",
       " 'isdigit',\n",
       " 'isidentifier',\n",
       " 'islower',\n",
       " 'isnumeric',\n",
       " 'isprintable',\n",
       " 'isspace',\n",
       " 'istitle',\n",
       " 'isupper',\n",
       " 'join',\n",
       " 'ljust',\n",
       " 'lower',\n",
       " 'lstrip',\n",
       " 'maketrans',\n",
       " 'partition',\n",
       " 'replace',\n",
       " 'rfind',\n",
       " 'rindex',\n",
       " 'rjust',\n",
       " 'rpartition',\n",
       " 'rsplit',\n",
       " 'rstrip',\n",
       " 'split',\n",
       " 'splitlines',\n",
       " 'startswith',\n",
       " 'strip',\n",
       " 'swapcase',\n",
       " 'title',\n",
       " 'translate',\n",
       " 'upper',\n",
       " 'zfill']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Her bir metodun kısa bir açıklaması için `help()` komutunu kullanabilirsiniz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method_descriptor:\n",
      "\n",
      "capitalize(...)\n",
      "    S.capitalize() -> str\n",
      "    \n",
      "    Return a capitalized version of S, i.e. make the first character\n",
      "    have upper case and the rest lower case.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(str.capitalize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Burada bu metodların belli başlılarının kullanımlarını örnekleyerek açıklayacağız. Özellikle, metin şeklindeki verilerin analizinde kullanılabilecek metodları seçtik. Tam bir liste için [Python yardım belgelerine](https://docs.python.org/3.6/library/stdtypes.html#string-methods) bakabilirsiniz."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "startswith, endswith\n",
    "----------------\n",
    "\n",
    "Bir dizenin başlangıcında veya sonunda belli bir alt dizenin bulunması halinde `True` verirler."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"Python Programlamaya Giriş\"\n",
    "s.startswith(\"Pyth\"), s.startswith(\"python\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.endswith(\"iriş\"), s.endswith(\"xyz\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Büyük-küçük harf değişiklikleri\n",
    "---------\n",
    "Dizeleri tamamen küçük veya büyük harfe çevirmek, cümlenin ilk harfinin büyük olmasını sağlamak, veya bir başlıktaki gibi her kelimenin büyük harfle başlamasını sağlamak için çeşitli dize metodları vardır. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s.upper(): PIJAMALI HASTA YAĞIZ ŞOFÖRE ÇABUCAK GÜVENDI.\n",
      "s.lower(): pijamalı hasta yağız şoföre çabucak güvendi.\n",
      "s.capitalize(): Pijamalı hasta yağız şoföre çabucak güvendi.\n",
      "s.swapcase(): pIJAMALI HASTA YAĞIZ ŞOFÖRE ÇABUCAK GÜVENDI.\n",
      "s.title(): Pijamalı Hasta Yağız Şoföre Çabucak Güvendi.\n"
     ]
    }
   ],
   "source": [
    "s = \"Pijamalı hasta yağız şoföre çabucak güvendi.\"\n",
    "\n",
    "print(\"s.upper():\", s.upper())   # Hepsini büyük harfe çevir.\n",
    "print(\"s.lower():\", s.lower())   # Hepsini küçük harfe çevir.\n",
    "print(\"s.capitalize():\", s.capitalize())   # Sadece cümlelerin ilk harfini büyük yap. \n",
    "print(\"s.swapcase():\", s.swapcase())   # Büyük harfleri küçüğe, küçükleri büyüğe çevir.\n",
    "print(\"s.title():\", s.title())   # Her kelimenin ilk harfini büyük yap."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Görüldüğü gibi bu fonksiyonlar Türkçedeki i ve I harflerini doğru şekilde işleyemiyorlar. Küçük i harfi büyük I harfine (ve tersine) dönüştürülüyor. Bu yüzden Python'un dize metodları, yazılımda [Türkiye testi](http://www.moserware.com/2008/02/does-your-code-pass-turkey-test.html) olarak bilinen testi geçemiyor. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('i i̇', 'I I')"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"I İ\".lower(), \"ı i\".upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bu problemin çevresinden dolaşmak için kullanılacak bir yöntemi [şuradan](https://stackoverflow.com/a/41316018) öğrenebilirsiniz."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Alt dizeleri saymak: count\n",
    "-----\n",
    "Bir dize içinde bir alt dizenin kaç kere geçtiğinin sayısını verir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"ABCDABCAAABC\".count(\"ABC\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sadece örtüşmeyen alt dizeler sayılır. Sözgelişi, `\"AAAAA\"` dizesinin içinde, örtüşmeleri sayarsak `\"AA\"` altdizesi 5 kere mevcuttur, ama `count` 2 sonucunu verir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"AAAAA\".count(\"AA\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bir alt dizenin yerini bulmak: find, rfind, index, rindex\n",
    "-------------------\n",
    "`find` metodu, bir dizenin içinde bir alt dizenin ilk bulunduğu konumu verir. Aranan alt dize mevcut değilse -1 döndürür."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"ABRAKADABRA\"\n",
    "s.find(\"RA\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.find(\"XYZ\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Konum saymanın sıfır ile başladığını hatırlayın; o yüzden `\"RA\"` dizesi üçüncü harfte başlıyor, ama konum indeksi 2.\n",
    "\n",
    "Dikkat: Amacınız belli bir alt dizenin yerini bulmak değil, sadece mevcut olup olmadığını anlamaksa `find` yerine `in` kullanın."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"RA\" in s, \"XYZ\" in s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aramaya sağdan başlamak isterseniz `rfind` metodunu kullanın."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.rfind(\"RA\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`index` ile `find` aynı işi yapar. Tek farkları, aranan alt dize bulunamayınca `index`'in bir hata işareti (`\"ValueError\"`) vermesidir. Hata yakalamaya dayalı programlarda tercih edilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.index(\"RA\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "substring not found",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-24-de36660908dd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ms\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"XYZ\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: substring not found"
     ]
    }
   ],
   "source": [
    "s.index(\"XYZ\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aramaya sağdan başlamak isterseniz `rindex` komutunu kullanabilirsiniz.\n",
    "\n",
    "Dizeleri birleştirmek: join\n",
    "-------------\n",
    "Bir sıralı nesnenin (liste, çokuz, dize, vs.) dize tipi elemanlarını birleştirerek yeni bir dize üretir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A67B0.15'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\".join([\"A\",\"67\",\"B\",\"0.15\"])    # yanyana yapıştırır"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A 67 B 0.15'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\" \".join([\"A\",\"67\",\"B\",\"0.15\"])   # araya bir boşluk koyarak yapıştırır"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A-*-67-*-B-*-0.15'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"-*-\".join([\"A\",\"67\",\"B\",\"0.15\"]) # araya -*- koyarak yapıştır"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Boşlukları atmak: lstrip, rstrip, strip\n",
    "--------------------\n",
    "Bu metodlar bir dizenin sol ve/veya sağ tarafındaki boş karakterleri (boşluk, kaydırma `\\t`, satırbaşı `\\n`) kaldırır. `lstrip` soldaki, `rstrip` sağdaki, `strip` ise her iki yandaki boşlukları temizler. Bu metodlar özellikle bir dosya satır satır okunurken yararlı olur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n        ferah  ferah   \\n'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"\"\"\n",
    "        ferah  ferah   \n",
    "\"\"\"\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ferah  ferah   \\n'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.lstrip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n        ferah  ferah'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.rstrip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ferah  ferah'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Değiştirme: replace\n",
    "-----------\n",
    "Dizede belli bir alt dizenin ortaya çıktığı her yeri başka bir alt dizeyle değiştirir.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"yenişehir'de yeni bir evde yeni bir kapı\""
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"eskişehir'de eski bir evde eski bir kapı\"\n",
    "s.replace(\"eski\", \"yeni\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tercihe bağlı olarak, soldan itibaren sadece belli sayıda değiştirme de yapılabilir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"yenişehir'de yeni bir evde eski bir kapı\""
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.replace(\"eski\", \"yeni\", 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bölme: split, rsplit, splitlines\n",
    "----------------\n",
    "`split` metodu bir dizedeki kelimeleri belli yerlerden (varsayılan olarak boşluk karakterlerinden) böler ve ortaya çıkan bölümlerden oluşan bir dize listesi verir. Fazlalık boşluklar hesaba katılmaz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['kedi', 'köpek', 'balık', 'kuş']"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"   kedi köpek   balık    kuş   \".split()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Boşluk yerine başka bir ayırıcı kullanılabilir. Ayrıcı istenilen sayıda karakterden oluşabilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', '2', '3', '4', '5', '6']"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"1,2,3,4,5,6\".split(\",\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c', 'd', 'e']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"a<>b<>c<>d<>e\".split(\"<>\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sadece belli sayıda bölme yapmak da mümkündür. Arta kalan kısım tek bir dizede toplanır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['kedi', 'köpek', 'balık    kuş   ']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"   kedi köpek   balık    kuş   \".split(maxsplit=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Soldan değil sağdan başlayarak ayırmamız gerekirse `rsplit` metodunu kullanırız."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['   kedi köpek', 'balık', 'kuş']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"   kedi köpek   balık    kuş   \".rsplit(maxsplit=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Birden fazla satır barındıran bir dizeyi satır sınırlarından bölmek için `splitlines` metodu kullanılabilir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abcç', 'defgğ', 'hıi', 'jkl']"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"\"\"abcç\n",
    "defgğ\n",
    "hıi\n",
    "jkl\"\"\"\n",
    "\n",
    "s.splitlines()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`splitlines` metodu sadece satırbaşı (`\"\\n\"`) ile değil, `\"\\r\"`, `\"\\v\"`, `\"\\f\"`, ve satır sonu sayılan başka birkaç karakter ile de böler. Ayrıca, `split`'ten farklı olarak dize sonundaki `\"\\n\"` karakterini de göz ardı eder. Bir dosyanın içeriğini bütün olarak bir dizeye yüklediyseniz, onu satırlara bölmek için en uygunu `splitlines` kullanmaktır."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}