Part 1. Python Tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1장. 시작"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 프로그램(program)\n",
    "* 프로그램이란 컴퓨터에게 내리는 명령어들의 집합이다.\n",
    "* 프로그램은 프로그래밍 언어로 작성된다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 개발 환경 구축"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. 통합 개발 환경(Integrated Development Environment, IDE)\n",
    "* 코딩, 디버깅, 컴파일, 배포 등  프로그램 개발에 관련된 모든 작업을 하나의 프로그램 안에서 처리하는 환경을 제공하는 소프트웨어\n",
    "    * IDEL (Python 3.x 32 bit) \n",
    "    * Pycharm\n",
    "    * Spyder\n",
    "    * Jupyter Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    \n",
    "### 2. 아나콘다(Anaconda) 설치\n",
    "* Python을 수학, 과학 분야에서 활용하기 편하도록 각종 라이브러리와 개발환경을 설치해주는 소프트웨어.\n",
    "* 꼭 설치해야하는 것은 아니지만 설치해두면 편하다! (순정 vs. 튜닝)\n",
    "* 설치 URL: https://www.anaconda.com/distribution/#download-section"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Spyder 기본 사용법\n",
    "* 과학 분야에 최적화된 개발 환경이지만 한 줄 코드 실행이 편리해서 사용.\n",
    "* 스크립트(Script): 실제로 코드를 짜는 부분\n",
    "* 콘솔(Console): 코드의 실행결과가 나타나는 부분\n",
    "* 변수 탐색기(Variable Explorer): 내가 정의한 변수의 목록과 값을 확인할 수 있는 창.\n",
    "* 실행과 디버깅 \n",
    "* 단축키 설정"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Python 기본"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. 계산"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 간단한 계산\n",
    "print(2+3)\n",
    "print(2-3)\n",
    "print(2*3)\n",
    "print(2/3)\n",
    "\n",
    "# 복잡한 계산\n",
    "print(12345*12345)\n",
    "\n",
    "# 매우 복잡한 계산\n",
    "print(123456789 * 987654321)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. 문자열 출력"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 문자열 접합\n",
    "print(\"멋있는 \"+\"사나이\")\n",
    "\n",
    "# 문자열 반복\n",
    "print(\"멋있는 \"*20)\n",
    "\n",
    "# 문자열과 숫자\n",
    "print(\"100\" + \"200\")\n",
    "print(100 + 200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. 문법 오류와 실행시 오류"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 문법 오류\n",
    "pront(\"Hello World!\")\n",
    "print(Hello World)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행시 오류\n",
    "print(\"안녕하세요? 파이썬에 오신 것을 환영합니다.\")\n",
    "print(\"프로그래밍 공부를 즐기셨으면 합니다.\")\n",
    "print(\"안녕!\" + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 주석(Comment)\n",
    "* 주석은 소스코드에 붙이는 설명글과 같은 글로서 프로그램의 실행 결과에는 영향을 미치지 않는다. \n",
    "* Python은 '#'으로 시작하는 부분부터 끝까지 주석으로 취급. (e.g. # Add two numbers.)\n",
    "* 여러줄의 텍스트를 주석으로 삼고 싶을 때에는 큰 따옴표 세개를 활용 (\"\"\" \"\"\")\n",
    "* 주석은 자기 자신과 동료 개발자들이 프로그램을 이해하는데 있어서 매우 중요하기 때문에 상세하게 다는 것이 좋다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2장. 변수(variable)\n",
    "\n",
    "## 1. 변수의 할당(assignment)\n",
    "* 프로그램이 데이터를 기억하는 방식\n",
    "* 컴퓨터의 메모리의 공간에 이름을 붙이는 것으로 음식 재료를 사다가 그릇안에 담아 놓은 것과 유사\n",
    "* 엑셀의 \"이름정의\"와 유사\n",
    "* 바뀔 수 없는 리터럴(literal)과 달리 바뀔 수 있기(variable) 때문에 변수만 새롭게 정의하면 해당 변수가 사용된 모든 곳에 변화가 적용된다. \n",
    "* Python은 변수의 선언(declaration)과 할당(assignment)를 동시에 할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* input() 함수를 이용하면 사용자로부터 변수를 입력받을 수도 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = input(\"당신의 이름은 무엇입니까?: \")\n",
    "print(\"만나서 반갑습니다!\", name+\"님\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 변수의 명명(naming)\n",
    "* 변수의 명명은 프로그래머의 자유이나 서로 다른 변수들끼리 식별될 수 있도록 몇 가지 규칙을 따라야 한다.\n",
    "    * 변수의 이름은 영문자와 숫자, 밑줄 문자(_)로 이루어진다.\n",
    "    * 식별자의 중간에 공백이 들어가면 안된다.\n",
    "    * 식별자의 첫 글자는 반드시 영문자 또는 밑줄 문자(_)이어야 한다. 즉, 숫자로 시작할 수 없다. \n",
    "    * 대문자와 소문자는 구별된다. (case-sensitive)\n",
    "* 또한 미리 정의된 Python 키워드(keyword)는 변수명으로 사용될 수 없다. (e.g. True, False, for, while 등)\n",
    "* 변수의 이름은 해당 변수의 내용을 잘 설명하도록 지어야 한다. 변수의 이름이 잘 지어져야 읽기 쉬운 프로그램이 된다. \n",
    "* 중구난방으로 지어진 변수는 프로그램이 조금만 길어지거나 오랜만에 다시 보게 되면 고통을 선사한다. \n",
    "* 명명 규칙(Case Naming Convention)\n",
    "    * R: lowerCamelCase (e.g. myPython)\n",
    "    * Python: snake_case (e.g. my_python)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수 명명 예시\n",
    "my_variable = 10\n",
    "_my_variable = 20\n",
    "my_variable_ = 30"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 수학과 프로그래밍에서의 등호(=)의 차이\n",
    "* 수학에서의 \"a=b\"는 a와 b의 값이 같다는 것을 의미하지만, 프로그래밍에서는 a라는 이름의 변수에 b를 할당한다는 의미다. \n",
    "* Python에서는 두개의 등호가 등호의 의미를 갖는다.(a == b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 할당 예시 1\n",
    "a = 10 # 'a'라는 이름의 변수에 10이라는 숫자를 할당해라. \n",
    "b = a #  'b'라는 이름의 변수에 변수 a(현재는 10)를 할당해라.\n",
    "print(\"a:\", a, \"b:\", b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# 할당 예시 2\n",
    "count = 0\n",
    "count = count + 1\n",
    "print(\"count:\", count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3장.연산(operation)\n",
    "* 수식(expression)이란 피연산자(operand)들과 연산자(operator)들의 조합이다.\n",
    "* 피연산자는 연산의 대상이 되는 것을 의미한다. \n",
    "* 연산자는 어떤 연산을 나타내는 기호를 의미한다. \n",
    "* 컴퓨터는 인간을 위하여 복잡한 계산을 대신 해주지만, 우리가 올바른 수식을 알려주지 않는다면 그 계산 결과도 틀릴 것이다. \n",
    "* 올바른 수식을 작성하기 위해서는 연산자의 기능과 올바른 순서를 알고 있어야 한다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 사칙연산 연산자\n",
    "* 덧셈: +\n",
    "* 뺄셈: -\n",
    "* 곱셈: *\n",
    "* 나눗셈: /"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 사칙연산 연산자\n",
    "print(2+3)\n",
    "print(2-3)\n",
    "print(2*3)\n",
    "print(2/3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 나머지 연산자\n",
    "* 나눗셈(몫): //\n",
    "* 나눗셈(나머지): %"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 나눗셈의 몫과 나머지\n",
    "p = 10\n",
    "q = 3\n",
    "quotient = 10 // 3\n",
    "remainder = 10 % 3\n",
    "print(p,\"/\",q,\"의 몫은 \",quotient, \", 나머지는 \", remainder, \"입니다.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 지수 및 대입(할당) 연산자\n",
    "* 거듭제곱: **\n",
    "* 할당: ="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 거듭제곱\n",
    "print(2 ** 3)\n",
    "\n",
    "# 할당\n",
    "powered = 2 ** 3\n",
    "print(powered)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 복합 연산자\n",
    "* 복합 연산자는 대입연산자와 다른 연산자를 간결하게 합쳐놓은 것이다. 반복문에서 유용하게 쓰인다.\n",
    "* x += y: x = x + y\n",
    "* x -= y: x = x - y\n",
    "* x *= y: x = x * y\n",
    "* x /= y: x = x / y\n",
    "* x %= y: x = x % y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. 연산자의 우선순위\n",
    "* PEMDAS\n",
    "    * Parentheses (괄호)\n",
    "    * Exponents (지수)\n",
    "    * Muliplication/Division (곱셈, 나눗셈)\n",
    "    * Addition/Subtraction (덧셈, 뺄셈)\n",
    "* 잘 모르겠으면 소괄호 사용"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4장. 자료(data)\n",
    "## 1. 기본 자료형\n",
    "* Python의 기본 자료형에는 정수(integer), 실수(floating-poing), 문자열(string), 부울(bool)이 있다. \n",
    "\n",
    "## 2. 문자열(string)\n",
    "### 1. 문자열과 따옴표\n",
    "* 문자열은 문자들의 나열이다.\n",
    "* Python에서는 텍스트를 큰따옴표(\" \")나 작은 따옴표(' ')로 감싸면 무조건 문자열이 된다. \n",
    "* 같은 종류의 따옴표로 열리고 닫히지 않는 '따옴표의 불일치'는 오류를 불러온다. (e.g. \" ', \" )\n",
    "* 큰따옴표가 안은 텍스트 내에서 작은 따옴표를 사용하여 텍스트의 일부처럼 처리할 수 있다. (e.g. \"나는 '전설'이다.\")\n",
    "* 큰따옴표가 안은 텍스트 내에 큰 따옴표가 또 사용되어야 하는 상황(e.g. WEX 쿼리)이라면 큰따옴표 3개를 활용 (e.g. \"\"\".../\"USA\")) AND ...\"\"\" )\n",
    "* 같은 숫자라도 자료형이 다를 수 있다. (e.g. 100은 정수이지만 \"100\" 또는 '100'은 문자열이다.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 문자열 만들기\n",
    "print(\"Python\")\n",
    "print('Python')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 따옴표의 불일치\n",
    "print(\"Python')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 따옴표의 혼용\n",
    "print(\"제 이름은 '홍길동'입니다.\")\n",
    "print(\"\"\"제 이름은 \"홍길동\"입니다.\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " * type() 함수는 자료의 유형을 반환한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 문자열과 숫자\n",
    "print(type(\"100\"))\n",
    "print(type(100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 문자열과 숫자의 계산\n",
    "100 + \"100\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. 자료형 변환\n",
    "* int(): 자료형을 정수로 변환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실수를 정수로 변환\n",
    "print(int(3.2))\n",
    "\n",
    "# 문자열을 정수로 변환\n",
    "print(int(\"100\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* float(): 자료형을 실수로 변환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정수를 실수로 변환\n",
    "print(float(3))\n",
    "\n",
    "# 문자열을 실수로 변환\n",
    "print(float(\"3.2\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* str(): 자료형을 문자열로 변환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# 숫자를 문자열로 변환\n",
    "print(str(100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* bool(): 자료형을 부울로 변환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 숫자를 부울로 변환\n",
    "print(bool(0))\n",
    "print(bool(1))\n",
    "\n",
    "# 문자열을 부울로 변환\n",
    "print(bool(\"True\"))\n",
    "print(bool(\"False\"))\n",
    "print(bool(\"\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. 문자열 조작\n",
    "* 문자열 접합(string concatenation)\n",
    "    * 접합이란 문자와 문자를 붙이는 것으로서 엑셀의 CONCATENATE 함수나 \"&\" 연산자를 생각하면 된다. \n",
    "    * 더하기 연산자(+)는 정수와 실수에 대해서는 덧셈(addition)을 실시하지만, 문자열에 대해서는 접합(concatenation)을 실시한다. \n",
    "    * 숫자와 문자열을 접합할 수는 없기 때문에 숫자를 str() 함수를 이용하여 문자열로 만들어 준 다음 접합해야한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# 문자열 접합\n",
    "print(\"제 나이는 \"+25+\"살입니다.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 문자열 접합\n",
    "print(\"제 나이는 \"+str(25)+\"살입니다.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 문자열 반복\n",
    "    * 반복이란 동일한 문자열을 반복시켜서 새로운 문자열을 생성하는 것이다. \n",
    "    * 접합과 달리 문자열의 반복은 곱하기 연산자(*)를 이용한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 문자열 삽입\n",
    "    * 문자열에 변수의 값을 삽입하고 싶은 경우 %s(숫자형 변수의 경우 %d)를 활용한다. (e.g. \"제 나이는 %s살입니다.\" % age)\n",
    "    * 신버전에서는 {}를 사용 (e.g. \"제 나이는 {}살입니다.\".format(age))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 문자열 삽입\n",
    "greeting = \"안녕하세요?\"\n",
    "address = \"서울 강남구\"\n",
    "age = 25\n",
    "name = \"홍길동\"\n",
    "\n",
    "print(\"%s, 저는 %s에 사는 %d살 %s입니다.\" % (greeting, address, age, name))\n",
    "print(\"{}, 저는 {}에 사는 {}살 {}입니다.\".format(greeting, address, age, name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    \n",
    "* 문자열 추출\n",
    "    * 문자열 내의 문자들은 0부터 시작하는 번호가 매겨져 있는데, 이 번호를 인덱스(index)라고 한다. \n",
    "    * 특정 인덱스를 기준으로 문자열에서 개별 문자를 추출할 수 있다. 이러한 방식을 슬라이싱(slicing)이라고 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 문자열 슬라이싱\n",
    "my_string = \"Python is the best!\"\n",
    "print(my_string[0:6])\n",
    "print(my_string[7:10])\n",
    "print(my_string[-5:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. 특수 문자열\n",
    "* 문자열에서 역슬래시(\\)는 특별한 역할을 하는데 대표적인 것은 다음과 같다:\n",
    "    * \\n: 줄 바꿈 문자\n",
    "    * \\t: 탭 문자\n",
    "    * \\\\: 역슬래시 자체\n",
    "    * \\\": 큰따옴표 자체\n",
    "    * \\': 작은 따옴표 자체"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 특수 문자열\n",
    "print('Hello Grant,\\nI hope all is well.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 특수 문자열\n",
    "print('Hello Grant,\\nI hope all is well. How's it going?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 특수 문자열\n",
    "print('Hello Grant,\\nI hope all is well. How\\'s it going, dude?')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 리스트(list)\n",
    "### 1. 번호가 매겨진 자료들의 묶음\n",
    "* 지금까지는 하나의 변수에 숫자나 문자열을 저장하는 방법에 대해 알아보았다.\n",
    "* 프로그래밍을 하다보면 여러 가지 종류의 데이터를 하나로 묶어줘야할 경우가 생긴다.\n",
    "* 리스트는 Python에서 자료들을 묶는 유용한 방법 중 하나로서, 대괄호([,]) 안에 쉼표(,)로 구분된 자료들의 나열로 표현된다.\n",
    "* 리스트 안에 저장된 각 자료들을 항목(item)이라고 하며, 각 항목에는 인덱스(index)라고 하는 번호들이 매겨져 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. 리스트의 생성\n",
    "* 리스트를 생성하는 방법은 변수를 생성하는 방법과 같다.\n",
    "* 원하는 변수명에 대괄호로 묶인 자료들을 할당해주면 된다. e.g. brands = [\"SS\", \"lG\", \"BS\", \"ML\", \"SM\"], ratings = [5, 4, 3, 2, 1]\n",
    "* Python의 리스트는 어떠한 유형의 데이터도 저장할 수 있으며, 한 리스트 안에 서로 다른 자료형이 함께 저장될 수 있다.\n",
    "* 새로운 리스트를 생성하기 위해서는 변수명에 빈 대괄호([])를 할당해주면 된다. e.g. new_list = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. 리스트 항목의 추출과 슬라이싱\n",
    "#### 1. 리스트 항목 추출하기\n",
    "* 리스트의 항목에 추출할 때는 항목의 인덱스를 이용한다. \n",
    "* 해당 리스트의 이름 옆에 대괄호를 붙여주고 그 안에 원하는 항목의 인덱스를 입력하면 된다.\n",
    "* Python의 인덱스 번호는 0부터 시작한다.  \n",
    "cf) R의 인덱스는 1부터 시작."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# 인덱스를 이용한 리스트 항목 추출\n",
    "products = [\"냉장고\", \"세탁기\", \"건조기\"]\n",
    "print(products[0])\n",
    "print(products[1])\n",
    "print(products[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. 슬라이싱\n",
    "* 슬라이싱은 리스트의 여러개의 항목에 동시에 추출하는 방법이다. \n",
    "* 해당 리스트의 이름 옆에 대괄호를 붙여주고 그 안에 \"시작인덱스:끝인덱스+1\"의 형태로 원하는 항목의 인덱스 범위를 지정한다.\n",
    "* 슬라이싱을 하면 원본 리스트를 복사하여 슬라이싱된 새로운 리스트를 생성한다. 즉, 슬라이싱을 한다고 하더라도 원본 리스트에는 영향을 주지 않는다.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# 슬라이싱\n",
    "print(products[0:3])\n",
    "print(products[0:2])\n",
    "print(products[1:3])\n",
    "print(products[:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. 리스트 다루기\n",
    "* 리스트의 항목을 조작할 때 메서드(method)라는 개념이 필요한데, 메서드는 점 표기법(dot notation)으로 표현되며 하나의 객체(object)에 속하는 함수이다. \n",
    "* 이 단계에서는 변수 뒤에 점을 찍은 다음에 딸려오는 '특정한 기능을 수행하는' 함수 정도로 이해. \n",
    "\n",
    "#### 1. 리스트 항목의 추가\n",
    "* 리스트에 항목을 추가할 때는 append() 메서드를 사용한다. \n",
    "* 해당 리스트의 이름 옆에 '.append()'를 붙여주고 괄호 안에 추가하고자 하는 항목을 입력한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 리스트 항목 추가\n",
    "restaurants = [\"두부마을\", \"대독장\", \"봄날\"]\n",
    "print(restaurants)\n",
    "restaurants.append(\"행복한 초밥\")\n",
    "print(restaurants)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. 리스트 항목의 변경"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 리스트는 가변객체(mutable object)이므로 항목의 값을 변경할 수 있다.\n",
    "* 리스트의 항목을 변경할 때는 해당 인덱스에 새로운 값을 할당해주면 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# 리스트 항목 변경\n",
    "restaurants[0] = \"가조쿠\"\n",
    "print(restaurants)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. 리스트 항목의 삽입\n",
    "* 리스트에 항목을 삽입할 때는 insert() 메서드를 사용한다. \n",
    "* 해당 리스트의 이름 옆에 '.insert()'를 붙여주고 괄호 안에 추가하고자 하는 인덱스와 항목을 쉼표로 연결하여 입력한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 리스트 항목 삽입\n",
    "restaurants.insert(0, \"이도곰탕\")\n",
    "print(restaurants)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4. 리스트 항목의 삭제"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 리스트의 항목을 삭제할 때는 remove() 메서드를 사용한다. \n",
    "* 해당 리스트의 이름 옆에 '.remove()'를 붙여주고 괄호 안에 삭제하고자 하는 항목을 입력한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 리스트 항목 제거\n",
    "restaurants.remove(\"이도곰탕\")\n",
    "print(restaurants)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 리스트의 모든 항목을 삭제할 때는 clear() 메소드를 이용한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 리스트 항목 비우기\n",
    "restaurants.clear()\n",
    "print(restaurants)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. 리스트의 탐색"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* index() 메서드를 활용하면 특정 항목의 인덱스를 반환할 수 있다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# 항목의 인덱스 반환\n",
    "print(products.index(\"냉장고\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 예악어(reserved words) 'in'을 사용하면, 리스트에 특정 항목이 존재하는지 논리값으로 반환된다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 리스트 내 항목 탐색\n",
    "print(\"세탁기\" in products)\n",
    "print(\"제습기\" in products)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 리스트 내의 모든 항목을 추출하고 싶다면 for 반복문을 이용하면 된다. 자세한 내용은 이후 반복문 챕터에서 다룬다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 리스트 내의 모든 항목 추출\n",
    "for item in products:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. 리스트의 정렬\n",
    "* 리스트의 항목을 정렬할 때는 sort() 메서드 또는 sorted() 함수를 사용한다. \n",
    "* sort()는 원본 리스트를 정렬하고, sorted()는 원본리스트를 복사한뒤 복사본을 정렬한다.\n",
    "* sort()와 sorted() 모두 기본값은 오름차순이지만, 'reverse' 옵션을 사용하면 내림차순으로 정렬할 수도 있다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. Sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 리스트 정의\n",
    "brands = [\"Samsung\", \"LG\", \"Bosch\", \"Miele\", \"Siemens\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 오름차순(기본값)\n",
    "brands.sort()\n",
    "print(brands)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 내림차순\n",
    "brands.sort(reverse=True)\n",
    "print(brands)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Sorted()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 리스트 정의\n",
    "brands = [\"Samsung\", \"LG\", \"Bosch\", \"Miele\", \"Siemens\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 오름차순(기본값)\n",
    "brands_aes = sorted(brands)\n",
    "print(\"brands_aes: \", brands_aes)\n",
    "print(\"brands: \", brands)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 내림차순\n",
    "brands_des = sorted(brands, reverse=True)\n",
    "print(\"brands_aes: \", brands_des)\n",
    "print(\"brands: \", brands)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. 리스트 내포(list comprehension)\n",
    "* 리스트 내포는 리스트를 생성하는 편리한 방법으로서 리스트 내에서 for문과 if절을 사용할 수 있다. |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 2, 4]\n"
     ]
    }
   ],
   "source": [
    "# 리스트 내포 예시\n",
    "list_comprehension = [v for v in range(5) if v % 2 == 0]; print(list_comprehension)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 딕셔너리(dictionary)\n",
    "### 1. 이름이 매겨진 자료들의 묶음\n",
    "* 리스트와 마찬가지로 딕셔너리도 값을 묶어서 저장하는 방법이다.\n",
    "* 딕셔너리는 중괄호({,}) 안에 쉼표(,)로 구분된 키(key)와 값(value)의 대응으로 표현된다 .\n",
    "* 리스트에 인덱스가 항목의 번호를 나타내는 것이었다면, 딕셔너리의 키는 값의 이름에 해당하는 것이다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. 딕셔너리의 생성\n",
    "* 딕셔너리를 생성하는 방법은 변수를 생성하는 방법과 같다.\n",
    "* 원하는 변수명에 중괄호로 묶인 자료들을 할당해주면 된다. \n",
    "* 새로운 딕셔너리를 생성하기 위해서는 변수명에 빈 중괄호({})를 할당해주면 된다. e.g. new_dict = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 딕셔너리 정의\n",
    "query_facets = {\n",
    "    \"regions\": [\"US\", \"UK\"],\n",
    "    \"category\": [\"refrigerator\", \"washer\", \"dryer\"],\n",
    "}\n",
    "print(query_facets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. 딕셔너리의 값의 추출\n",
    "#### 1. 딕셔너리에서 특정한 값의 추출\n",
    "* 딕셔너리에서 값을 찾을 때는 해당 딕셔너리의 이름 옆에 대괄호를 붙여주고 그 안에 원하는 값의 키를 입력한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# 키를 이용한 딕셔너리 값 추출\n",
    "query_facets[\"regions\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. 딕셔너리의 모든 항목 추출\n",
    "* 딕셔너리 내의 모든 키와 값을 추출하고 싶다면 for 반복문을 이용하면 된다. 자세한 내용은 이후 반복문 챕터에서 다룬다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 딕셔너리 모든 항목 추출\n",
    "for key in query_facets.keys():\n",
    "    print(key, query_facets[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. 딕셔너리의 탐색\n",
    "* 딕셔너리의 키와 값을 확인하기 위해서는 각각 keys()와 values() 메서드를 사용하면 된다. \n",
    "* item() 메서드를 사용하면 각각의 키와 값의 쌍으로 반환한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# 딕셔너리의 키, 값, 항목 반환\n",
    "print(query_facets.keys())\n",
    "print(query_facets.values())\n",
    "print(query_facets.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 리스트와 마찬가지로 키워드 'in'을 사용하면, 딕셔너리의 키나 값에 특정 항목이 존재하는지 논리값으로 반환된다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 딕셔너리 내 항목 탐색\n",
    "print(\"regions\" in query_facets)\n",
    "print(\"Korea\" in query_facets[\"regions\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. 딕셔너리 다루기\n",
    "#### 1. 딕셔너리 값 추가\n",
    "* 딕셔너리에 값을 추가할 때는 어떤 키에 값을 추가할지 알려줘야 한다. \n",
    "* 딕셔너리의 특정 키에 값을 추가할 때에는 해당 딕셔너리의 이름 옆에 대괄호를 붙여주고 그 안에 값을 추가할 키를 입력한 뒤 추가할 값을 할당한다.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# 딕셔너리 키에 값 추가\n",
    "query_facets[\"brands\"] = ['Samsung', 'LG', 'Bosch', 'Miele', 'Siemens']\n",
    "print(query_facets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. 딕셔너리 값 삭제\n",
    "* 딕셔너리에서 항목을 삭제할 때는 키워드 'del'을 사용한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 딕셔너리 키에서 값 제거\n",
    "del query_facets[\"brands\"]\n",
    "print(query_facets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 딕셔너리의 모든 항목을 삭제하려면 중괄호를 할당해주거나 clear() 메서드를 사용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 딕셔너리 비우기\n",
    "query_facets.clear()\n",
    "print(query_facets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. 딕셔너리 내포(dictionary comprehension)\n",
    "* 리스트 내포와 마찬가지로 딕셔너리 내포 역시 딕셔너리를 생성하는 편리한 방법이다.\n",
    "* 역시 딕셔너리 내에서 for문과 if절을 사용할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: '가', 1: '나', 2: '다', 3: '라', 4: '마'}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 딕셔너리 내포\n",
    "value = [\"가\", \"나\", \"다\", \"라\", \"마\"]\n",
    "dictionary_comprehension = {key: value[key] for key in range(5)}; dictionary_comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5장. 조건문(conditional statement)\n",
    "## 1. 선택 구조(selection)\n",
    "* 프로그래밍을 하다보면 조건에 따라 서로 다른 명령을 실행해야하는 경우가 있다.\n",
    "* 프로그래밍 언어에서 선택 구조를 실행할 수 있는 구문을 '조건문(conditional statement)'라고 한다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 관계 연산자와 논리 연산자\n",
    "### 1. 관계 연산자\n",
    "* 관계연산자는 두 개의 피연산자를 비교하는 데 사용되며, 그 결과는 참(True)과 거짓(False)으로 계산된다.\n",
    "* x == y: x와 y가 같은가?\n",
    "* x != y: x와 y가 다른가?\n",
    "* x > y: x가 y보다 큰가?\n",
    "* x < y: x가 y보다 작은가?\n",
    "* x >= y: x가 y보다 크거나 작은가?\n",
    "* x <= y: x가 y보다 작거나 같은가?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 관계 연산자\n",
    "print(1 == 1)\n",
    "print(1 != 1)\n",
    "print(1 > 1)\n",
    "print(1 < 1)\n",
    "print(1 >= 1)\n",
    "print(1 <= 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. 논리 연산자\n",
    "* 복잡한 조건은 관계연산자만으로 표현할 수 없기 때문에 논리연산자가 필요하다.\n",
    "* x and y: x와 y 모두 참일때만 참.\n",
    "* x or y: x와 y 둘 중에 하나만 참이여도 참.\n",
    "* not x: x가 참이면 거짓, 거짓이면 참."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 논리 연산자\n",
    "print(True and True)\n",
    "print(True and False)\n",
    "print(True or False)\n",
    "print(False or False)\n",
    "print(not (False or False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. if-else문\n",
    "* Python의 조건문에는 'if-else'문이 있다.\n",
    "* if-else문은 '만약 조건이 참이면 이것을 실행하고, 거짓이면 저것을 실행해라'라는 의미이다. \n",
    "* 조건문 뒤에는 콜론(:)이 따르며, 이는 Python에게 아직 전체 문장이 끝나지 않았으니 해석을 보류해달라는 의미이다. \n",
    "* 조건문 다음줄에는 해당 조건이 참일 경우에 실행되는 코드들(블록)이 오며, 블록은 반드시 들여쓰기(indentation)가 되어야한다. \n",
    "* 각 조건과 블록은 상호배타적으로 실행된다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. if와 else\n",
    "* 조건이 한 개밖에 없는 경우 키워드 'if'와 'else'만으로 조건문을 만들 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 합격/불합격 판별기\n",
    "score = int(input(\"성적을 입력하시오: \"))\n",
    "if score >= 60:\n",
    "    print(\"합격입니다.\")\n",
    "else:\n",
    "    print(\"불합격입니다.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 홀짝 구분기\n",
    "num = int(input(\"정수를 입력하시오: \"))\n",
    "if num % 2 == 0:\n",
    "    print(\"짝수입니다.\")\n",
    "else:\n",
    "    print(\"홀수입니다.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. elif\n",
    "* 조건이 두 개 이상인 경우 키워드 'elif'를 사용하여 조건을 추가할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정수 부호 판별기\n",
    "num = int(input(\"정수를 입력하시오: \"))\n",
    "\n",
    "if num > 0:\n",
    "    print(\"양수입니다.\")\n",
    "elif num == 0:\n",
    "    print(\"0입니다.\")\n",
    "else:\n",
    "    print(\"음수입니다\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. 중첩 if문(nested if statement)\n",
    "* if문 안에 다른 if문이 들어가는 것을 중첩 if문이라고 한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 중첩 if문\n",
    "num = int(input(\"정수를 입력하시오: \"))\n",
    "if num >= 0:\n",
    "    if num == 0:\n",
    "        print(\"0입니다.\")\n",
    "    else:\n",
    "        print(\"양수입니다.\")\n",
    "else:\n",
    "    print(\"음수입니다.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6장. 반복문(repetition statement)\n",
    "## 1. 반복의 중요성\n",
    "* 우리가 컴퓨터를 쓰는 이유는 인간의 수고를 덜기 위함이다. \n",
    "* 동일한 작업은 반복 구조를 이용하여 프로그래밍하는 것이 효율적이다. \n",
    "* 프로그래밍에서 반복적인 작업을 실행할 수 있도록 하는 구문을 '반복문(repetition statement)'라고 한다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 반복의 종류\n",
    "* Python에는 2가지 종류의 반복이 있다:\n",
    "    * 횟수 제어 반복(for문): 정해진 횟수만큼 반복.\n",
    "    * 조건 제어 반복(while문): 특정한 조건이 만족되면 계속 반복."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 횟수 제어 반복\n",
    "* 많은 프로그래밍 언어에서 for문을 이용하여 횟수 제어 반복을 제공하고 있다. \n",
    "* 반복 횟수를 알고 있을 때 사용한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# for문 예시 1\n",
    "numbers = [\"하나\", \"둘\", \"셋\", \"넷\", \"다섯\"]\n",
    "for number in numbers:\n",
    "    print(\"숫자 세기!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for문 예시 2\n",
    "for number in numbers:\n",
    "    print(number+\"!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* range()는 옵션에 따라 특정한 규칙대로 숫자들을 반환하는 함수이다. \n",
    "* range(시작값, 종료값+1, 증분값)의 형태로 사용하며, 기본값으로서 시작값은 0, 증분값은 1이다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# range() 함수 1\n",
    "print(range(5))\n",
    "print(list(range(5)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# range() 함수 2\n",
    "print(range(1, 6))\n",
    "print(list(range(1, 6)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# range() 함수 3\n",
    "print(range(0, 10, 2))\n",
    "print(list(range(0, 10, 2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# 리스트의 인덱스로서의 range() 함수\n",
    "for index in range(len(numbers)):\n",
    "    print(numbers[index])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 조건 제어 반복\n",
    "* Python에서는 조건 제어 반복을 위하여 while문을 제공하고 있다.  \n",
    "* 반복해야하는 조건을 알고 있을 때 사용한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "마녀: 거울아, 거울아, 세상에서 누가 제일 이쁘니? 저요\n",
      "마녀: 괜찮으니 솔직하게 말해보거라.백설공주입니다.\n",
      "마녀: 음 그래? (그렇다면 살려두어서는 안되겠군.)\n"
     ]
    }
   ],
   "source": [
    "# 예시(입력값 검증, input validation)\n",
    "정해진_답 = \"백설공주입니다.\"\n",
    "정해진_답 = input(\"마녀: 거울아, 거울아, 세상에서 누가 제일 이쁘니? \")\n",
    "while 정해진_답 != \"백설공주입니다.\":\n",
    "    정해진_답 = input(\"마녀: 괜찮으니 솔직하게 말해보거라.\")\n",
    "print(\"마녀: 음 그래? (그렇다면 살려두어서는 안되겠군.)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 반복 회수를 알고 있는 경우에도 카운터 변수(counter variable)을 이용하여 while문을 사용할 수 있다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 카운터 변수를 이용한 while문 예시\n",
    "count = 0\n",
    "while count <= 5:\n",
    "    print(count)\n",
    "    count = count + 1\n",
    "print(\"당신은\", count-1, \"까지 세었습니다.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. 무한루프(infinite loop)와 break\n",
    "* 무한루프는 무한히 반복되는 반복문이다. \n",
    "* 일부러 사용할 때도 있지만 프로그램이 끝나지 않기 때문에 컴퓨터 메모리에 큰 부담을 줄 수 있다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 무한루프 예시\n",
    "while 1+1 == 2:\n",
    "    print(\"1 더하기 1은 2다!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 키워드 break을 사용하면 무한루프에서 빠져나올 수 있다. 그러나 좋은 프로그래머들은 break을 가능하면 사용하지 않는다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "마녀: 거울아, 거울아, 세상에서 누가 제일 이쁘니?\n",
      "나: 저요\n",
      "마녀: 뭐? 저요?  괜찮으니 솔직하게 말해보거라.\n",
      "마녀: 거울아, 거울아, 세상에서 누가 제일 이쁘니?\n",
      "나: 백설공주입니다.\n",
      "마녀: 음 그래? (그렇다면 살려두어서는 안되겠군.)\n"
     ]
    }
   ],
   "source": [
    "# 키워드 break의 사용 예시\n",
    "while True:\n",
    "    정해진_답 = input(\"마녀: 거울아, 거울아, 세상에서 누가 제일 이쁘니?\\n나: \")\n",
    "    if 정해진_답 == \"백설공주입니다.\":\n",
    "        break\n",
    "    print(\"마녀: 뭐?\", 정해진_답+\"?\", \" 괜찮으니 솔직하게 말해보거라.\")\n",
    "print(\"마녀: 음 그래? (그렇다면 살려두어서는 안되겠군.)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7장. 함수(function)\n",
    "## 1. 추상화(abstraction)와 문제 분해(decomposition)\n",
    "* 프로그래밍은 문제의 해결과정이며, 추상화와 문제 분해는 효과적인 문제 해결 방법이다.  \n",
    "* 어떠한 것이 \"어떻게\"보다는 \"무엇을\"하는지에 초점을 맞추는 방법을 추상화라고 한다. \n",
    "* 큰 문제를 여러가지의 작은 문제로 쪼개어서 생각하는 것을 문제 분해라고 한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 함수의 정의\n",
    "* 함수는 일을 수행하는 코드의 덩어리로서, 큰 프로그램을 구축하기 위한 추상화와 문제 분해의 유용한 도구이다. \n",
    "* 함수는 입력을 받아서 정해진 규칙에 따라 출력을 내보내는 블랙박스로 생각할 수 있다. \n",
    "* 함수는 한 번 정의해놓으면 매번 똑같은 동작을 반복하기 때문에 편리하다. \n",
    "* 함수는 정의되더라도 호출되기 전까지는 실행되지 않는다.\n",
    "* 함수를 정의하는 방법\n",
    "    * 함수 정의는 키워드 'def'로 시작된다.\n",
    "    * 공백을 한 칸 띄우고 함수의 이름을 입력한다. 함수의 이름에는 공백이 들어갈 수 없다. \n",
    "    * 함수의 이름 바로 뒤에 소괄호를 입력하고, 인자(arguement)가 있으면 입력한다.\n",
    "    * 바로 뒤에 콜론(:)을 입력한 뒤, 다음 줄부터 함수 내용에 해당하는 블록을 입력한다. 블록은 반드시 들여쓰기가 되어야 한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 함수의 정의 예시\n",
    "def print_my_address():\n",
    "    print(\"홍길동: \", \"서울특별시 종로구\")\n",
    "    print(\"John Doe: \", \"Chapel Hill, North Carolina\")\n",
    "    \n",
    "# 함수의 호출 예시\n",
    "print_my_address()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 인수(arguement)와 매개변수(parameter)\n",
    "* 외부에서 함수에 전달하는 값을 인수라고 한다. 정의하기에 따라 함수는 인수를 갖지 않을 수도 있다. \n",
    "* 함수가 정의될 때 인수가 입력되는 변수를 매개변수라고 한다. \n",
    "* 인수는 두 개 이상이 될 수도 있다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# name, address는 매개변수에 해당한다. \n",
    "def print_my_address(name, address):\n",
    "    print(name, address)\n",
    "    \n",
    "# \"홍길동\", \"서울특별시 종로구\"는 인수에 해당한다. \n",
    "print_my_address(\"홍길동\", \"서울특별시 종로구\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 값의 반환\n",
    "* 함수가 유용한 이유는 값을 입력된 값에 일정한 규칙을 적용하여 출력값을 반환할 수 있기 때문이다. \n",
    "* 함수로부터 되돌아오는 값을 반환값이라고 하며, 키워드 'return'을 사용하면 된다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 값의 반환 예시 1\n",
    "def say_hello(name):\n",
    "    return \"Hello \" + str(name) + \"!\"\n",
    "\n",
    "greeting = say_hello(\"지성\")\n",
    "print(greeting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 값의 반환 예시 2\n",
    "def get_average(m, n):\n",
    "    return (m+n)/2\n",
    "\n",
    "avg = get_average(2, 4)\n",
    "print(avg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. 변수의 범위(scope of the variable)\n",
    "* 변수의 범위란 정의된 변수가 유효한 범위를 의미한다. \n",
    "* 변수를 정의했다고 하더라도 변수의 범위를 벗어나게 되면 Python은 변수가 정의되지 않았다고 간주한다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. 전역변수(global variable)\n",
    "* 프로그램 어디에서나 사용할 수 있는 변수를 전역변수라고 한다. \n",
    "\n",
    "### 2. 지역변수(local variable)\n",
    "* 함수 안에서 생성되는 변수를 지역변수라고 한다. 이 변수는 함수 내에서만 사용이 가능하다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 함수 정의\n",
    "def calculate_area(radius):\n",
    "    # result는 지역변수\n",
    "    result = 3.14 * radius**2\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# r은 전역변수\n",
    "r = 3\n",
    "area = calculate_area(r)\n",
    "\n",
    "# 지역변수인 result를 출력\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# r과 area는 전역변수\n",
    "r = 3\n",
    "area = calculate_area(r)\n",
    "\n",
    "# 전역변수인 area를 출력\n",
    "print(area)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 전역변수를 함수 내에서 새롭게 정의한다고 하더라도 함수가 끝나는 순간 새롭게 정의된 변수는 사용할 수 없게 된다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 함수 정의\n",
    "def calculate_area(radius):\n",
    "    # 함수 내에서 전역변수 area 재정의\n",
    "    area = 3.14 * radius**2\n",
    "    return "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 함수 밖에서 전역변수 정의\n",
    "area = 0\n",
    "r = 3\n",
    "calculate_area(r)\n",
    "\n",
    "# 함수 밖에서의 정의만 유효하다. \n",
    "print(area)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. 디폴트 인수(default arguement)와 키워드 인수(keyword arguement)\n",
    "### 1. 디폴트 인수\n",
    "* Python에서는 매개변수가 기본값을 가질 수 있는데, 이를 디폴트 인수라고 한다. \n",
    "* 디폴트 인수는 인수가 부족한 경우에 기본값을 넣어주기 때문에 편리하다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 디폴트 인수\n",
    "def greet(name, msg=\"잘 지내지요?\"):\n",
    "    print(name, msg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 모든 인수 전달\n",
    "greet(\"철수\", \"안녕\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 디폴트 인수 생략\n",
    "greet(\"철수\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. 키워드 인수\n",
    "* Python에서 대부분의 인수들은 함수 호출시의 위치에 의해서 구별된다. \n",
    "* 키워드 인수는 인수들 앞에 키워드를 두어서 명시적으로 이름을 지정한다. \n",
    "* 키워드 인수를 사용하는 것의 장점은 인수의 위치가 매개변수의 위치와 달라도 된다는 것이다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 키워드 인수\n",
    "def find_power(base, exponent):\n",
    "    return base ** exponent\n",
    "\n",
    "find_power(exponent=2, base=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 위치 인수와 키워드 인수가 섞일 수 있지만 위치 인수가 키워드 인수 앞에 나와야 한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 키워드 인수가 위치 인수의 앞에 오는 경우\n",
    "find_power(exponent=2, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 위치 인수가 키워드 인수 앞에 오는 경우\n",
    "find_power(10, exponent = 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. 람다(lambda) 함수\n",
    "* Python에서는 키워드 'def'를 이용해 함수를 정의한다.\n",
    "* 그러나 람다 함수를 이용하면 단 한 줄만으로 간편하게 함수를 정의할 수 있다. \n",
    "* 람다 함수의 형식은 다음과 같다.\n",
    "    * lambda 매개변수: 표현식\n",
    "    * 매개변수에 입력된 인자는 표현식에서 정해준 연산을 거쳐 값을 출력하게 되는 것이다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 람다 함수 예시\n",
    "lambda_function = lambda x: x ** 2; lambda_function(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8장. 예외처리(exception)\n",
    "* 아무리 잘 짠 프로그램이라도 오류(버그), 즉 \"예외적 상황\"은 필연적으로 일어난다. \n",
    "* 예외처리는 프로그램 실행 중 오류가 일어나더라도 프로그램을 중단시키지 않고 미리 정해둔 조치를 취할 수 있게 해주는 프로그래밍 언어의 배려이다.\n",
    "* Python에서는 try-except문을 통해 제공된다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. try-except문\n",
    "* try-except문의 기본 구성요소는 try절과 except절이다.\n",
    "* try절의 블록에서 오류가 발생되면 프로그램이 멈추지 않고 except절이 해당 오류를 받아 미리 정해진 명령을 수행하며 예외처리한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 예외처리가 없는 경우\n",
    "number = int(input(\"숫자를 입력하세요: \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "숫자를 입력하세요: 숫자?\n",
      "숫자가 아니잖아요.\n"
     ]
    }
   ],
   "source": [
    "# 예외처리\n",
    "try:\n",
    "    number = int(input(\"숫자를 입력하세요: \"))\n",
    "except ValueError:\n",
    "    print(\"그건 숫자가 아니잖아요.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 오류를 변수로 저장하는 것도 가능하다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "숫자를 입력하세요: 숫자?\n",
      "invalid literal for int() with base 10: '숫자?'\n"
     ]
    }
   ],
   "source": [
    "# 오류를 변수로 저장하기\n",
    "try:\n",
    "    number = int(input(\"숫자를 입력하세요: \"))\n",
    "except ValueError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 두 개 이상의 except절을 사용할 수도 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 두 개 이상의 except절\n",
    "try:\n",
    "    number = int(input(\"당신이 가진 10개의 초코 와플을 친구들에게 나눠주려고 합니다. 와플을 나누어줄 친구가 몇명인가요?: \"))\n",
    "    print(\"한 사람당\", 10/number, \"개의 와플을 먹을 수 있겠네요.\")\n",
    "except ValueError:\n",
    "    print(\"그건 숫자가 아니잖아요. \")\n",
    "except ZeroDivisionError:\n",
    "    print(\"10을 0으로 나눌 수는 없습니다.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "* 키워드 'except'만을 사용하면 모든 종류의 예외를 처리하도록 설정할 수도 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 모든 종류의 예외처리 설정\n",
    "try:\n",
    "    number = int(input(\"당신이 가진 10개의 초코 와플을 친구들에게 나눠주려고 합니다. 와플을 나누어줄 친구가 몇명인가요?: \"))\n",
    "    print(\"한 사람당\", 10/number, \"개의 와플을 먹을 수 있겠네요.\")\n",
    "except:\n",
    "    print(\"뭐가 문제인지는 모르겠는데 어쨌든 당신의 입력값에 문제가 있어요.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. else\n",
    "* else절을 사용하면 try절의 블록에서 예외가 발생하지 않은 경우 실행할 명령을 지정할 수 있다. 이 경우 except절은 실행되지 않는다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# else 절\n",
    "try:\n",
    "    number = int(input(\"당신이 가진 10개의 초코 와플을 친구들에게 나눠주려고 합니다. 와플을 나누어줄 친구가 몇명인가요?: \"))\n",
    "    print(\"한 사람당\", 10/number, \"개의 와플을 먹을 수 있겠네요.\")\n",
    "except:\n",
    "    print(\"뭐가 문제인지는 모르겠는데 어쨌든 당신의 입력값에 문제가 있어요.\")\n",
    "else:\n",
    "    print(\"와플을 먹은 당신의 친구들이 행복해합니다.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. finally\n",
    "* 예외의 발생과 관계없이 무조건 실행해야할 명령을 finally절을 이용해 지정할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "당신이 가진 10개의 초코 와플을 친구들에게 나눠주려고 합니다. 와플을 나누어줄 친구가 몇명인가요?: 0\n",
      "뭐가 문제인지는 모르겠는데 어쨌든 당신의 입력값에 문제가 있어요.\n",
      "프로그램을 종료합니다.\n"
     ]
    }
   ],
   "source": [
    "# finally 절\n",
    "try:\n",
    "    number = int(input(\"당신이 가진 10개의 초코 와플을 친구들에게 나눠주려고 합니다. 와플을 나누어줄 친구가 몇명인가요?: \"))\n",
    "    print(\"한 사람당\", 10/number, \"개의 와플을 먹을 수 있겠네요.\")\n",
    "except:\n",
    "    print(\"뭐가 문제인지는 모르겠는데 어쨌든 당신의 입력값에 문제가 있어요.\")\n",
    "else:\n",
    "    print(\"와플을 먹은 당신의 친구들이 행복해합니다.\")\n",
    "finally:\n",
    "    print(\"프로그램을 종료합니다.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9장. 라이브러리(library)\n",
    "## 1. 모듈(module)과 패키지(package)\n",
    "* 프로그래밍이 무에서 유를 창조하는 매우 유용한 활동이다. 하지만 그렇다고 해서 다른 사람이 이미 만들어놓은 것이 있는데 굳이 새롭게 처음부터 만들 필요는 없을 것이다.\n",
    "* 모듈이란 이런 비효율의 문제를 피하기 위해 전역변수, 함수 등을 모아놓은 프로그램의 부품과 같은 것으로서 대부분의 프로그래밍 언어에서 지원한다. \n",
    "* 패키지는 여러 모듈들이 구조화되어 모여있는 것을 의미한다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 라이브러리 불러오기\n",
    "* 라이브러리는 모듈과 패키지로 구성되어 있다.  \n",
    "* Python에서는 다양한 목적을 위한 라이브러리를 지원하고 있고, 키워드 'from'과 'import'를 활용하여 이루어진다.\n",
    "* 라이브러리를 불러오는 방법은 크게 다음과 같다:\n",
    "    * import 라이브러리\n",
    "    * import 라이브러리 as 별명\n",
    "    * from 라이브러리 import 모듈"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* random은 숫자를 무작위로 생성할 때 유용하게 사용할 수 있는 라이브러리이다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# import 라이브러리\n",
    "import random\n",
    "random.randint(0, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# import 라이브러리 as 별명\n",
    "import random as rd\n",
    "rd.randint(0, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# from 라이브러리 import 모듈\n",
    "from random import randint\n",
    "randint(0, 10)"
   ]
  },
  {
   "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.6.8"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "276.775px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}