{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# numpy, pandas 기초" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* 싸이그래머 : 생물심리Py\n", "* 발표자 : 김무성 " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# 차례" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* 추천 사이트\n", "* 추천 예제\n", "* NumPy 기초 [1,2, 3]\n", "* pandas 기초 [1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# 추천 사이트" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* NumPy 공식 페이지 - http://www.numpy.org/\n", "* pandas 공식 페이지 - http://pandas.pydata.org/\n", "* 선형대수(코세라 강좌 coding the matrix의 결과물) - http://codingthematrix.com/\n", "* 선형대수 소개 ppt - http://www.fil.ion.ucl.ac.uk/spm/doc/mfd/2010/page1/LinearAlgebra.ppt\n", "* 선형대수 소개 pdf - http://www.win.tue.nl/~nikhil/courses/2DI75/recap-slides.pdf" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# 추천 예제" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* pandas를 이용한 아파치 로그 분석 - http://nbviewer.ipython.org/github/koldunovn/nk_public_notebooks/blob/master/Apache_log.ipynb\n", "* NumPy를 이용한 PCA 예제 - http://glowingpython.blogspot.kr/2011/07/principal-component-analysis-with-numpy.html\n", "* 전국 시군구 버거지수 - http://openlook.org/wp/does-lotteria-locate-different/ " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# NumPy 기초" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* NumPy란?\n", "* NumPy ndarray : 다차원 배열 객체\n", "* ndarray의 자료형\n", "* NumPy 기본 연산" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## NumPy란?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Numercial Python의 줄임말로 고성능의 과학계산 컴퓨팅과 데이터 분석에 필요한 기본 패키지다. 다음과 같은 기능을 제공한다.\n", "\n", "* 빠르고 메모리를 효율적으로 사용하며 벡터 산술연산과 세련된 브로드캐스팅 기능을 제공하는 다차원 배열인 ndarray\n", "* 반복문을 작성할 필요 없이 전체 데이터 배열에 대해 빠른 연산을 제공하는 표준 수학 함수\n", "* 배열 데이터를 디스크에 쓰거나 읽을 수 있는 도구와 메모리에 올려진 파일을 사용하는 도구\n", "* 선형대수, 난수 발생기, 푸리에 변환 기능\n", "* C, C++, 포트란으로 쓰여진 코드를 통합하는 도구" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "대부분의 데이터 분석 애플리케이션에서 중요하게 사용되는 기능은 다음과 같다\n", "\n", "* 백터 배열상에서 데이터 개조, 정제, 부분 집합, 필터링, 변형, 다른 종류 연산의 빠른 수행\n", "* 정렬, 유일 원소 찾기, 집합연산 같은 일반적인 배열 처리 알고리즘\n", "* 통계의 효과적인 표현과 데이터의 수집/요약\n", "* 다른 종류의 데이터 묶음을 병합하고 엮기 위한 데이터 정렬과 데이터 간의 관계 조작\n", "* if-elif-else를 포함하는 반복문 대신 사용할 수 있는 조건절을 표현할 수 있는 배열 표현\n", "* 데이터 그룹 전체에 적용할 수 있는 수집, 변형, 함수 적용 같은 데이터 처리." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## NumPy ndarray : 다차원 배열 객체" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* N차원의 배열 객체\n", "* 같은 종류의 데이터만 담을 수 있다(원소는 같은 자료형이여야 한다)\n", "* 모든 배열은 각 차원의 크기를 알려주는 shape라는 튜플과 배열에 저장된 자료형을 알려주는 dtype이라는 객체를 가지고 있다." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* ndarray 특징\n", "* 리스트와 ndarray와의 비교\n", "* ndarray 생성" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### ndarray 특징" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false }, "outputs": [], "source": [ "import numpy as np\n", "\n", "data = np.array([[0.9526, -0.246, -0.8856],\n", " [0.5639, 0.2379, 0.9104]])" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 9.526, -2.46 , -8.856],\n", " [ 5.639, 2.379, 9.104]])" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data * 10" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 1.9052, -0.492 , -1.7712],\n", " [ 1.1278, 0.4758, 1.8208]])" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data + data" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "(2, 3)" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data.shape" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "dtype('float64')" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data.dtype" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 리스트와 ndarray와의 비교" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false }, "outputs": [], "source": [ "import numpy as np\n", "\n", "# 10^7개의 원소를 갖는 배열 생성 \n", "arr = np.arange(1e7)\n", "\n", "# ndarray를 리스트로 변환 \n", "larr = arr.tolist()\n", "\n", "# 리스트는 브로드캐스트가 불가능하다\n", "# 그래서 ndarray의 브로드캐스트를 흉내 내는 함수를 제작\n", "def list_times(alist, scalar): \n", " for i, val in enumerate(alist):\n", " alist[i] = val * scalar \n", " \n", " return alist" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10 loops, best of 3: 118 ms per loop\n" ] } ], "source": [ "%timeit arr * 1.1" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1 loops, best of 3: 1.13 s per loop\n" ] } ], "source": [ "%timeit list_times(larr, 1.1)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "9.576271186440678" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 약 9.6배 빠르다(실행 환경마다 다를 수 있음)\n", "1.13 * 1000 / 118.0" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### ndarray 생성" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([1, 2, 3])" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "alist = [1, 2, 3]\n", "arr = np.array(alist)\n", "arr" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 0., 0., 0., 0., 0.])" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 0으로 초기화된 5개의 원소를 갖는 배열을 생성 \n", "arr = np.zeros(5)\n", "arr" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", " 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n", " 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,\n", " 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,\n", " 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,\n", " 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99])" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 0부터 99까지를 원소로 하는 배열\n", "arr = np.arange(100)\n", "arr" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,\n", " 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,\n", " 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,\n", " 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,\n", " 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,\n", " 95, 96, 97, 98, 99])" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 10부터 99\n", "arr = np.arange(10,100)\n", "arr" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 0. , 0.01010101, 0.02020202, 0.03030303, 0.04040404,\n", " 0.05050505, 0.06060606, 0.07070707, 0.08080808, 0.09090909,\n", " 0.1010101 , 0.11111111, 0.12121212, 0.13131313, 0.14141414,\n", " 0.15151515, 0.16161616, 0.17171717, 0.18181818, 0.19191919,\n", " 0.2020202 , 0.21212121, 0.22222222, 0.23232323, 0.24242424,\n", " 0.25252525, 0.26262626, 0.27272727, 0.28282828, 0.29292929,\n", " 0.3030303 , 0.31313131, 0.32323232, 0.33333333, 0.34343434,\n", " 0.35353535, 0.36363636, 0.37373737, 0.38383838, 0.39393939,\n", " 0.4040404 , 0.41414141, 0.42424242, 0.43434343, 0.44444444,\n", " 0.45454545, 0.46464646, 0.47474747, 0.48484848, 0.49494949,\n", " 0.50505051, 0.51515152, 0.52525253, 0.53535354, 0.54545455,\n", " 0.55555556, 0.56565657, 0.57575758, 0.58585859, 0.5959596 ,\n", " 0.60606061, 0.61616162, 0.62626263, 0.63636364, 0.64646465,\n", " 0.65656566, 0.66666667, 0.67676768, 0.68686869, 0.6969697 ,\n", " 0.70707071, 0.71717172, 0.72727273, 0.73737374, 0.74747475,\n", " 0.75757576, 0.76767677, 0.77777778, 0.78787879, 0.7979798 ,\n", " 0.80808081, 0.81818182, 0.82828283, 0.83838384, 0.84848485,\n", " 0.85858586, 0.86868687, 0.87878788, 0.88888889, 0.8989899 ,\n", " 0.90909091, 0.91919192, 0.92929293, 0.93939394, 0.94949495,\n", " 0.95959596, 0.96969697, 0.97979798, 0.98989899, 1. ])" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 0부터 1까지 100단계로\n", "arr = np.linspace(0, 1, 100)\n", "arr" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 1. , 1.02353102, 1.04761575, 1.07226722,\n", " 1.09749877, 1.12332403, 1.149757 , 1.17681195,\n", " 1.20450354, 1.23284674, 1.26185688, 1.29154967,\n", " 1.32194115, 1.35304777, 1.38488637, 1.41747416,\n", " 1.45082878, 1.48496826, 1.51991108, 1.55567614,\n", " 1.59228279, 1.62975083, 1.66810054, 1.70735265,\n", " 1.7475284 , 1.78864953, 1.83073828, 1.87381742,\n", " 1.91791026, 1.96304065, 2.009233 , 2.05651231,\n", " 2.10490414, 2.15443469, 2.20513074, 2.25701972,\n", " 2.3101297 , 2.36448941, 2.42012826, 2.47707636,\n", " 2.53536449, 2.59502421, 2.65608778, 2.71858824,\n", " 2.7825594 , 2.84803587, 2.91505306, 2.98364724,\n", " 3.05385551, 3.12571585, 3.19926714, 3.27454916,\n", " 3.35160265, 3.43046929, 3.51119173, 3.59381366,\n", " 3.67837977, 3.76493581, 3.85352859, 3.94420606,\n", " 4.03701726, 4.1320124 , 4.22924287, 4.32876128,\n", " 4.43062146, 4.53487851, 4.64158883, 4.75081016,\n", " 4.86260158, 4.97702356, 5.09413801, 5.21400829,\n", " 5.33669923, 5.46227722, 5.59081018, 5.72236766,\n", " 5.85702082, 5.9948425 , 6.13590727, 6.28029144,\n", " 6.42807312, 6.57933225, 6.73415066, 6.8926121 ,\n", " 7.05480231, 7.22080902, 7.39072203, 7.56463328,\n", " 7.74263683, 7.92482898, 8.11130831, 8.30217568,\n", " 8.49753436, 8.69749003, 8.90215085, 9.11162756,\n", " 9.32603347, 9.54548457, 9.77009957, 10. ])" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 로그 스케일로 1부터 10까지 100단계로\n", "arr = np.logspace(0, 1, 100, base=10.0)\n", "arr" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0., 0., 0., 0., 0.],\n", " [ 0., 0., 0., 0., 0.],\n", " [ 0., 0., 0., 0., 0.],\n", " [ 0., 0., 0., 0., 0.],\n", " [ 0., 0., 0., 0., 0.]])" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 5x5 형식의, 0으로 채워진 배열(이미지) 만들기 \n", "image = np.zeros((5,5))\n", "image" ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[[1, 1, 1, 1, 1],\n", " [1, 1, 1, 1, 1],\n", " [1, 1, 1, 1, 1],\n", " [1, 1, 1, 1, 1],\n", " [1, 1, 1, 1, 1]],\n", "\n", " [[1, 1, 1, 1, 1],\n", " [1, 1, 1, 1, 1],\n", " [1, 1, 1, 1, 1],\n", " [1, 1, 1, 1, 1],\n", " [1, 1, 1, 1, 1]],\n", "\n", " [[1, 1, 1, 1, 1],\n", " [1, 1, 1, 1, 1],\n", " [1, 1, 1, 1, 1],\n", " [1, 1, 1, 1, 1],\n", " [1, 1, 1, 1, 1]],\n", "\n", " [[1, 1, 1, 1, 1],\n", " [1, 1, 1, 1, 1],\n", " [1, 1, 1, 1, 1],\n", " [1, 1, 1, 1, 1],\n", " [1, 1, 1, 1, 1]],\n", "\n", " [[1, 1, 1, 1, 1],\n", " [1, 1, 1, 1, 1],\n", " [1, 1, 1, 1, 1],\n", " [1, 1, 1, 1, 1],\n", " [1, 1, 1, 1, 1]]])" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 5x5x5 형식의, 1로 채워진 배열을 만든다.\n", "# astype() 메서드는 원소들을 정수로 설정한다. \n", "cube = np.zeros((5,5,5)).astype(int) + 1\n", "cube" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[[ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.]],\n", "\n", " [[ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.]],\n", "\n", " [[ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.]],\n", "\n", " [[ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.]],\n", "\n", " [[ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.]]], dtype=float16)" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 16비트 부동소수점으로\n", "cube = np.ones((5, 5, 5)).astype(np.float16)\n", "cube" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## ndarray의 자료형" ] }, { "cell_type": "code", "execution_count": 124, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.],\n", " [ 1., 1., 1., 1., 1.]])" ] }, "execution_count": 124, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr = np.ones((10,5))\n", "arr" ] }, { "cell_type": "code", "execution_count": 125, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "(10, 5)" ] }, "execution_count": 125, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 배열의 형태를 나타내는 튜플\n", "arr.shape" ] }, { "cell_type": "code", "execution_count": 127, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "dtype('float64')" ] }, "execution_count": 127, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 자료형\n", "arr.dtype" ] }, { "cell_type": "code", "execution_count": 130, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "(40, 8)" ] }, "execution_count": 130, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 하나의 원소에서 다음 원소까지의 너비를 표현한 정수를 담고 있는 stride 튜플\n", "# 스트라이드 값은 배열을 복사하지 않고 뷰를 생성하기 위한 필수 값으로 사용된다.\n", "arr.strides" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 1. 2. 3.]\n", "float64\n" ] } ], "source": [ "# dtype은 ndarray가 특정 데이터를 메모리에서 해석하기 위해 필요한 정보를 담고 있는 특수한 객체\n", "\n", "arr1 = np.array([1,2,3], dtype=np.float64)\n", "print arr1\n", "print arr1.dtype" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1 2 3]\n", "int32\n" ] } ], "source": [ "arr2 = np.array([1,2,3], dtype=np.int32)\n", "print arr2\n", "print arr2.dtype" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "int64\n", "float64\n" ] } ], "source": [ "# astype 메서드로 배열의 dtype을 다른 형으로 명시적 변경 가능.\n", "arr = np.array([1, 2, 3, 4, 5])\n", "print arr.dtype\n", "\n", "float_arr = arr.astype(np.float64)\n", "print float_arr.dtype" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['1.25' '-9.6' '42']\n", "[ 1.25 -9.6 42. ]\n" ] } ], "source": [ "# 숫자 형식의 문자열도 astype으로 숫자로 변경가능.\n", "numeric_strings = np.array(['1.25', '-9.6', '42'], dtype=np.string_)\n", "print numeric_strings\n", "\n", "numbers = numeric_strings.astype(float)\n", "print numbers" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## NumPy 기본 연산" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* 배열과 스칼라 연산\n", "* 색인과 슬라이싱 기초\n", "* 슬라이스 색인\n", "* 배열 전치와 축 바꾸기\n", "* 유니버셜 함수\n", "* 배열 데이터 조작, 특수처리\n", "* 배열 재형성\n", "* 브로드캐스팅\n", "* 배열 이어붙이고 나누기, 반복\n", "* 선형대수" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 배열과 스칼라 연산" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 1., 2., 3.],\n", " [ 4., 5., 6.]])" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr = np.array([[1., 2., 3.],\n", " [4., 5., 6.]])\n", "arr" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 2., 4., 6.],\n", " [ 8., 10., 12.]])" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 더하기\n", "arr + arr" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0., 0., 0.],\n", " [ 0., 0., 0.]])" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 빼기\n", "arr - arr" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 1., 4., 9.],\n", " [ 16., 25., 36.]])" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 곱하기 (개별 원소 곱)\n", "arr * arr" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 1. , 0.5 , 0.33333333],\n", " [ 0.25 , 0.2 , 0.16666667]])" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 스칼라에 대한 산술 연산은 각 요소로 전달\n", "1 / arr" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0.5, 1. , 1.5],\n", " [ 2. , 2.5, 3. ]])" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr * 0.5" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 1. , 1.41421356, 1.73205081],\n", " [ 2. , 2.23606798, 2.44948974]])" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr ** 0.5" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 색인과 슬라이싱 기초" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* 슬라이싱 기초\n", "* 다차원 배열" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 슬라이싱 기초" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr = np.arange(10)\n", "arr" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "5" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr[5]" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([5, 6, 7])" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr[5:8]" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 0, 1, 2, 3, 4, 12, 12, 12, 8, 9])" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 브로드캐스팅. 배열 슬라이스에 스칼라 값을 대입하면, 그 범위에 값이 전파된다.\n", "arr[5:8] = 12\n", "arr" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 0 1 2 3 4 12 12 12 8 9]\n", "[ 0 1 2 3 4 12 12345 12 8 9]\n", "[ 0 1 2 3 4 64 64 64 8 9]\n" ] } ], "source": [ "# 배열 슬라이스는 값을 복사하는게 아니다. 그러므로 배열 슬라이스의 값을 바꿔도 원본에 반영된다.\n", "arr_slice = arr[5:8] # arr_slice로 arr[5:8]의 값이 복사된게 아님. view의 역할을 할뿐.\n", "\n", "print arr\n", "\n", "arr_slice[1] = 12345\n", "\n", "print arr\n", "\n", "arr_slice[:] = 64\n", "\n", "print arr" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[64 64 64]\n", "[ 0 1 2 3 4 64 64 64 8 9]\n", "[8 8 8]\n", "[ 0 1 2 3 4 64 64 64 8 9]\n" ] } ], "source": [ "# 뷰 대신에 슬라이스의 복사본을 얻고 싶다면.\n", "arr_slice_copy = arr[5:8].copy()\n", "print arr_slice_copy\n", "print arr\n", "\n", "arr_slice_copy[:] = 8\n", "print arr_slice_copy\n", "print arr" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 다차원 배열" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 3],\n", " [4, 5, 6],\n", " [7, 8, 9]])" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 2차원 배열\n", "arr2d = np.array([[1, 2, 3],\n", " [4, 5, 6],\n", " [7, 8, 9]])\n", "arr2d" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "0,0 | 0,1 | 0,2\n", "------|--------|--------\n", "1,0 | 1,1 | 1,2\n", "2,0 | 2,1 | 2,2" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([7, 8, 9])" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 특정 행에 접근\n", "arr2d[2]" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 특정 원소에 접근\n", "arr2d[0][2]" ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 위의 것은 다음과 같이 쓸 수 있다.\n", "arr2d[0,2]" ] }, { "cell_type": "code", "execution_count": 43, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([1, 4, 7])" ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 특정 열 추출\n", "arr2d[:,0]" ] }, { "cell_type": "code", "execution_count": 46, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([7, 8, 9])" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr2d[:][2]" ] }, { "cell_type": "code", "execution_count": 61, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[[ 1, 2, 3],\n", " [ 4, 5, 6]],\n", "\n", " [[ 7, 8, 9],\n", " [10, 11, 12]]])" ] }, "execution_count": 61, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 3차원 배열\n", "arr3d = np.array([\n", " [[1, 2, 3],\n", " [4, 5, 6]],\n", " [[7, 8, 9],\n", " [10, 11, 12]]\n", " ])\n", "arr3d" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "0 | | | \n", "------|--------|--------\n", "0,0 | 0,1 | 0,2\n", "1,0 | 1,1 | 1,2\n", "1 | | \n", "0,0 | 0,1 | 0,2\n", "1,0 | 1,1 | 1,2" ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 3],\n", " [4, 5, 6]])" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr3d[0]" ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 7, 8, 9],\n", " [10, 11, 12]])" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr3d[1]" ] }, { "cell_type": "code", "execution_count": 51, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([4, 5, 6])" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr3d[0][1]" ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([4, 5, 6])" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr3d[0, 1]" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "12" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr3d[1][1][2]" ] }, { "cell_type": "code", "execution_count": 53, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "12" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr3d[1, 1, 2]" ] }, { "cell_type": "code", "execution_count": 54, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 6, 12])" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr3d[:, 1, 2]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 슬라이스에 값 넣기" ] }, { "cell_type": "code", "execution_count": 62, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[[ 1, 2, 3],\n", " [ 4, 5, 6]],\n", "\n", " [[ 7, 8, 9],\n", " [10, 11, 12]]])" ] }, "execution_count": 62, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr3d" ] }, { "cell_type": "code", "execution_count": 63, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 3],\n", " [4, 5, 6]])" ] }, "execution_count": 63, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr3d[0]" ] }, { "cell_type": "code", "execution_count": 64, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[[42, 42, 42],\n", " [42, 42, 42]],\n", "\n", " [[ 7, 8, 9],\n", " [10, 11, 12]]])" ] }, "execution_count": 64, "metadata": {}, "output_type": "execute_result" } ], "source": [ "old_values = arr3d[0].copy() # 원래의 값을 보존하기 위해 복사.\n", "\n", "arr3d[0] = 42 # 슬라이스에 스칼라 대입\n", "arr3d" ] }, { "cell_type": "code", "execution_count": 65, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[[ 1, 2, 3],\n", " [ 4, 5, 6]],\n", "\n", " [[ 7, 8, 9],\n", " [10, 11, 12]]])" ] }, "execution_count": 65, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr3d[0] = old_values # 슬라이스에 배열 대입 가능(차원이 맞아야 함)\n", "arr3d" ] }, { "cell_type": "code", "execution_count": 66, "metadata": { "collapsed": false }, "outputs": [ { "ename": "ValueError", "evalue": "could not broadcast input array from shape (2) into shape (2,3)", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0marr3d\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\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;31mValueError\u001b[0m: could not broadcast input array from shape (2) into shape (2,3)" ] } ], "source": [ "arr3d[0] = np.array([1,2])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 배열 전치와 축 바꾸기" ] }, { "cell_type": "code", "execution_count": 74, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])" ] }, "execution_count": 74, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr = np.arange(15)\n", "arr" ] }, { "cell_type": "code", "execution_count": 76, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 1, 2, 3, 4],\n", " [ 5, 6, 7, 8, 9],\n", " [10, 11, 12, 13, 14]])" ] }, "execution_count": 76, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr = arr.reshape((3, 5))\n", "arr" ] }, { "cell_type": "code", "execution_count": 77, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 5, 10],\n", " [ 1, 6, 11],\n", " [ 2, 7, 12],\n", " [ 3, 8, 13],\n", " [ 4, 9, 14]])" ] }, "execution_count": 77, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 전치(transpose)\n", "arr.T" ] }, { "cell_type": "code", "execution_count": 78, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 5, 10],\n", " [ 1, 6, 11],\n", " [ 2, 7, 12],\n", " [ 3, 8, 13],\n", " [ 4, 9, 14]])" ] }, "execution_count": 78, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr.transpose()" ] }, { "cell_type": "code", "execution_count": 79, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[-0.2076657 , -1.12094658, 0.61984314],\n", " [ 0.94419704, -0.64767335, 0.8012834 ],\n", " [ 0.53443576, -0.26279777, -1.34619569],\n", " [-0.19775452, -0.8455633 , -0.3602344 ],\n", " [-0.8157946 , 0.33324178, -0.18393122],\n", " [-1.38288628, -0.6405826 , -0.85682243]])" ] }, "execution_count": 79, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 행렬 내적 \n", "arr = np.random.randn(6,3)\n", "arr" ] }, { "cell_type": "code", "execution_count": 81, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 3.83725683, 0.26201237, 1.31457021],\n", " [ 0.26201237, 2.98143811, -0.06783077],\n", " [ 1.31457021, -0.06783077, 3.73624765]])" ] }, "execution_count": 81, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.dot(arr.T, arr)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 유니버설 함수" ] }, { "cell_type": "code", "execution_count": 83, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" ] }, "execution_count": 83, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr = np.arange(10)\n", "arr" ] }, { "cell_type": "code", "execution_count": 84, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 0. , 1. , 1.41421356, 1.73205081, 2. ,\n", " 2.23606798, 2.44948974, 2.64575131, 2.82842712, 3. ])" ] }, "execution_count": 84, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 단항 유니버설 함수\n", "np.sqrt(arr)" ] }, { "cell_type": "code", "execution_count": 85, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 1.00000000e+00, 2.71828183e+00, 7.38905610e+00,\n", " 2.00855369e+01, 5.45981500e+01, 1.48413159e+02,\n", " 4.03428793e+02, 1.09663316e+03, 2.98095799e+03,\n", " 8.10308393e+03])" ] }, "execution_count": 85, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.exp(arr)" ] }, { "cell_type": "code", "execution_count": 86, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 0.0967883 -1.67521403 1.64327249 1.95540243 0.58640696 -0.54404345\n", " 0.51192415 0.59918442]\n", "[ 0.55136643 -1.62589557 -0.75345847 -0.38791841 -1.22037736 -1.11515184\n", " 0.55690104 0.11316851]\n" ] }, { "data": { "text/plain": [ "array([ 0.55136643, -1.62589557, 1.64327249, 1.95540243, 0.58640696,\n", " -0.54404345, 0.55690104, 0.59918442])" ] }, "execution_count": 86, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 다항 유니버설 함수 - 인자 두 개를 취해서 단일 배열을 반환하는 함수\n", "x = randn(8)\n", "print x\n", "y = randn(8)\n", "print y\n", "\n", "np.maximum(x, y) # element-wise maximum" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 배열 데이터 조작, 특수처리" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* 조건절 표현\n", "* 수학 메서드와 통계 메서드\n", "* 불리언 배열을 위한 메서드\n", "* 정렬\n", "* 집합 함수" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 조건절 표현" ] }, { "cell_type": "code", "execution_count": 91, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[-0.80226147, 1.67485488, 0.13617279, 1.33824164],\n", " [-0.76138352, 0.18015578, -0.79917102, 0.69047915],\n", " [-0.23689069, 1.62039386, -0.56544592, 0.18518925],\n", " [-0.50333841, -0.2041948 , -0.35954173, 1.87880381]])" ] }, "execution_count": 91, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 배열연산 조건절 표현하기\n", "arr = np.random.randn(4, 4)\n", "arr" ] }, { "cell_type": "code", "execution_count": 88, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 2, 2, -2, -2],\n", " [ 2, 2, 2, 2],\n", " [-2, -2, 2, -2],\n", " [-2, -2, -2, 2]])" ] }, "execution_count": 88, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.where( arr > 0, 2, -2) # 양수는 모두 2로, 음수는 모두 -1로 변경" ] }, { "cell_type": "code", "execution_count": 90, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 2. , 2. , -1.81220706, -0.05290094],\n", " [ 2. , 2. , 2. , 2. ],\n", " [-0.08778373, -1.31906435, 2. , -0.18864948],\n", " [-1.01932823, -0.69414154, -1.32050374, 2. ]])" ] }, "execution_count": 90, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.where( arr > 0, 2, arr) # 양수는 2로, 음수는 원래 값 그대로" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 수학 메서드와 통계 메서드" ] }, { "cell_type": "code", "execution_count": 94, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[-0.18872156, -0.00937502, 1.02528247, -0.2336773 ],\n", " [ 0.13697903, 0.40498426, -0.02145654, -0.53837257],\n", " [ 0.02580721, 0.22526115, -0.76233053, 0.26992687],\n", " [ 0.07412079, 1.57429726, -0.19075057, 0.38820259],\n", " [-0.10767344, -1.7242222 , 0.716758 , -1.5607776 ]])" ] }, "execution_count": 94, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# randn (normally-distributed data)\n", "arr = np.random.randn(5, 4)\n", "arr" ] }, { "cell_type": "code", "execution_count": 95, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "-0.024786884534673759" ] }, "execution_count": 95, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr.mean()" ] }, { "cell_type": "code", "execution_count": 96, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "-0.024786884534673759" ] }, "execution_count": 96, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.mean(arr)" ] }, { "cell_type": "code", "execution_count": 97, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "-0.49573769069347517" ] }, "execution_count": 97, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr.sum()" ] }, { "cell_type": "code", "execution_count": 99, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 0.14837715, -0.00446646, -0.06033383, 0.46146752, -0.66897881])" ] }, "execution_count": 99, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# mean이나 sum같은 함수는 axis 인자를 받아, 해당 axis에 대한 통계를 계산하고 한 차수 낮은 배열을 반환한다.\n", "arr.mean(axis=1)" ] }, { "cell_type": "code", "execution_count": 100, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([-0.05948797, 0.47094545, 0.76750284, -1.67469801])" ] }, "execution_count": 100, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr.sum(0)" ] }, { "cell_type": "code", "execution_count": 102, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[0, 1, 2],\n", " [3, 4, 5],\n", " [6, 7, 8]])" ] }, "execution_count": 102, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# cumsum과 cumprod 메서드는 중간 계산 값을 담고 있는 배열을 반환한다.\n", "arr = np.array([\n", " [0, 1, 2],\n", " [3, 4, 5],\n", " [6, 7, 8]\n", " ])\n", "arr" ] }, { "cell_type": "code", "execution_count": 103, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 0, 1, 3, 6, 10, 15, 21, 28, 36])" ] }, "execution_count": 103, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr.cumsum()" ] }, { "cell_type": "code", "execution_count": 104, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 1, 2],\n", " [ 3, 5, 7],\n", " [ 9, 12, 15]])" ] }, "execution_count": 104, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr.cumsum(0)" ] }, { "cell_type": "code", "execution_count": 105, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 0, 0],\n", " [ 3, 12, 60],\n", " [ 6, 42, 336]])" ] }, "execution_count": 105, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr.cumprod(1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 정렬" ] }, { "cell_type": "code", "execution_count": 109, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([-0.74932004, 0.81202617, -0.94114978, 0.66775995, -0.21599847,\n", " -0.53131814, 1.18755295, -0.17303755])" ] }, "execution_count": 109, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr = np.random.randn(8)\n", "arr" ] }, { "cell_type": "code", "execution_count": 111, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([-0.94114978, -0.74932004, -0.53131814, -0.21599847, -0.17303755,\n", " 0.66775995, 0.81202617, 1.18755295])" ] }, "execution_count": 111, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr.sort()\n", "arr" ] }, { "cell_type": "code", "execution_count": 112, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[-1.15729656, 0.53208771, 0.82451164],\n", " [ 1.00494958, -0.37859057, 0.64012556],\n", " [ 0.83376375, -1.45444792, -1.3117023 ],\n", " [-0.96079299, 1.48396206, -0.76299037],\n", " [-0.11370724, -0.56658628, 0.40526753]])" ] }, "execution_count": 112, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr = randn(5, 3)\n", "arr" ] }, { "cell_type": "code", "execution_count": 113, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[-1.15729656, 0.53208771, 0.82451164],\n", " [-0.37859057, 0.64012556, 1.00494958],\n", " [-1.45444792, -1.3117023 , 0.83376375],\n", " [-0.96079299, -0.76299037, 1.48396206],\n", " [-0.56658628, -0.11370724, 0.40526753]])" ] }, "execution_count": 113, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr.sort(1)\n", "arr" ] }, { "cell_type": "code", "execution_count": 114, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "-1.662950929232514" ] }, "execution_count": 114, "metadata": {}, "output_type": "execute_result" } ], "source": [ "large_arr = randn(1000)\n", "large_arr.sort()\n", "large_arr[int(0.05 * len(large_arr))]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### 집합 함수" ] }, { "cell_type": "code", "execution_count": 116, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['Bob' 'Joe' 'Will' 'Bob' 'Will' 'Joe' 'Joe']\n", "['Bob' 'Joe' 'Will']\n" ] } ], "source": [ "# 중복 제거 \n", "names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])\n", "print names\n", "\n", "print np.unique(names)" ] }, { "cell_type": "code", "execution_count": 118, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[6 0 0 3 2 5 6]\n", "[2, 3, 6]\n", "[ True False False True True False True]\n" ] } ], "source": [ "# 2개의 배열을 인자로 받아 첫 번째 배열의 각 원소가 두 번째 배열의 원소를 포함하는지를 나타내는 불리언 배열을 반환\n", "values = np.array([6, 0, 0, 3, 2, 5, 6])\n", "print values\n", "\n", "print [2, 3, 6]\n", "print np.in1d(values, [2, 3, 6])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 배열 재형성" ] }, { "cell_type": "code", "execution_count": 131, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4, 5, 6, 7])" ] }, "execution_count": 131, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr = np.arange(8)\n", "arr" ] }, { "cell_type": "code", "execution_count": 132, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[0, 1],\n", " [2, 3],\n", " [4, 5],\n", " [6, 7]])" ] }, "execution_count": 132, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr.reshape((4,2))" ] }, { "cell_type": "code", "execution_count": 134, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[0, 1, 2, 3],\n", " [4, 5, 6, 7]])" ] }, "execution_count": 134, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 다차원 재형성도 가능\n", "arr.reshape((4,2)).reshape((2,4))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 배열 이어붙이고 나누기, 반복" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* concatenate\n", "* vstack, hstack" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### concatenate" ] }, { "cell_type": "code", "execution_count": 143, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 3],\n", " [4, 5, 6]])" ] }, "execution_count": 143, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr1 = np.array([[1, 2, 3], [4, 5, 6]])\n", "arr1" ] }, { "cell_type": "code", "execution_count": 144, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 7, 8, 9],\n", " [10, 11, 12]])" ] }, "execution_count": 144, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr2 = np.array([[7, 8, 9], [10, 11, 12]])\n", "arr2" ] }, { "cell_type": "code", "execution_count": 145, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 1, 2, 3],\n", " [ 4, 5, 6],\n", " [ 7, 8, 9],\n", " [10, 11, 12]])" ] }, "execution_count": 145, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# axis에 맞춰 합친다 0=로우 우선, 1=컬럼 우선\n", "np.concatenate([arr1, arr2], axis=0)" ] }, { "cell_type": "code", "execution_count": 146, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 1, 2, 3, 7, 8, 9],\n", " [ 4, 5, 6, 10, 11, 12]])" ] }, "execution_count": 146, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.concatenate([arr1, arr2], axis=1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### hstack, vstack" ] }, { "cell_type": "code", "execution_count": 148, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 1, 2, 3, 7, 8, 9],\n", " [ 4, 5, 6, 10, 11, 12]])" ] }, "execution_count": 148, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.hstack((arr1, arr2))" ] }, { "cell_type": "code", "execution_count": 149, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 1, 2, 3],\n", " [ 4, 5, 6],\n", " [ 7, 8, 9],\n", " [10, 11, 12]])" ] }, "execution_count": 149, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.vstack((arr1, arr2))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 브로드캐스팅" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* 브로드캐스팅은 다른 모양의 배열 간 산술연산을 어떻게 수행해야 하는지 설명한다.\n", "* 특정 스칼라 값이나 배열 조각이 배열의 전체 원소로 전파(broadcat)된다." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4])" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 배열과 스칼라 값 연산의 경우\n", "import numpy as np\n", "arr = np.arange(5)\n", "arr" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([4, 5, 6, 7, 8])" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 4의 곱 브로드캐스팅\n", "arr + 4" ] }, { "cell_type": "code", "execution_count": 196, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0.41949176, -0.40404443, -0.40992978],\n", " [-0.31286111, 1.24607613, 0.98488495],\n", " [ 0.32951646, 0.04936468, 1.65439179],\n", " [ 0.5054299 , 1.63305808, 0.56269416]])" ] }, "execution_count": 196, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 배열의 각 칼럼에서 칼럼의 평균 값을 빼기\n", "arr = randn(4,3)\n", "arr" ] }, { "cell_type": "code", "execution_count": 197, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 0.23539425, 0.63111361, 0.69801028])" ] }, "execution_count": 197, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr.mean(0)" ] }, { "cell_type": "code", "execution_count": 198, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0.1840975 , -1.03515804, -1.10794006],\n", " [-0.54825536, 0.61496251, 0.28687467],\n", " [ 0.09412221, -0.58174894, 0.95638151],\n", " [ 0.27003565, 1.00194446, -0.13531612]])" ] }, "execution_count": 198, "metadata": {}, "output_type": "execute_result" } ], "source": [ "demeaned = arr - arr.mean(0)\n", "demeaned" ] }, { "cell_type": "code", "execution_count": 199, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0.41949176, -0.40404443, -0.40992978],\n", " [-0.31286111, 1.24607613, 0.98488495],\n", " [ 0.32951646, 0.04936468, 1.65439179],\n", " [ 0.5054299 , 1.63305808, 0.56269416]])" ] }, "execution_count": 199, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 칼럼이 아니라 각 로우에서 평균 값 빼기\n", "arr" ] }, { "cell_type": "code", "execution_count": 200, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([-0.13149415, 0.63936665, 0.67775764, 0.90039404])" ] }, "execution_count": 200, "metadata": {}, "output_type": "execute_result" } ], "source": [ "row_means = arr.mean(1)\n", "row_means" ] }, { "cell_type": "code", "execution_count": 201, "metadata": { "collapsed": false }, "outputs": [ { "ename": "ValueError", "evalue": "operands could not be broadcast together with shapes (4,3) (4,) ", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0marr\u001b[0m \u001b[1;33m-\u001b[0m \u001b[0mrow_means\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mValueError\u001b[0m: operands could not be broadcast together with shapes (4,3) (4,) " ] } ], "source": [ "# 4 x 3 자료형에서 1x4 배열을 빼므로 차원이 맞지 않다.\n", "arr - row_means" ] }, { "cell_type": "code", "execution_count": 202, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[-0.13149415],\n", " [ 0.63936665],\n", " [ 0.67775764],\n", " [ 0.90039404]])" ] }, "execution_count": 202, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 4 X 1 로 바꿔준다.\n", "row_means.reshape((4,1))" ] }, { "cell_type": "code", "execution_count": 203, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([[ 0.55098591, -0.27255028, -0.27843563],\n", " [-0.95222776, 0.60670947, 0.34551829],\n", " [-0.34824118, -0.62839297, 0.97663415],\n", " [-0.39496415, 0.73266403, -0.33769989]])" ] }, "execution_count": 203, "metadata": {}, "output_type": "execute_result" } ], "source": [ "arr - row_means.reshape((4,1))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 행렬연산" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false }, "outputs": [ { "ename": "NameError", "evalue": "name 'np' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# 행렬 덧셈, 뺄셈\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m A = np.array([[1,2,3],\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m [7,8,9]])\n\u001b[1;32m 5\u001b[0m \u001b[0;32mprint\u001b[0m \u001b[0mA\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined" ] } ], "source": [ "# 행렬 덧셈, 뺄셈\n", "A = np.array([[1,2,3],\n", " [4,5,6],\n", " [7,8,9]])\n", "print A\n", "\n", "B = np.array([[1,1,1],\n", " [1,1,1],\n", " [1,1,1]])\n", "print B\n", "\n", "print A + B" ] }, { "cell_type": "code", "execution_count": 257, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[0 1 2]\n", " [3 4 5]\n", " [6 7 8]]\n" ] } ], "source": [ "print A - B" ] }, { "cell_type": "code", "execution_count": 258, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[1 2 3]\n", " [4 5 6]\n", " [7 8 9]]\n", "[[ 2 4 6]\n", " [ 8 10 12]\n", " [14 16 18]]\n" ] } ], "source": [ "# 행렬 곱\n", "\n", "print A\n", "\n", "# 스칼라 곱\n", "print A*2" ] }, { "cell_type": "code", "execution_count": 261, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[1 2 3]\n", " [4 5 6]\n", " [7 8 9]]\n", "[[2]\n", " [2]\n", " [2]]\n", "[[12]\n", " [30]\n", " [48]]\n" ] } ], "source": [ "print A\n", "\n", "C = np.array([[2],[2],[2]])\n", "print C\n", "\n", "# 행렬곱\n", "print np.dot(A,C)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# pandas 기초" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* pandas란 ?\n", "* pandas 자료 구조\n", "* pandas 기본 기능" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## pandas란 ?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* NumPy 기반으로 개발된, 고수준 자료 구조를 제공하는 데이터 분석 패키지\n", "* pandas 연관 단어 : NumPy, SciPy, matplotlib, DataFrame, 시계열 분석 " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### pandas 창시자가 원했던 기능\n", "\n", "* 자동적으로 혹은 명시적으로 축의 이름에 따라 데이터를 정렬할 수 있는 자료 구조\n", "* 잘못 정렬된 데이터에 의한 일반적인 오류를 예방하고 \n", "* 다양한 소스에서 가져온 다양한 방식으로 색인되어 있는 데이터를 다룰 수 있는 기능\n", "* 통합된 시계열 기능\n", "* 시계열 데이터와 비시계열 데이터를 함께 다룰 수 있는 통합 자료 구조\n", "* 산술연산과 한 축의 모든 값을 더하는 등의 데이터 축약연산은 축의 이름 같은 메타데이터로 전달될 수 있어야 함\n", "* 누락된 데이터를 유연하게 처리할 수 있는 기능\n", "* SQL 같은 일반 데이터베이스처럼 합치고 관계연산을 수행하는 기능" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## pandas 자료 구조" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* Series\n", "* DataFrame" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Series" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* 일련의 객체를 담을 수 있는 1차원 배열 같은 자료 구조(어떤 NumPy 자료형이라도 담을 수 있다)\n", "* 파이썬의 사전형과 비슷하다(정렬된 사전형이라고 보면 된다)\n", "* 파이썬 사전형 객체에서 생성할 수 있다." ] }, { "cell_type": "code", "execution_count": 312, "metadata": { "collapsed": false }, "outputs": [], "source": [ "from pandas import Series\n", "import pandas as pd" ] }, { "cell_type": "code", "execution_count": 327, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "0 4\n", "1 7\n", "2 -5\n", "3 3\n", "dtype: int64" ] }, "execution_count": 327, "metadata": {}, "output_type": "execute_result" } ], "source": [ "obj = Series([4, 7, -5, 3])\n", "\n", "# 결과의 왼쪽이 색인(index), 오른쪽이 값\n", "obj" ] }, { "cell_type": "code", "execution_count": 315, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "array([ 4, 7, -5, 3])" ] }, "execution_count": 315, "metadata": {}, "output_type": "execute_result" } ], "source": [ "obj.values" ] }, { "cell_type": "code", "execution_count": 316, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "Int64Index([0, 1, 2, 3], dtype='int64')" ] }, "execution_count": 316, "metadata": {}, "output_type": "execute_result" } ], "source": [ "obj.index" ] }, { "cell_type": "code", "execution_count": 317, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "d 4\n", "b 7\n", "a -5\n", "c 3\n", "dtype: int64" ] }, "execution_count": 317, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 색인을 지정해서 생성할 수 있다.\n", "obj2 = Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c'])\n", "obj2" ] }, { "cell_type": "code", "execution_count": 318, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "Index([u'd', u'b', u'a', u'c'], dtype='object')" ] }, "execution_count": 318, "metadata": {}, "output_type": "execute_result" } ], "source": [ "obj2.index" ] }, { "cell_type": "code", "execution_count": 320, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 320, "metadata": {}, "output_type": "execute_result" } ], "source": [ "obj2[0]" ] }, { "cell_type": "code", "execution_count": 321, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "-5" ] }, "execution_count": 321, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 색인을 이용해 접근\n", "obj2['a']" ] }, { "cell_type": "code", "execution_count": 322, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "d 6\n", "b 7\n", "a -5\n", "c 3\n", "dtype: int64" ] }, "execution_count": 322, "metadata": {}, "output_type": "execute_result" } ], "source": [ "obj2['d'] = 6\n", "obj2" ] }, { "cell_type": "code", "execution_count": 323, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "c 3\n", "a -5\n", "d 6\n", "dtype: int64" ] }, "execution_count": 323, "metadata": {}, "output_type": "execute_result" } ], "source": [ "obj2[['c', 'a', 'd']]" ] }, { "cell_type": "code", "execution_count": 324, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "d 6\n", "b 7\n", "c 3\n", "dtype: int64" ] }, "execution_count": 324, "metadata": {}, "output_type": "execute_result" } ], "source": [ "obj2[obj2 > 0]" ] }, { "cell_type": "code", "execution_count": 325, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "d 12\n", "b 14\n", "a -10\n", "c 6\n", "dtype: int64" ] }, "execution_count": 325, "metadata": {}, "output_type": "execute_result" } ], "source": [ "obj2 * 2" ] }, { "cell_type": "code", "execution_count": 326, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "d 403.428793\n", "b 1096.633158\n", "a 0.006738\n", "c 20.085537\n", "dtype: float64" ] }, "execution_count": 326, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.exp(obj2)" ] }, { "cell_type": "code", "execution_count": 328, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "{'Ohio': 35000, 'Oregon': 16000, 'Texas': 71000, 'Utah': 5000}" ] }, "execution_count": 328, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 사전형 객체로부터 생성\n", "sdata = {'Ohio': 35000,\n", " 'Texas': 71000,\n", " 'Oregon': 16000,\n", " 'Utah': 5000}\n", "sdata" ] }, { "cell_type": "code", "execution_count": 329, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "Ohio 35000\n", "Oregon 16000\n", "Texas 71000\n", "Utah 5000\n", "dtype: int64" ] }, "execution_count": 329, "metadata": {}, "output_type": "execute_result" } ], "source": [ "obj3 = Series(sdata)\n", "obj3" ] }, { "cell_type": "code", "execution_count": 331, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "California NaN\n", "Ohio 35000\n", "Oregon 16000\n", "Texas 71000\n", "dtype: float64" ] }, "execution_count": 331, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 사전으로 형성된 객체에, 새 인덱스가 추가되면 값이 NaN으로 매핑된다.\n", "states = ['California', 'Ohio', 'Oregon', 'Texas']\n", "obj4 = Series(sdata, index=states)\n", "obj4" ] }, { "cell_type": "code", "execution_count": 332, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "California True\n", "Ohio False\n", "Oregon False\n", "Texas False\n", "dtype: bool" ] }, "execution_count": 332, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 누락값을 찾기 위해서 pandas의 함수를 사용한다.\n", "\n", "# isnull \n", "pd.isnull(obj4)" ] }, { "cell_type": "code", "execution_count": 333, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "California False\n", "Ohio True\n", "Oregon True\n", "Texas True\n", "dtype: bool" ] }, "execution_count": 333, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# notnull\n", "pd.notnull(obj4)" ] }, { "cell_type": "code", "execution_count": 334, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "California True\n", "Ohio False\n", "Oregon False\n", "Texas False\n", "dtype: bool" ] }, "execution_count": 334, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Series의 메서드에도 있음.\n", "obj4.isnull()" ] }, { "cell_type": "code", "execution_count": 335, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "California False\n", "Ohio True\n", "Oregon True\n", "Texas True\n", "dtype: bool" ] }, "execution_count": 335, "metadata": {}, "output_type": "execute_result" } ], "source": [ "obj4.notnull()" ] }, { "cell_type": "code", "execution_count": 339, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "Bob 4\n", "Steve 7\n", "Jeff -5\n", "Ryan 3\n", "dtype: int64" ] }, "execution_count": 339, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# index 멤버객체에 리스트로 인덱스를 대입하면 인덱스 변경가능\n", "obj" ] }, { "cell_type": "code", "execution_count": 340, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "Bob 4\n", "Steve 7\n", "Jeff -5\n", "Ryan 3\n", "dtype: int64" ] }, "execution_count": 340, "metadata": {}, "output_type": "execute_result" } ], "source": [ "obj.index = ['Bob', 'Steve', 'Jeff', 'Ryan']\n", "obj" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### DataFrame" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* 표 같은 스프레드시트 형식의 자료 구조\n", "* 각 칼럼은 서로 다른 종류의 값(숫자, 문자열, 불리언) 담을 수 있다\n", "* 로우와 컬럼 각각에 색인 존재\n", "* 각 칼럼마다 Series 객체를 담고 있는 사전으로 생각하면 편하다\n", "* R의 data.frame과 비슷" ] }, { "cell_type": "code", "execution_count": 341, "metadata": { "collapsed": false }, "outputs": [], "source": [ "from pandas import DataFrame" ] }, { "cell_type": "code", "execution_count": 345, "metadata": { "collapsed": false }, "outputs": [], "source": [ "# Series 객체를 담고 있는 사전으로 생성\n", "data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],\n", " 'year': [2000, 2001, 2002, 2001, 2002],\n", " 'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}" ] }, { "cell_type": "code", "execution_count": 344, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
popstateyear
0 1.5 Ohio 2000
1 1.7 Ohio 2001
2 3.6 Ohio 2002
3 2.4 Nevada 2001
4 2.9 Nevada 2002
\n", "
" ], "text/plain": [ " pop state year\n", "0 1.5 Ohio 2000\n", "1 1.7 Ohio 2001\n", "2 3.6 Ohio 2002\n", "3 2.4 Nevada 2001\n", "4 2.9 Nevada 2002" ] }, "execution_count": 344, "metadata": {}, "output_type": "execute_result" } ], "source": [ "frame = DataFrame(data)\n", "frame" ] }, { "cell_type": "code", "execution_count": 346, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
yearstatepop
0 2000 Ohio 1.5
1 2001 Ohio 1.7
2 2002 Ohio 3.6
3 2001 Nevada 2.4
4 2002 Nevada 2.9
\n", "
" ], "text/plain": [ " year state pop\n", "0 2000 Ohio 1.5\n", "1 2001 Ohio 1.7\n", "2 2002 Ohio 3.6\n", "3 2001 Nevada 2.4\n", "4 2002 Nevada 2.9" ] }, "execution_count": 346, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 순서를 정해서 생성\n", "DataFrame(data, columns=['year', 'state', 'pop'])" ] }, { "cell_type": "code", "execution_count": 347, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
yearstatepopdebt
one 2000 Ohio 1.5 NaN
two 2001 Ohio 1.7 NaN
three 2002 Ohio 3.6 NaN
four 2001 Nevada 2.4 NaN
five 2002 Nevada 2.9 NaN
\n", "
" ], "text/plain": [ " year state pop debt\n", "one 2000 Ohio 1.5 NaN\n", "two 2001 Ohio 1.7 NaN\n", "three 2002 Ohio 3.6 NaN\n", "four 2001 Nevada 2.4 NaN\n", "five 2002 Nevada 2.9 NaN" ] }, "execution_count": 347, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 로우 인덱스도 함께 생성\n", "frame2 = DataFrame(data, columns=['year', 'state', 'pop', 'debt'],\n", " index=['one', 'two', 'three', 'four', 'five'])\n", "frame2" ] }, { "cell_type": "code", "execution_count": 349, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "Index([u'year', u'state', u'pop', u'debt'], dtype='object')" ] }, "execution_count": 349, "metadata": {}, "output_type": "execute_result" } ], "source": [ "frame2.columns" ] }, { "cell_type": "code", "execution_count": 350, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "one Ohio\n", "two Ohio\n", "three Ohio\n", "four Nevada\n", "five Nevada\n", "Name: state, dtype: object" ] }, "execution_count": 350, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 컬럼 접근 방법 \n", "\n", "# 사전 형식 표기법\n", "frame2['state']" ] }, { "cell_type": "code", "execution_count": 351, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "one Ohio\n", "two Ohio\n", "three Ohio\n", "four Nevada\n", "five Nevada\n", "Name: state, dtype: object" ] }, "execution_count": 351, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#속성 형식으로\n", "frame2.state" ] }, { "cell_type": "code", "execution_count": 352, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "year 2002\n", "state Ohio\n", "pop 3.6\n", "debt NaN\n", "Name: three, dtype: object" ] }, "execution_count": 352, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 로우 접근 방법\n", "frame2.ix['three']" ] }, { "cell_type": "code", "execution_count": 353, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
yearstatepopdebt
one 2000 Ohio 1.5 16.5
two 2001 Ohio 1.7 16.5
three 2002 Ohio 3.6 16.5
four 2001 Nevada 2.4 16.5
five 2002 Nevada 2.9 16.5
\n", "
" ], "text/plain": [ " year state pop debt\n", "one 2000 Ohio 1.5 16.5\n", "two 2001 Ohio 1.7 16.5\n", "three 2002 Ohio 3.6 16.5\n", "four 2001 Nevada 2.4 16.5\n", "five 2002 Nevada 2.9 16.5" ] }, "execution_count": 353, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 값 넣기\n", "frame2['debt'] = 16.5\n", "frame2" ] }, { "cell_type": "code", "execution_count": 355, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
yearstatepopdebt
one 2000 Ohio 1.5 0
two 2001 Ohio 1.7 1
three 2002 Ohio 3.6 2
four 2001 Nevada 2.4 3
five 2002 Nevada 2.9 4
\n", "
" ], "text/plain": [ " year state pop debt\n", "one 2000 Ohio 1.5 0\n", "two 2001 Ohio 1.7 1\n", "three 2002 Ohio 3.6 2\n", "four 2001 Nevada 2.4 3\n", "five 2002 Nevada 2.9 4" ] }, "execution_count": 355, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 배열도 대입가능\n", "frame2['debt'] = np.arange(5.)\n", "frame2" ] }, { "cell_type": "code", "execution_count": 356, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
NevadaOhio
2000 NaN 1.5
2001 2.4 1.7
2002 2.9 3.6
\n", "
" ], "text/plain": [ " Nevada Ohio\n", "2000 NaN 1.5\n", "2001 2.4 1.7\n", "2002 2.9 3.6" ] }, "execution_count": 356, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 로우, 컬럼 변경\n", "\n", "pop = {'Nevada': {2001: 2.4,\n", " 2002: 2.9},\n", " 'Ohio': {2000: 1.5,\n", " 2001: 1.7,\n", " 2002: 3.6}}\n", "\n", "frame3 = DataFrame(pop)\n", "frame3" ] }, { "cell_type": "code", "execution_count": 357, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
200020012002
Nevada NaN 2.4 2.9
Ohio 1.5 1.7 3.6
\n", "
" ], "text/plain": [ " 2000 2001 2002\n", "Nevada NaN 2.4 2.9\n", "Ohio 1.5 1.7 3.6" ] }, "execution_count": 357, "metadata": {}, "output_type": "execute_result" } ], "source": [ "frame3.T" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## pandas 기본 기능" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "* 하나의 로우 또는 칼럼 삭제\n", "* 색인하기, 선택하기, 거르기" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 하나의 로우 또는 칼럼 삭제" ] }, { "cell_type": "code", "execution_count": 365, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "a 0\n", "b 1\n", "c 2\n", "d 3\n", "e 4\n", "dtype: float64" ] }, "execution_count": 365, "metadata": {}, "output_type": "execute_result" } ], "source": [ "obj = Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])\n", "obj" ] }, { "cell_type": "code", "execution_count": 366, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "a 0\n", "b 1\n", "d 3\n", "e 4\n", "dtype: float64" ] }, "execution_count": 366, "metadata": {}, "output_type": "execute_result" } ], "source": [ "new_obj = obj.drop('c')\n", "new_obj" ] }, { "cell_type": "code", "execution_count": 367, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "a 0\n", "b 1\n", "e 4\n", "dtype: float64" ] }, "execution_count": 367, "metadata": {}, "output_type": "execute_result" } ], "source": [ "obj.drop(['d', 'c'])" ] }, { "cell_type": "code", "execution_count": 368, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
onetwothreefour
Ohio 0 1 2 3
Colorado 4 5 6 7
Utah 8 9 10 11
New York 12 13 14 15
\n", "
" ], "text/plain": [ " one two three four\n", "Ohio 0 1 2 3\n", "Colorado 4 5 6 7\n", "Utah 8 9 10 11\n", "New York 12 13 14 15" ] }, "execution_count": 368, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data = DataFrame(np.arange(16).reshape((4, 4)),\n", " index=['Ohio', 'Colorado', 'Utah', 'New York'],\n", " columns=['one', 'two', 'three', 'four'])\n", "data" ] }, { "cell_type": "code", "execution_count": 369, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
onetwothreefour
Utah 8 9 10 11
New York 12 13 14 15
\n", "
" ], "text/plain": [ " one two three four\n", "Utah 8 9 10 11\n", "New York 12 13 14 15" ] }, "execution_count": 369, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 로우 삭제\n", "data.drop(['Colorado', 'Ohio'])" ] }, { "cell_type": "code", "execution_count": 370, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
onethree
Ohio 0 2
Colorado 4 6
Utah 8 10
New York 12 14
\n", "
" ], "text/plain": [ " one three\n", "Ohio 0 2\n", "Colorado 4 6\n", "Utah 8 10\n", "New York 12 14" ] }, "execution_count": 370, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 컬럼 삭제\n", "data.drop(['two', 'four'], axis=1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 색인하기, 선택하기, 거르기" ] }, { "cell_type": "code", "execution_count": 371, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "a 0\n", "b 1\n", "c 2\n", "d 3\n", "dtype: float64" ] }, "execution_count": 371, "metadata": {}, "output_type": "execute_result" } ], "source": [ "obj = Series(np.arange(4.), index=['a', 'b', 'c', 'd'])\n", "obj" ] }, { "cell_type": "code", "execution_count": 372, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "1.0" ] }, "execution_count": 372, "metadata": {}, "output_type": "execute_result" } ], "source": [ "obj['b']" ] }, { "cell_type": "code", "execution_count": 373, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "1.0" ] }, "execution_count": 373, "metadata": {}, "output_type": "execute_result" } ], "source": [ "obj[1]" ] }, { "cell_type": "code", "execution_count": 374, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "c 2\n", "d 3\n", "dtype: float64" ] }, "execution_count": 374, "metadata": {}, "output_type": "execute_result" } ], "source": [ "obj[2:4]" ] }, { "cell_type": "code", "execution_count": 375, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "b 1\n", "a 0\n", "d 3\n", "dtype: float64" ] }, "execution_count": 375, "metadata": {}, "output_type": "execute_result" } ], "source": [ "obj[['b', 'a', 'd']]" ] }, { "cell_type": "code", "execution_count": 376, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "a 0\n", "b 1\n", "dtype: float64" ] }, "execution_count": 376, "metadata": {}, "output_type": "execute_result" } ], "source": [ "obj[obj < 2]" ] }, { "cell_type": "code", "execution_count": 377, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "b 1\n", "c 2\n", "dtype: float64" ] }, "execution_count": 377, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 라벨 이름으로 슬라이싱하는 것은 시작점과 끝점을 포함한다는 점이 일반 파이썬에서의 슬라이싱과 다른 점\n", "obj['b':'c']" ] }, { "cell_type": "code", "execution_count": 378, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
onetwothreefour
Ohio 0 1 2 3
Colorado 4 5 6 7
Utah 8 9 10 11
New York 12 13 14 15
\n", "
" ], "text/plain": [ " one two three four\n", "Ohio 0 1 2 3\n", "Colorado 4 5 6 7\n", "Utah 8 9 10 11\n", "New York 12 13 14 15" ] }, "execution_count": 378, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data = DataFrame(np.arange(16).reshape((4, 4)),\n", " index=['Ohio', 'Colorado', 'Utah', 'New York'],\n", " columns=['one', 'two', 'three', 'four'])\n", "data" ] }, { "cell_type": "code", "execution_count": 379, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "Ohio 1\n", "Colorado 5\n", "Utah 9\n", "New York 13\n", "Name: two, dtype: int64" ] }, "execution_count": 379, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 컬럼 선택\n", "data['two']" ] }, { "cell_type": "code", "execution_count": 380, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
threeone
Ohio 2 0
Colorado 6 4
Utah 10 8
New York 14 12
\n", "
" ], "text/plain": [ " three one\n", "Ohio 2 0\n", "Colorado 6 4\n", "Utah 10 8\n", "New York 14 12" ] }, "execution_count": 380, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data[['three', 'one']]" ] }, { "cell_type": "code", "execution_count": 383, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
onetwothreefour
Ohio 0 1 2 3
Colorado 4 5 6 7
\n", "
" ], "text/plain": [ " one two three four\n", "Ohio 0 1 2 3\n", "Colorado 4 5 6 7" ] }, "execution_count": 383, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 로우 선택\n", "data[:2]" ] }, { "cell_type": "code", "execution_count": 384, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "one 4\n", "two 5\n", "three 6\n", "four 7\n", "Name: Colorado, dtype: int64" ] }, "execution_count": 384, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data.ix['Colorado']" ] }, { "cell_type": "code", "execution_count": 385, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/plain": [ "two 5\n", "three 6\n", "Name: Colorado, dtype: int64" ] }, "execution_count": 385, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data.ix['Colorado', ['two', 'three']]" ] }, { "cell_type": "code", "execution_count": 386, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
onetwothreefour
Colorado 4 5 6 7
Utah 8 9 10 11
\n", "
" ], "text/plain": [ " one two three four\n", "Colorado 4 5 6 7\n", "Utah 8 9 10 11" ] }, "execution_count": 386, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data.ix[['Colorado', 'Utah']]" ] }, { "cell_type": "code", "execution_count": 387, "metadata": { "collapsed": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
twothree
Colorado 5 6
Utah 9 10
\n", "
" ], "text/plain": [ " two three\n", "Colorado 5 6\n", "Utah 9 10" ] }, "execution_count": 387, "metadata": {}, "output_type": "execute_result" } ], "source": [ "data.ix[['Colorado', 'Utah'], ['two', 'three']]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 참고자료 \n", "\n", " * [1] 파이썬 라이브러리를 활용한 데이터 분석 - http://www.hanbit.co.kr/book/look.html?isbn=978-89-6848-047-8\n", " * [2] 데이터/수치 분석을 위한 파이썬 라이브러리 SciPy와 NumPy - http://www.hanbit.co.kr/ebook/look.html?isbn=9788968486135\n", " * [3] 선형대수 보강(바이오파이썬) - http://nbviewer.ipython.org/github/biopy/biopy.github.io/blob/master/notebook/Part3/Week4/spB_LinearAlgebra/linear.ipynb" ] } ], "metadata": { "kernelspec": { "display_name": "Python 2", "language": "python", "name": "python2" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", "version": "2.7.6" } }, "nbformat": 4, "nbformat_minor": 0 }