Skip to content

Instantly share code, notes, and snippets.

@HyeongWookKim

HyeongWookKim/Numpy 기초.ipynb

Created June 4, 2020 14:08
Show Gist options
  • Save HyeongWookKim/f5083d7a08cd8d5ac5350966a3f8a5f3 to your computer and use it in GitHub Desktop.
Save HyeongWookKim/f5083d7a08cd8d5ac5350966a3f8a5f3 to your computer and use it in GitHub Desktop.
Download ZIP
[Numpy 기초] from "파이썬 머신러닝 완벽 가이드(권철민 저)"
Display the source blob
Display the rendered blob
Raw
Numpy 기초.ipynb
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Numpy (넘파이) 기초"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Numpy ndarray 개요"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**ndarray 생성 np.array()**\n",
"- 파이썬의 리스트와 같은 다양한 인자를 입력 받아서 ndarrary로 변환하는 기능을 수행"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:11.336803Z",
"start_time": "2020-05-17T15:29:08.338679Z"
}
},
"outputs": [],
"source": [
"# 일반적으로 넘파이 별칭으로 np를 사용한다\n",
"import numpy as np"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:11.929225Z",
"start_time": "2020-05-17T15:29:11.910211Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"list1: [1, 2, 3]\n",
"list1 type: <class 'list'>\n",
"array1: [1 2 3]\n",
"array1 type: <class 'numpy.ndarray'>\n"
]
}
],
"source": [
"list1 = [1, 2, 3]\n",
"print(\"list1:\", list1)\n",
"print(\"list1 type:\", type(list1))\n",
"\n",
"array1 = np.array(list1)\n",
"print(\"array1:\", array1)\n",
"print(\"array1 type:\", type(array1))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**ndarray 의 형태(shape)와 차원**\n",
"- 생성된 ndarray 배열의 shape 변수는 ndarray의 크기, 즉 행과 열의 수를 '튜플' 형태로 갖고 있으며, 이를 통해 ndarray 배열의 차원까지 알 수 있다\n",
"- 다시 말해, ndarray.shape는 ndarray의 차원과 크기를 '튜플' 형태로 나타내 준다"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:12.925934Z",
"start_time": "2020-05-17T15:29:12.912923Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"array1 type: <class 'numpy.ndarray'>\n",
"array1 array 형태: (3,)\n",
"array2 type: <class 'numpy.ndarray'>\n",
"array2 array 형태: (2, 3)\n",
"array3 type: <class 'numpy.ndarray'>\n",
"array3 array 형태: (1, 3)\n"
]
}
],
"source": [
"# 1차원 array로 3개의 데이터를 가지고 있음을 뜻함\n",
"array1 = np.array([1, 2, 3])\n",
"print('array1 type:', type(array1))\n",
"print('array1 array 형태:', array1.shape)\n",
"\n",
"# 2차원 array로 2개의 row와 3개의 column으로 구성\n",
"# 즉, 6개의 데이터를 가지고 있음을 뜻함\n",
"array2 = np.array([[1, 2, 3],\n",
" [2, 3, 4]])\n",
"print('array2 type:', type(array2))\n",
"print('array2 array 형태:', array2.shape)\n",
"\n",
"# 2차원 array로 1개의 row와 3개의 column으로 구성\n",
"# 즉, 3개의 데이터를 가지고 있음을 뜻함\n",
"array3 = np.array([[1, 2, 3]])\n",
"print('array3 type:', type(array3))\n",
"print('array3 array 형태:', array3.shape)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**ndarray.ndim을 통해 각 array의 차원을 알 수 있다**"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:13.741513Z",
"start_time": "2020-05-17T15:29:13.735510Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"array1: 1차원, array2: 2차원, array3: 2차원\n"
]
}
],
"source": [
"print('array1: {:0}차원, array2: {:1}차원, array3: {:2}차원'.format(array1.ndim, array2.ndim, array3.ndim))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**ndarray 데이터 값 타입**\n",
"- ndarray 내의 데이터 타입은 dtype 속성으로 확인할 수 있다\n",
"- 숫자 값, 문자열 값, bool 값 등이 모두 가능하다\n",
"- ndarray 내의 데이터 타입은 그 연산의 특성상 같은 데이터 타입만 가능하다!!\n",
"- ex) 한 개의 ndarray 객체에 int 와 float 가 함께 있을 수 없다"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:14.532072Z",
"start_time": "2020-05-17T15:29:14.525086Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'list'>\n",
"<class 'numpy.ndarray'>\n",
"[1 2 3] int32\n"
]
}
],
"source": [
"list1 = [1, 2, 3]\n",
"print(type(list1))\n",
"array1 = np.array(list1)\n",
"\n",
"print(type(array1))\n",
"print(array1, array1.dtype)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**만약 다른 데이터 유형이 섞여 있는 리스트를 ndarray로 변경하면, 데이터의 크기가 더 큰 데이터 타입으로 형 변환을 일괄 적용!**"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:15.214557Z",
"start_time": "2020-05-17T15:29:15.207550Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['1' '2' 'test'] <U11\n",
"[1. 2. 3.] float64\n"
]
}
],
"source": [
"list2 = [1, 2, 'test']\n",
"array2 = np.array(list2) # 정수형 값들이 모두 사이즈가 큰 '문자열'로 변경된다\n",
"print(array2, array2.dtype)\n",
"\n",
"list3 = [1, 2, 3.0]\n",
"array3 = np.array(list3) # 정수형 값들이 모두 사이즈가 큰 '실수형'으로 변경된다\n",
"print(array3, array3.dtype)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**ndarray 내 데이터 값의 타입 변경도 astype() 메소드를 이용해서 할 수 있다**\n",
"- 데이터 타입을 변경하는 경우는 대용량 데이터의 ndarray를 만들 때, 메모리를 더 절약하기 위해서 보통 이용한다"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:15.616841Z",
"start_time": "2020-05-17T15:29:15.604833Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1. 2. 3.] float64\n",
"[1 2 3] int32\n",
"[1 2 3] int32\n"
]
}
],
"source": [
"array_int = np.array([1, 2, 3])\n",
"array_float = array_int.astype('float64') # float 형으로 변경\n",
"print(array_float, array_float.dtype)\n",
"\n",
"array_int1= array_float.astype('int32') # int 형으로 변경\n",
"print(array_int1, array_int1.dtype)\n",
"\n",
"array_float1 = np.array([1.1, 2.1, 3.1])\n",
"array_int2= array_float1.astype('int32') # int 형으로 변경\n",
"print(array_int2, array_int2.dtype)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**ndarray에서 axis 기반의 연산함수 수행**\n",
"- axis = 0 은 행 방향을 의미\n",
"- axis = 1 은 열 방향을 의미"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:15.968093Z",
"start_time": "2020-05-17T15:29:15.961090Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"15\n",
"[3 5 7]\n",
"[6 9]\n"
]
}
],
"source": [
"array2 = np.array([[1, 2, 3],\n",
" [2, 3, 4]])\n",
"\n",
"print(array2.sum()) # 모든 값들을 sum\n",
"print(array2.sum(axis = 0)) # 행 방향으로 sum\n",
"print(array2.sum(axis = 1)) # 열 방향으로 sum"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**ndarray를 편리하게 생성하기 - arange, zeros, ones**\n",
"- 특정 크기와 차원을 가진 ndarray를 연속값이나 0 또는 1로 초기화해 쉽게 생성해야 할 필요가 있는 경우에 사용한다\n",
"- 주로 테스트용으로 데이터를 만들거나 대규모의 데이터를 일괄적으로 초기화해야 할 경우에 사용된다\n",
"\n",
"**1. arange() 함수**\n",
"- array를 range()로 표현하는 것\n",
"- 파이썬 표준 함수인 range()와 유사한 기능을 한다"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:16.289319Z",
"start_time": "2020-05-17T15:29:16.283315Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0 1 2 3 4 5 6 7 8 9]\n",
"int32 (10,)\n"
]
}
],
"source": [
"sequence_array = np.arange(10)\n",
"print(sequence_array)\n",
"print(sequence_array.dtype, sequence_array.shape)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**2. zeros() 함수**\n",
"- 함수 인자로 '튜플' 형태의 shape 값을 입력하면, 모든 값을 0으로 채운 해당 shape를 가진 ndarray를 반환해준다\n",
"\n",
"**3. ones() 함수**\n",
"- 함수 인자로 '튜플' 형태의 shape 값을 입력하면, 모든 값을 1로 채운 해당 shape를 가진 ndarray를 반환해준다\n",
"\n",
"##### <참고> 위의 두 함수 모두 dtype을 정해주지 않으면, default로 'float64' 형의 데이터로 ndarray를 채운다"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:16.582526Z",
"start_time": "2020-05-17T15:29:16.572518Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[0 0]\n",
" [0 0]\n",
" [0 0]]\n",
"int32 (3, 2)\n",
"[[1. 1.]\n",
" [1. 1.]\n",
" [1. 1.]]\n",
"float64 (3, 2)\n"
]
}
],
"source": [
"# dtype 을 지정해준 경우\n",
"zero_array = np.zeros((3,2), dtype = 'int32')\n",
"print(zero_array)\n",
"print(zero_array.dtype, zero_array.shape)\n",
"\n",
"# dtype 을 지정해주지 않은 경우\n",
"one_array = np.ones((3, 2))\n",
"print(one_array)\n",
"print(one_array.dtype, one_array.shape)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**ndarray의 shape를 변경하는 reshape()**\n",
"- ndarray를 특정 차원 및 크기로 변환한다\n",
"- 변환을 원하는 크기를 함수 인자로 부여하면 된다\n",
"- reshape() 는 지정된 사이즈로 변경이 불가능하면 오류를 발생시킨다"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:16.871731Z",
"start_time": "2020-05-17T15:29:16.860724Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"array1:\n",
" [0 1 2 3 4 5 6 7 8 9]\n",
"array2:\n",
" [[0 1 2 3 4]\n",
" [5 6 7 8 9]]\n",
"array3:\n",
" [[0 1]\n",
" [2 3]\n",
" [4 5]\n",
" [6 7]\n",
" [8 9]]\n"
]
}
],
"source": [
"array1 = np.arange(10)\n",
"print('array1:\\n', array1)\n",
"\n",
"array2 = array1.reshape(2, 5) # 2 row x 5 column 의 형태로 2차원 ndarray로 변환\n",
"print('array2:\\n', array2)\n",
"\n",
"array3 = array1.reshape(5, 2) # 5 row x 2 column 의 형태로 2차원 ndarray로 변환\n",
"print('array3:\\n', array3)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:17.273015Z",
"start_time": "2020-05-17T15:29:17.007829Z"
}
},
"outputs": [
{
"ename": "ValueError",
"evalue": "cannot reshape array of size 10 into shape (4,3)",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m<ipython-input-12-77b99fb809df>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m# 변환할 수 있는 shape구조를 입력하면 오류 발생!\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0marray1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\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: cannot reshape array of size 10 into shape (4,3)"
]
}
],
"source": [
"# 변환할 수 있는 shape구조를 입력하면 오류 발생!\n",
"array1.reshape(4, 3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**<실제로 reshape()를 효율적으로 사용하는 경우>**\n",
"\n",
"**reshape()에 -1 인자값을 부여하여 특정 차원으로 고정된 가변적인 ndarray형태 변환**\n",
"- -1 을 인자로 사용하면 원래 ndarray와 호환되는 새로운 shape로 변환해준다"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:17.387099Z",
"start_time": "2020-05-17T15:29:17.380093Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0 1 2 3 4 5 6 7 8 9]\n",
"array2 shape: (2, 5)\n",
"array2:\n",
" [[0 1 2 3 4]\n",
" [5 6 7 8 9]]\n",
"array3 shape: (5, 2)\n",
"array3:\n",
" [[0 1]\n",
" [2 3]\n",
" [4 5]\n",
" [6 7]\n",
" [8 9]]\n"
]
}
],
"source": [
"array1 = np.arange(10)\n",
"print(array1)\n",
"\n",
"# array1과 호환될 수 있는 '2차원 ndarray'로 변환하되, column axis 크기는 5에 고정하고, row axis 크기를 이에 맞춰 자동으로 변환\n",
"# 즉, 2 x 5 형태로 변환\n",
"array2 = array1.reshape(-1, 5)\n",
"print('array2 shape:', array2.shape)\n",
"print('array2:\\n', array2)\n",
"\n",
"# array1과 호환될 수 있는 '2차원 ndarray'로 변환하되, row axis 크기는 5로 고정하고, column axis크기는 이에 맞춰 자동으로 변환\n",
"# 즉, 5 x 2 형태로 변환 \n",
"array3 = array1.reshape(5, -1)\n",
"print('array3 shape:', array3.shape)\n",
"print('array3:\\n', array3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- reshape()는 (-1, 1), (-1,)와 같은 형태로 주로 사용됨\n",
"- 1차원 ndarray를 2차원으로 또는 2차원 ndarray를 1차원으로 변환 시 사용"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:17.589240Z",
"start_time": "2020-05-17T15:29:17.580237Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"array2d_1 shape: (5, 1)\n",
"array2d_1:\n",
" [[0]\n",
" [1]\n",
" [2]\n",
" [3]\n",
" [4]]\n",
"array1d shape: (5,)\n",
"array1d:\n",
" [0 1 2 3 4]\n"
]
}
],
"source": [
"array1 = np.arange(5)\n",
"\n",
"# 1차원 ndarray를 2차원으로 변환하되, column axis크기는 반드시 1 이여야 함 \n",
"array2d_1 = array1.reshape(-1, 1)\n",
"print(\"array2d_1 shape:\", array2d_1.shape)\n",
"print(\"array2d_1:\\n\", array2d_1)\n",
"\n",
"# 2차원 ndarray를 1차원으로 변환\n",
"array1d = array2d_1.reshape(-1,)\n",
"print(\"array1d shape:\", array1d.shape)\n",
"print(\"array1d:\\n\", array1d)"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:17.742366Z",
"start_time": "2020-05-17T15:29:17.726337Z"
},
"scrolled": true
},
"outputs": [
{
"ename": "ValueError",
"evalue": "cannot reshape array of size 10 into shape (4)",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m<ipython-input-15-fbdf562f57f0>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m# -1 을 적용하여도 변환이 불가능한 형태로의 변환을 요구할 경우 오류 발생\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 2\u001b[0m \u001b[0marray1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0marray4\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0marray1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m4\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: cannot reshape array of size 10 into shape (4)"
]
}
],
"source": [
"# -1 을 적용하여도 변환이 불가능한 형태로의 변환을 요구할 경우 오류 발생\n",
"array1 = np.arange(10)\n",
"array4 = array1.reshape(-1, 4)"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:17.882447Z",
"start_time": "2020-05-17T15:29:17.866439Z"
},
"scrolled": true
},
"outputs": [
{
"ename": "ValueError",
"evalue": "can only specify one unknown dimension",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m<ipython-input-16-68c145d1f1a0>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[1;31m# 반드시 -1 값은 1개의 인자만 입력해야 함 --> 그렇지 않으면 오류 발생\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0marray1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[1;31mValueError\u001b[0m: can only specify one unknown dimension"
]
}
],
"source": [
"# 반드시 -1 값은 1개의 인자만 입력해야 함 --> 그렇지 않으면 오류 발생\n",
"array1.reshape(-1, -1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**nadrray를 tolist() 메소드를 이용해서 리스트 자료형으로 변환**\n",
"- print를 이용해서 출력할 때, 시각적으로 더 이해하기 쉽도록 tolist() 메소드를 사용할 수도 있다"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:18.198672Z",
"start_time": "2020-05-17T15:29:18.190672Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"array3d:\n",
" [[[0, 1], [2, 3]], [[4, 5], [6, 7]]]\n",
"array5:\n",
" [[0], [1], [2], [3], [4], [5], [6], [7]]\n",
"array5 shape: (8, 1)\n",
"array6:\n",
" [[0], [1], [2], [3], [4], [5], [6], [7]]\n",
"array6 shape: (8, 1)\n"
]
}
],
"source": [
"array1 = np.arange(8)\n",
"array3d = array1.reshape((2, 2, 2))\n",
"print('array3d:\\n', array3d.tolist())\n",
"\n",
"# 3차원 ndarray를 2차원 ndarray로 변환\n",
"array5 = array3d.reshape(-1, 1)\n",
"print('array5:\\n', array5.tolist())\n",
"print('array5 shape:', array5.shape)\n",
"\n",
"# 1차원 ndarray를 2차원 ndarray로 변환\n",
"array6 = array1.reshape(-1, 1)\n",
"print('array6:\\n', array6.tolist())\n",
"print('array6 shape:', array6.shape)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### ndarray의 데이터 세트 선택하기 – 인덱싱(Indexing)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**특정 위치의 단일 값 추출**\n",
"- 원하는 위치의 인덱스 값을 지정하면, 해당 위치의 데이터가 반환"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:18.633981Z",
"start_time": "2020-05-17T15:29:18.626977Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"array1: [1 2 3 4 5 6 7 8 9]\n",
"value: 3\n",
"<class 'numpy.int32'>\n"
]
}
],
"source": [
"# 1에서 부터 9 까지의 1차원 ndarray 생성 \n",
"array1 = np.arange(start = 1, stop = 10)\n",
"print('array1:', array1)\n",
"\n",
"# index는 0 부터 시작하므로, array1[2]는 3번째 index 위치의 데이터 값을 의미\n",
"value = array1[2]\n",
"print('value:', value)\n",
"print(type(value))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- 인덱스 -1 은 맨 뒤의 데이터 값을 의미"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:18.951205Z",
"start_time": "2020-05-17T15:29:18.944202Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"맨 뒤의 값: 9 , 맨 뒤에서 두번째 값: 8\n"
]
}
],
"source": [
"print('맨 뒤의 값:', array1[-1], ', 맨 뒤에서 두번째 값:', array1[-2])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- 단일 인덱스를 이용해 ndarray 내의 데이터 값 수정"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:19.235409Z",
"start_time": "2020-05-17T15:29:19.230421Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"array1: [9 2 3 4 5 6 7 8 0]\n"
]
}
],
"source": [
"array1[0] = 9\n",
"array1[8] = 0\n",
"print('array1:', array1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- 다차원 ndarray에서 단일 값 추출\n",
"- 2차원의 경우 콤마(,)로 분리된 row 와 column 위치의 인덱스를 통해 접근 --> [row, column]"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:19.528615Z",
"start_time": "2020-05-17T15:29:19.517609Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[1 2 3]\n",
" [4 5 6]\n",
" [7 8 9]]\n",
"(row = 0, col = 0) index 가리키는 값: 1\n",
"(row = 0, col = 1) index 가리키는 값: 2\n",
"(row = 1, col = 0) index 가리키는 값: 4\n",
"(row = 2, col = 2) index 가리키는 값: 9\n"
]
}
],
"source": [
"array1d = np.arange(start = 1, stop = 10)\n",
"array2d = array1d.reshape(3, 3)\n",
"print(array2d)\n",
"\n",
"print('(row = 0, col = 0) index 가리키는 값:', array2d[0, 0])\n",
"print('(row = 0, col = 1) index 가리키는 값:', array2d[0, 1])\n",
"print('(row = 1, col = 0) index 가리키는 값:', array2d[1, 0])\n",
"print('(row = 2, col = 2) index 가리키는 값:', array2d[2, 2])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**슬라이싱(Slicing)**\n",
"- 연속된 인덱스 상의 ndarray를 추출하는 방식\n",
"- ':' 기호 사이에 시작 인덱스와 종료 인덱스를 표시하면, '시작 인덱스'부터 '종료 인덱스 - 1' 위치까지 데이터의 ndarray를 반환"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:19.812817Z",
"start_time": "2020-05-17T15:29:19.804812Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1 2 3 4 5 6 7 8 9]\n",
"[1 2 3]\n",
"<class 'numpy.ndarray'>\n"
]
}
],
"source": [
"array1 = np.arange(start = 1, stop = 10)\n",
"print(array1)\n",
"array3 = array1[0:3]\n",
"print(array3)\n",
"print(type(array3))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- ':' 기호 앞에 시작 인덱스를 생략하면, 자동으로 맨 처음 인덱스인 0 으로 간주\n",
"- ':' 기호 뒤에 종료 인덱스를 생략하면, 자동으로 맨 마지막 인덱스로 간주\n",
"- ':' 기호 앞/뒤에 시작/종료 인덱스를 생략하면, 자동으로 맨 처음/맨 마지막 인덱스로 간주"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:20.141055Z",
"start_time": "2020-05-17T15:29:20.131043Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1 2 3]\n",
"[4 5 6 7 8 9]\n",
"[1 2 3 4 5 6 7 8 9]\n"
]
}
],
"source": [
"array1 = np.arange(start = 1, stop = 10)\n",
"array4 = array1[:3]\n",
"print(array4)\n",
"\n",
"array5 = array1[3:]\n",
"print(array5)\n",
"\n",
"array6 = array1[:]\n",
"print(array6)"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:20.327181Z",
"start_time": "2020-05-17T15:29:20.309170Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"array2d:\n",
" [[1 2 3]\n",
" [4 5 6]\n",
" [7 8 9]]\n",
"\n",
"array2d[0:2, 0:2] \n",
" [[1 2]\n",
" [4 5]]\n",
"array2d[1:3, 0:3] \n",
" [[4 5 6]\n",
" [7 8 9]]\n",
"array2d[1:3, :] \n",
" [[4 5 6]\n",
" [7 8 9]]\n",
"array2d[:, :] \n",
" [[1 2 3]\n",
" [4 5 6]\n",
" [7 8 9]]\n",
"array2d[:2, 1:] \n",
" [[2 3]\n",
" [5 6]]\n",
"array2d[:2, 0] \n",
" [1 4]\n",
"array2d[0] \n",
" [1 2 3]\n"
]
}
],
"source": [
"array1d = np.arange(start = 1, stop = 10)\n",
"array2d = array1d.reshape(3, 3)\n",
"print('array2d:\\n', array2d)\n",
"print()\n",
"\n",
"print('array2d[0:2, 0:2] \\n', array2d[0:2, 0:2])\n",
"print('array2d[1:3, 0:3] \\n', array2d[1:3, 0:3])\n",
"print('array2d[1:3, :] \\n', array2d[1:3, :])\n",
"print('array2d[:, :] \\n', array2d[:, :])\n",
"print('array2d[:2, 1:] \\n', array2d[:2, 1:])\n",
"print('array2d[:2, 0] \\n', array2d[:2, 0])\n",
"\n",
"# 2차원 ndarray에서 뒤에 오는 인덱스를 없애면, 1차원 ndarray를 반환\n",
"# 즉, array2d[0]과 같이 2차원에서 뒤에 오는 인덱스를 없애면, row 축(axis = 0)의 첫 번째 row ndarray를 반환\n",
"print('array2d[0] \\n', array2d[0])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**팬시 인덱싱(fancy indexing)**\n",
"- 일정한 인덱싱 집합을 리스트 또는 ndarray 형태로 지정해, 해당 위치에 있는 데이터의 ndarray를 반환"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:20.642421Z",
"start_time": "2020-05-17T15:29:20.630398Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[1 2 3]\n",
" [4 5 6]\n",
" [7 8 9]]\n",
"array2d[[0, 1], 2] => [3, 6]\n",
"array2d[[0, 2], 0:2] => [[1, 2], [7, 8]]\n",
"array2d[[0, 1]] => [[1, 2, 3], [4, 5, 6]]\n"
]
}
],
"source": [
"array1d = np.arange(start = 1, stop = 10)\n",
"array2d = array1d.reshape(3, 3)\n",
"print(array2d)\n",
"\n",
"array3 = array2d[[0, 1], 2]\n",
"print('array2d[[0, 1], 2] => ', array3.tolist())\n",
"\n",
"array4 = array2d[[0, 2], 0:2]\n",
"print('array2d[[0, 2], 0:2] => ', array4.tolist())\n",
"\n",
"array5 = array2d[[0, 1]]\n",
"print('array2d[[0, 1]] => ', array5.tolist())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**불린 인덱싱(Boolean indexing)**\n",
"- 조건 필터링과 검색을 동시에 할 수 있기 때문에 매우 자주 사용!!\n",
"- 특정 조건에 해당하는지 여부인 True/False 값 인덱싱 집합을 기반으로, True에 해당하는 인덱스 위치에 있는 데이터의 ndarray를 반환\n",
"- 불린 인덱싱은 ndarray의 인덱스를 지정하는 [ ] 내에 조건문을 그대로 기재하기만 하면 된다\n",
"\n",
"**불린 인덱싱 처리 과정 요약 예시**\n",
"- Step 1. array1d > 5 Boolean 조건을 [ ] 내에 입력\n",
"- Step 2. False 값은 무시하고, True 값에 해당하는 index 값만 저장\n",
"- Step 3. 저장된 index 값으로 데이터 조회"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:20.924607Z",
"start_time": "2020-05-17T15:29:20.916601Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1 2 3 4 5 6 7 8 9]\n",
"[False False False False False True True True True]\n",
"var1: [False False False False False True True True True]\n",
"<class 'numpy.ndarray'>\n"
]
}
],
"source": [
"array1d = np.arange(start = 1, stop = 10)\n",
"print(array1d)\n",
"print(array1d > 5)\n",
"\n",
"var1 = array1d > 5\n",
"print(\"var1:\", var1)\n",
"print(type(var1))"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:21.104733Z",
"start_time": "2020-05-17T15:29:21.097730Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1 2 3 4 5 6 7 8 9]\n",
"array1d > 5 불린 인덱싱 결과 값 : [6 7 8 9]\n"
]
}
],
"source": [
"# [ ] 안에 array1d > 5 Boolean indexing을 적용 \n",
"print(array1d)\n",
"array3 = array1d[array1d > 5]\n",
"print('array1d > 5 불린 인덱싱 결과 값 :', array3)"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:21.254839Z",
"start_time": "2020-05-17T15:29:21.247836Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"불린 인덱스로 필터링 결과 : [6 7 8 9]\n"
]
}
],
"source": [
"boolean_indexes = np.array([False, False, False, False, False, True, True, True, True])\n",
"array3 = array1d[boolean_indexes]\n",
"print('불린 인덱스로 필터링 결과 :', array3)"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:21.394939Z",
"start_time": "2020-05-17T15:29:21.388936Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"일반 인덱스로 필터링 결과 : [6 7 8 9]\n"
]
}
],
"source": [
"indexes = np.array([5, 6, 7, 8])\n",
"array4 = array1d[indexes]\n",
"print('일반 인덱스로 필터링 결과 :', array4)"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:21.577069Z",
"start_time": "2020-05-17T15:29:21.567077Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[6 7 8 9]\n"
]
}
],
"source": [
"# 불린 인덱싱을 사용하지 않은 경우(코드가 길어짐)\n",
"array1d = np.arange(start = 1, stop = 10)\n",
"target = []\n",
"\n",
"for i in range(0, 9):\n",
" if array1d[i] > 5:\n",
" target.append(array1d[i])\n",
"\n",
"array_selected = np.array(target)\n",
"print(array_selected)"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:21.722170Z",
"start_time": "2020-05-17T15:29:21.714170Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[6 7 8 9]\n"
]
}
],
"source": [
"print(array1d[array1 > 5])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 행렬의 정렬 – sort( )와 argsort( )\n",
"\n",
"**행렬 정렬**\n",
"\n",
"**1. np.sort()**\n",
"- 원 행렬은 그대로 유지한 채, 원 행렬의 정렬된 행렬을 반환\n",
"\n",
"**2. ndarray.sort()**\n",
"- 원 행렬 자체를 정렬한 형태로 반환하며, 반환 값은 None이다"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:22.040397Z",
"start_time": "2020-05-17T15:29:22.032395Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"원본 행렬: [3 1 9 5]\n",
"np.sort( ) 호출 후 반환된 정렬 행렬: [1 3 5 9]\n",
"np.sort( ) 호출 후 원본 행렬: [3 1 9 5]\n",
"org_array.sort( ) 호출 후 반환된 행렬: None\n",
"org_array.sort( ) 호출 후 원본 행렬: [1 3 5 9]\n"
]
}
],
"source": [
"org_array = np.array([3, 1, 9, 5]) \n",
"print('원본 행렬:', org_array)\n",
"\n",
"# np.sort( )로 정렬 \n",
"sort_array1 = np.sort(org_array) \n",
"print ('np.sort( ) 호출 후 반환된 정렬 행렬:', sort_array1) \n",
"print('np.sort( ) 호출 후 원본 행렬:', org_array)\n",
"\n",
"# ndarray.sort( )로 정렬\n",
"sort_array2 = org_array.sort()\n",
"org_array.sort()\n",
"print('org_array.sort( ) 호출 후 반환된 행렬:', sort_array2)\n",
"print('org_array.sort( ) 호출 후 원본 행렬:', org_array)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- np.sort() 와 ndarray.sort() 모두 기본적으로 '오름차순'으로 행렬 내 원소를 정렬\n",
"- '내림차순'으로 정렬하기 위해서는 [::-1]을 적용해야 한다!"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:22.375634Z",
"start_time": "2020-05-17T15:29:22.368631Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"내림차순으로 정렬: [9 5 3 1]\n"
]
}
],
"source": [
"sort_array1_desc = np.sort(org_array)[::-1]\n",
"print ('내림차순으로 정렬:', sort_array1_desc)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- 행렬이 2차원 이상일 경우, axis 축 값 설정을 통해 row 방향 또는 column 방향으로 정렬을 수행할 수 있다"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:23.598503Z",
"start_time": "2020-05-17T15:29:23.590495Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"로우 방향으로 정렬:\n",
" [[ 7 1]\n",
" [ 8 12]]\n",
"컬럼 방향으로 정렬:\n",
" [[ 8 12]\n",
" [ 1 7]]\n"
]
}
],
"source": [
"array2d = np.array([[8, 12], \n",
" [7, 1]])\n",
"\n",
"sort_array2d_axis0 = np.sort(array2d, axis = 0)\n",
"print('로우 방향으로 정렬:\\n', sort_array2d_axis0)\n",
"\n",
"sort_array2d_axis1 = np.sort(array2d, axis = 1)\n",
"print('컬럼 방향으로 정렬:\\n', sort_array2d_axis1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**3. np.argsort()**\n",
"- 정렬된 행렬의 '원본 행렬 인덱스'를 ndarray 형으로 반환"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:24.528161Z",
"start_time": "2020-05-17T15:29:24.522174Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1 3 5 9]\n",
"<class 'numpy.ndarray'>\n",
"행렬 정렬 시 원본 행렬의 인덱스: [1 0 3 2]\n"
]
}
],
"source": [
"org_array = np.array([3, 1, 9, 5]) \n",
"print(np.sort(org_array))\n",
"\n",
"sort_indices = np.argsort(org_array)\n",
"print(type(sort_indices))\n",
"print('행렬 정렬 시 원본 행렬의 인덱스:', sort_indices)"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:24.927445Z",
"start_time": "2020-05-17T15:29:24.921446Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[9 5 3 1]\n",
"행렬 내림차순 정렬 시 원본 행렬의 인덱스: [2 3 0 1]\n"
]
}
],
"source": [
"# [::-1] 를 사용해서 '내림차순' 정렬된 행렬의 '원본 행렬 인덱스'를 반환하기\n",
"org_array = np.array([3, 1, 9, 5]) \n",
"print(np.sort(org_array)[::-1])\n",
"\n",
"sort_indices_desc = np.argsort(org_array)[::-1]\n",
"print('행렬 내림차순 정렬 시 원본 행렬의 인덱스:', sort_indices_desc)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**argsort() 는 넘파이에서 매우 활용도가 높음**\n",
"- 넘파이의 데이터 추출에서 많이 사용됨\n",
"- ex) 'key-value' 형태의 데이터를 John=78, Mike=95, Sarah=84, Kate=98, Samuel=88 을 ndarray로 만들고, argsort()를 이용하여 key 값을 정렬"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:25.575904Z",
"start_time": "2020-05-17T15:29:25.565902Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"성적 오름차순 정렬시 score_array의 인덱스: [0 2 4 1 3]\n",
"성적 오름차순으로 name_array의 이름 출력: ['John' 'Sarah' 'Samuel' 'Mike' 'Kate']\n",
"성적 오름차순으로 score_array의 점수 출력: [78 84 88 95 98]\n"
]
}
],
"source": [
"name_array = np.array(['John', 'Mike', 'Sarah', 'Kate', 'Samuel'])\n",
"score_array = np.array([78, 95, 84, 98, 88])\n",
"\n",
"# score_array의 정렬된 값에 해당하는 '원본 행렬 위치 인덱스' 반환하고, 이를 이용하여 name_array에서 name 값 추출\n",
"sort_indices = np.argsort(score_array)\n",
"print('성적 오름차순 정렬시 score_array의 인덱스:', sort_indices)\n",
"\n",
"name_array_sort = name_array[sort_indices]\n",
"score_array_sort = score_array[sort_indices]\n",
"\n",
"print('성적 오름차순으로 name_array의 이름 출력:', name_array_sort)\n",
"print('성적 오름차순으로 score_array의 점수 출력:', score_array_sort)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 선형대수 연산 – 행렬 내적과 전치 행렬 구하기\n",
"\n",
"**행렬 내적**\n",
"- 두 행렬 A와 B의 내적은 np.dot()을 이용해서 계산이 가능"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:26.513570Z",
"start_time": "2020-05-17T15:29:26.506566Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"행렬 내적 결과:\n",
" [[ 58 64]\n",
" [139 154]]\n"
]
}
],
"source": [
"A = np.array([[1, 2, 3],\n",
" [4, 5, 6]])\n",
"B = np.array([[7, 8],\n",
" [9, 10],\n",
" [11, 12]])\n",
"\n",
"dot_product = np.dot(A, B)\n",
"print('행렬 내적 결과:\\n', dot_product)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**전치 행렬**\n",
"- 원 행렬에서 행과 열의 위치를 교환한 원소로 구성한 행렬\n",
"- 넘파이의 transpose()를 이용해서 쉽게 전치 행렬을 구할 수 있다"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {
"ExecuteTime": {
"end_time": "2020-05-17T15:29:27.308133Z",
"start_time": "2020-05-17T15:29:27.300129Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"A의 전치 행렬:\n",
" [[1 3]\n",
" [2 4]]\n"
]
}
],
"source": [
"A = np.array([[1, 2],\n",
" [3, 4]])\n",
"transpose_mat = np.transpose(A)\n",
"print('A의 전치 행렬:\\n', transpose_mat)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.6"
},
"toc": {
"base_numbering": 1,
"nav_menu": {},
"number_sections": true,
"sideBar": true,
"skip_h1_title": false,
"title_cell": "Table of Contents",
"title_sidebar": "Contents",
"toc_cell": false,
"toc_position": {},
"toc_section_display": true,
"toc_window_display": false
}
},
"nbformat": 4,
"nbformat_minor": 2
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment