Python廖雪峰1.Python基础.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "300"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "100+200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world!\n"
     ]
    }
   ],
   "source": [
    "print(\"hello world!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "exit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python字符串拼接 使用,如print(\"123\",\"312\",\"111\"),注意‘,’会变为一个空格"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123 321 111\n"
     ]
    }
   ],
   "source": [
    "print(\"123\",\"321\",\"111\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100+200= 300\n"
     ]
    }
   ],
   "source": [
    "print(\"100+200=\",100+200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "想要获得用户输入使用input()，使用input()时需要提示用户输入，并告知输入什么，可以通过input(\"Please input your name:\")来完成这项操作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please input your name:kk\n"
     ]
    }
   ],
   "source": [
    "name=input(\"Please input your name:\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello kk\n"
     ]
    }
   ],
   "source": [
    "print(\"hello\",name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "source": [
    "#这是一条注释\n",
    "a = 100\n",
    "if a>=0:\n",
    "    print(a)\n",
    "else:\n",
    "    print(-a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.Python基础"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1数据类型和变量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4095"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#十六进制\n",
    "0xfff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "整数计算在计算机中永远是正确的，包括除法\n",
    "但 浮点数运算会有舍入误差"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm \"OK\"!\n",
      "I\\'m \\\"OK\\\"!\n",
      "sdfsdfsdf\n",
      "sdsdfs\n",
      "ddfsfsdd\n"
     ]
    }
   ],
   "source": [
    "##字符串\n",
    "#使用\\作为转义字符，如\\n换行,\\t制表符，\\\\表示\\本身\n",
    "print('I\\'m \\\"OK\\\"!')\n",
    "#使用r表示内部字符不转义\n",
    "print(r'I\\'m \\\"OK\\\"!')\n",
    "print('sdfsdfsdf\\nsdsdfs\\nddfsfsdd')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##布尔值 and or not\n",
    "True and 3 > 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "##空值None\n",
    "None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ABC\n"
     ]
    }
   ],
   "source": [
    "##变量,Python中的变量为动态变量，并不固定类型，与之相反的是C++中的 int a =0;\n",
    "a=1\n",
    "t_007 = 'T007'\n",
    "Answer = True\n",
    "#重点，当把a的值幅值给b时，实际上是把b指向变量a所指向的数据\n",
    "a = 'ABC'\n",
    "b=a\n",
    "a='ZXC'\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "##常量，不能改变的量，通常全部大写的变量名表示常量，如PI\n",
    "PI =3.1415926535"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.888888888888889"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##Python中有两种除法，\n",
    "#\"/\"表示标准的除法，即与除号两边数据类型无关，计算结果均为浮点数.\n",
    "#\"//\"表示地板除，结果为整数，将正常除法的结果向下取整\n",
    "#\"%\"表示取除法的余数\n",
    "10/3\n",
    "7//1.8\n",
    "7/1.8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### 1.2字符串和编码\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ASCII Unicode UTF-8\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "       <td>Foo</td>\n",
    "    </tr>\n",
    "</table>\n",
    "<pre><code>print()</code></pre>\n",
    "\n",
    "Unicode为ASCII扩展到2字节的表示，对于原ASCII的编码在Unicode中补零即可  \n",
    "UTF-8为Unicode的可变长表示，常用英文字母为一个字节，汉字为3个字节，生僻的字符为4~6个字节  \n",
    "通过使用UTF-8可以节约存储空间，并且可以直接兼容ASCII  \n",
    "在计算机内存中统一使用Unicode，但需要保存或传输时转为UTF-8  \n",
    "Python3使用的是Unicode  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adsfsfs的说法是分散四的发生\n"
     ]
    }
   ],
   "source": [
    "print('Adsfsfs的说法是分散四的发生')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "65"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#获取字符的整数表示\n",
    "ord('A')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20013"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('中')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'中'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#通过整数输出对应的字符\n",
    "chr(66)\n",
    "chr(20013)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'中文'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'\\u4e2d\\u6587'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "bytes can only contain ASCII literal characters. (<ipython-input-58-9a815a33b078>, line 5)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-58-9a815a33b078>\"\u001b[0;36m, line \u001b[0;32m5\u001b[0m\n\u001b[0;31m    y = b'中'\u001b[0m\n\u001b[0m       ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m bytes can only contain ASCII literal characters.\n"
     ]
    }
   ],
   "source": [
    "#通过使用b表示叫字符串转为以字节为单位的bytes\n",
    "x = b'ABC'\n",
    "print(x)\n",
    "#汉字无法使用ASCII表示因此报错\n",
    "y = b'中'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "ename": "UnicodeEncodeError",
     "evalue": "'ascii' codec can't encode character '\\u4e2d' in position 0: ordinal not in range(128)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnicodeEncodeError\u001b[0m                        Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-62-43e4b6d22432>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[1;34m'ABC'\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mencode\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'ascii'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[1;34m'中'\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mencode\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'utf-8'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[1;34m'中'\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mencode\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'ascii'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mUnicodeEncodeError\u001b[0m: 'ascii' codec can't encode character '\\u4e2d' in position 0: ordinal not in range(128)"
     ]
    }
   ],
   "source": [
    "'ABC'.encode('ascii')\n",
    "'中'.encode('utf-8')\n",
    "'中'.encode('ascii')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'中'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#当从网络或磁盘读取字节流，数据为bytes.通过使用decode()把bytes变为str\n",
    "b'\\xe4\\xb8\\xad\\xe6\\x96\\x87'.decode('utf-8')\n",
    "#通过使用erros='ignore'忽略字符串中无法解析的字节\n",
    "b'\\xe4\\xb8\\xad\\xf1'.decode('utf-8',errors='ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#通过该函数计算字符数，如果为bytes则计算字节数\n",
    "len('ABC')\n",
    "len('中文')\n",
    "len('中文'.encode('utf-8'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过使用在python文件头的注释表示python的代码使用utf-8格式  \n",
    ">\\#!/use/bin/env python3  \n",
    ">\\#-*- coding: utf-8 -*-  \n",
    "\n",
    "第一行表示该程序为Python的可执行程序\n",
    "第二行表示使用utf-8对文件解码，否则文件中文输出有乱码"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**如何格式化输出字符串**  \n",
    "与C语言一致，通过%实现  \n",
    "常见占位符 %d,整数 %f,浮点数  %s,字符串  %x,十六进制整数  \n",
    "有多少占位符后面需要跟几个变量，若仅有一个占位符时可以省略\n",
    "%%输出一个%\n",
    "若不清楚输出格式，%s最合适，会将所有格式转化为字符串输出"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 3-01\n",
      "3.14\n"
     ]
    }
   ],
   "source": [
    "print('%2d-%02d' % (3, 1))\n",
    "#通过.2实现保留两位小数\n",
    "print('%.2f' % 3.1415926)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**另一种格式化字符串的办法**\n",
    "使用.format()的方法，将传入的方法替换字符串内的占位符{0}，{1}，{2}..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "小明的成绩为小明，提升了17.2%\n"
     ]
    }
   ],
   "source": [
    "print('小明的成绩为{0}，提升了{1:.1f}%'.format('小明',17.25))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18.1%\n"
     ]
    }
   ],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "\n",
    "s1 = 72\n",
    "s2 = 85\n",
    "r = (s2-s1)/s1*100\n",
    "print('%.1f%%' % r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "### 1.3使用list和tuple(元组)\n",
    "list是一种**有序**的集合，可以随时添加删除其中的元素，通过**方括号**定义的为list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'sdfs'"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classmate = ['sdfs','kkk','jjj']\n",
    "classmate\n",
    "len(classmate)\n",
    "#索引从0开始\n",
    "classmate[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'jjj'"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#可以通过负数反向索引，这里-1表示最后一个元素\n",
    "classmate[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['sdfs', 'kkk', 'insert2', 'insert2', 'insert2', 'insert2', 'insert2', 'jjj', 'Apend1', 'Apend1', 'Apend1']\n",
      "['sdfs', 'kkk', 'insert2', 'insert2', 'insert2', 'insert2', 'insert2', 'jjj', 'Apend1', 'Apend1']\n",
      "['sdfs', 'kkk', 'insert2', 'insert2', 'insert2', 'insert2', 'insert2', 'jjj', 'Apend1']\n",
      "['sdfs', 'kkk', 'insert2', 'insert2', 'insert2', 'insert2', 'insert2', 'jjj', 'lvlv']\n"
     ]
    }
   ],
   "source": [
    "#通过append向list尾部添加元素\n",
    "classmate.append('Apend1')\n",
    "#插入index为2的位置\n",
    "classmate.insert(2,'insert2')\n",
    "print(classmate)\n",
    "#使用pop()删除尾部元素\n",
    "classmate.pop()\n",
    "print(classmate)\n",
    "#使用pop(i)删除指定位置的元素\n",
    "classmate.pop(-1)\n",
    "print(classmate)\n",
    "#替换元素直接对对应位置赋值\n",
    "classmate[-1] = 'lvlv'\n",
    "print(classmate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "list中元素类型不必一致，甚至可以元素为另外一个list,且可以通过使用p[2][3]来索引列表中索引为2的列表中索引位置为3的元素，此时列表被视为一个高维数组，可推广至二维三维..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L=[]\n",
    "len(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**元组**  \n",
    "另一种有序列表，一旦初始化好之后无法更改，通过**圆括号**定义  \n",
    "无法更改意味着代码更安全，能用tuple替代list就尽量替代"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ccc'"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classmetas = ('aaa','bbb','ccc')\n",
    "#可以通过索引获取元素\n",
    "classmetas[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1,) 1\n"
     ]
    }
   ],
   "source": [
    "#仅有一个元素的tuple需要在第一个元素后添加‘,’区分数学中的小括号和元组\n",
    "a = (1,)\n",
    "b =(1) \n",
    "print(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', 'b', 'c', ['123', '321', 'qwe'])\n",
      "('a', 'b', 'c', ['123', '666', 'qwe'])\n"
     ]
    }
   ],
   "source": [
    "#元组的不可修改是指元组的指向不可修改并非是指向的的元素也无法修改，如元组中的元素有一个为list，list可以修改，但无法修改指向至别的list...\n",
    "t = ('a','b','c',['123','321','qwe'])\n",
    "print(t)\n",
    "t[3][1] = '666'\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.4条件判断"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用判别条件后跟一个冒号定义if  \n",
    "根据缩进判断是否属于该if的范围  \n",
    "缩进为4个空格   \n",
    "同时else:后也要跟冒号  \n",
    "通过elif实现嵌套"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's a baby\n"
     ]
    }
   ],
   "source": [
    "age = 0\n",
    "if age!=0:\n",
    "    print('age is not equl to 0')\n",
    "else:\n",
    "    print('It\\'s a baby')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "finish\n"
     ]
    }
   ],
   "source": [
    "age =0\n",
    "if age>1:\n",
    "    print('a>1')\n",
    "elif age<-1:\n",
    "    print('a<-1')\n",
    "elif age==0:\n",
    "    print('finish')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "please input your year1982\n",
      "00前\n"
     ]
    }
   ],
   "source": [
    "#input获得的用户输入为字符串，需要根据实际情况转为不同的数据类型\n",
    "birth = int(input('please input your year'))\n",
    "if birth>2000:\n",
    "    print('00后')\n",
    "else:\n",
    "        print('00前')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please input you height(m):1.81\n",
      "Please input you weight(km):110\n",
      "你的BMI指数为33.6,严重肥胖\n"
     ]
    }
   ],
   "source": [
    "height = float(input('Please input you height(m):'))\n",
    "weight = float(input('Please input you weight(km):'))\n",
    "bmi = weight/(height**2)\n",
    "if bmi>32:\n",
    "    print('你的BMI指数为%.1f,严重肥胖' %bmi)\n",
    "elif bmi>28:\n",
    "    print('你的BMI指数为%.1f,肥胖' %bmi)\n",
    "elif bmi>25:\n",
    "    print('你的BMI指数为%.1f,过重' %bmi)\n",
    "elif bmi>18.5:\n",
    "    print('你的BMI指数为%.1f,正常' %bmi)\n",
    "elif bmi<=18.5:\n",
    "    print('你的BMI指数为%.1f,过轻' %bmi)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.5 循环\n",
    "+ **循环语法 For循环 for...in X**   \n",
    "X可以为一个list或者一个元组  \n",
    "使用list(range(5)),生成一个元素为[1,2,3,4,5]的列表，实现c++中for i=1;i<6.i++的效果  \n",
    "\n",
    "+ **While循环** while n>0:\n",
    "+ continue跳出当前循环执行下一次循环\n",
    "+ break结束所有循环"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4950\n"
     ]
    }
   ],
   "source": [
    "sum = 0\n",
    "n = 99\n",
    "while n>0:\n",
    "    sum =sum +n\n",
    "    n=n-1\n",
    "print(sum)    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.6 dict和set\n",
    "字典，在其它语言中也称为map，**键-值存储**  \n",
    "例如想要查询一个同学名字和对应的成绩，使用list需要2个，但可以使用一个字典来实现  \n",
    "并且使用list会随着数据规模的增大而耗时增加  使用Dict的耗时与数据规模无关（字典使用了索引）  \n",
    "通过{'aaa':123,'bbb':222}大括号声明一个字典  \n",
    "通过方括号索引键获取值  \n",
    "一个键对应一个值  \n",
    "\n",
    "可以通过in方法查询键是否在字典中，如'KKK' in d  \n",
    "还可以通过字典的get()方法，如key不存在，可以返回none，或自己指定的值 d.get('Thomas',-1)  \n",
    "删除一个key使用pop('key')方法\n",
    "\n",
    "**比较dict和list**\n",
    "dict特点：\n",
    "+ 查找插入极快，不随数据量增加时间\n",
    "+ 需要占用大量内存，内存浪费很多\n",
    "list特点与之相反，因此dict是一种使用内存空间换取时间的方法\n",
    "\n",
    "整数、字符串等不可变，因此可以作为key **list不可作为key**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "95"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}\n",
    "d['Michael']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Set key的一组集合**  \n",
    "通过set()方法初始化一个set，set方法需要一个list作为输入  \n",
    "向set中增加对象使用s.add('key')  \n",
    "删除一个对象需要使用s.remove('key')\n",
    "set是一个无重复对象的集合，因此可以做交并操作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "s = set([1,2,3])\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Abc\n",
      "abc\n"
     ]
    }
   ],
   "source": [
    "a = 'abc'\n",
    "#虽然打印出的为Abc，但其实是在A的基础上重新创建了一个新的字符串，原有a对应的内容并未发生变化\n",
    "print(a.replace('a', 'A'))\n",
    "print(a)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "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": 1
}