{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 문자열 분리하기 \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['에스프레소', '아케리카노', '카페라테']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"에스프레소,아케리카노,카페라테\".split(\",\")   # 콤마로 구분된 문자열이 있을 때, split(\",\")하면 콤마를 기준으로 단어 분리"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['에스프레소', '아메리카노', '카페라테']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"에스프레소 아메리카노 카페라테\".split(\" \")  # 공백으로 구분된 문자열은 공백 구분자를 인자로 갖는 split(\" \")으로 분리"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['에스프레소', '아메리카노', '카페라테']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"에스프레소 아메리카노 카페라테\".split()    # 공백 구분자를 인자로 갖는 split(\" \")사용할 때, 인자없이도 사용가능"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['에스프레소', '아메리카노', '카페라테', '카푸치노']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"   에스프레소  \\n\\n  아메리카노  \\n  카페라테   카푸치노 \\n\\n\".split() # 문자열에 인자없이 split()하면 모든 공백과 개행문자를 없앰"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 maxsplit "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " 원하는 횟수만큼 문자열 분리"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['에스프레소', '아메리카노', '카페라테 카푸치노']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"에스프레소 아메리카노 카페라테 카푸치노\".split(maxsplit=2)     # 앞에서부터 2개의 공백까지만 문자열을 나눠 3개 항목의 리스트 됨"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 활용"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 국가번호 뺀 나머지번호 구하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['+82', '01-2345-6789']\n",
      "국내전화번호: 01-2345-6789\n"
     ]
    }
   ],
   "source": [
    "phone_number=\"+82-01-2345-6789\"        # 국가번호가 포함된 번호\n",
    "split_num= phone_number.split(\"-\",1)   # 국가번호와 나머지번호 분리\n",
    "\n",
    "print(split_num)\n",
    "print(\"국내전화번호: {0}\".format(split_num[1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 필요없는 문자열 삭제하기\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 strip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"aaaaPythonaaa\".strip('a')    # 앞뒤의 모든 'a' 제거"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_str = \"aaabbPythonbbbaa\"   # 지우고자 하는 문자가 둘이면 strip을 두번 사용하면 됨\n",
    "temp1 = test_str.strip('a')     # 문자열 앞뒤의 모든 'a' 제거\n",
    "temp1\n",
    "temp1.strip('b')                # 문자열 앞뒤의 모든 'b' 제거"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_str.strip('ab')        # 문자열 앞뒤의 'a'와 'b' 동시에 제거(순서 상관없음)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"  Python   \".strip(' ')    # 문자열 앞뒤의 공백 제거"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\\n  Python  \\n\\n\".strip(' \\n')   # 문자열 앞뒤의 공백과 개행문자 제거"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\\n  Python  \\n\\n\".strip()        # 문자열 앞뒤의 공백과 개행문자 제거시 strip() 빈 인자로도 가능"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 다른 문자를 만날 때까지만 지정한 문자 삭제됨"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ball'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"aaaBallaaa\".strip('a')   # ball의 'a'는 삭제되지 않음"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is very \\n fast.'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\\n This is very \\n fast. \\n\\n\".strip()  # 문자열 중간에 있는 공백과 개행문자는 삭제되지 않음"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 위의 경우 lstrip, rstrip 사용"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python is easy to learn.\n",
      "Python is easy to learn.000\n",
      "000Python is easy to learn.\n"
     ]
    }
   ],
   "source": [
    "str_lr = \"000Python is easy to learn.000\"\n",
    "print(str_lr.strip('0'))\n",
    "print(str_lr.lstrip('0'))\n",
    "print(str_lr.rstrip('0'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['  에스프레소', ' 아메리카노', '    카페라테   ', ' 카푸치노  ']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "coffee_menu = \"  에스프레소, 아메리카노,    카페라테   , 카푸치노  \"   \n",
    "coffee_menu_list = coffee_menu.split(',')   # split(',')사용해 문자열을 리스트로 분리\n",
    "coffee_menu_list     # 공백을 포함한 문자열의 리스트가 나옴"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['에스프레소', '아메리카노', '카페라테', '카푸치노']\n"
     ]
    }
   ],
   "source": [
    "coffee_list = []                  # 빈 리스트 생성\n",
    "for coffee in coffee_menu_list:\n",
    "    temp = coffee.strip()         # 문자열의 공백 제거\n",
    "    coffee_list.append(temp)      # 리스트 변수에 공백이 제거된 문자열 추가\n",
    "    \n",
    "print(coffee_list)                # 최종 문자열 리스트 출력"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 문자열 연결하기 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 +"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 문자열과 문자열을 연결"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "철수님, 주소와 전화 번호를 입력해 주세요.\n",
      "영미님, 주소와 전화 번호를 입력해 주세요.\n"
     ]
    }
   ],
   "source": [
    "name1 = \"철수\"\n",
    "name2 = \"영미\"\n",
    "\n",
    "hello = \"님, 주소와 전화 번호를 입력해 주세요.\"\n",
    "print(name1 + hello)     \n",
    "print(name2 + hello)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 join"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 리스트의 모든 항목을 하나의 문자열로 만들기 위해 사용"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['서울시', '서초구', '반포대로', '201(반포동)']"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "address_list = [\"서울시\",\"서초구\",\"반포대로\",\"201(반포동)\"]    # 문자열을 항목으로 갖는 리스트 생성\n",
    "address_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'서울시 서초구 반포대로 201(반포동)'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \" \"                # address_list 리스트를 공백으로 연결해 문자열을 생성\n",
    "a.join(address_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'서울시 서초구 반포대로 201(반포동)'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\" \".join(address_list) # 구분자 문자열을 변수에 할당하지 않고도 가능"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'서울시*^-^*서초구*^-^*반포대로*^-^*201(반포동)'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"*^-^*\".join(address_list)    # 구분자 문자열을 변수에 할당하지 않고도 가능"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 문자열 찾기 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 find"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 특정 문자열을 찾아서 맨 처음 발견된 위치를 반환\n",
    "- 찾는 문자열이 없으면 -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "찾는 문자열의 위치: 0\n",
      "찾는 문자열의 위치: 7\n",
      "찾는 문자열의 위치: 5\n",
      "찾는 문자열의 위치: -1\n"
     ]
    }
   ],
   "source": [
    "str_f = \"Python code.\"       \n",
    "print(\"찾는 문자열의 위치:\", str_f.find(\"Python\"))\n",
    "print(\"찾는 문자열의 위치:\", str_f.find(\"code\"))\n",
    "print(\"찾는 문자열의 위치:\", str_f.find(\"n\"))\n",
    "print(\"찾는 문자열의 위치:\", str_f.find(\"easy\")) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "-1\n"
     ]
    }
   ],
   "source": [
    "str_f_se = \"Python is powerful. Python is easy to learn.\"\n",
    "\n",
    "print(str_f_se.find(\"Python\", 10, 30))  # 시작 위치(start)와 끝 위치(end) 지정\n",
    "print(str_f_se.find(\"Python\", 35))      # 찾기 위한 시작 위치(start) 지정"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 문자열에서 찾고자 하는 문자열과 일치하는 횟수를 반환\n",
    "- 없으면 0을 반환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python의 개수는?: 3\n",
      "powerful의 개수는?: 1\n",
      "IPython의 개수는?: 0\n"
     ]
    }
   ],
   "source": [
    "str_c = \"Python is powerful. Python is easy to learn. Python is open.\"\n",
    "\n",
    "print(\"Python의 개수는?:\", str_c.count(\"Python\"))\n",
    "print(\"powerful의 개수는?:\", str_c.count(\"powerful\"))\n",
    "print(\"IPython의 개수는?:\", str_c.count(\"IPython\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 startwith, endwith"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 각각 문자열이 지정된 문자열로 시작하는지, 끝나는지 검사"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python으로 시작?: True\n",
      "is로 시작?: False\n",
      ".로 끝?: True\n",
      "learn으로 끝?: False\n"
     ]
    }
   ],
   "source": [
    "str_se=\"Python is powerful. Python is easy to learn.\"\n",
    "\n",
    "print(\"Python으로 시작?:\", str_se.startswith(\"Python\"))\n",
    "print(\"is로 시작?:\", str_se.startswith(\"is\"))\n",
    "print(\".로 끝?:\", str_se.endswith(\".\"))\n",
    "print(\"learn으로 끝?:\", str_se.endswith(\"learn\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. 문자열 바꾸고 제거하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- replace(old, new, count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1 문자열 바꾸기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IPython is fast. IPython is friendly. IPython is open.\n",
      "IPython is fast. IPython is friendly. Python is open.\n"
     ]
    }
   ],
   "source": [
    "str_a = 'Python is fast. Python is friendly. Python is open.'   \n",
    "print(str_a.replace('Python', 'IPython'))      \n",
    "print(str_a.replace('Python', 'IPython', 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2 문자열 제거하기 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Python] [is] [fast]\n",
      "Python] is] fast]\n",
      "Python is fast\n"
     ]
    }
   ],
   "source": [
    "str_b = '[Python] [is] [fast]'     # 2개 모두 제거하려면 replace 두번 사용\n",
    "str_b1 = str_b.replace('[', '')    # 문자열에서 '['를 제거\n",
    "str_b2 = str_b1.replace(']', '')   # 결과 문자열에서 다시 ']'를 제거\n",
    "      \n",
    "print(str_b)\n",
    "print(str_b1)\n",
    "print(str_b2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. 문자열의 구성 확인하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 문자열이 숫자, 특수문자, 공백이 아닌 문자로 구성되어있는지 검사"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print('Python'.isalpha())   # 문자열에 공백, 특수 문자, 숫자가 없음\n",
    "print('Ver. 3.x'.isalpha()) # 공백, 특수 문자, 숫자 중 하나가 있음"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 모든 문자가 숫자로 구성되어있는지 검사"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print('12345'.isdigit())   # 문자열이 모두 숫자로 구성됨\n",
    "print('12345abc'.isdigit())# 문자열이 숫자로만 구성되지 않음"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 문자열이 특수문자나 공백이 아닌 문자와 숫자로 구성되어있는지 검사"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print('abc1234'.isalnum())    # 특수 문자나 공백이 아닌 문자와 숫자로 구성됨\n",
    "print('   abc1234'.isalnum()) # 문자열에 공백이 있음"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 문자열이 공백문자로만 구성되어있는지 검사"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print('   '.isspace()) # 문자열이 공백으로만 구성됨\n",
    "print(' 1 '.isspace()) # 문자열에 공백 외에 다른 문자가 있음"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 문자열이 모두 대문자, 소문자로 구성되었는지 검사"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print('PYTHON'.isupper()) # 문자열이 모두 대문자로 구성됨\n",
    "print('Python'.isupper()) # 문자열에 대문자와 소문자가 있음\n",
    "print('python'.islower()) # 문자열이 모두 소문자로 구성됨\n",
    "print('Python'.islower()) # 문자열에 대문자와 소문자가 있음"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. 대소문자로 변경하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python is powerful. python is easy to learn.\n",
      "PYTHON IS POWERFUL. PYTHON IS EASY TO LEARN.\n"
     ]
    }
   ],
   "source": [
    "string1 =  'Python is powerful. PYTHON IS EASY TO LEARN.'   \n",
    "print(string1.lower())\n",
    "print(string1.upper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Python' == 'python'    # 같은 글자지만 대소문자 차이가 있어 다른글자로 인식"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}