numpy_lesson1-Basics, Array Creation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "## This lesson is designed for \"Basics\" & \"Array Creation\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a=>[1 2 3 4 5]\n",
      "b.dtype=>int64\n",
      "\n",
      "b.dtype=>float64\n"
     ]
    }
   ],
   "source": [
    "## Data type of array\n",
    "a = np.array([1, 2, 3, 4, 5])\n",
    "print(\"a=>{0}\".format(a))\n",
    "print(\"b.dtype=>{0}\".format(a.dtype))\n",
    "print()\n",
    "b = np.array([1.25, 2.25, 3.25, 4.25, 5.25])\n",
    "print(\"b.dtype=>{0}\".format(b.dtype))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a=>[6 5 4 3 2]\n",
      "\n",
      "b=>[0 1 2 3 4 5 6 7 8 9]\n",
      "\n",
      "c=>[0.  1.5 3.  4.5 6.  7.5 9. ]\n"
     ]
    }
   ],
   "source": [
    "## 1 dimension array.\n",
    "## 1維陣列\n",
    "a = np.array([6, 5, 4, 3, 2])\n",
    "print(\"a=>{0}\".format(a))\n",
    "print()\n",
    "b = np.arange(10)\n",
    "print(\"b=>{0}\".format(b))\n",
    "print()\n",
    "c = np.arange(0, 10, 1.5, dtype=np.float64)\n",
    "print(\"c=>{0}\".format(c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b=>[[1.1 1.2 1.3]\n",
      " [2.1 2.2 2.3]]\n"
     ]
    }
   ],
   "source": [
    "## 2 dimension array. (2-by-3 matrix)\n",
    "## 2維陣列 2-by-3 array\n",
    "b = np.array([[1.1, 1.2, 1.3], [2.1, 2.2, 2.3]])\n",
    "print(\"b=>{0}\".format(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c1=>[[1.1+0.j 1.2+0.j 1.3+0.j]\n",
      " [2.1+0.j 2.2+0.j 2.3+0.j]]\n",
      "\n",
      "c2=>[2.1 +6.j 3.2 +9.j 4.3+12.j]\n"
     ]
    }
   ],
   "source": [
    "## Declare c1 as a complex array/matrix.\n",
    "## 宣告c1為一個複數矩陣\n",
    "c1 = np.array([(1.1, 1.2, 1.3), (2.1, 2.2, 2.3)], dtype=complex)\n",
    "print(\"c1=>{0}\".format(c1))\n",
    "print()\n",
    "c2 = np.array([2.1+6j, 3.2+9j, 4.3+12j])\n",
    "print(\"c2=>{0}\".format(c2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aa=>[[1 1 1]\n",
      " [2 2 2]]\n"
     ]
    }
   ],
   "source": [
    "## Assign a particular data type to an array.\n",
    "## 指定一個特定的資料型態給陣列.\n",
    "aa = np.array([(1.9, 1.5, 1.3), (2.9, 2.5, 2.3)], dtype=np.int16)\n",
    "print(\"aa=>{0}\".format(aa))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ndim:2\n",
      "shape:(2, 3)\n",
      "size:6\n",
      "dtype:int16\n",
      "itemsize:2\n",
      "data:<memory at 0x7f670004a7e0>\n"
     ]
    }
   ],
   "source": [
    "# What's the different between array in Python and array in NumPy?\n",
    "# Array in NumPy is based on a class called \"ndarray\", and this class support multi-dimension matrix operations.\n",
    "# Array in Python is developed from the standard libraries in Python. it only supports one-dimension operations, and the functions or options are less than NumPy.\n",
    "# NumPy中的array和Python的array有何不同呢？\n",
    "# NumPy的array是NumPy中名為ndarray的Class所定義的，而這個array當然支援多維度陣列，也可以說它是一個支援Martix的類別！\n",
    "# Python的array則是標準函式庫內建的Class-->array.array。他只能支援單維度的陣列，而且提供的功能選項也比NumPy來得少！\n",
    "\n",
    "# ndarray.ndim: the numbers of dimension of ndarray object\n",
    "# ndarray.ndim: ndarray物件的維度\n",
    "print(\"ndim:{0}\".format(aa.ndim))\n",
    "\n",
    "# ndarry.shape: the size of each dimension of ndarry objects. it returns a Tuple.\n",
    "# ndarry.shape: ndarry物件的每一個維度的大小(size)，回傳資料類別為Tuple\n",
    "print(\"shape:{0}\".format(aa.shape))\n",
    "\n",
    "# ndarry.size: it summarizes the number of elements in this ndarray object. the returns value will equal to the each elements of ndarray.shape times to each other.\n",
    "# ndarry.size: ndarry物件所組成之array的總元素數量，回應之數值會等於ndarray.shape的每個元素相乘\n",
    "print(\"size:{0}\".format(aa.size))\n",
    "\n",
    "# ndarry.dtype: the data type of ndarray object.\n",
    "# ndarry.dtype: ndarray物件內組成元素的型態\n",
    "print(\"dtype:{0}\".format(aa.dtype))\n",
    "\n",
    "# ndarray.itemsize: the data size of elements in array.(Bytes)\n",
    "# ndarray.itemsize: 陣列中每一個元素的大小(Bytes) (ex: int16=>16/8=2 Bytes)\n",
    "print(\"itemsize:{0}\".format(aa.itemsize))\n",
    "\n",
    "# ndarry.data: This is an address of an array. It usually keeps some buffer in memory.\n",
    "# ndarry.data: 這是一個存有實際陣列元素的緩衝，通常我們不需要使用這個屬性，因為我們可以使用index存取這些元素。\n",
    "print(\"data:{0}\".format(aa.data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "zeros=>[[0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "## Zeros\n",
    "zeros = np.zeros( (3, 5) )\n",
    "print(\"zeros=>{0}\".format(zeros))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ones=>[[1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1.]\n",
      " [1. 1. 1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "## Ones\n",
    "ones = np.ones( (3, 5) )\n",
    "print(\"ones=>{0}\".format(ones))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e=>[[0.0e+000 4.9e-324 9.9e-324 1.5e-323 2.0e-323]\n",
      " [2.5e-323 3.0e-323 3.5e-323 4.0e-323 4.4e-323]]\n"
     ]
    }
   ],
   "source": [
    "## Empty\n",
    "## It means that we want to declare a uninitialized matrix.\n",
    "e = np.empty( (2, 5) )\n",
    "print(\"e=>{0}\".format(e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "r1=>[25.  25.5 26.  26.5 27.  27.5 28.  28.5 29.  29.5]\n"
     ]
    }
   ],
   "source": [
    "## Arange\n",
    "r1 = np.arange(25, 30, .5)\n",
    "print(\"r1=>{0}\".format(r1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lin=>\n",
      "[3.   3.25 3.5  3.75 4.   4.25 4.5  4.75 5.  ]\n"
     ]
    }
   ],
   "source": [
    "## Linspace\n",
    "lin = np.linspace(3, 5, 9)\n",
    "print(\"lin=>\\n{0}\".format(lin))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}