넘파이 클래스와 모듈 확인 .ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [ \"absolute_import\", \"add_newdocs\", \n",
    "\"bool\", \"bool8\", \"bool_\", \"broadcast\", \"busdaycalendar\", \n",
    "\"byte\", \"bytes0\", \"bytes_\", \"c_\", \"cast\", \n",
    "\"cdouble\", \"cfloat\", \"char\", \"character\", \"chararray\", \n",
    "\"clongdouble\", \"clongfloat\", \"compat\", \"complex\", \"complex128\", \n",
    "\"complex64\", \"complex_\", \"complexfloating\", \"core\",\"csingle\", \n",
    "\"ctypeslib\", \"datetime64\",\"division\", \"double\", \"dtype\", \n",
    "\"e\", \"emath\", \"errstate\", \"euler_gamma\", \"fft\", \n",
    "\"finfo\", \"flatiter\", \"flexible\", \"float\", \"float16\", \n",
    "\"float32\", \"float64\", \"float_\", \"floating\", \"format_parser\", \n",
    "\"generic\", \"half\", \"iinfo\", \"index_exp\", \"inexact\", \n",
    "\"inf\", \"infty\", \"int\", \"int0\", \"int16\", \n",
    "\"int32\", \"int64\", \"int8\", \"int_\", \"intc\", \n",
    "\"integer\", \"intp\",\"lib\", \"linalg\", \"little_endian\", \n",
    "\"long\", \"longcomplex\", \"longdouble\", \"longfloat\", \"longlong\", \n",
    "\"ma\", \"math\", \"matrix\", \"matrixlib\", \"memmap\", \n",
    "\"mgrid\", \"nan\", \"nbytes\", \"ndarray\", \"ndenumerate\", \n",
    "\"ndindex\", \"nditer\", \"newaxis\", \"numarray\", \"number\", \n",
    "\"object\", \"object0\", \"object_\", \"ogrid\", \"oldnumeric\", \n",
    "\"pi\", \"poly1d\", \"polynomial\", \"print_function\", \"r_\", \n",
    "\"random\", \"rec\", \"recarray\", \"record\", \"s_\", \n",
    "\"sctypeDict\", \"sctypeNA\", \"sctypes\", \"short\", \"signedinteger\", \n",
    "\"single\", \"singlecomplex\", \"str\", \"str0\", \"str_\", \n",
    "\"string_\",\"sys\", \"test\", \"testing\", \"timedelta64\", \n",
    "\"tracemalloc_domain\", \"typeDict\", \"typeNA\", \"typecodes\", \"ubyte\", \n",
    "\"ufunc\", \"uint\", \"uint0\", \"uint16\", \"uint32\", \n",
    "\"uint64\", \"uint8\", \"uintc\", \"uintp\", \"ulonglong\", \n",
    "\"unicode\", \"unicode_\", \"unsignedinteger\", \"ushort\", \"vectorize\", \n",
    "\"version\", \"void\", \"void0\", \"warnings\" ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 모듈 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "add_newdocs : <class 'module'>\n",
      "char : <class 'module'>\n",
      "compat : <class 'module'>\n",
      "core : <class 'module'>\n",
      "ctypeslib : <class 'module'>\n",
      "emath : <class 'module'>\n",
      "fft : <class 'module'>\n",
      "lib : <class 'module'>\n",
      "linalg : <class 'module'>\n",
      "ma : <class 'module'>\n",
      "math : <class 'module'>\n",
      "matrixlib : <class 'module'>\n",
      "polynomial : <class 'module'>\n",
      "random : <class 'module'>\n",
      "rec : <class 'module'>\n",
      "sys : <class 'module'>\n",
      "testing : <class 'module'>\n",
      "version : <class 'module'>\n",
      "warnings : <class 'module'>\n"
     ]
    }
   ],
   "source": [
    "for i in l :\n",
    "    if type(np.__dict__[i]) == types. ModuleType : \n",
    "        print(i + \" : \" + str(type(np.__dict__[i])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 클래스 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bool : <class 'type'>\n",
      "bool8 : <class 'type'>\n",
      "bool_ : <class 'type'>\n",
      "broadcast : <class 'type'>\n",
      "busdaycalendar : <class 'type'>\n",
      "byte : <class 'type'>\n",
      "bytes0 : <class 'type'>\n",
      "bytes_ : <class 'type'>\n",
      "cdouble : <class 'type'>\n",
      "cfloat : <class 'type'>\n",
      "character : <class 'type'>\n",
      "chararray : <class 'type'>\n",
      "clongdouble : <class 'type'>\n",
      "clongfloat : <class 'type'>\n",
      "complex : <class 'type'>\n",
      "complex128 : <class 'type'>\n",
      "complex64 : <class 'type'>\n",
      "complex_ : <class 'type'>\n",
      "complexfloating : <class 'type'>\n",
      "csingle : <class 'type'>\n",
      "datetime64 : <class 'type'>\n",
      "double : <class 'type'>\n",
      "dtype : <class 'type'>\n",
      "errstate : <class 'type'>\n",
      "finfo : <class 'type'>\n",
      "flatiter : <class 'type'>\n",
      "flexible : <class 'type'>\n",
      "float : <class 'type'>\n",
      "float16 : <class 'type'>\n",
      "float32 : <class 'type'>\n",
      "float64 : <class 'type'>\n",
      "float_ : <class 'type'>\n",
      "floating : <class 'type'>\n",
      "format_parser : <class 'type'>\n",
      "generic : <class 'type'>\n",
      "half : <class 'type'>\n",
      "iinfo : <class 'type'>\n",
      "inexact : <class 'type'>\n",
      "int : <class 'type'>\n",
      "int0 : <class 'type'>\n",
      "int16 : <class 'type'>\n",
      "int32 : <class 'type'>\n",
      "int64 : <class 'type'>\n",
      "int8 : <class 'type'>\n",
      "int_ : <class 'type'>\n",
      "intc : <class 'type'>\n",
      "integer : <class 'type'>\n",
      "intp : <class 'type'>\n",
      "long : <class 'type'>\n",
      "longcomplex : <class 'type'>\n",
      "longdouble : <class 'type'>\n",
      "longfloat : <class 'type'>\n",
      "longlong : <class 'type'>\n",
      "matrix : <class 'type'>\n",
      "memmap : <class 'type'>\n",
      "ndarray : <class 'type'>\n",
      "ndenumerate : <class 'type'>\n",
      "ndindex : <class 'type'>\n",
      "nditer : <class 'type'>\n",
      "number : <class 'type'>\n",
      "object : <class 'type'>\n",
      "object0 : <class 'type'>\n",
      "object_ : <class 'type'>\n",
      "poly1d : <class 'type'>\n",
      "recarray : <class 'type'>\n",
      "record : <class 'type'>\n",
      "short : <class 'type'>\n",
      "signedinteger : <class 'type'>\n",
      "single : <class 'type'>\n",
      "singlecomplex : <class 'type'>\n",
      "str : <class 'type'>\n",
      "str0 : <class 'type'>\n",
      "str_ : <class 'type'>\n",
      "string_ : <class 'type'>\n",
      "timedelta64 : <class 'type'>\n",
      "ubyte : <class 'type'>\n",
      "ufunc : <class 'type'>\n",
      "uint : <class 'type'>\n",
      "uint0 : <class 'type'>\n",
      "uint16 : <class 'type'>\n",
      "uint32 : <class 'type'>\n",
      "uint64 : <class 'type'>\n",
      "uint8 : <class 'type'>\n",
      "uintc : <class 'type'>\n",
      "uintp : <class 'type'>\n",
      "ulonglong : <class 'type'>\n",
      "unicode : <class 'type'>\n",
      "unicode_ : <class 'type'>\n",
      "unsignedinteger : <class 'type'>\n",
      "ushort : <class 'type'>\n",
      "vectorize : <class 'type'>\n",
      "void : <class 'type'>\n",
      "void0 : <class 'type'>\n"
     ]
    }
   ],
   "source": [
    "for i in l :\n",
    "    if type(np.__dict__[i]) == type : \n",
    "        print(i + \" : \" + str(type(np.__dict__[i])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 속성값"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "absolute_import : <class '__future__._Feature'>\n",
      "c_ : <class 'numpy.lib.index_tricks.CClass'>\n",
      "cast : <class 'numpy.core.numerictypes._typedict'>\n",
      "division : <class '__future__._Feature'>\n",
      "e : <class 'float'>\n",
      "euler_gamma : <class 'float'>\n",
      "index_exp : <class 'numpy.lib.index_tricks.IndexExpression'>\n",
      "inf : <class 'float'>\n",
      "infty : <class 'float'>\n",
      "little_endian : <class 'bool'>\n",
      "mgrid : <class 'numpy.lib.index_tricks.nd_grid'>\n",
      "nan : <class 'float'>\n",
      "nbytes : <class 'numpy.core.numerictypes._typedict'>\n",
      "newaxis : <class 'NoneType'>\n",
      "numarray : <class 'str'>\n",
      "ogrid : <class 'numpy.lib.index_tricks.nd_grid'>\n",
      "oldnumeric : <class 'str'>\n",
      "pi : <class 'float'>\n",
      "print_function : <class '__future__._Feature'>\n",
      "r_ : <class 'numpy.lib.index_tricks.RClass'>\n",
      "s_ : <class 'numpy.lib.index_tricks.IndexExpression'>\n",
      "sctypeDict : <class 'dict'>\n",
      "sctypeNA : <class 'dict'>\n",
      "sctypes : <class 'dict'>\n",
      "test : <class 'numpy.testing._private.pytesttester.PytestTester'>\n",
      "tracemalloc_domain : <class 'int'>\n",
      "typeDict : <class 'dict'>\n",
      "typeNA : <class 'dict'>\n",
      "typecodes : <class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "for i in l :\n",
    "    if (type(np.__dict__[i]) == type or\n",
    "        type(np.__dict__[i]) == types. ModuleType) : \n",
    "        continue\n",
    "        \n",
    "    print(i + \" : \" + str(type(np.__dict__[i])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 넘파이 타입 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{numpy.bool_: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.bool_'>)>,\n",
       " numpy.int8: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.int8'>)>,\n",
       " numpy.uint8: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.uint8'>)>,\n",
       " numpy.int16: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.int16'>)>,\n",
       " numpy.uint16: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.uint16'>)>,\n",
       " numpy.int32: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.int32'>)>,\n",
       " numpy.uint32: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.uint32'>)>,\n",
       " numpy.int32: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.int32'>)>,\n",
       " numpy.uint32: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.uint32'>)>,\n",
       " numpy.int64: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.int64'>)>,\n",
       " numpy.uint64: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.uint64'>)>,\n",
       " numpy.float16: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.float16'>)>,\n",
       " numpy.float32: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.float32'>)>,\n",
       " numpy.float64: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.float64'>)>,\n",
       " numpy.float64: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.float64'>)>,\n",
       " numpy.complex64: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.complex64'>)>,\n",
       " numpy.complex128: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.complex128'>)>,\n",
       " numpy.complex128: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.complex128'>)>,\n",
       " numpy.object_: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.object_'>)>,\n",
       " numpy.bytes_: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.bytes_'>)>,\n",
       " numpy.str_: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.str_'>)>,\n",
       " numpy.void: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.void'>)>,\n",
       " numpy.datetime64: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.datetime64'>)>,\n",
       " numpy.timedelta64: <function numpy.core.numerictypes.<lambda>(x, k=<class 'numpy.timedelta64'>)>}"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.cast"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.void, numpy.void)"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.void, np.void0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## bool 타입 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.bool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.bool is bool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.bool_"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.bool8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "ba = np.bool8()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ba.itemsize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ba.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.bool8 is np.uint8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.bool8 is np.int8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.bool_"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.bool_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 정수 처리 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "iinfo(min=-2147483648, max=2147483647, dtype=int32)"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.iinfo('int')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.int is int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.int64, numpy.int32)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.int0, np.int_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.int8, numpy.int16, numpy.int32, numpy.int64)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.int8, np.int16, np.int32, np.int64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.integer"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.int32, numpy.int64)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.intc, np.intp,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.uint32, numpy.uint64)"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.uint, np.uint0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.uint8, numpy.uint16, numpy.uint32, numpy.uint64)"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.uint8,np.uint16, np.uint32, np.uint64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.uint32, numpy.uint64)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.uintc, np.uintp,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(int, numpy.int64)"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.long, np.longlong,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.int16"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.short"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.uint64, numpy.uint16)"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ulonglong, np.ushort,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.unsignedinteger,)"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " np.unsignedinteger, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.signedinteger"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.signedinteger"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 부동소수점 실수 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "finfo(resolution=1e-15, min=-1.7976931348623157e+308, max=1.7976931348623157e+308, dtype=float64)"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.finfo('float')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.float is float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.float16, numpy.float32, numpy.float64)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np. float16, np.float32, np.float64, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.float64"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.float_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.floating"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " np.floating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.float64"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.double"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.float64, numpy.float64)"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " np.longdouble, np.longfloat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 복소수 처리 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "complex"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.complex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.complex is complex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.complex128, numpy.complex64, numpy.complex128)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.complex128, np.complex64, np.complex_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.complex128,)"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.longcomplex,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.complex128, numpy.complex128)"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.cdouble, np.cfloat,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.complex128, numpy.complex128)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.clongdouble, np.clongfloat,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.float32, numpy.complex64, numpy.complex64)"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.single, np.singlecomplex, np.csingle"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 무한대와 결측값 처리 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "inf"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.inf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.nan"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 수 처리 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.complexfloating"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.complexfloating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.inexact,)"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.complexfloating.__bases__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.number,)"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.inexact.__bases__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.number"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.generic,)"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.number.__bases__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.generic"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.generic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 바이트 문자열 처리 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.int8"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.byte"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.bytes_, numpy.bytes_)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.bytes0, np.bytes_,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 문자 클래스 처리"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<module 'numpy.core.defchararray' from 'C:\\\\Users\\\\John\\\\Anaconda3\\\\lib\\\\site-packages\\\\numpy\\\\core\\\\defchararray.py'>"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.char"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.character"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.character"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 문자열 클래스 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.little_endian"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.str is str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.str_, numpy.str_)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.str0, np.str_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.bytes_,)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.string_,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(str, True)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unicode, np.unicode is str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.str_,)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unicode_,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "object"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.object is object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.object_, numpy.object_)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.object0, np.object_, "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 날짜 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.datetime64"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.datetime64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.timedelta64"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.timedelta64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.busdaycalendar"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.busdaycalendar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}