基础语法回顾.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0.9205247243972096,\n",
       " 1: -0.9902158570092646,\n",
       " 2: 1.73960344086924,\n",
       " 3: -0.2028540615954352,\n",
       " 4: -2.02751798285988,\n",
       " 5: -1.8413977990254702,\n",
       " 6: -1.5240207420540328}"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "data={i: np.random.randn() for i in range(7)}#创建了一个字典\n",
    "data#许多python对象被格式化为更易读的形式，被称作pretty-printed 如果直接用print打印输出，可读性有可能降低"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1;31mType:\u001b[0m        dict\n",
      "\u001b[1;31mString form:\u001b[0m {0: 0.9205247243972096, 1: -0.9902158570092646, 2: 1.73960344086924, 3: -0.2028540615954352, 4: -2.02751798285988, 5: -1.8413977990254702, 6: -1.5240207420540328}\n",
      "\u001b[1;31mLength:\u001b[0m      7\n",
      "\u001b[1;31mDocstring:\u001b[0m  \n",
      "dict() -> new empty dictionary\n",
      "dict(mapping) -> new dictionary initialized from a mapping object's\n",
      "    (key, value) pairs\n",
      "dict(iterable) -> new dictionary initialized as if via:\n",
      "    d = {}\n",
      "    for k, v in iterable:\n",
      "        d[k] = v\n",
      "dict(**kwargs) -> new dictionary initialized with the name=value pairs\n",
      "    in the keyword argument list.  For example:  dict(one=1, two=2)\n"
     ]
    }
   ],
   "source": [
    "data?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "UsageError: Line magic function `%cpaste` not found.\n"
     ]
    }
   ],
   "source": [
    "%cpaste"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35.5 µs ± 640 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "a=np.random.randn(100,100)\n",
    "%timeit np.dot(a,a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x2220ffb6520>]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(np.random.randn(50).cumsum())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.61056565,  2.47862917,  4.41497436,  2.78597971,  1.52733983,\n",
       "        0.15450671,  0.75306459,  1.17411033,  1.75356606,  0.6240819 ,\n",
       "        0.96864343,  0.31032768,  1.39749289,  1.82492381, -0.02198827,\n",
       "       -1.56331353, -1.51506442, -0.97476561, -2.04200549, -1.63923678,\n",
       "       -3.21694887, -2.63614144, -2.74610338, -1.17469017, -0.31037525,\n",
       "        0.27837871, -0.33444905, -1.05339531, -2.33726099, -2.16858631,\n",
       "       -3.68110275, -5.23882163, -3.33061335, -1.31820825, -1.60495287,\n",
       "       -0.87387784, -1.20049152, -1.33922343, -0.39435357, -1.73639373,\n",
       "       -3.08486658, -1.50886214, -1.50243594, -1.34428939, -2.24116414,\n",
       "       -1.14660867, -0.2975072 ,  0.8395402 ,  2.85854113,  3.06368038])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randn(50).cumsum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 5  7  9]\n",
      " [12 15 18]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 1,  3,  6],\n",
       "       [ 4,  9, 15],\n",
       "       [ 7, 15, 24]], dtype=int32)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=np.asarray([[1,2,3],\n",
    "             [4,5,6],\n",
    "             [7,8,9]])\n",
    "b=a.cumsum(axis=0)#按行累加\n",
    "print(b)\n",
    "c=a.cumsum(axis=1)#按列累加\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(a,np.ndarray)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def isiterable(obj):\n",
    "    try:\n",
    "        iter(obj)\n",
    "        return True\n",
    "    except TypeError:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'4.56 Argentine Pesos are worth US$1'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{0:.2f} {1:s} are worth US${2:d}'.format(4.5560,'Argentine Pesos',1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 日期和时间"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2011-10-29 20:30:21\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from datetime import datetime , date ,time \n",
    "dt=datetime(2011,10,29,20,30,21)#年月日时分秒\n",
    "print(dt)\n",
    "dt.day\n",
    "dt.minute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2011, 10, 29, 20, 0)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt.date()#提取出日期对象\n",
    "dt.time()#提取出时间对象\n",
    "#strftime转化为字符串，需要填写格式符\n",
    "dt.strftime('%m/%d/%Y %H:%M')\n",
    "#将字符串转换为datetime对象，一样需要填写格式符\n",
    "datetime.strptime('19981225','%Y%m%d')\n",
    "#datetime为不可变类型，在聚类或对时间序列进行分组时，替换datetimes的time字段会非常有用\n",
    "dt.replace(minute=0,second=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2011, 11, 15, 22, 30)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt2=datetime(2011,11,15,22,30)\n",
    "#两个datetime对象相减，会产生一个datetiem.timedelta类型，可以与datetime进行相加减\n",
    "delta=dt2-dt\n",
    "delta#转换为days，second结果\n",
    "dt+delta#将timedelta添加到datetime会得到一个新的datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 5, 6)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#直接用逗号分隔是创建元组的最简方式\n",
    "tup=4,5,6\n",
    "tup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, [3, 4, 5])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "values=1,2,3,4,5\n",
    "a,b,*rest=values#*rest表示剩下部分的变量\n",
    "a,b,rest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, None, 'foo', 7, 8, (2, 3)]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#列表使用extend方法可以追加多个元素\n",
    "x=[4,None,'foo']\n",
    "x.extend([7,8,(2,3)])\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "616 ns ± 40.1 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "everything=[]\n",
    "list_of_list=[[1,2,3],[4,5,6],[7,8,9]]\n",
    "for chunk in list_of_list:\n",
    "    everything.extend(chunk)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "499 ns ± 39.1 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "everything=[]\n",
    "list_of_list=[[1,2,3],[4,5,6],[7,8,9]]\n",
    "for chunk in list_of_list:\n",
    "    everything+=chunk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 2, 2, 3, 4, 6, 7]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#二分搜索\n",
    "import bisect\n",
    "c=[1,2,2,2,3,4,7]\n",
    "bisect.bisect(c,2) #bisect方法返回插入该元素后在列表中所处位置\n",
    "bisect.insort(c,6)\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 0, 6, 5, 7, 3, 2, 7]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#使用-1间隔取元素可以把列表颠倒过来\n",
    "seq=[7,2,3,7,5,6,0,1]\n",
    "seq[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一些有用的序列函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# enumerate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 7\n",
      "1 2\n",
      "2 3\n",
      "3 7\n",
      "4 5\n",
      "5 6\n",
      "6 0\n",
      "7 1\n"
     ]
    }
   ],
   "source": [
    "#enumerate函数,为当前项自动返回序号\n",
    "for i ,value in enumerate(seq):\n",
    "    print(i,value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'foo': 0, 'bar': 1, 'baz': 2}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "some_list=['foo','bar','baz']\n",
    "mapping={}\n",
    "for i,v in enumerate(some_list):\n",
    "    mapping[v]=i\n",
    "mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 2, 3, 6, 7]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#sorted函数返回一个新的排好序的列表\n",
    "sorted([7,1,2,6,0,3,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# zip函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('foo', 'one'), ('bar', 'two'), ('baz', 'three')]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#zip函数,可以将多个列表、元组或其他序列一一对应成对组合成一个元组列表\n",
    "seq1=['foo','bar','baz']\n",
    "seq2=['one','two','three']\n",
    "zipped=zip(seq1,seq2)\n",
    "list(zipped)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('foo', 'one', False), ('bar', 'two', True)]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq3=[False,True]\n",
    "#zip可以处理人任意多的序列，元素个数取决于最短的序列\n",
    "list(zip(seq1,seq2,seq3))#结果中没有baz与three"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0:foo,one\n",
      "1:bar,two\n",
      "2:baz,three\n"
     ]
    }
   ],
   "source": [
    "#zip可与enumerate结合使用，同时迭代多个序列\n",
    "for i, (a,b) in enumerate(zip(seq1,seq2)):\n",
    "    print('{0}:{1},{2}'.format(i,a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(('Nolan', 'Roger', 'Schilling'), ('Ryan', 'Clemens', 'Curt'))"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#zip还可以用来解压“被压缩”的序列\n",
    "pitchers=[('Nolan','Ryan'),('Roger','Clemens'),('Schilling','Curt')]\n",
    "first_names,last_names=zip(*pitchers)#*不能少\n",
    "first_names,last_names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# reversed函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#可以从后向前迭代一个序列：\n",
    "list(reversed(range(10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'some value', 'b': 'foo', 'c': 12}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#使用update方法可以将一个字典与另一个融合\n",
    "d1={'a':'some value','b':[1,2,3,4]}\n",
    "d1.update({'b':'foo','c':12})\n",
    "d1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 4, 1: 3, 2: 2, 3: 1, 4: 0}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mapping=dict(zip(range(5),reversed(range(5))))#通过zip可将两个序列配对组合成字典\n",
    "mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']}"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#通过一个首字母将一个列表里面的单词分类\n",
    "words=['apple','bat','bar','atom','book']\n",
    "by_letter={}#首字母对应的单词列表都放在一个dict里面\n",
    "for word in words:\n",
    "    letter=word[0]\n",
    "    if letter not in by_letter:\n",
    "        by_letter[letter]=[word]#不能直接写word,要写成列表形式\n",
    "    else:\n",
    "        by_letter[letter].append(word)\n",
    "by_letter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1;31mSignature:\u001b[0m \u001b[0mdict\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msetdefault\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdefault\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m/\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mDocstring:\u001b[0m\n",
      "Insert key with a value of default if key is not in the dictionary.\n",
      "\n",
      "Return the value for key if key is in the dictionary, else default.\n",
      "\u001b[1;31mType:\u001b[0m      method_descriptor\n"
     ]
    }
   ],
   "source": [
    "# 上述代码可以使用setdefault进行改写，如果字典里面没有该key则插会添加该键，并将default内容设置为默认键值\n",
    "dict.setdefault?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']}"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "words=['apple','bat','bar','atom','book']\n",
    "by_letter={}#首字母对应的单词列表都放在一个dict里面.\n",
    "for word in words:\n",
    "    letter=word[0]\n",
    "    by_letter.setdefault(letter,[]).append(word)\n",
    "by_letter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(list, {'a': ['apple', 'atom'], 'b': ['bat', 'bar', 'book']})"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import defaultdict\n",
    "by_letter={}\n",
    "by_letter=defaultdict(list)#以list类型生成该字典中每个键值的默认值，这里是为空list\n",
    "for word in words:\n",
    "    by_letter[word[0]].append(word)\n",
    "by_letter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_data = [['John', 'Emily', 'Michael', 'Mary', 'Steven'],['Maria', 'Juan', 'Javier', 'Natalia', 'Pilar']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Steven']"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name_of_interst=[]\n",
    "for names in all_data:\n",
    "    enough_es=[name for name in names if name.count('e')>=2]\n",
    "    name_of_interst.extend(enough_es)\n",
    "name_of_interst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 函数也是对象"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "states=['   Alabama ', 'Georgia!', 'Georgia', 'georgia', 'FlOrIda','south   carolina##', 'West virginia?']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Alabama',\n",
       " 'Georgia',\n",
       " 'Georgia',\n",
       " 'Georgia',\n",
       " 'Florida',\n",
       " 'South   Carolina',\n",
       " 'West Virginia']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#需要做很多事情：去除空白符、删除各种标点符号、正确的大写格式等。做法之一是使用内建的字符串方法和正则表达式re模块：\n",
    "states=['Alabama ', 'Georgia!', 'Georgia', 'georgia', 'FlOrIda','south   carolina##', 'West virginia?']\n",
    "import re\n",
    "def clean_strings(strings):\n",
    "    result=[]\n",
    "    for value in strings:\n",
    "        value=value.strip()#去除空白符，第一个函数操作\n",
    "        value=re.sub('[!#?]','',value)#把字符串里面的#!?符号去掉，第二个函数操作\n",
    "        \n",
    "        value=value.title()#正确的大写格式，第三个函数操作\n",
    "        result.append(value)\n",
    "    return result\n",
    "\n",
    "states=clean_strings(states)\n",
    "states\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 将需要在一组给定字符串上执行的所有运算做成一个列表："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def remove_punctuation(value):\n",
    "    return re.sub('[!#?]','',value)\n",
    "\n",
    "clean_ops=[str.strip,remove_punctuation,str.title]\n",
    "\n",
    "def clean_strings(strings,ops):\n",
    "    result=[]\n",
    "    for string in strings:\n",
    "        for function in ops:\n",
    "            string=function(string)\n",
    "        result.append(string)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Alabama',\n",
       " 'Georgia',\n",
       " 'Georgia',\n",
       " 'Georgia',\n",
       " 'Florida',\n",
       " 'South   Carolina',\n",
       " 'West Virginia']"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "states=['   Alabama ', 'Georgia!', 'Georgia', 'georgia', 'FlOrIda','south   carolina##', 'West virginia?']\n",
    "states=clean_strings(states,clean_ops)\n",
    "states"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# map函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Alabama \n",
      "Georgia\n",
      "Georgia\n",
      "georgia\n",
      "FlOrIda\n",
      "south   carolina\n",
      "West virginia\n"
     ]
    }
   ],
   "source": [
    "states=['   Alabama ', 'Georgia!', 'Georgia', 'georgia', 'FlOrIda','south   carolina##', 'West virginia?']\n",
    "for x in map(remove_punctuation,states):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# lambda函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[16, 0, 1, 25, 36]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def apply_to_list(some_list,f):\n",
    "    return [f(x) for x in some_list]\n",
    "ints=[4,0,1,5,6]\n",
    "apply_to_list(ints,lambda x: x**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['aaaa', 'foo', 'abab', 'bar', 'card']"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "strings=['foo','card','bar','aaaa','abab']\n",
    "#根据字符串不同字母的数量进行排序，非常巧妙，把每个元素转化成set，再进行len计数，得到的就是不同字母的数量\n",
    "strings.sort(key=lambda x:len(set(x)))\n",
    "strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 柯里化：部分参数应用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#从现有函数中派生出新函数，定义了一个可以调用现有函数的新函数\n",
    "def add_numbers(x,y):\n",
    "    return x+y\n",
    "add_five=lambda y: add_numbers(5,y)\n",
    "add_five(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 生成器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一般的函数执行之后只会返回单个值，而生成器则是以延迟的方式返回一个值序列，即每返回一个值之后暂停，直到下一个值被请求时再继续。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object squares at 0x00000222100A6890>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def squares(n=10):\n",
    "    print('Generating squares from 1 to {0}'.format(n**2))\n",
    "    for i in range(1,n+1):\n",
    "        yield i**2\n",
    "a=squares()\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating squares from 1 to 100\n",
      "1 4 9 16 25 36 49 64 81 100 "
     ]
    }
   ],
   "source": [
    "#直到你从该生成器中请求元素时，他才会开始执行代码,暂时理解为一个未被启动的函数，通过请求元素时，会被激活\n",
    "for x in a:\n",
    "    print(x,end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 通过生成器表达式可以更快的写出生成器，两边是不是方括号，而是圆括号\n",
    "gen=(x**2 for x in range(100))\n",
    "#for x in gen:\n",
    "#    print(x)\n",
    "\n",
    "dict((i,i**2) for i in range(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# itertools模块"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A ['Alan', 'Adam']\n",
      "W ['Wes', 'Will']\n",
      "A ['Albert']\n",
      "S ['Steven']\n"
     ]
    }
   ],
   "source": [
    "import itertools\n",
    "#itertools里面的groupby接受任何序列和一个函数，根据函数的返回值对序列中的连续元素进行分组\n",
    "first_letter=lambda x: x[0]\n",
    "names=['Alan','Adam','Wes','Will','Albert','Steven']\n",
    "for letter,names in itertools.groupby(names,first_letter):\n",
    "    print(letter,list(names))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 错误与异处理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#处理float 错误\n",
    "def attempt_float(x):\n",
    "    try:\n",
    "        return float(x)\n",
    "    except (ValueError,TypeError):#可以使用元组包含多个指定异常\n",
    "        return x\n",
    "\n",
    "attempt_float('1.26454')\n",
    "attempt_float('something')\n",
    "attempt_float((1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'path' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-61-bd3d2af622bc>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# 当不想抑制异常，无论try的代码是否成功时，都执行一段代码，则可以使用finally\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mf\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpath\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m'w'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[0mwrite_to_file\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mf\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;32mexcept\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'path' is not defined"
     ]
    }
   ],
   "source": [
    "# 当不想抑制异常，无论try的代码是否成功时，都执行一段代码，则可以使用finally\n",
    "f=open(path,'w')\n",
    "try: \n",
    "    write_to_file(f)\n",
    "except:\n",
    "    print('Failed')\n",
    "else:\n",
    "    print('Succeeded')\n",
    "finally:\n",
    "    f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 文件和操作系统"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "path=r'D:\\tnsnames.ora'\n",
    "f=open(path)#获取文件的句柄"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# tnsnames.ora Network Configuration File: E:\\software\\Oracle\\product\\11.2.0\\dbhome_1\\network\\admin\\tnsnames.ora\n",
      "\n",
      "# Generated by Oracle configuration tools.\n",
      "\n",
      "\n",
      "\n",
      "DEUS =\n",
      "\n",
      "  (DESCRIPTION =\n",
      "\n",
      "    (ADDRESS = (PROTOCOL = TCP)(HOST = localhost)(PORT = 1521))\n",
      "\n",
      "    (CONNECT_DATA =\n",
      "\n",
      "      (SERVER = DEDICATED)\n",
      "\n",
      "      (SERVICE_NAME = deus)\n",
      "\n",
      "    )\n",
      "\n",
      "  )\n",
      "\n",
      "\n",
      "\n",
      "GROUPLIN =\n",
      "\n",
      "  (DESCRIPTION =\n",
      "\n",
      "    (ADDRESS_LIST =\n",
      "\n",
      "      (ADDRESS = (PROTOCOL = TCP)(HOST = 218.192.166.14)(PORT = 1521))\n",
      "\n",
      "    )\n",
      "\n",
      "    (CONNECT_DATA =\n",
      "\n",
      "      (SERVER = DEDICATED)\n",
      "\n",
      "      (SERVICE_NAME = grouplin)\n",
      "\n",
      "    )\n",
      "\n",
      "  )\n",
      "\n",
      "\n",
      "\n",
      "  \n",
      "\n",
      "ORACLR_CONNECTION_DATA =\n",
      "\n",
      "  (DESCRIPTION =\n",
      "\n",
      "    (ADDRESS_LIST =\n",
      "\n",
      "      (ADDRESS = (PROTOCOL = IPC)(KEY = EXTPROC1521))\n",
      "\n",
      "    )\n",
      "\n",
      "    (CONNECT_DATA =\n",
      "\n",
      "      (SID = CLRExtProc)\n",
      "\n",
      "      (PRESENTATION = RO)\n",
      "\n",
      "    )\n",
      "\n",
      "  )\n",
      "\n",
      "\n",
      "\n",
      "ORCL =\n",
      "\n",
      "  (DESCRIPTION =\n",
      "\n",
      "    (ADDRESS = (PROTOCOL = TCP)(HOST = 202.38.228.20)(PORT = 1521))\n",
      "\n",
      "    (CONNECT_DATA =\n",
      "\n",
      "      (SERVER = DEDICATED)\n",
      "\n",
      "      (SERVICE_NAME = orcl)\n",
      "\n",
      "    )\n",
      "\n",
      "  )\n",
      "\n",
      "\n",
      "\n",
      "LISTENER_DEUS =\n",
      "\n",
      "  (ADDRESS = (PROTOCOL = TCP)(HOST = localhost)(PORT = 1521))\n",
      "\n",
      "\n",
      "\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for line in f:\n",
    "    print(line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['# tnsnames.ora Network Configuration File: E:\\\\software\\\\Oracle\\\\product\\\\11.2.0\\\\dbhome_1\\\\network\\\\admin\\\\tnsnames.ora',\n",
       " '# Generated by Oracle configuration tools.',\n",
       " '',\n",
       " 'DEUS =',\n",
       " '  (DESCRIPTION =',\n",
       " '    (ADDRESS = (PROTOCOL = TCP)(HOST = localhost)(PORT = 1521))',\n",
       " '    (CONNECT_DATA =',\n",
       " '      (SERVER = DEDICATED)',\n",
       " '      (SERVICE_NAME = deus)',\n",
       " '    )',\n",
       " '  )',\n",
       " '',\n",
       " 'GROUPLIN =',\n",
       " '  (DESCRIPTION =',\n",
       " '    (ADDRESS_LIST =',\n",
       " '      (ADDRESS = (PROTOCOL = TCP)(HOST = 218.192.166.14)(PORT = 1521))',\n",
       " '    )',\n",
       " '    (CONNECT_DATA =',\n",
       " '      (SERVER = DEDICATED)',\n",
       " '      (SERVICE_NAME = grouplin)',\n",
       " '    )',\n",
       " '  )',\n",
       " '',\n",
       " '',\n",
       " 'ORACLR_CONNECTION_DATA =',\n",
       " '  (DESCRIPTION =',\n",
       " '    (ADDRESS_LIST =',\n",
       " '      (ADDRESS = (PROTOCOL = IPC)(KEY = EXTPROC1521))',\n",
       " '    )',\n",
       " '    (CONNECT_DATA =',\n",
       " '      (SID = CLRExtProc)',\n",
       " '      (PRESENTATION = RO)',\n",
       " '    )',\n",
       " '  )',\n",
       " '',\n",
       " 'ORCL =',\n",
       " '  (DESCRIPTION =',\n",
       " '    (ADDRESS = (PROTOCOL = TCP)(HOST = 202.38.228.20)(PORT = 1521))',\n",
       " '    (CONNECT_DATA =',\n",
       " '      (SERVER = DEDICATED)',\n",
       " '      (SERVICE_NAME = orcl)',\n",
       " '    )',\n",
       " '  )',\n",
       " '',\n",
       " 'LISTENER_DEUS =',\n",
       " '  (ADDRESS = (PROTOCOL = TCP)(HOST = localhost)(PORT = 1521))',\n",
       " '',\n",
       " '']"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#得到一组没有EOL的行\n",
    "lines=[x.rstrip() for x in open(path)]\n",
    "lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 用open创建文件对象时，一定要用close关闭，来释放操作系统的资源\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['# tnsnames.ora Network Configuration File: E:\\\\software\\\\Oracle\\\\product\\\\11.2.0\\\\dbhome_1\\\\network\\\\admin\\\\tnsnames.ora',\n",
       " '# Generated by Oracle configuration tools.',\n",
       " '',\n",
       " 'DEUS =',\n",
       " '  (DESCRIPTION =',\n",
       " '    (ADDRESS = (PROTOCOL = TCP)(HOST = localhost)(PORT = 1521))',\n",
       " '    (CONNECT_DATA =',\n",
       " '      (SERVER = DEDICATED)',\n",
       " '      (SERVICE_NAME = deus)',\n",
       " '    )',\n",
       " '  )',\n",
       " '',\n",
       " 'GROUPLIN =',\n",
       " '  (DESCRIPTION =',\n",
       " '    (ADDRESS_LIST =',\n",
       " '      (ADDRESS = (PROTOCOL = TCP)(HOST = 218.192.166.14)(PORT = 1521))',\n",
       " '    )',\n",
       " '    (CONNECT_DATA =',\n",
       " '      (SERVER = DEDICATED)',\n",
       " '      (SERVICE_NAME = grouplin)',\n",
       " '    )',\n",
       " '  )',\n",
       " '',\n",
       " '',\n",
       " 'ORACLR_CONNECTION_DATA =',\n",
       " '  (DESCRIPTION =',\n",
       " '    (ADDRESS_LIST =',\n",
       " '      (ADDRESS = (PROTOCOL = IPC)(KEY = EXTPROC1521))',\n",
       " '    )',\n",
       " '    (CONNECT_DATA =',\n",
       " '      (SID = CLRExtProc)',\n",
       " '      (PRESENTATION = RO)',\n",
       " '    )',\n",
       " '  )',\n",
       " '',\n",
       " 'ORCL =',\n",
       " '  (DESCRIPTION =',\n",
       " '    (ADDRESS = (PROTOCOL = TCP)(HOST = 202.38.228.20)(PORT = 1521))',\n",
       " '    (CONNECT_DATA =',\n",
       " '      (SERVER = DEDICATED)',\n",
       " '      (SERVICE_NAME = orcl)',\n",
       " '    )',\n",
       " '  )',\n",
       " '',\n",
       " 'LISTENER_DEUS =',\n",
       " '  (ADDRESS = (PROTOCOL = TCP)(HOST = localhost)(PORT = 1521))',\n",
       " '',\n",
       " '']"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#采用with语句，可以在退出代码块时，自动关闭文件\n",
    "with open(path)as f:\n",
    "    lines=[x.rstrip() for x in f]\n",
    "lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['# tnsnames.ora Network Configuration File: E:\\\\software\\\\Oracle\\\\product\\\\11.2.0\\\\dbhome_1\\\\network\\\\admin\\\\tnsnames.ora\\n',\n",
       " '# Generated by Oracle configuration tools.\\n',\n",
       " 'DEUS =\\n',\n",
       " '  (DESCRIPTION =\\n',\n",
       " '    (ADDRESS = (PROTOCOL = TCP)(HOST = localhost)(PORT = 1521))\\n',\n",
       " '    (CONNECT_DATA =\\n',\n",
       " '      (SERVER = DEDICATED)\\n',\n",
       " '      (SERVICE_NAME = deus)\\n',\n",
       " '    )\\n',\n",
       " '  )\\n',\n",
       " 'GROUPLIN =\\n',\n",
       " '  (DESCRIPTION =\\n',\n",
       " '    (ADDRESS_LIST =\\n',\n",
       " '      (ADDRESS = (PROTOCOL = TCP)(HOST = 218.192.166.14)(PORT = 1521))\\n',\n",
       " '    )\\n',\n",
       " '    (CONNECT_DATA =\\n',\n",
       " '      (SERVER = DEDICATED)\\n',\n",
       " '      (SERVICE_NAME = grouplin)\\n',\n",
       " '    )\\n',\n",
       " '  )\\n',\n",
       " '  \\n',\n",
       " 'ORACLR_CONNECTION_DATA =\\n',\n",
       " '  (DESCRIPTION =\\n',\n",
       " '    (ADDRESS_LIST =\\n',\n",
       " '      (ADDRESS = (PROTOCOL = IPC)(KEY = EXTPROC1521))\\n',\n",
       " '    )\\n',\n",
       " '    (CONNECT_DATA =\\n',\n",
       " '      (SID = CLRExtProc)\\n',\n",
       " '      (PRESENTATION = RO)\\n',\n",
       " '    )\\n',\n",
       " '  )\\n',\n",
       " 'ORCL =\\n',\n",
       " '  (DESCRIPTION =\\n',\n",
       " '    (ADDRESS = (PROTOCOL = TCP)(HOST = 202.38.228.20)(PORT = 1521))\\n',\n",
       " '    (CONNECT_DATA =\\n',\n",
       " '      (SERVER = DEDICATED)\\n',\n",
       " '      (SERVICE_NAME = orcl)\\n',\n",
       " '    )\\n',\n",
       " '  )\\n',\n",
       " 'LISTENER_DEUS =\\n',\n",
       " '  (ADDRESS = (PROTOCOL = TCP)(HOST = localhost)(PORT = 1521))\\n']"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用write或writelines方法来创建一个无空行版的prof_mod.py\n",
    "with open('tmp.txt','w')as handle:\n",
    "    handle.writelines(x for x in open(path)if len(x)>1)\n",
    "\n",
    "with open('tmp.txt')as f:\n",
    "    lines=f.readlines()\n",
    "lines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 连接数据库"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pymysql\n",
    "connection = pymysql.connect(host='8.129.214.224', #host属性\n",
    "                             user='root',\n",
    "                             password='13106999886@Ab',\n",
    "                             db='freight'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 创建光标对象，一个连接可以有很多光标，一个光标跟踪一种数据状态。\n",
    "# 光标对象作用是：创建、删除、写入、查询等等"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(('app',), ('chat',), ('data_auditing',), ('emission',), ('freight',), ('gz_freight',), ('information_schema',), ('log4j',), ('mysql',), ('performance_schema',), ('report',), ('sys',), ('team',), ('userplate',))\n"
     ]
    }
   ],
   "source": [
    "cur=connection.cursor()\n",
    "#查看有哪些数据库\n",
    "cur.execute('show databases')\n",
    "print(cur.fetchall())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用数据库\n",
    "cur.execute('use freight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "a8f61be024eba58adef938c9aa1e29e02cb3dece83a5348b1a2dafd16a070453"
  },
  "kernelspec": {
   "display_name": "Python 3.8.8 64-bit ('base': conda)",
   "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.8.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}