syntax,string hw .ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "a= [1,2,3,4,5]\n",
    "for i in a:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a는 6개의 요소로 이루어진 리스트이다. range(6)을 취한것과 같으므로 0,1,2,3,4,5 총 6회의 i값이 출력된다. 따라서 0,1,2,3,4,5가 그대로 출력된다. 아래와같은 경우엔 리스트 안에 요소로서 또 리스트가 있지만 하나의 요소로 취급한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "a=[1,2,3,[4],5,67]\n",
    "for i in range(len(a)):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "리스트 안에 요소의 값이 문자여도 같은 원리가 적용됨을 알 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "a=['10','2','3','[4,5,6]']\n",
    "for i in range(len(a)):\n",
    "    print(i+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "red\n",
      "green\n",
      "blue\n",
      "purple\n"
     ]
    }
   ],
   "source": [
    "a=['red','green','blue','purple']\n",
    "for i in a:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "이번에는 스트링으로 이루어진 리스트에서 리스트의 길이 (즉 4)를 i값으로 취했다. 앞에번처럼 print(i) 를 하면 range(len(4))를 한 값이 나오지만 이번에는 모든 a[0] 부터 a[3]에 해당하는 실제 값들을 모두 출력하도록 하였다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "red\n",
      "green\n",
      "blue\n",
      "purple\n"
     ]
    }
   ],
   "source": [
    "a=['red','green','blue','purple']\n",
    "for i in range(len(a)):\n",
    "    print(a[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "이번에는 {}:{}% 의 모양으로 결과가 도출되도록 하였다. enumerate함수는 요소와 index를 동시에 출력하도록 한다. 이 때 리스트b의 요소들에는 10을 곱하도록 하였고 a리스트의 순서와 1대1 대응하여 나타내도록 하였다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "red:20%\n",
      "green:30%\n",
      "blue:10%\n",
      "purple:40%\n"
     ]
    }
   ],
   "source": [
    "a=['red','green','blue','purple']\n",
    "b=[2,3,1,4]\n",
    "for i, a in enumerate(a):\n",
    "    print('{}:{}%'. format(a,b[i]*10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "enumerate함수를 이번에는 a,b 리스트의 요소의 개수를 다르게 설정해 보았다. 이러한 경우 b리스트의 3째 인덱스 4에 대응하는 값이 출력되지 않았다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "red:20%\n",
      "green:30%\n",
      "blue:10%\n"
     ]
    }
   ],
   "source": [
    "a=['red','green','blue']\n",
    "b=[2,3,1,4]\n",
    "for i, a in enumerate(a):\n",
    "    print('{}:{}%'. format(a,b[i]*10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "그러나, enumerate함수의 기준이 되던 a리스트가 아니라, b[i]값을 취하게 되는 b리스트의 요소의 개수를 줄여보았더니, 결과가 도출되기는 도출되었는데 syntax error가 함께 발생하였다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "red:20%\n",
      "green:30%\n",
      "blue:10%\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-11-e000547aeaea>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ma\u001b[0m \u001b[1;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'{}:{}%'\u001b[0m\u001b[1;33m.\u001b[0m \u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "a=['red','green','blue','purple']\n",
    "b=[2,3,1]\n",
    "for i, a in enumerate(a):\n",
    "    print('{}:{}%'. format(a,b[i]*10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a와 b를 바꾸어 보았다. 이 때 a리스트의 index 0,1,2,3의 순서대로 2,3,1,4가 도출되었고 b리스트의 index 0,1,2,3번째에 해당하는 요소들이 10회 곱해진 값% 의 형태로 1대1 대응을 이루었다. enumerate 함수는 인덱스값대로 리스트의 요소를 대응 및 출력하는 함수이며, 숫자이거나 문자이거나는 관계가 없다는 점을 알 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2:redredredredredredredredredred%\n",
      "3:greengreengreengreengreengreengreengreengreengreen%\n",
      "1:blueblueblueblueblueblueblueblueblueblue%\n",
      "4:purplepurplepurplepurplepurplepurplepurplepurplepurplepurple%\n"
     ]
    }
   ],
   "source": [
    "a=[2,3,1,4]\n",
    "b=['red','green','blue','purple']\n",
    "for i, a in enumerate(a):\n",
    "    print('{}:{}%'. format(a,b[i]*10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b리스트의 요소를 a리스트 요소보다 적게 설정하였더니 a[0:2]에 해당하는 값들은 출력이 되었고 동시에 인덱스에러 역시 발생하였다. a[3]에 해당하는 값, 즉 a의 3번째 인덱스에 대응하는 값을 b리스트에서 발견하지 못 하였기 때문이라고 추정된다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2:redredredredredredredredredred%\n",
      "3:greengreengreengreengreengreengreengreengreengreen%\n",
      "1:blueblueblueblueblueblueblueblueblueblue%\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-7-914985c18383>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'red'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m'green'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m'blue'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0ma\u001b[0m \u001b[1;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'{}:{}%'\u001b[0m\u001b[1;33m.\u001b[0m \u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "a=[2,3,1,4]\n",
    "b=['red','green','blue']\n",
    "for i, a in enumerate(a):\n",
    "    print('{}:{}%'. format(a,b[i]*10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "기존의 a,b 리스트에서 이번에는 enumerate가 아니라 zip함수를 사용하였다. zip합수는 enumerate와는 달리 인덱스를 기준으로 함수값을 나열하는 것이 아니라 복수의 리스트에서 같은 인덱스값에 해당하는 값들을 바로 1대1 대응하는 함수라고 추정하였다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "red:20%\n",
      "green:30%\n",
      "blue:10%\n",
      "purple:40%\n"
     ]
    }
   ],
   "source": [
    "a=['red','green','blue','purple']\n",
    "b=[2,3,1,4]\n",
    "for a_, b_ in zip(a,b):\n",
    "    print('{}:{}%'. format(a_,b_*10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "이번에도 리스트를 반대로 했지만 같은 결과가 나온다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2:redredredredredredredredredred%\n",
      "3:greengreengreengreengreengreengreengreengreengreen%\n",
      "1:blueblueblueblueblueblueblueblueblueblue%\n",
      "4:purplepurplepurplepurplepurplepurplepurplepurplepurplepurple%\n"
     ]
    }
   ],
   "source": [
    "a=[2,3,1,4]\n",
    "b=['red','green','blue','purple']\n",
    "for a_, b_ in zip(a,b):\n",
    "    print('{}:{}%'. format(a_,b_*10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "위에와 마찬가지로 zip 함수에 적용되는 두 리스트의 요소의 개수가 다른 경우를 가정하였다. 우선 a가 b보다 개수가 적을때이다. b[3]에 해당하는 'purple'이라는 문자는 아예 버려졌다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2:redredredredredredredredredred%\n",
      "3:greengreengreengreengreengreengreengreengreengreen%\n",
      "1:blueblueblueblueblueblueblueblueblueblue%\n"
     ]
    }
   ],
   "source": [
    "a=[2,3,1]\n",
    "b=['red','green','blue','purple']\n",
    "for a_, b_ in zip(a,b):\n",
    "    print('{}:{}%'. format(a_,b_*10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "enumerate와 명확한 차이점이 여기서 드러난다. enumerate함수와 달리 zip함수는 리스트에 요소의 개수에 구애받지 않고 일대일 가능한 요소끼리만 결과값을 출력하고, 인덱스에러는 일절 발생하지 않는다는 점을 알 수 있다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2:redredredredredredredredredred%\n",
      "3:greengreengreengreengreengreengreengreengreengreen%\n",
      "1:blueblueblueblueblueblueblueblueblueblue%\n"
     ]
    }
   ],
   "source": [
    "a=[2,3,1,4]\n",
    "b=['red','green','blue']\n",
    "for a_, b_ in zip(a,b):\n",
    "    print('{}:{}%'. format(a_,b_*10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "=기호와 ==기호에 대한 기본적인 활용이다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "a=0\n",
    "if a ==0:\n",
    "    print(a)\n",
    "else:\n",
    "    print(a+1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "range라는 개념은 python에서 이상,이하,미만,초과 개념 중 이상~미만의 개념이라고 이해하면 된다. 즉 (1,3) 이라고 되어있을 때 range의 의미를 \"1이상 3미만\" 이라고 이해하면 편할 듯 하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n",
      "6\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,3):\n",
    "    for j in range(3,5):\n",
    "        print(i*j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "부등호의 활용법에 대해 알아보았다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,3):\n",
    "    for j in range(3,5):\n",
    "        if j >=4:\n",
    "            print(i*j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "위와는 달리 변수 j를 활용하지 않고 리스트의 형식을 활용하였다. 그로 인해 위와는 달리 2보다 크거나 같은 요소 2,3,4가 리스트의 형태로 나타났다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=[1,2,3,4]\n",
    "b=[i for i in a if i>=2]\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "len변수에 대해 알아보았다. 스트링들이 요소를 이루고 있는데 그 중 단어의 길이가 5개 이상인 스트링들만 출력된다. 역시 b리스트를 활용했기 때문에 리스트의 형태로 결과가 나타난다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['green', 'purple']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a= ['red','green','blue','purple']\n",
    "b=[i for i in a if len(i) >=5]\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "s라는 스트링에서 인덱싱과 슬라이싱을 어떻게 하는지 알아보았다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "a f f a\n",
      "bc bcdef abc abcdef\n"
     ]
    }
   ],
   "source": [
    "s='abcdef'\n",
    "print(type(s))\n",
    "print(s[0],s[5],s[-1],s[-6])\n",
    "print(s[1:3],s[1:],s[:3],s[:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "인덱싱과 슬라이싱을 스트링 뿐 아니라 리스트에서도 사용할 수 있다는 점을 알았다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "100 300 300 100\n",
      "[200] [200, 300] [100, 200] [100, 200, 300]\n"
     ]
    }
   ],
   "source": [
    "n=[100,200,300]\n",
    "print(type(n))\n",
    "print(n[0],n[2],n[-1],n[-3])\n",
    "print(n[1:2],n[1:],n[:2],n[:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "여담으로, 어떠한 변수에 대해 그것의 종류를 판별할 때 명령어로 print(type(a))와 type(a) 두가지를 활용할 수 있다. 아래의 결과와 위에 인덱싱, 슬라이싱을 연습한 데서 볼 수 있듯, print(type(a))를 활용했을 때만 그 변수의 class도 판별할 수 있고 다른 작업도 처리할 수 있다. type만 했을때는 a라는 함수에 대해 class를 나타내주지 않는다.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[100]\n"
     ]
    }
   ],
   "source": [
    "a=[1,2,3]\n",
    "type(a)\n",
    "print(n[0:1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "s스트링의 길이를 나타내보았다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "스트링에서의 덧셈과 곱셈을 해보았다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'bdefefefefefefefefefef'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1]+s[3]+s[4:]*10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "뺄셈을 시도하였지만 type에러가 발생하였다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for -: 'str' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-45-21a008748d42>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ms\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0ms\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'str' and 'str'"
     ]
    }
   ],
   "source": [
    "s[4]-s[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "위와는 달리 abcde - de 의 형태로 뺄셈을 해보았다. abc가 결과값으로 나오지 않을까 해보았지만 역시 type에러가 발생하였다. 단일 스트링 내에서는 뺄셈은 성립하지 않는 듯하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for -: 'str' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-49-9dc04282cebc>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ms\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0ms\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for -: 'str' and 'str'"
     ]
    }
   ],
   "source": [
    "s[0:5]-s[3:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "s스트링의 문자들을 대문자로 치환하였다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ABCDEF'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "당연히 대문자를 소문자로 치환하는 것도 가능하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcdef'"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "질문1) 스트링 내의 문자를 일부분만 대/소문자로 치환하는 기능은 없습니까? \n",
    "replace 기능을 이용하는 방법 이외에는 현재까진 아는 바가 없습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a2cdef'"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.replace('a','A')\n",
    "s.replace('b','2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' this is a house built this year.\\n'"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s=' this is a house built this year.\\n'\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "스트링에서 특정 단어의 위치를 알려주는 함수이다. 위치라기보다는 찾으려는 단어가 몇번째 인덱스부터 시작하는지를 알 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result=s.find('house')\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.find('this')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.index('this')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "문자 위치를 알 수 있는 명령처리를 총 4회 각각 다르게 처리해 보았는데 모두 같은 결과를 얻었다. index함수와 find함수가 어떻게 다른지, result를 사용할 때와 안 할때는 어떻게 다른지 찾아볼 필요가 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result=s.index('this')\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result=s.rindex('this')\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.rindex('this')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.rfind('this')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "스트링 내에 같은 단어가 반복될 때 뒷 단어의 인덱스를 알고 싶을때\n",
    "사용한다. 마찬가지로 네 가지 경우를 모두 시도해 보았는데 결과는\n",
    "같았다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result=s.rfind('this')\n",
    "result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "strip은 공백을 지우는 함수이다. rstrip을 하면 오른편 공백이, lstrip을 하면 왼편, 그냥 strip을 하면 양면 공백이 사라진다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is a house built this year.'"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s=s.strip()\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "split함수는 문자를 나누는 기능이 있다. 이 때 나눠진 문자들이 하나의 리스트로 나타난다는 점이 흥미롭다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['this', 'is', 'a', 'house', 'built', 'this', 'year.']"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokens=s.split(' ')\n",
    "tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is a house built this year.'"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s=' '.join(tokens)\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['this', 'is', 'a', 'house', 'built', 'this', 'year.']"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokens=s.split(' ')\n",
    "tokens"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "token을 활용하여 스트링을 다시 복구하는 방법과, 아래와 같이\n",
    "join 함수를 직접 이용하는 방식 두가지를 모두 해보았다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is a house built this year.'"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.join(' ')\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is a house built this year.'"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "위에서 대,소문자를 바꿀때 활용한 기억이 있는 replace함수를 이용하여 this 라는 문자를 that으로 치환하였다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'that is a house built that year.'"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s=s.replace('this','that')\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}