numpy_top_200_separate_cells.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# NumPy 常用方法示例 (每个示例独立单元格)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import math"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 2 3]\n"
          ]
        }
      ],
      "source": [
        "# 1. np.array\n",
        "arr = np.array([1, 2, 3])\n",
        "print(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 3 5 7 9]\n"
          ]
        }
      ],
      "source": [
        "# 2. np.arange\n",
        "arr = np.arange(1, 10, 2)\n",
        "print(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.   0.25 0.5  0.75 1.  ]\n"
          ]
        }
      ],
      "source": [
        "# 3. np.linspace\n",
        "arr = np.linspace(0, 1, 5)\n",
        "print(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[  1.           3.16227766  10.          31.6227766  100.        ]\n"
          ]
        }
      ],
      "source": [
        "# 4. np.logspace\n",
        "arr = np.logspace(0, 2, 5)\n",
        "print(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[0. 0. 0.]\n",
            " [0. 0. 0.]]\n"
          ]
        }
      ],
      "source": [
        "# 5. np.zeros\n",
        "arr = np.zeros((2, 3))\n",
        "print(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1. 1. 1.]\n",
            " [1. 1. 1.]]\n"
          ]
        }
      ],
      "source": [
        "# 6. np.ones\n",
        "arr = np.ones((2, 3))\n",
        "print(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[99 99]\n",
            " [99 99]]\n"
          ]
        }
      ],
      "source": [
        "# 7. np.full\n",
        "arr = np.full((2, 2), 99)\n",
        "print(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[0.25 0.5 ]\n",
            " [0.75 1.  ]]\n"
          ]
        }
      ],
      "source": [
        "# 8. np.empty\n",
        "arr = np.empty((2, 2))\n",
        "print(arr)  # 内容不确定"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1. 0. 0.]\n",
            " [0. 1. 0.]\n",
            " [0. 0. 1.]]\n"
          ]
        }
      ],
      "source": [
        "# 9. np.eye\n",
        "arr = np.eye(3)\n",
        "print(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1. 0. 0.]\n",
            " [0. 1. 0.]\n",
            " [0. 0. 1.]]\n"
          ]
        }
      ],
      "source": [
        "# 10. np.identity\n",
        "arr = np.identity(3)\n",
        "print(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[0 1 2]\n",
            " [1 2 3]\n",
            " [2 3 4]]\n"
          ]
        }
      ],
      "source": [
        "# 11. np.fromfunction\n",
        "def func(i, j):\n",
        "    return i + j\n",
        "arr = np.fromfunction(func, (3, 3), dtype=int)\n",
        "print(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0. 1. 2. 3. 4.]\n"
          ]
        }
      ],
      "source": [
        "# 12. np.fromiter\n",
        "iterable = range(5)\n",
        "arr = np.fromiter(iterable, dtype=float)\n",
        "print(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 2 3 4]\n"
          ]
        }
      ],
      "source": [
        "# 13. np.fromstring\n",
        "s = '1 2 3 4'\n",
        "arr = np.fromstring(s, dtype=int, sep=' ')\n",
        "print(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 2 3] [99  2  3]\n"
          ]
        }
      ],
      "source": [
        "# 14. np.copy\n",
        "original = np.array([1, 2, 3])\n",
        "arr_copy = np.copy(original)\n",
        "arr_copy[0] = 99\n",
        "print(original, arr_copy)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 2 3]\n"
          ]
        }
      ],
      "source": [
        "# 15. np.asarray\n",
        "x = [1, 2, 3]\n",
        "arr = np.asarray(x)\n",
        "print(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "<class 'numpy.matrix'>\n"
          ]
        }
      ],
      "source": [
        "# 16. np.asanyarray\n",
        "x = np.matrix([[1,2],[3,4]])\n",
        "arr = np.asanyarray(x)\n",
        "print(type(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "float32\n"
          ]
        }
      ],
      "source": [
        "# 17. np.asfarray\n",
        "arr = np.asarray([1, 2, 3], dtype=np.float32)\n",
        "print(arr.dtype)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "# 18. np.ascontiguousarray\n",
        "arr = np.ascontiguousarray([[1, 2, 3], [4, 5, 6]])\n",
        "print(arr.flags['C_CONTIGUOUS'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "# 19. np.asfortranarray\n",
        "arr = np.asfortranarray([[1, 2], [3, 4]])\n",
        "print(arr.flags['F_CONTIGUOUS'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[5] (1,)\n"
          ]
        }
      ],
      "source": [
        "# 20. np.atleast_1d\n",
        "arr = np.atleast_1d(5)\n",
        "print(arr, arr.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1 2 3]] (1, 3)\n"
          ]
        }
      ],
      "source": [
        "# 21. np.atleast_2d\n",
        "arr = np.atleast_2d([1, 2, 3])\n",
        "print(arr, arr.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(1, 3, 1)\n"
          ]
        }
      ],
      "source": [
        "# 22. np.atleast_3d\n",
        "arr = np.atleast_3d([1, 2, 3])\n",
        "print(arr.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(2, 3)\n"
          ]
        }
      ],
      "source": [
        "# 23. arr.shape\n",
        "arr_2d = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "print(arr_2d.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2\n"
          ]
        }
      ],
      "source": [
        "# 24. arr.ndim\n",
        "print(arr_2d.ndim)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "6\n"
          ]
        }
      ],
      "source": [
        "# 25. arr.size\n",
        "print(arr_2d.size)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "int64\n"
          ]
        }
      ],
      "source": [
        "# 26. arr.dtype\n",
        "print(arr_2d.dtype)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "8\n"
          ]
        }
      ],
      "source": [
        "# 27. arr.itemsize\n",
        "print(arr_2d.itemsize)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "48\n"
          ]
        }
      ],
      "source": [
        "# 28. arr.nbytes\n",
        "print(arr_2d.nbytes)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1 4]\n",
            " [2 5]\n",
            " [3 6]]\n"
          ]
        }
      ],
      "source": [
        "# 29. arr.T\n",
        "print(arr_2d.T)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[np.int64(1), np.int64(2), np.int64(3), np.int64(4), np.int64(5), np.int64(6)]\n"
          ]
        }
      ],
      "source": [
        "# 30. arr.flat\n",
        "print(list(arr_2d.flat))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "# 31. arr.base\n",
        "sub_arr = arr_2d[0, :]\n",
        "print(sub_arr.base is arr_2d)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[0 1 2]\n",
            " [3 4 5]]\n"
          ]
        }
      ],
      "source": [
        "# 32. np.reshape\n",
        "arr = np.arange(6)\n",
        "arr_reshaped = arr.reshape((2, 3))\n",
        "print(arr_reshaped)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0 1 2 3 4 5]\n"
          ]
        }
      ],
      "source": [
        "# 33. ravel\n",
        "print(arr_reshaped.ravel())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0 1 2 3 4 5]\n"
          ]
        }
      ],
      "source": [
        "# 34. flatten\n",
        "print(arr_reshaped.flatten())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(1, 3)\n"
          ]
        }
      ],
      "source": [
        "# 35. expand_dims\n",
        "x = np.array([1, 2, 3])\n",
        "y = np.expand_dims(x, axis=0)\n",
        "print(y.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(3,)\n"
          ]
        }
      ],
      "source": [
        "# 36. squeeze\n",
        "x = np.array([[[1, 2, 3]]])\n",
        "y = np.squeeze(x)\n",
        "print(y.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1 4]\n",
            " [2 5]\n",
            " [3 6]]\n"
          ]
        }
      ],
      "source": [
        "# 37. swapaxes\n",
        "arr_2d = np.array([[1,2,3],[4,5,6]])\n",
        "swapped = np.swapaxes(arr_2d, 0, 1)\n",
        "print(swapped)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 39,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(3, 4, 2)\n"
          ]
        }
      ],
      "source": [
        "# 38. moveaxis\n",
        "arr_3d = np.ones((2, 3, 4))\n",
        "moved = np.moveaxis(arr_3d, 0, -1)\n",
        "print(moved.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 40,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 2 3 4]\n"
          ]
        }
      ],
      "source": [
        "# 39. concatenate\n",
        "a = np.array([1, 2])\n",
        "b = np.array([3, 4])\n",
        "c = np.concatenate((a, b))\n",
        "print(c)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1 2]\n",
            " [3 4]]\n"
          ]
        }
      ],
      "source": [
        "# 40. vstack\n",
        "a = np.array([1,2])\n",
        "b = np.array([3,4])\n",
        "c = np.vstack((a,b))\n",
        "print(c)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1 3]\n",
            " [2 4]]\n"
          ]
        }
      ],
      "source": [
        "# 41. hstack\n",
        "a = np.array([[1],[2]])\n",
        "b = np.array([[3],[4]])\n",
        "c = np.hstack((a,b))\n",
        "print(c)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(2, 2, 2)\n"
          ]
        }
      ],
      "source": [
        "# 42. dstack\n",
        "a = np.array([[1,2],[3,4]])\n",
        "b = np.array([[5,6],[7,8]])\n",
        "c = np.dstack((a, b))\n",
        "print(c.shape)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 44,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1 2]\n",
            " [3 4]]\n"
          ]
        }
      ],
      "source": [
        "# 43. stack\n",
        "a = np.array([1, 2])\n",
        "b = np.array([3, 4])\n",
        "c = np.stack((a, b), axis=0)\n",
        "print(c)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]\n"
          ]
        }
      ],
      "source": [
        "# 44. split\n",
        "arr = np.arange(9)\n",
        "splitted = np.split(arr, 3)\n",
        "print(splitted)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8, 9])]\n"
          ]
        }
      ],
      "source": [
        "# 45. array_split\n",
        "arr = np.arange(10)\n",
        "splitted = np.array_split(arr, 3)\n",
        "print(splitted)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[array([[0],\n",
            "       [3]]), array([[1],\n",
            "       [4]]), array([[2],\n",
            "       [5]])]\n"
          ]
        }
      ],
      "source": [
        "# 46. hsplit\n",
        "arr = np.arange(6).reshape(2,3)\n",
        "splitted = np.hsplit(arr, 3)\n",
        "print(splitted)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 48,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[array([[0, 1, 2]]), array([[3, 4, 5]])]\n"
          ]
        }
      ],
      "source": [
        "# 47. vsplit\n",
        "arr = np.arange(6).reshape(2,3)\n",
        "splitted = np.vsplit(arr, 2)\n",
        "print(splitted)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[(2, 2, 1), (2, 2, 1)]\n"
          ]
        }
      ],
      "source": [
        "# 48. dsplit\n",
        "arr = np.arange(8).reshape(2,2,2)\n",
        "splitted = np.dsplit(arr, 2)\n",
        "print([s.shape for s in splitted])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 50,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1. 1. 0. 0.]\n",
            " [1. 1. 0. 0.]\n",
            " [7. 7. 1. 0.]\n",
            " [7. 7. 0. 1.]]\n"
          ]
        }
      ],
      "source": [
        "# 49. block\n",
        "A = np.block([\n",
        "    [np.ones((2,2)), np.zeros((2,2))],\n",
        "    [np.full((2,2), 7), np.eye(2)]\n",
        "])\n",
        "print(A)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 51,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 2 3]\n"
          ]
        }
      ],
      "source": [
        "# 50. 基本切片\n",
        "arr = np.array([0, 1, 2, 3, 4])\n",
        "print(arr[1:4])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 52,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1 2]\n",
            " [4 5]]\n"
          ]
        }
      ],
      "source": [
        "# 51. 多维切片\n",
        "arr_2d = np.array([[0,1,2],[3,4,5],[6,7,8]])\n",
        "print(arr_2d[:2, 1:])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 53,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[3 4 5]\n"
          ]
        }
      ],
      "source": [
        "# 52. 布尔索引\n",
        "arr = np.array([1, 2, 3, 4, 5])\n",
        "bool_idx = arr > 2\n",
        "print(arr[bool_idx])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 54,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[10 30 50]\n"
          ]
        }
      ],
      "source": [
        "# 53. 花式索引\n",
        "arr = np.array([10, 20, 30, 40, 50])\n",
        "idx = [0, 2, 4]\n",
        "print(arr[idx])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 55,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(array([2, 3]),)\n"
          ]
        }
      ],
      "source": [
        "# 54. np.where\n",
        "arr = np.array([10, 20, 30, 40])\n",
        "result = np.where(arr > 25)\n",
        "print(result)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 56,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1 0]\n",
            " [1 1]]\n"
          ]
        }
      ],
      "source": [
        "# 55. np.argwhere\n",
        "arr = np.array([[1, 2], [3, 4]])\n",
        "print(np.argwhere(arr > 2))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 57,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(array([1, 3, 4]),)\n"
          ]
        }
      ],
      "source": [
        "# 56. np.nonzero\n",
        "arr = np.array([0, 1, 0, 2, 3])\n",
        "print(np.nonzero(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 58,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[20 40]\n"
          ]
        }
      ],
      "source": [
        "# 57. np.take\n",
        "arr = np.array([10, 20, 30, 40])\n",
        "print(np.take(arr, [1,3]))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 59,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[99 20 88 40]\n"
          ]
        }
      ],
      "source": [
        "# 58. np.put\n",
        "arr = np.array([10, 20, 30, 40])\n",
        "np.put(arr, [0, 2], [99, 88])\n",
        "print(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 60,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[10 50 30]\n"
          ]
        }
      ],
      "source": [
        "# 59. np.choose\n",
        "x = np.array([0, 1, 0])\n",
        "choice_arrays = [np.array([10,20,30]), np.array([40,50,60])]\n",
        "result = np.choose(x, choice_arrays)\n",
        "print(result)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 61,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 2 3]\n"
          ]
        }
      ],
      "source": [
        "# 60. np.unique\n",
        "arr = np.array([1, 2, 2, 3, 3, 3])\n",
        "print(np.unique(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 62,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[False  True False]\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "C:\\Users\\minqliu\\AppData\\Local\\Temp\\ipykernel_23488\\2127864927.py:4: DeprecationWarning: `in1d` is deprecated. Use `np.isin` instead.\n",
            "  print(np.in1d(arr1, arr2))\n"
          ]
        }
      ],
      "source": [
        "# 61. np.in1d\n",
        "arr1 = np.array([1, 2, 3])\n",
        "arr2 = np.array([2, 4])\n",
        "print(np.in1d(arr1, arr2))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 63,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[2]\n"
          ]
        }
      ],
      "source": [
        "# 62. np.intersect1d\n",
        "print(np.intersect1d(arr1, arr2))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 64,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 2 3 4]\n"
          ]
        }
      ],
      "source": [
        "# 63. np.union1d\n",
        "print(np.union1d(arr1, arr2))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 65,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 3]\n"
          ]
        }
      ],
      "source": [
        "# 64. np.setdiff1d\n",
        "print(np.setdiff1d(arr1, arr2))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 66,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 3 4]\n"
          ]
        }
      ],
      "source": [
        "# 65. np.setxor1d\n",
        "print(np.setxor1d(arr1, arr2))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 67,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 2 3]\n"
          ]
        }
      ],
      "source": [
        "# 66. np.sort\n",
        "arr = np.array([3, 1, 2])\n",
        "print(np.sort(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 68,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 2 3]\n"
          ]
        }
      ],
      "source": [
        "# 67. arr.sort (就地)\n",
        "arr.sort()\n",
        "print(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 69,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 2 0]\n"
          ]
        }
      ],
      "source": [
        "# 68. np.argsort\n",
        "arr = np.array([3, 1, 2])\n",
        "print(np.argsort(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 70,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 0 2 3]\n"
          ]
        }
      ],
      "source": [
        "# 69. np.lexsort\n",
        "names = np.array(['Bob','Alice','Bob','Charlie'])\n",
        "grades = np.array([70,90,70,80])\n",
        "idx = np.lexsort((grades, names))\n",
        "print(idx)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 71,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2\n"
          ]
        }
      ],
      "source": [
        "# 70. np.searchsorted\n",
        "arr = np.array([1,2,3,4,5])\n",
        "idx = np.searchsorted(arr, 3)\n",
        "print(idx)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 72,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 2 3 5 7]\n"
          ]
        }
      ],
      "source": [
        "# 71. np.partition\n",
        "arr = np.array([7,2,3,1,5])\n",
        "parted = np.partition(arr, 2)\n",
        "print(parted)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 73,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[3 1 2 4 0]\n"
          ]
        }
      ],
      "source": [
        "# 72. np.argpartition\n",
        "arr = np.array([7,2,3,1,5])\n",
        "print(np.argpartition(arr, 2))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 74,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "4 1\n"
          ]
        }
      ],
      "source": [
        "# 73. np.max / np.min\n",
        "arr = np.array([1, 2, 3, 4])\n",
        "print(np.max(arr), np.min(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 75,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3 0\n"
          ]
        }
      ],
      "source": [
        "# 74. np.argmax / np.argmin\n",
        "print(np.argmax(arr), np.argmin(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 76,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "6\n"
          ]
        }
      ],
      "source": [
        "# 75. np.ptp\n",
        "arr2 = np.array([1,3,7,2])\n",
        "print(np.ptp(arr2))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 77,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2.5\n"
          ]
        }
      ],
      "source": [
        "# 76. np.mean\n",
        "arr = np.array([1,2,3,4])\n",
        "print(np.mean(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 78,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2.5\n"
          ]
        }
      ],
      "source": [
        "# 77. np.median\n",
        "print(np.median(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 79,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3.0\n"
          ]
        }
      ],
      "source": [
        "# 78. np.average\n",
        "print(np.average(arr, weights=[1,2,3,4]))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 80,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1.118033988749895\n"
          ]
        }
      ],
      "source": [
        "# 79. np.std\n",
        "print(np.std(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 81,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1.25\n"
          ]
        }
      ],
      "source": [
        "# 80. np.var\n",
        "print(np.var(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 82,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "10\n"
          ]
        }
      ],
      "source": [
        "# 81. np.sum\n",
        "print(np.sum(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 83,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "24\n"
          ]
        }
      ],
      "source": [
        "# 82. np.prod\n",
        "print(np.prod(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 84,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 1  3  6 10]\n"
          ]
        }
      ],
      "source": [
        "# 83. np.cumsum\n",
        "print(np.cumsum(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 85,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 1  2  6 24]\n"
          ]
        }
      ],
      "source": [
        "# 84. np.cumprod\n",
        "print(np.cumprod(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 86,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3.0\n"
          ]
        }
      ],
      "source": [
        "# 85. np.percentile\n",
        "arr = np.array([1,2,3,4,5])\n",
        "print(np.percentile(arr, 50))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 87,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2.0\n"
          ]
        }
      ],
      "source": [
        "# 86. np.quantile\n",
        "print(np.quantile(arr, 0.25))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 88,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[2 2 3 3]\n"
          ]
        }
      ],
      "source": [
        "# 87. np.clip\n",
        "arr = np.array([1,2,3,4])\n",
        "print(np.clip(arr, 2, 3))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 89,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1.2 2.3 3.5]\n"
          ]
        }
      ],
      "source": [
        "# 88. np.round / np.around\n",
        "x = np.array([1.234, 2.345, 3.456])\n",
        "print(np.round(x,1))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 90,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1. 2. 3.]\n"
          ]
        }
      ],
      "source": [
        "# 89. np.floor\n",
        "print(np.floor(x))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 91,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[2. 3. 4.]\n"
          ]
        }
      ],
      "source": [
        "# 90. np.ceil\n",
        "print(np.ceil(x))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 92,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1. 2. 3.]\n"
          ]
        }
      ],
      "source": [
        "# 91. np.trunc\n",
        "print(np.trunc(x))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 93,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[2. 2. 3.]\n"
          ]
        }
      ],
      "source": [
        "# 92. np.rint\n",
        "x = np.array([1.5, 2.5, 3.1])\n",
        "print(np.rint(x))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 94,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 2.  2. -3.]\n"
          ]
        }
      ],
      "source": [
        "# 93. np.fix\n",
        "x = np.array([2.1, 2.9, -3.2])\n",
        "print(np.fix(x))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 95,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ True False False] [False  True False] [False False  True]\n"
          ]
        }
      ],
      "source": [
        "# 94. np.isfinite / isinf / isnan\n",
        "arr = np.array([1, np.inf, np.nan])\n",
        "print(np.isfinite(arr), np.isinf(arr), np.isnan(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 96,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "# 95. np.isclose\n",
        "a=0.3\n",
        "b=0.1+0.2\n",
        "print(np.isclose(a,b))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 97,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "# 96. np.allclose\n",
        "arr1 = np.array([1.0,2.0,3.0])\n",
        "arr2 = np.array([1.0000001,2.0000001,3.0])\n",
        "print(np.allclose(arr1, arr2))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 98,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "# 97. np.array_equal\n",
        "arr1 = np.array([1,2,3])\n",
        "arr2 = np.array([1,2,3])\n",
        "print(np.array_equal(arr1, arr2))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 99,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "# 98. np.array_equiv\n",
        "arr1 = np.array([1,1,1])\n",
        "arr2 = np.array([[1,1,1],[1,1,1]])\n",
        "print(np.array_equiv(arr1, arr2))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 100,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3\n"
          ]
        }
      ],
      "source": [
        "# 99. np.count_nonzero\n",
        "arr = np.array([0,1,2,0,3])\n",
        "print(np.count_nonzero(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 101,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1.00000000e+000 0.00000000e+000 1.79769313e+308]\n"
          ]
        }
      ],
      "source": [
        "# 100. np.nan_to_num\n",
        "arr = np.array([1, np.nan, np.inf])\n",
        "print(np.nan_to_num(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 102,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[False False  True] [ True False  True]\n"
          ]
        }
      ],
      "source": [
        "# 101. np.logical_and / np.logical_or\n",
        "a = np.array([True, False, True])\n",
        "b = np.array([False, False, True])\n",
        "print(np.logical_and(a,b), np.logical_or(a,b))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 103,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[False False  True] [False  True False]\n"
          ]
        }
      ],
      "source": [
        "# 102. np.greater, np.equal\n",
        "x = np.array([1,2,3])\n",
        "y = np.array([2,2,2])\n",
        "print(np.greater(x,y), np.equal(x,y))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 104,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "False\n"
          ]
        }
      ],
      "source": [
        "# 103. np.all\n",
        "arr = np.array([True, True, False])\n",
        "print(np.all(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 105,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "True\n"
          ]
        }
      ],
      "source": [
        "# 104. np.any\n",
        "print(np.any(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 106,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[5 7 9] [-3 -3 -3] [ 4 10 18]\n"
          ]
        }
      ],
      "source": [
        "# 105. np.add / subtract / multiply\n",
        "x = np.array([1,2,3])\n",
        "y = np.array([4,5,6])\n",
        "print(np.add(x,y), np.subtract(x,y), np.multiply(x,y))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 107,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.25 0.4  0.5 ] [0 0 0]\n"
          ]
        }
      ],
      "source": [
        "# 106. np.divide / floor_divide\n",
        "print(np.divide(x,y), np.floor_divide(x,y))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 108,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 4 9]\n"
          ]
        }
      ],
      "source": [
        "# 107. np.power\n",
        "print(np.power(x,2))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 109,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0 1 0]\n"
          ]
        }
      ],
      "source": [
        "# 108. np.mod\n",
        "print(np.mod(y,x))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 110,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 2.71828183  7.3890561  20.08553692] [2. 4. 8.]\n"
          ]
        }
      ],
      "source": [
        "# 109. np.exp / np.exp2\n",
        "arr = np.array([1,2,3])\n",
        "print(np.exp(arr), np.exp2(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 111,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0. 1. 2.] [0.         1.44269504 2.88539008] [0.         0.43429448 0.86858896]\n"
          ]
        }
      ],
      "source": [
        "# 110. np.log / np.log2 / np.log10\n",
        "arr = np.array([1, math.e, math.e**2])\n",
        "print(np.log(arr), np.log2(arr), np.log10(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 112,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.         0.00995033 0.09531018] [0.         0.01005017 0.10517092]\n"
          ]
        }
      ],
      "source": [
        "# 111. np.log1p / np.expm1\n",
        "arr = np.array([0,0.01,0.1])\n",
        "print(np.log1p(arr), np.expm1(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 113,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 2 3]\n"
          ]
        }
      ],
      "source": [
        "# 112. np.abs\n",
        "arr = np.array([-1,-2,3])\n",
        "print(np.abs(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 114,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[-1  2 -3] [ 1 -2  3]\n"
          ]
        }
      ],
      "source": [
        "# 113. np.negative / np.positive\n",
        "arr = np.array([1, -2, 3])\n",
        "print(np.negative(arr), np.positive(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 115,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[-1  0  1]\n"
          ]
        }
      ],
      "source": [
        "# 114. np.sign\n",
        "arr = np.array([-5,0,5])\n",
        "print(np.sign(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 116,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.0000000e+00 1.0000000e+00 1.2246468e-16] [ 1.000000e+00  6.123234e-17 -1.000000e+00] [ 0.00000000e+00  1.63312394e+16 -1.22464680e-16]\n"
          ]
        }
      ],
      "source": [
        "# 115. np.sin / np.cos / np.tan\n",
        "x = np.array([0, np.pi/2, np.pi])\n",
        "print(np.sin(x), np.cos(x), np.tan(x))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 117,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 0.          1.57079633 -1.57079633]\n"
          ]
        }
      ],
      "source": [
        "# 116. np.arcsin / arccos / arctan\n",
        "y = np.array([0,1,-1])\n",
        "print(np.arcsin(y))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 118,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 0.          1.17520119 -1.17520119] [1.         1.54308063 1.54308063] [ 0.          0.76159416 -0.76159416]\n"
          ]
        }
      ],
      "source": [
        "# 117. np.sinh / cosh / tanh\n",
        "x = np.array([0,1,-1])\n",
        "print(np.sinh(x), np.cosh(x), np.tanh(x))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 119,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.         0.88137359 1.44363548] [0.         0.34657359 0.80471896]\n"
          ]
        }
      ],
      "source": [
        "# 118. np.arcsinh / arctanh\n",
        "x = np.array([0,1,2])\n",
        "print(np.arcsinh(x), np.arctanh(x/3))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 120,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.         3.14159265 6.28318531]\n",
            "[  0. 180. 360.]\n"
          ]
        }
      ],
      "source": [
        "# 119. np.deg2rad / rad2deg\n",
        "deg = np.array([0,180,360])\n",
        "print(np.deg2rad(deg))\n",
        "rad = np.array([0, np.pi, 2*np.pi])\n",
        "print(np.rad2deg(rad))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 121,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 5. 13.]\n"
          ]
        }
      ],
      "source": [
        "# 120. np.hypot\n",
        "x = np.array([3,5])\n",
        "y = np.array([4,12])\n",
        "print(np.hypot(x,y))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 122,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1 2 3]\n",
            " [1 2 3]] [[10 10 10]\n",
            " [20 20 20]]\n"
          ]
        }
      ],
      "source": [
        "# 121. np.meshgrid\n",
        "x = np.array([1,2,3])\n",
        "y = np.array([10,20])\n",
        "X, Y = np.meshgrid(x, y)\n",
        "print(X, Y)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 123,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1 2 3]\n",
            " [1 2 3]\n",
            " [1 2 3]]\n"
          ]
        }
      ],
      "source": [
        "# 122. np.broadcast_to\n",
        "a = np.array([1,2,3])\n",
        "b = np.broadcast_to(a, (3,3))\n",
        "print(b)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 124,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1 2 3]\n",
            " [1 2 3]\n",
            " [1 2 3]] [[10 10 10]\n",
            " [20 20 20]\n",
            " [30 30 30]]\n"
          ]
        }
      ],
      "source": [
        "# 123. np.broadcast_arrays\n",
        "a = np.array([1,2,3])\n",
        "b = np.array([[10],[20],[30]])\n",
        "A, B = np.broadcast_arrays(a, b)\n",
        "print(A, B)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 125,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[19 22]\n",
            " [43 50]]\n"
          ]
        }
      ],
      "source": [
        "# 124. np.dot\n",
        "x = np.array([[1,2],[3,4]])\n",
        "y = np.array([[5,6],[7,8]])\n",
        "print(np.dot(x,y))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 126,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(70-8j)\n"
          ]
        }
      ],
      "source": [
        "# 125. np.vdot\n",
        "a = np.array([1+2j, 3+4j])\n",
        "b = np.array([5+6j, 7+8j])\n",
        "print(np.vdot(a,b))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 127,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "32\n"
          ]
        }
      ],
      "source": [
        "# 126. np.inner\n",
        "a = np.array([1,2,3])\n",
        "b = np.array([4,5,6])\n",
        "print(np.inner(a,b))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 128,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[ 4  5  6]\n",
            " [ 8 10 12]\n",
            " [12 15 18]]\n"
          ]
        }
      ],
      "source": [
        "# 127. np.outer\n",
        "print(np.outer(a,b))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 129,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[19 22]\n",
            " [43 50]]\n"
          ]
        }
      ],
      "source": [
        "# 128. np.matmul\n",
        "x = np.array([[1,2],[3,4]])\n",
        "y = np.array([[5,6],[7,8]])\n",
        "print(np.matmul(x,y))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 130,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[19 22]\n",
            " [43 50]]\n"
          ]
        }
      ],
      "source": [
        "# 129. np.tensordot\n",
        "a = np.array([[1,2],[3,4]])\n",
        "b = np.array([[5,6],[7,8]])\n",
        "print(np.tensordot(a,b,axes=1))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 131,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "32\n"
          ]
        }
      ],
      "source": [
        "# 130. np.einsum\n",
        "a = np.array([1,2,3])\n",
        "b = np.array([4,5,6])\n",
        "c = np.einsum('i,i->', a, b)\n",
        "print(c)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 132,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[-2.   1. ]\n",
            " [ 1.5 -0.5]]\n"
          ]
        }
      ],
      "source": [
        "# 131. np.linalg.inv\n",
        "mat = np.array([[1,2],[3,4]])\n",
        "inv_mat = np.linalg.inv(mat)\n",
        "print(inv_mat)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 133,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "-2.0000000000000004\n"
          ]
        }
      ],
      "source": [
        "# 132. np.linalg.det\n",
        "print(np.linalg.det(mat))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 134,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2\n"
          ]
        }
      ],
      "source": [
        "# 133. np.linalg.matrix_rank\n",
        "print(np.linalg.matrix_rank(mat))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 135,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[-0.37228132  5.37228132] [[-0.82456484 -0.41597356]\n",
            " [ 0.56576746 -0.90937671]]\n"
          ]
        }
      ],
      "source": [
        "# 134. np.linalg.eig\n",
        "vals, vecs = np.linalg.eig(mat)\n",
        "print(vals, vecs)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 136,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[-0.37228132  5.37228132]\n"
          ]
        }
      ],
      "source": [
        "# 135. np.linalg.eigvals\n",
        "print(np.linalg.eigvals(mat))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 137,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[2. 3.]\n"
          ]
        }
      ],
      "source": [
        "# 136. np.linalg.solve\n",
        "A = np.array([[3,1],[1,2]])\n",
        "b = np.array([9,8])\n",
        "x = np.linalg.solve(A,b)\n",
        "print(x)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 138,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "5.0\n"
          ]
        }
      ],
      "source": [
        "# 137. np.linalg.norm\n",
        "v = np.array([3,4])\n",
        "print(np.linalg.norm(v))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 139,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[-0.16903085  0.89708523]\n",
            " [-0.50709255  0.27602622]\n",
            " [-0.84515425 -0.34503278]] [[-5.91607978 -7.43735744]\n",
            " [ 0.          0.82807867]]\n"
          ]
        }
      ],
      "source": [
        "# 138. np.linalg.qr\n",
        "mat = np.array([[1,2],[3,4],[5,6]])\n",
        "Q,R = np.linalg.qr(mat)\n",
        "print(Q, R)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 140,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[2. 0.]\n",
            " [3. 2.]]\n"
          ]
        }
      ],
      "source": [
        "# 139. np.linalg.cholesky\n",
        "A = np.array([[4,6],[6,13]])\n",
        "L = np.linalg.cholesky(A)\n",
        "print(L)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 141,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[-0.2298477   0.88346102]\n",
            " [-0.52474482  0.24078249]\n",
            " [-0.81964194 -0.40189603]] [9.52551809 0.51430058] [[-0.61962948 -0.78489445]\n",
            " [-0.78489445  0.61962948]]\n"
          ]
        }
      ],
      "source": [
        "# 140. np.linalg.svd\n",
        "A = np.array([[1,2],[3,4],[5,6]])\n",
        "U, s, Vt = np.linalg.svd(A, full_matrices=False)\n",
        "print(U, s, Vt)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 142,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1.16666667 0.75      ] [0.04166667] 2 [4.07914333 0.60049122]\n"
          ]
        }
      ],
      "source": [
        "# 141. np.linalg.lstsq\n",
        "A = np.array([[1,1],[1,2],[1,3]])\n",
        "b = np.array([2,2.5,3.5])\n",
        "x, residuals, rank, s = np.linalg.lstsq(A,b, rcond=None)\n",
        "print(x, residuals, rank, s)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 143,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[10.+0.j -2.+2.j -2.+0.j -2.-2.j] [1.+0.j 2.+0.j 3.+0.j 4.+0.j]\n"
          ]
        }
      ],
      "source": [
        "# 142. fft / ifft\n",
        "from numpy.fft import fft, ifft, fftn, ifftn, rfft, irfft\n",
        "arr = np.array([1,2,3,4])\n",
        "freq = fft(arr)\n",
        "time_ = ifft(freq)\n",
        "print(freq, time_)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 144,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[10.+0.j -2.+0.j]\n",
            " [-4.+0.j  0.+0.j]] [[1.+0.j 2.+0.j]\n",
            " [3.+0.j 4.+0.j]]\n"
          ]
        }
      ],
      "source": [
        "# 143. fftn / ifftn\n",
        "arr_2d = np.array([[1,2],[3,4]])\n",
        "freq_2d = fftn(arr_2d)\n",
        "time_2d = ifftn(freq_2d)\n",
        "print(freq_2d, time_2d)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 145,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[10.+0.j -2.+2.j -2.+0.j] [1. 2. 3. 4.]\n"
          ]
        }
      ],
      "source": [
        "# 144. rfft / irfft\n",
        "arr = np.array([1,2,3,4])\n",
        "freq_real = rfft(arr)\n",
        "time_real = irfft(freq_real)\n",
        "print(freq_real, time_real)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 146,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "38\n"
          ]
        }
      ],
      "source": [
        "# 145. np.poly1d\n",
        "p = np.poly1d([1,2,3])\n",
        "print(p(5))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 147,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "38\n"
          ]
        }
      ],
      "source": [
        "# 146. np.polyval\n",
        "coeffs = [1,2,3]\n",
        "print(np.polyval(coeffs,5))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 148,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1. 1. 1.]\n"
          ]
        }
      ],
      "source": [
        "# 147. np.polyfit\n",
        "x = np.array([0,1,2,3])\n",
        "y = np.array([1,3,7,13])\n",
        "cf = np.polyfit(x,y, deg=2)\n",
        "print(cf)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 149,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[-1. -1.]\n"
          ]
        }
      ],
      "source": [
        "# 148. np.roots\n",
        "coeffs = [1,2,1]\n",
        "print(np.roots(coeffs))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 150,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1.  1.5 2.5 3.5 4. ]\n"
          ]
        }
      ],
      "source": [
        "# 149. np.gradient\n",
        "arr = np.array([1,2,4,7,11])\n",
        "print(np.gradient(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 151,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 2 3 4]\n"
          ]
        }
      ],
      "source": [
        "# 150. np.diff\n",
        "print(np.diff(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 152,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 1 1 1 1]\n"
          ]
        }
      ],
      "source": [
        "# 151. np.ediff1d\n",
        "arr_2d = np.array([[1,2,3],[4,5,6]])\n",
        "print(np.ediff1d(arr_2d))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 153,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.         1.57079633 3.14159265 3.92699082]\n"
          ]
        }
      ],
      "source": [
        "# 152. np.unwrap\n",
        "angles = np.array([0, np.pi/2, np.pi, -3*np.pi/4])\n",
        "print(np.unwrap(angles))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 154,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3.0\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "C:\\Users\\minqliu\\AppData\\Local\\Temp\\ipykernel_23488\\897648374.py:4: DeprecationWarning: `trapz` is deprecated. Use `trapezoid` instead, or one of the numerical integration functions in `scipy.integrate`.\n",
            "  print(np.trapz(y,x))\n"
          ]
        }
      ],
      "source": [
        "# 153. np.trapz\n",
        "x = np.array([0,1,2])\n",
        "y = np.array([0,1,4])\n",
        "print(np.trapz(y,x))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 155,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[ 0  5  0 10]\n",
            " [ 6  7 12 14]\n",
            " [ 0 15  0 20]\n",
            " [18 21 24 28]]\n"
          ]
        }
      ],
      "source": [
        "# 154. np.kron\n",
        "A = np.array([[1,2],[3,4]])\n",
        "B = np.array([[0,5],[6,7]])\n",
        "print(np.kron(A,B))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 156,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 2 1 4] [1. 2. 3. 4. 5.]\n"
          ]
        }
      ],
      "source": [
        "# 155. np.histogram\n",
        "data = np.array([1,2,2,3,4,4,4,5])\n",
        "hist,bins = np.histogram(data,bins=4)\n",
        "print(hist,bins)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 157,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 2 2 2 3 3 3 3]\n"
          ]
        }
      ],
      "source": [
        "# 156. np.digitize\n",
        "bins = [0,2,4,6]\n",
        "print(np.digitize(data, bins))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 158,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 2 3]\n"
          ]
        }
      ],
      "source": [
        "# 157. np.bincount\n",
        "arr = np.array([0,1,1,2,2,2])\n",
        "print(np.bincount(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 159,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[ 1. -1.]\n",
            " [-1.  1.]]\n"
          ]
        }
      ],
      "source": [
        "# 158. np.cov\n",
        "x = np.array([0,1,2])\n",
        "y = np.array([2,1,0])\n",
        "print(np.cov(x,y))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 160,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[ 1. -1.]\n",
            " [-1.  1.]]\n"
          ]
        }
      ],
      "source": [
        "# 159. np.corrcoef\n",
        "print(np.corrcoef(x,y))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 161,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3.0 1.0\n"
          ]
        }
      ],
      "source": [
        "# 160. np.nanmax / nanmin\n",
        "arr = np.array([1, np.nan, 3])\n",
        "print(np.nanmax(arr), np.nanmin(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 162,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2 0\n"
          ]
        }
      ],
      "source": [
        "# 161. np.nanargmax / nanargmin\n",
        "print(np.nanargmax(arr), np.nanargmin(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 163,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "4.0\n"
          ]
        }
      ],
      "source": [
        "# 162. np.nansum\n",
        "print(np.nansum(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 164,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2.0\n"
          ]
        }
      ],
      "source": [
        "# 163. np.nanmean\n",
        "print(np.nanmean(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 165,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2.0 4.0\n"
          ]
        }
      ],
      "source": [
        "# 164. np.nanstd / np.nanvar\n",
        "arr = np.array([1, np.nan, 5])\n",
        "print(np.nanstd(arr), np.nanvar(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 166,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1. 1. 3. 6.] [1. 1. 2. 6.]\n"
          ]
        }
      ],
      "source": [
        "# 165. np.nancumsum / np.nancumprod\n",
        "arr = np.array([1, np.nan, 2, 3])\n",
        "print(np.nancumsum(arr), np.nancumprod(arr))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 167,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[0.70107684 0.78421294 0.06800185]\n",
            " [0.07091766 0.68622638 0.1399112 ]]\n"
          ]
        }
      ],
      "source": [
        "# 166. np.random.rand\n",
        "r = np.random.rand(2,3)\n",
        "print(r)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 168,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[-1.18248356 -0.67300596  0.67198531]\n",
            " [-0.23331329  0.647586   -0.15205689]]\n"
          ]
        }
      ],
      "source": [
        "# 167. np.random.randn\n",
        "r = np.random.randn(2,3)\n",
        "print(r)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 169,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[1 9 6]\n",
            " [1 0 4]]\n"
          ]
        }
      ],
      "source": [
        "# 168. np.random.randint\n",
        "r = np.random.randint(0,10,size=(2,3))\n",
        "print(r)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 170,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1.00900519 1.92355541 2.8180942  3.34792559 1.47782878]\n"
          ]
        }
      ],
      "source": [
        "# 169. np.random.uniform\n",
        "r = np.random.uniform(1,5,size=5)\n",
        "print(r)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 171,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[-0.39682416  0.51424917 -0.79080725 -0.20995163 -0.89902034]\n"
          ]
        }
      ],
      "source": [
        "# 170. np.random.normal\n",
        "r = np.random.normal(loc=0, scale=1, size=5)\n",
        "print(r)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 172,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[6 7 5 4 5]\n"
          ]
        }
      ],
      "source": [
        "# 171. np.random.binomial\n",
        "r = np.random.binomial(n=10, p=0.5, size=5)\n",
        "print(r)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 173,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[4 5 6 5 7]\n"
          ]
        }
      ],
      "source": [
        "# 172. np.random.poisson\n",
        "r = np.random.poisson(lam=5,size=5)\n",
        "print(r)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 174,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.46199268 0.43315992 0.07217999 0.18954255 0.18800894]\n"
          ]
        }
      ],
      "source": [
        "# 173. np.random.beta\n",
        "r = np.random.beta(a=2,b=5,size=5)\n",
        "print(r)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 175,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 1.38044134  1.18018499  0.10989858  0.09555416 10.71363988]\n"
          ]
        }
      ],
      "source": [
        "# 174. np.random.exponential\n",
        "r = np.random.exponential(scale=2.0,size=5)\n",
        "print(r)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 176,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[6.16123896 2.51579241 8.40003217 4.09873316 3.84610768]\n"
          ]
        }
      ],
      "source": [
        "# 175. np.random.gamma\n",
        "r = np.random.gamma(shape=2.0, scale=2.0, size=5)\n",
        "print(r)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 177,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[2.5347835  0.15533243 3.19808368 7.97160871 2.77479636]\n"
          ]
        }
      ],
      "source": [
        "# 176. np.random.chisquare\n",
        "r = np.random.chisquare(df=2, size=5)\n",
        "print(r)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 178,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 0.20091207  0.65903775 -0.13460124 -1.53489178  1.08496221]\n"
          ]
        }
      ],
      "source": [
        "# 177. np.random.gumbel\n",
        "r = np.random.gumbel(loc=0, scale=1, size=5)\n",
        "print(r)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 179,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 2.91100763 -0.2259794  -0.72644531 -5.56130482  0.90797293]\n"
          ]
        }
      ],
      "source": [
        "# 178. np.random.logistic\n",
        "r = np.random.logistic(loc=0, scale=1, size=5)\n",
        "print(r)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 180,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[-1.00633288 -1.09834408 -0.08392512 -1.81321727 -0.53064222]\n"
          ]
        }
      ],
      "source": [
        "# 179. np.random.laplace\n",
        "r = np.random.laplace(loc=0, scale=1, size=5)\n",
        "print(r)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 181,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.35927846 0.8852013  0.82353884 0.51964622 0.19257968]\n"
          ]
        }
      ],
      "source": [
        "# 180. np.random.lognormal\n",
        "r = np.random.lognormal(mean=0, sigma=1, size=5)\n",
        "print(r)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 182,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[[ 0.49319277 -1.26932335]\n",
            " [ 0.12885436  0.21247467]\n",
            " [-0.22592843  0.40213569]\n",
            " [ 1.52618007  1.84322818]\n",
            " [-0.24961351  0.79172781]]\n"
          ]
        }
      ],
      "source": [
        "# 181. np.random.multivariate_normal\n",
        "mean = [0,0]\n",
        "cov = [[1,0.5],[0.5,1]]\n",
        "r = np.random.multivariate_normal(mean,cov,size=5)\n",
        "print(r)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 183,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[40 10 40]\n"
          ]
        }
      ],
      "source": [
        "# 182. np.random.choice\n",
        "arr = np.array([10,20,30,40])\n",
        "print(np.random.choice(arr,size=3))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 184,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1 4 2 0 3] [0 1 2 3 4]\n"
          ]
        }
      ],
      "source": [
        "# 183. np.random.permutation\n",
        "arr = np.arange(5)\n",
        "print(np.random.permutation(arr), arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 185,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0 3 2 1 4]\n"
          ]
        }
      ],
      "source": [
        "# 184. np.random.shuffle\n",
        "arr = np.arange(5)\n",
        "np.random.shuffle(arr)\n",
        "print(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 186,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.37454012 0.95071431 0.73199394]\n"
          ]
        }
      ],
      "source": [
        "# 185. np.random.seed\n",
        "np.random.seed(42)\n",
        "print(np.random.rand(3))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 187,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[0.59865848 0.15601864 0.15599452]\n"
          ]
        }
      ],
      "source": [
        "# 186. np.random.get_state / set_state\n",
        "state = np.random.get_state()\n",
        "temp = np.random.rand(3)\n",
        "np.random.set_state(state)\n",
        "print(np.random.rand(3))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 188,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "需要实际文件操作,此处略\n"
          ]
        }
      ],
      "source": [
        "# 187. np.loadtxt / 188. np.savetxt\n",
        "print('需要实际文件操作,此处略')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 189,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "需要实际文件操作,此处略\n"
          ]
        }
      ],
      "source": [
        "# 189. np.genfromtxt\n",
        "print('需要实际文件操作,此处略')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 190,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "需要实际文件操作,此处略\n"
          ]
        }
      ],
      "source": [
        "# 190. np.load / np.save / np.savez\n",
        "print('需要实际文件操作,此处略')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 191,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "交互式环境有效,此处略\n"
          ]
        }
      ],
      "source": [
        "# 191. np.who\n",
        "print('交互式环境有效,此处略')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 192,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "需要二进制文件操作,此处略\n"
          ]
        }
      ],
      "source": [
        "# 192. np.fromfile / 193. np.tofile\n",
        "print('需要二进制文件操作,此处略')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 193,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "需要大文件映射,此处略\n"
          ]
        }
      ],
      "source": [
        "# 194. np.memmap\n",
        "print('需要大文件映射,此处略')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 194,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1.+1.e-14j 2.+3.e+00j]\n"
          ]
        }
      ],
      "source": [
        "# 195. np.real_if_close\n",
        "arr = np.array([1+1e-14j, 2+3j])\n",
        "print(np.real_if_close(arr, tol=1000))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 195,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[1.+1.j 1.+2.j 2.+1.j]\n"
          ]
        }
      ],
      "source": [
        "# 196. np.sort_complex\n",
        "c = np.array([1+2j,1+1j,2+1j])\n",
        "print(np.sort_complex(c))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 196,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[ 1  2 99 99 99]\n"
          ]
        }
      ],
      "source": [
        "# 197. np.place\n",
        "arr = np.array([1,2,3,4,5])\n",
        "np.place(arr, arr>2, [99])\n",
        "print(arr)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 197,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "[10 20  3  4 -5]\n"
          ]
        }
      ],
      "source": [
        "# 198. np.select\n",
        "arr = np.array([1,2,3,4,5])\n",
        "cond_list = [arr<3, arr>4]\n",
        "choice_list = [arr*10, arr*-1]\n",
        "res = np.select(cond_list, choice_list, default=arr)\n",
        "print(res)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 198,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "已在 #45 示例\n"
          ]
        }
      ],
      "source": [
        "# 199. np.array_split (见45)\n",
        "print('已在 #45 示例')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 199,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "(np.int64(1), np.int64(2))\n",
            "5\n"
          ]
        }
      ],
      "source": [
        "# 200. np.unravel_index / np.ravel_multi_index\n",
        "idx = np.unravel_index(5, (2,3))\n",
        "print(idx)\n",
        "lin = np.ravel_multi_index((1,2), (2,3))\n",
        "print(lin)"
      ]
    }
  ],
  "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.11.9"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}