python_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  1. 环境搭建"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1.0 安装python\n",
    "直接安装anaconda，安装好anaconda，python解释器和jupyter notebook,pandas,sklearn等数据分析相关的包都有了,推荐到清华大学镜像站下载：\n",
    "<br>\n",
    "https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/\n",
    "<br>\n",
    "如果不想安装anaconda，到https://www.python.org/downloads/ 下载python3的安装包，一直next,最后记得勾选add python to envirnment path，finish\n",
    "<br>\n",
    "#### 1.1 安装扩展包\n",
    "<pre>pip3 install package_name</pre> package_name是想要安装的包的名字。默认情况下会到国外网站下载相应的包，下载速度很慢，推荐使用清华大学的镜像站，从清华大学的镜像站下载安装扩展包的速度很快。\n",
    "参考配置：https://mirrors.tuna.tsinghua.edu.cn/help/pypi/</br>\n",
    "有时会安装失败，无非以下几种原因：<br>\n",
    "（1）网络连接失败，下载超时，重试即可；<br>\n",
    "（2）下载的扩展包无法在window下编译通过，因为扩展包是用c或者c++写的，window环境下没有编译工具，这时报错信息下面会给出一个网址，到网址下载编译工具安装即可。<br>\n",
    "另一种解决方法：到网站：www.lfd.uci.edu/~gohlke/pythonlibs/#numpy 下载已经编译好的whl文件，在window下执行<pre>pip3 install numpy‑1.14.0rc1+mkl‑cp36‑cp36m‑win_amd64.whl</pre>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;(这里以numpy包为例)安装即可<br>\n",
    "（3）Could not find a version that satisfies the requirement package_name.(找不到对应的包，检查扩展包名是否写错)\n",
    "#### 1.2 学习路线\n",
    "<b>python2版本和python3版本的主要差别：</b><br>\n",
    "1. print函数；2. 字符串编码；推荐直接学python3；<br>\n",
    "<br>第一阶段：<b><i>掌握基础语法(加减乘除取余数取整，字符串操作，数据类型[int,float,bool,str]，数据结构[list,tuple,dict,set]，控制流[if,while,for等]，初步的面向对象思想)</i></b><br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;建议看完本教程后，搭好python环境，花几个小时把<a href=\"http://www.kuqin.com/abyteofpython_cn/\">简明python教程</a>敲一遍，然后把\n",
    "<a href=\"http://www.runoob.com/python/python-exercise-example1.html\">菜鸟教程(附练习题)</a>的习题做一遍，如果对一些概念不是很清楚，可以到<a href=\"https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000\">廖雪峰python教程</a>查找相关概念\n",
    "<br>\n",
    "第二阶段：<b><i>具备面向对象思想，学习pandas包</i></b><br>\n",
    "&nbsp;&nbsp;&nbsp;&nbsp;pandas包借鉴R语言的dataFrame数据结构(类似表格的二维表结构)。具备了面向对象的思想，就不用死记pandas包的函数，需要用到函数的时候查找<a href=\"http://pandas.pydata.org/pandas-docs/stable/api.html\">pandas包的api文档</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. 基本语句"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "True\n",
      "I 'm pythoner\n",
      "<class 'str'>\n",
      "<class 'bool'>\n",
      "<class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "# 数据类型\n",
    "x_0 = 2  # 整形， int\n",
    "x_1 = 5  # 整形， int\n",
    "print(type(x_0))\n",
    "y_0 = 1.1 # 浮点型，float\n",
    "y_1 = 1.0 # 浮点型，float\n",
    "print(type(y_0))\n",
    "z_0 = \"abc\"  # 字符串，用单引号或者双引号皆可，特殊字符用\\转义\n",
    "z_1 = 'abc'  # 字符串\n",
    "print(z_0 == z_1)  # True,说明单引号和双引号是一样的\n",
    "z_2 = 'I \\'m a sententence' \n",
    "print(z_2)   # I 'm  a sententence,单引号成功打印出来，单斜杆没有打印出来，单斜杆起转义作用\n",
    "print(type(z_0))\n",
    "a = True  # 布尔值\n",
    "print(type(a))\n",
    "b = None  # None值，通常一个函数没有return语句，则返回None\n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.1\n",
      "0.10000000000000009\n",
      "1.1\n",
      "1.1\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# 加\n",
    "print(y_0 + y_1) # 2.1\n",
    "# 减\n",
    "print(y_0 - y_1) # 0.10000000000000009,浮点数精度问题\n",
    "# 乘\n",
    "print(y_0 * y_1) # 1.1\n",
    "# 除\n",
    "print(y_0 / y_1) # 1.1\n",
    "# 取余数\n",
    "print(x_1 % x_0) # 1\n",
    "# 取整\n",
    "print(x_1 // x_0) # 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "str_a 的最后6个字符串为： string\n",
      "切割后的字符串为： ['add', 'a', 'string']\n",
      "替换后的字符串为： minus a string\n"
     ]
    }
   ],
   "source": [
    "# 字符串常用操作\n",
    "# 字符串拼接\n",
    "str_a = \"add a string\"\n",
    "str_b = \"add another string\"\n",
    "str_c = str_a + \",\" + str_b  # 字符串拼接，都是字符串的情况下才能拼接\n",
    "str_d = \"{} , {}\".format(str_a, str_b)  # 字符串拼接，大括号为留白部分，把str_a, str_b分别填入第一第二个大括号\n",
    "# 字符串切片\n",
    "add_str = str_a[0:4]  # add_str = \"add\",取前三个字符\n",
    "# 取最后6个字符\n",
    "last_str = str_a[-6:] # string\n",
    "print(\"str_a 的最后6个字符串为：\",last_str)\n",
    "# 字符串切割\n",
    "split_list = str_a.split(\" \") # 以空格为分割符切割str_a字符串\n",
    "print(\"切割后的字符串为：\", split_list)\n",
    "# 字符串替换\n",
    "new_str_a = str_a.replace(\"add\", \"minus\")\n",
    "print(\"替换后的字符串为：\", new_str_a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. 控制流"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 == 2\n",
      "current i is: 1\n",
      "current i is: 3\n",
      "current i is: 5\n",
      "current i is: 7\n",
      "break the loop\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# 条件语句\n",
    "if 1 == 0:\n",
    "    print(\"1 == 0\")\n",
    "elif 2 == 2:\n",
    "    print(\"2 == 2\")\n",
    "else:\n",
    "    print(\"other situation\")\n",
    "    \n",
    "# 循环语句\n",
    "for i in range(1,10):\n",
    "    if i % 2 == 0:  # 如果是偶数，则跳过不往下执行\n",
    "        continue  # 跳过此次循环，不往下执行\n",
    "    elif i == 8:\n",
    "        print(\"break the loop\")# 跳出整个循环\n",
    "        break\n",
    "    print(\"current i is: \" + str(i))\n",
    "    \n",
    "# while\n",
    "i = 0\n",
    "while i < 10:\n",
    "    print(i)\n",
    "    i += 1  # i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. 数据类型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.1 list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.1.1 创建列表"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = [1, 2, \"a\", 4, 5]\n",
    "b = range(1,5)  # -->  [1, 2, 3, 4]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.1.2 获取列表元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "len(a): 5\n",
      "a[0] : 1\n",
      "a[-1] : 5\n",
      "a[1:4] : [2, 'a', 4]\n",
      "a.index(\"a\"): 2\n"
     ]
    }
   ],
   "source": [
    "# a的长度\n",
    "print(\"len(a):\", len(a))\n",
    "# 取出a的第一个元素\n",
    "print(\"a[0] :\", a[0])  # 下标从0开始\n",
    "#  取出a的最后一个元素\n",
    "print(\"a[-1] :\",a[-1])\n",
    "# 取出第二到第4个元素\n",
    "print(\"a[1:4] :\",a[1:4])  # 注意：a[4]是取不到的\n",
    "\n",
    "# 找出某个值在列表中的下标\n",
    "print('a.index(\"a\"):', a.index(\"a\"))  # 2, 说明 \"a\"在列表a中的下标为 2\n",
    "# 从面向对象的角度来讲，list是一个类，a是list类的一个实例化的对象， index是list类里面的一个方法，a.index， 通过. 调用list类的index方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.1.3 常用方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "id(a_list) == id(tmp): True\n",
      "a_list.count(\"a\"): 1\n",
      "b_list.count(\"a\"): 2\n"
     ]
    }
   ],
   "source": [
    "a_list = [\"x\", \"y\", \"z\"]\n",
    "tmp = a_list\n",
    "print(\"id(a_list) == id(tmp):\", id(a_list) == id(tmp))  # 内存中的地址一样\n",
    "b_list = a_list.copy()  # 复制一份a_list, 不能用b_list = a_list,如果使用 b_list = a_list,在内存中共用一个地址，对a_list操作，b_list的值也会改变\n",
    "# 往列表添加元素, append 和extend\n",
    "a_list.append(\"a\")  # -->  [\"x\", \"y\", \"z\", \"a\"]\n",
    "b_list.extend(\"a\")  # -->  [\"x\", \"y\", \"z\", \"a\"]\n",
    "a_list.append([\"a\",\"b\",\"c\"]) #--> [\"x\", \"y\", \"z\", \"a\", [\"a\",\"b\",\"c\"]]\n",
    "b_list.extend([\"a\",\"b\",\"c\"]) #--> [\"x\", \"y\", \"z\", \"a\", \"a\",\"b\",\"c\"]\n",
    "# 计算a_list里面有多少个\"a\"\n",
    "print('a_list.count(\"a\"):', a_list.count(\"a\"))  # --> 1\n",
    "print('b_list.count(\"a\"):', b_list.count(\"a\"))   # --> 2\n",
    "## 更多方法请参考python帮助文档"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.2 tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "tuple（元组）与list(列表)很相似，不同的是，tuple里面的值不可变，往元组里面添加，删除，修改元素都会报错。\n",
    "a_tuple = (1, 2, 3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#### 4.3 字典"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "字典是一种 keys-->valus 键值对，keys值唯一，无序，values可以是各种各样的值，可以是列表，元组，不同key值对应的values的长度可以不等"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.3.1 创建字典"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "a_dict = {\"a\":1, \"b\":2, \"c\":3}\n",
    "b_dict = {\"a\":[1,2,3,4], \"b\":(1,2,3), \"c\":\"c\"} # key值分别为a,b,c  , 对应的values值为[1,2,3,4]， (1,2,3)， c\n",
    "another_dict = dict(a=1, b=2, c=3)\n",
    "print(a_dict == another_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.3.2 获取字典元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "dict_keys(['b', 'a', 'c'])\n",
      "dict_values([2, 1, 3])\n"
     ]
    }
   ],
   "source": [
    "a_dict[\"a\"]  #  --> 1,根据key值取value\n",
    "#a_dict[\"d\"]  #  keyerror, 获取不到key值为d 的value,报错\n",
    "a_dict.get(\"a\") # --> 1\n",
    "print(a_dict.get(\"d\")) # --> 不会报错，返回None,因为a_dict的key里面没有\"d\"\n",
    "print(a_dict.keys())\n",
    "print(a_dict.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.3.3 迭代字典"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key: b\n",
      "value: 2\n",
      "key: a\n",
      "value: 1\n",
      "key: c\n",
      "value: 3\n",
      "----------------------------------------------------------------\n",
      "key: b\n",
      "value: 2\n",
      "key: a\n",
      "value: 1\n",
      "key: c\n",
      "value: 3\n"
     ]
    }
   ],
   "source": [
    "# 同时迭代key和value\n",
    "for k,v in a_dict.items():  # 字典比较大的时候推荐使用\n",
    "    print(\"key:\", k)\n",
    "    print(\"value:\", v)\n",
    "print(\"--------\" * 8)  # 分割线\n",
    "for k in a_dict:\n",
    "    print(\"key:\", k)\n",
    "    print(\"value:\", a_dict[k])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 4.3.4 添加，更新，删除字典元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a_dict: {'b': 2, 'a': 1, 'c': 3}\n"
     ]
    }
   ],
   "source": [
    "a_dict[\"d\"] = [1, 2, 3, 4, 5]  # 赋值\n",
    "a_dict[\"d\"] = [0, 1, 2, 3]  # 修改 a_dict的key值为d的value为[0, 1, 2, 3]\n",
    "del a_dict[\"d\"]  # 删除key值为d的键值对\n",
    "print(\"a_dict:\", a_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4.4 集合"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "集合是一种无序，不含重复值的数据结构"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a_set: {'b', 'a', 'd', 'c'}\n",
      "b_set: {'z', 'a', 'x', 'y'}\n"
     ]
    }
   ],
   "source": [
    "#  创建集合\n",
    "a_set = set([\"a\", \"b\", \"c\", \"d\", \"a\", \"b\", \"c\", \"d\"])\n",
    "print(\"a_set:\", a_set)  # 重复值会被剔除掉\n",
    "b_set = set([\"a\", \"x\", \"y\", \"z\", \"a\"])\n",
    "print(\"b_set:\", b_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "diff_set: {'z', 'x', 'y'}\n",
      "union_set: {'d', 'c', 'y', 'b', 'z', 'a', 'x'}\n",
      "inter_set: {'a'}\n"
     ]
    }
   ],
   "source": [
    "#  集合运算\n",
    "# 1. 求差集\n",
    "diff_set = b_set - a_set\n",
    "print(\"diff_set:\", diff_set) # b_set和a_set共有的元素为\"a\", b_set - a_set 的差集为{'z', 'x', 'y'} ，即b_set中有的，而a_set中没有的元素\n",
    "union_set = a_set | b_set  # 并集\n",
    "print(\"union_set:\", union_set)\n",
    "inter_set = a_set & b_set  # 交集\n",
    "print(\"inter_set:\", inter_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. 函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5 形参与实参"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "#  定义函数，arg1,arg2叫做形式参数\n",
    "def f(arg1, arg2):\n",
    "    x = arg1 + arg2\n",
    "    print(x)\n",
    "    return x\n",
    "a = 1\n",
    "b = 2\n",
    "f(a, b)  #  这里的a， b是实际参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.0 传值or传址"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "函数内部a的值为： 3\n",
      "函数外部a的值为： 1\n",
      "函数内部a的值为： [1, 2, 3, 4, 5, 6]\n",
      "函数外部a的值为： [1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "#  传值进入函数\n",
    "a = 1\n",
    "b = 2\n",
    "def f(a, b):\n",
    "    a = a + b  # 函数内部改变a的值, a=3\n",
    "    print(\"函数内部a的值为：\",a)\n",
    "f(a, b)\n",
    "print(\"函数外部a的值为：\",a) #-->  未改变a的值，因为传入函数内部的是a的值，相当于把a的值复制一份传入函数内部，不影响外部的a值\n",
    "#  传(引用)地址进入函数\n",
    "a = [1, 2, 3]\n",
    "b = [4, 5, 6]\n",
    "def f(a, b):\n",
    "    a.extend(b)  # a的值变为 [1, 2, 3, 4, 5, 6]\n",
    "    print(\"函数内部a的值为：\",a)\n",
    "f(a, b)\n",
    "print(\"函数外部a的值为：\",a) #--> [1, 2, 3, 4, 5, 6]， 已改变a的值,因为传入函数内部的是a的地址，函数内部的a和函数外部的a是同一个地址"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.1 全局变量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "# a为全局变量\n",
    "a = 1\n",
    "def test1():\n",
    "    # 即使a的值没有传入函数，在函数内部还是可以打印出a的值\n",
    "    print(a)\n",
    "test1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.2 局部变量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'b' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-18d771e4aab5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[1;31m# 报错，因为b的值的作用域仅限于test1函数内部\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'b' is not defined"
     ]
    }
   ],
   "source": [
    "def test1():\n",
    "    # 这里的b为局部变量，只能在这个函数的内部可以获取得到b的值，在函数外部获取不到b的值\n",
    "    b = 1\n",
    "    # 不会报错，获取得到b的值\n",
    "    print(b)\n",
    "# 报错，因为b的值的作用域仅限于test1函数内部\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.3 变量作用域"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 在Python程序中创建、改变、查找变量名时，都是在一个保存变量名的空间中进行，我们称之为命名空间，也被称之为作用域"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5.4 装饰器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><pre>*******先跳过*******</pre></b><br>\n",
    "推荐文章：\n",
    "<pre>\n",
    "<a href=\"https://www.zhihu.com/question/25950466/answer/31731502\">理解python里面的装饰器</a>\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. 面向对象"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><pre>************重点内容************</pre></b><br>\n",
    "面向对象的设计思想是从自然界中来的，因为在自然界中，类（Class）和实例（Instance）的概念是很自然的。Class是一种抽象概念，比如我们定义的Class——Student，是指学生这个概念，而实例（Instance）则是一个个具体的Student，比如，Bart Simpson和Lisa Simpson是两个具体的Student。\n",
    "\n",
    "所以，面向对象的设计思想是抽象出Class，根据Class创建Instance。\n",
    "\n",
    "面向对象的抽象程度又比函数要高，因为一个Class既包含数据，又包含操作数据的方法。\n",
    "<pre>\n",
    "参考：\n",
    "<a href=\"https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014318645694388f1f10473d7f416e9291616be8367ab5000\">面向对象编程</a>\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ian: hi\n",
      "Joel: hello\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'*grunt*'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## 来源：http://www.code123.cc/1049.html\n",
    "# We subclass from object to get a class.\n",
    "# 我们可以从对象中继承，来得到一个类。\n",
    "# @classmethod(类方法),@staticmethod(静态方法)先跳过，知道有这两个东西就好\n",
    "class Human(object):\n",
    "    # A class attribute. It is shared by all instances of this class\n",
    "    # 下面是一个类属性。它将被这个类的所有实例共享。\n",
    "    species = \"H. sapiens\"\n",
    "\n",
    "    # Basic initializer\n",
    "    # 基本的初始化函数（构造函数）\n",
    "    def __init__(self, name):\n",
    "        # Assign the argument to the instance's name attribute\n",
    "        # 把参数赋值为实例的 name 属性\n",
    "        self.name = name\n",
    "\n",
    "    # An instance method. All methods take self as the first argument\n",
    "    # 下面是一个实例方法。所有方法都以 self 作为第一个参数。\n",
    "    def say(self, msg):\n",
    "       return \"%s: %s\" % (self.name, msg)\n",
    "\n",
    "    # A class method is shared among all instances\n",
    "    # They are called with the calling class as the first argument\n",
    "    # 类方法会被所有实例共享。\n",
    "    # 类方法在调用时，会将类本身作为第一个函数传入。\n",
    "    @classmethod\n",
    "    def get_species(cls):\n",
    "        return cls.species\n",
    "\n",
    "    # A static method is called without a class or instance reference\n",
    "    # 静态方法在调用时，不会传入类或实例的引用。\n",
    "    @staticmethod\n",
    "    def grunt():\n",
    "        return \"*grunt*\"\n",
    "\n",
    "\n",
    "# Instantiate a class\n",
    "# 实例化一个类\n",
    "i = Human(name=\"Ian\")\n",
    "print(i.say(\"hi\"))     # prints out \"Ian: hi\"\n",
    "                      # 打印出 \"Ian: hi\"\n",
    "\n",
    "j = Human(\"Joel\")\n",
    "print(j.say(\"hello\"))  # prints out \"Joel: hello\"\n",
    "                      # 打印出 \"Joel: hello\"\n",
    "\n",
    "# Call our class method\n",
    "# 调用我们的类方法\n",
    "i.get_species() #=> \"H. sapiens\"\n",
    "\n",
    "# Change the shared attribute\n",
    "# 修改共享属性\n",
    "Human.species = \"H. neanderthalensis\"\n",
    "i.get_species() #=> \"H. neanderthalensis\"\n",
    "j.get_species() #=> \"H. neanderthalensis\"\n",
    "\n",
    "# Call the static method\n",
    "# 调用静态方法\n",
    "Human.grunt() #=> \"*grunt*\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. 推荐资源：\n",
    "<pre>\n",
    "1. <a href=\"http://www.kuqin.com/abyteofpython_cn/\">简明python教程</a>\n",
    "2. <a href=\"http://www.runoob.com/python/python-exercise-example1.html\">菜鸟教程(附练习题)</a>\n",
    "3. <a href=\"https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000\">廖雪峰python教程</a>\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}