05 Built-in Modules/01_Common_Modules.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fast Python For Beginners\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2018-02-28 18:15:26.620246\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "\n",
    "now = datetime.now()\n",
    "print(now)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'datetime.datetime'>\n"
     ]
    }
   ],
   "source": [
    "print(type(now))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **datetime**转换为**timestamp**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1519812926.620246"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "now.timestamp()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **timestamp**转换为**datetime**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2018-02-28 18:15:26.620246\n"
     ]
    }
   ],
   "source": [
    "t = now.timestamp()\n",
    "print(datetime.fromtimestamp(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2018-02-28 10:15:26.620246\n"
     ]
    }
   ],
   "source": [
    "print(datetime.utcfromtimestamp(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **str**转换为**datetime**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2015-06-01 18:19:59\n"
     ]
    }
   ],
   "source": [
    "cday = datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')\n",
    "print(cday)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **datetime**转换为**str**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wed, Feb 28 18:15\n"
     ]
    }
   ],
   "source": [
    "now = datetime.now()\n",
    "print(now.strftime('%a, %b %d %H:%M'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.collections"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**namedtuple**\n",
    "> `namedtuple('名称', [属性list])`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from collections import namedtuple\n",
    "\n",
    "Point = namedtuple('Point', ['x', 'y'])\n",
    "p = Point(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Cicle = namedtuple('Circle', ['x', 'y', 'r'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**deque**\n",
    "> **deque**是为了高效实现**插入**和**删除**操作的**双向列表**，适合用于队列和栈"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque(['y', 'a', 'b', 'c', 'x'])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import deque\n",
    "\n",
    "q = deque(['a', 'b', 'c'])\n",
    "q.append('x')\n",
    "q.appendleft('y')\n",
    "q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['append',\n",
       " 'appendleft',\n",
       " 'clear',\n",
       " 'copy',\n",
       " 'count',\n",
       " 'extend',\n",
       " 'extendleft',\n",
       " 'index',\n",
       " 'insert',\n",
       " 'maxlen',\n",
       " 'pop',\n",
       " 'popleft',\n",
       " 'remove',\n",
       " 'reverse',\n",
       " 'rotate']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x for x in dir(deque) if not x.startswith('_') ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**defaultdict**\n",
    "> 使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict  \n",
    "除了在Key不存在时返回默认值，defaultdict的其他行为跟dict是完全一样的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "dd = defaultdict(lambda: 'N/A')\n",
    "dd['key1'] = 'abc'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abc\n",
      "N/A\n"
     ]
    }
   ],
   "source": [
    "print(dd['key1'])\n",
    "print(dd['key2'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**OrderedDict**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import OrderedDict\n",
    "\n",
    "d = dict([('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)])\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "od = OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)])\n",
    "od"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> OrderedDict的Key会按照插入的顺序排列，不是Key本身排序："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OrderedDict([('z', 2), ('y', 2), ('x', 3)])\n"
     ]
    }
   ],
   "source": [
    "od = OrderedDict()\n",
    "od['z'] = 1\n",
    "od['y'] = 2\n",
    "od['x'] = 3\n",
    "od['z'] = 2\n",
    "print(od)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> OrderedDict可以实现一个FIFO（先进先出）的dict，当容量超出限制时，先删除最早添加的Key："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from collections import OrderedDict\n",
    "\n",
    "class LastUpdateOrderedDict(OrderedDict):\n",
    "    \n",
    "    def __init__(self, capacity):\n",
    "        super(LastUpdateOrderedDict, self).__init__()\n",
    "        self._capacity = capacity\n",
    "        \n",
    "    def __setitem__(self, key, value):\n",
    "        containsKey = 1 if key in self else 0\n",
    "        if len(self) - containKey >= self._capacity:\n",
    "            last = self.popitem(last=False)\n",
    "            print('remove:', last)\n",
    "        if containsKey:\n",
    "            del self[key]\n",
    "            print('set:', (key, value))\n",
    "        else:\n",
    "            print('add:', (key, value))\n",
    "            \n",
    "        OrderedDict.__setitem__(self, key, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Counter**\n",
    "> Counter实际上也是dict的一个子类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'a': 1, 'g': 2, 'i': 1, 'm': 2, 'n': 1, 'o': 1, 'p': 1, 'r': 2})"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "c = Counter()\n",
    "for ch in 'programming':\n",
    "    c[ch] += 1\n",
    "    \n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.hashlib\n",
    "> Python的hashlib提供了常见的摘要算法，如MD5，SHA1等等。  \n",
    "摘要算法又称**哈希算法**、**散列算法**。它通过一个函数，把任意长度的数据转换为一个长度固定的数据串（通常用16进制的字符串表示）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d26a53750bc40b38b65a520292f69306\n"
     ]
    }
   ],
   "source": [
    "## MD5\n",
    "import hashlib\n",
    "\n",
    "md5 = hashlib.md5()\n",
    "md5.update(\"how to use md5 in python hashlib?\".encode('utf-8'))\n",
    "print(md5.hexdigest())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 如果数据量很大，可以分块多次调用update()，最后计算的结果是一样的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8d7f266bcebe4d9b68611c1eb4b02ef8\n"
     ]
    }
   ],
   "source": [
    "md5.update('how to use md5 in '.encode('utf-8'))\n",
    "md5.update('python hashlib?'.encode('utf-8'))\n",
    "print(md5.hexdigest())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> MD5的结果是固定的128 bit字节，通常用一个32位的16进制字符串表示。  \n",
    "SHA1的结果是160 bit字节，通常用一个40位的16进制字符串表示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2c76b57293ce30acef38d98f6046927161b46a44\n"
     ]
    }
   ],
   "source": [
    "## SHA1\n",
    "import hashlib\n",
    "\n",
    "sha1 = hashlib.sha1()\n",
    "sha1.update('how to use sha1 in '.encode('utf-8'))\n",
    "sha1.update('python hashlib?'.encode('utf-8'))\n",
    "print(sha1.hexdigest())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}