{
"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",
" pop | \n",
" state | \n",
" year | \n",
"
\n",
" \n",
" \n",
" \n",
" 0 | \n",
" 1.5 | \n",
" Ohio | \n",
" 2000 | \n",
"
\n",
" \n",
" 1 | \n",
" 1.7 | \n",
" Ohio | \n",
" 2001 | \n",
"
\n",
" \n",
" 2 | \n",
" 3.6 | \n",
" Ohio | \n",
" 2002 | \n",
"
\n",
" \n",
" 3 | \n",
" 2.4 | \n",
" Nevada | \n",
" 2001 | \n",
"
\n",
" \n",
" 4 | \n",
" 2.9 | \n",
" Nevada | \n",
" 2002 | \n",
"
\n",
" \n",
"
\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",
" year | \n",
" state | \n",
" pop | \n",
"
\n",
" \n",
" \n",
" \n",
" 0 | \n",
" 2000 | \n",
" Ohio | \n",
" 1.5 | \n",
"
\n",
" \n",
" 1 | \n",
" 2001 | \n",
" Ohio | \n",
" 1.7 | \n",
"
\n",
" \n",
" 2 | \n",
" 2002 | \n",
" Ohio | \n",
" 3.6 | \n",
"
\n",
" \n",
" 3 | \n",
" 2001 | \n",
" Nevada | \n",
" 2.4 | \n",
"
\n",
" \n",
" 4 | \n",
" 2002 | \n",
" Nevada | \n",
" 2.9 | \n",
"
\n",
" \n",
"
\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",
" year | \n",
" state | \n",
" pop | \n",
" debt | \n",
"
\n",
" \n",
" \n",
" \n",
" one | \n",
" 2000 | \n",
" Ohio | \n",
" 1.5 | \n",
" NaN | \n",
"
\n",
" \n",
" two | \n",
" 2001 | \n",
" Ohio | \n",
" 1.7 | \n",
" NaN | \n",
"
\n",
" \n",
" three | \n",
" 2002 | \n",
" Ohio | \n",
" 3.6 | \n",
" NaN | \n",
"
\n",
" \n",
" four | \n",
" 2001 | \n",
" Nevada | \n",
" 2.4 | \n",
" NaN | \n",
"
\n",
" \n",
" five | \n",
" 2002 | \n",
" Nevada | \n",
" 2.9 | \n",
" NaN | \n",
"
\n",
" \n",
"
\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",
" year | \n",
" state | \n",
" pop | \n",
" debt | \n",
"
\n",
" \n",
" \n",
" \n",
" one | \n",
" 2000 | \n",
" Ohio | \n",
" 1.5 | \n",
" 16.5 | \n",
"
\n",
" \n",
" two | \n",
" 2001 | \n",
" Ohio | \n",
" 1.7 | \n",
" 16.5 | \n",
"
\n",
" \n",
" three | \n",
" 2002 | \n",
" Ohio | \n",
" 3.6 | \n",
" 16.5 | \n",
"
\n",
" \n",
" four | \n",
" 2001 | \n",
" Nevada | \n",
" 2.4 | \n",
" 16.5 | \n",
"
\n",
" \n",
" five | \n",
" 2002 | \n",
" Nevada | \n",
" 2.9 | \n",
" 16.5 | \n",
"
\n",
" \n",
"
\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",
" year | \n",
" state | \n",
" pop | \n",
" debt | \n",
"
\n",
" \n",
" \n",
" \n",
" one | \n",
" 2000 | \n",
" Ohio | \n",
" 1.5 | \n",
" 0 | \n",
"
\n",
" \n",
" two | \n",
" 2001 | \n",
" Ohio | \n",
" 1.7 | \n",
" 1 | \n",
"
\n",
" \n",
" three | \n",
" 2002 | \n",
" Ohio | \n",
" 3.6 | \n",
" 2 | \n",
"
\n",
" \n",
" four | \n",
" 2001 | \n",
" Nevada | \n",
" 2.4 | \n",
" 3 | \n",
"
\n",
" \n",
" five | \n",
" 2002 | \n",
" Nevada | \n",
" 2.9 | \n",
" 4 | \n",
"
\n",
" \n",
"
\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",
" Nevada | \n",
" Ohio | \n",
"
\n",
" \n",
" \n",
" \n",
" 2000 | \n",
" NaN | \n",
" 1.5 | \n",
"
\n",
" \n",
" 2001 | \n",
" 2.4 | \n",
" 1.7 | \n",
"
\n",
" \n",
" 2002 | \n",
" 2.9 | \n",
" 3.6 | \n",
"
\n",
" \n",
"
\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",
" 2000 | \n",
" 2001 | \n",
" 2002 | \n",
"
\n",
" \n",
" \n",
" \n",
" Nevada | \n",
" NaN | \n",
" 2.4 | \n",
" 2.9 | \n",
"
\n",
" \n",
" Ohio | \n",
" 1.5 | \n",
" 1.7 | \n",
" 3.6 | \n",
"
\n",
" \n",
"
\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",
" one | \n",
" two | \n",
" three | \n",
" four | \n",
"
\n",
" \n",
" \n",
" \n",
" Ohio | \n",
" 0 | \n",
" 1 | \n",
" 2 | \n",
" 3 | \n",
"
\n",
" \n",
" Colorado | \n",
" 4 | \n",
" 5 | \n",
" 6 | \n",
" 7 | \n",
"
\n",
" \n",
" Utah | \n",
" 8 | \n",
" 9 | \n",
" 10 | \n",
" 11 | \n",
"
\n",
" \n",
" New York | \n",
" 12 | \n",
" 13 | \n",
" 14 | \n",
" 15 | \n",
"
\n",
" \n",
"
\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",
" one | \n",
" two | \n",
" three | \n",
" four | \n",
"
\n",
" \n",
" \n",
" \n",
" Utah | \n",
" 8 | \n",
" 9 | \n",
" 10 | \n",
" 11 | \n",
"
\n",
" \n",
" New York | \n",
" 12 | \n",
" 13 | \n",
" 14 | \n",
" 15 | \n",
"
\n",
" \n",
"
\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",
" one | \n",
" three | \n",
"
\n",
" \n",
" \n",
" \n",
" Ohio | \n",
" 0 | \n",
" 2 | \n",
"
\n",
" \n",
" Colorado | \n",
" 4 | \n",
" 6 | \n",
"
\n",
" \n",
" Utah | \n",
" 8 | \n",
" 10 | \n",
"
\n",
" \n",
" New York | \n",
" 12 | \n",
" 14 | \n",
"
\n",
" \n",
"
\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",
" one | \n",
" two | \n",
" three | \n",
" four | \n",
"
\n",
" \n",
" \n",
" \n",
" Ohio | \n",
" 0 | \n",
" 1 | \n",
" 2 | \n",
" 3 | \n",
"
\n",
" \n",
" Colorado | \n",
" 4 | \n",
" 5 | \n",
" 6 | \n",
" 7 | \n",
"
\n",
" \n",
" Utah | \n",
" 8 | \n",
" 9 | \n",
" 10 | \n",
" 11 | \n",
"
\n",
" \n",
" New York | \n",
" 12 | \n",
" 13 | \n",
" 14 | \n",
" 15 | \n",
"
\n",
" \n",
"
\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",
" three | \n",
" one | \n",
"
\n",
" \n",
" \n",
" \n",
" Ohio | \n",
" 2 | \n",
" 0 | \n",
"
\n",
" \n",
" Colorado | \n",
" 6 | \n",
" 4 | \n",
"
\n",
" \n",
" Utah | \n",
" 10 | \n",
" 8 | \n",
"
\n",
" \n",
" New York | \n",
" 14 | \n",
" 12 | \n",
"
\n",
" \n",
"
\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",
" one | \n",
" two | \n",
" three | \n",
" four | \n",
"
\n",
" \n",
" \n",
" \n",
" Ohio | \n",
" 0 | \n",
" 1 | \n",
" 2 | \n",
" 3 | \n",
"
\n",
" \n",
" Colorado | \n",
" 4 | \n",
" 5 | \n",
" 6 | \n",
" 7 | \n",
"
\n",
" \n",
"
\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",
" one | \n",
" two | \n",
" three | \n",
" four | \n",
"
\n",
" \n",
" \n",
" \n",
" Colorado | \n",
" 4 | \n",
" 5 | \n",
" 6 | \n",
" 7 | \n",
"
\n",
" \n",
" Utah | \n",
" 8 | \n",
" 9 | \n",
" 10 | \n",
" 11 | \n",
"
\n",
" \n",
"
\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",
" two | \n",
" three | \n",
"
\n",
" \n",
" \n",
" \n",
" Colorado | \n",
" 5 | \n",
" 6 | \n",
"
\n",
" \n",
" Utah | \n",
" 9 | \n",
" 10 | \n",
"
\n",
" \n",
"
\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
}