Numpy_a.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def printf(x) :\n",
    "    for i in dir(np) :\n",
    "          _ if i.startswith(\"_\") else (print(i) if i[0] == x else  _ )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abs\n",
      "absolute\n",
      "absolute_import\n",
      "add\n",
      "add_docstring\n",
      "add_newdoc\n",
      "add_newdoc_ufunc\n",
      "alen\n",
      "all\n",
      "allclose\n",
      "alltrue\n",
      "amax\n",
      "amin\n",
      "angle\n",
      "any\n",
      "append\n",
      "apply_along_axis\n",
      "apply_over_axes\n",
      "arange\n",
      "arccos\n",
      "arccosh\n",
      "arcsin\n",
      "arcsinh\n",
      "arctan\n",
      "arctan2\n",
      "arctanh\n",
      "argmax\n",
      "argmin\n",
      "argpartition\n",
      "argsort\n",
      "argwhere\n",
      "around\n",
      "array\n",
      "array2string\n",
      "array_equal\n",
      "array_equiv\n",
      "array_repr\n",
      "array_split\n",
      "array_str\n",
      "asanyarray\n",
      "asarray\n",
      "asarray_chkfinite\n",
      "ascontiguousarray\n",
      "asfarray\n",
      "asfortranarray\n",
      "asmatrix\n",
      "asscalar\n",
      "atleast_1d\n",
      "atleast_2d\n",
      "atleast_3d\n",
      "average\n"
     ]
    }
   ],
   "source": [
    "printf('a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  반전 처리"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ -1  -2  -3  -4  -5  -6  -7  -8  -9 -10]\n",
      "[ -1  -2  -3  -4  -5  -6  -7  -8  -9 -10]\n",
      "[ -1  -2  -3  -4  -5  -6  -7  -8  -9 -10]\n",
      "[ 0 -1 -2 -3 -4 -5 -6 -7 -8 -9]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "ar  = np.arange(10)\n",
    "print(~ar)\n",
    "print(np.invert(ar))\n",
    "print(ar.__invert__())\n",
    "\n",
    "print(np.negative(ar))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 절대값 처리"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = ~ a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ -1,  -2,  -3,  -4,  -5,  -6,  -7,  -8,  -9, -10])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.abs(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = np.absolute(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function argwhere in module numpy:\n",
      "\n",
      "argwhere(a)\n",
      "    Find the indices of array elements that are non-zero, grouped by element.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    a : array_like\n",
      "        Input data.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    index_array : ndarray\n",
      "        Indices of elements that are non-zero. Indices are grouped by element.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    where, nonzero\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    ``np.argwhere(a)`` is the same as ``np.transpose(np.nonzero(a))``.\n",
      "    \n",
      "    The output of ``argwhere`` is not suitable for indexing arrays.\n",
      "    For this purpose use ``nonzero(a)`` instead.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> x = np.arange(6).reshape(2,3)\n",
      "    >>> x\n",
      "    array([[0, 1, 2],\n",
      "           [3, 4, 5]])\n",
      "    >>> np.argwhere(x>1)\n",
      "    array([[0, 2],\n",
      "           [1, 0],\n",
      "           [1, 1],\n",
      "           [1, 2]])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.argwhere)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 특정조건에  성립하는 인덱스 위치 표시"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1차원 처리"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5],\n",
       "       [6],\n",
       "       [7],\n",
       "       [8],\n",
       "       [9]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argwhere(c > 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2차원 처리"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.arange(6).reshape(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 2],\n",
       "       [1, 0],\n",
       "       [1, 1],\n",
       "       [1, 2]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argwhere(x>1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3차원처리"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.arange(8).reshape(2,2,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0, 1],\n",
       "        [2, 3]],\n",
       "\n",
       "       [[4, 5],\n",
       "        [6, 7]]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 0],\n",
       "       [0, 1, 1],\n",
       "       [1, 0, 0],\n",
       "       [1, 0, 1],\n",
       "       [1, 1, 0],\n",
       "       [1, 1, 1]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argwhere(x>1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "add\n",
    "add_docstring\n",
    "add_newdoc\n",
    "add_newdoc_ufunc\n",
    "alen\n",
    "all\n",
    "allclose\n",
    "alltrue\n",
    "amax\n",
    "amin\n",
    "angle\n",
    "any\n",
    "append\n",
    "apply_along_axis\n",
    "apply_over_axes\n",
    "arange\n",
    "arccos\n",
    "arccosh\n",
    "arcsin\n",
    "arcsinh\n",
    "arctan\n",
    "arctan2\n",
    "arctanh\n",
    "argmax\n",
    "argmin\n",
    "argpartition\n",
    "argsort\n",
    "around\n",
    "array\n",
    "array2string\n",
    "array_equal\n",
    "array_equiv\n",
    "array_repr\n",
    "array_split\n",
    "array_str\n",
    "asanyarray\n",
    "asarray\n",
    "asarray_chkfinite\n",
    "ascontiguousarray\n",
    "asfarray\n",
    "asfortranarray\n",
    "asmatrix\n",
    "asscalar\n",
    "atleast_1d\n",
    "atleast_2d\n",
    "atleast_3d\n",
    "average\n"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}