Python 输入输出.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    },
    "toc": "true"
   },
   "source": [
    "# Table of Contents\n",
    " <p><div class=\"lev1 toc-item\"><a href=\"#Python-输入输出\" data-toc-modified-id=\"Python-输入输出-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Python 输入输出</a></div><div class=\"lev2 toc-item\"><a href=\"#标准输出\" data-toc-modified-id=\"标准输出-11\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>标准输出</a></div><div class=\"lev2 toc-item\"><a href=\"#命名规则\" data-toc-modified-id=\"命名规则-12\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>命名规则</a></div><div class=\"lev2 toc-item\"><a href=\"#格式化输出\" data-toc-modified-id=\"格式化输出-13\"><span class=\"toc-item-num\">1.3&nbsp;&nbsp;</span>格式化输出</a></div><div class=\"lev3 toc-item\"><a href=\"#&quot;%&quot;-百分号格式化\" data-toc-modified-id=\"&quot;%&quot;-百分号格式化-131\"><span class=\"toc-item-num\">1.3.1&nbsp;&nbsp;</span>\"%\" 百分号格式化</a></div><div class=\"lev3 toc-item\"><a href=\"#Format-格式化\" data-toc-modified-id=\"Format-格式化-132\"><span class=\"toc-item-num\">1.3.2&nbsp;&nbsp;</span>Format 格式化</a></div><div class=\"lev2 toc-item\"><a href=\"#终端输出彩色字体\" data-toc-modified-id=\"终端输出彩色字体-14\"><span class=\"toc-item-num\">1.4&nbsp;&nbsp;</span>终端输出彩色字体</a></div><div class=\"lev2 toc-item\"><a href=\"#用户输入\" data-toc-modified-id=\"用户输入-15\"><span class=\"toc-item-num\">1.5&nbsp;&nbsp;</span>用户输入</a></div><div class=\"lev2 toc-item\"><a href=\"#密文输入\" data-toc-modified-id=\"密文输入-16\"><span class=\"toc-item-num\">1.6&nbsp;&nbsp;</span>密文输入</a></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python 输入输出"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## 标准输出\n",
    "通过Python 的内置 **print** 函数就能轻松实现终端上的输出"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "?print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "def print(self, *args, sep=' ', end='\\n', file=None): \n",
    "    \n",
    "    print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
    "    \n",
    "    Prints the values to a stream, or to sys.stdout by default.\n",
    "    Optional keyword arguments:\n",
    "    file:  a file-like object (stream); defaults to the current sys.stdout.\n",
    "    sep:   string inserted between values, default a space.\n",
    "    end:   string appended after the last value, default a newline.\n",
    "    flush: whether to forcibly flush the stream.\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "\n",
    "    *args           非关键字可变长参数，可以接受任意个参数，参数之间用逗号“，”分隔\n",
    "    sep=''          默认参数，打印参数与参数之间默认有空格\n",
    "    end=‘\\n’        默认参数，打印后字符串结尾默认会换行。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "那么接下来，让我们来看看怎么使用吧：\n",
    "\n",
    "这里我往print里面传入了很多数字，每一个数字都是一个参数，每一个参数都要用逗号 **“,”** 隔开了。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5\n"
     ]
    }
   ],
   "source": [
    "print(0,1,2,3,4,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "字符串也是一样的，字符串用引号包含（“ ”／‘ ’）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "liangxiansen lixiaojie zhaoguifei liuaiqing\n"
     ]
    }
   ],
   "source": [
    "print('liangxiansen','lixiaojie','zhaoguifei','liuaiqing')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "如果我在print里面写 1+1 呢？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(1+1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "接下来，如果我传入一个列表呢？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 23, 'liang', 'xian', 'sen']\n"
     ]
    }
   ],
   "source": [
    "list_1 = [1,23,'liang','xian','sen']\n",
    "print(list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "列表当做一个参数传递进去，一次打印出来，所以显示list得形式。\n",
    "\n",
    "我不想要list的形式，就想要里面的每一个元素的内容呢？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 23 liang xian sen "
     ]
    }
   ],
   "source": [
    "for n in list_1:\n",
    "    print(n,end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "因为print默认会在结尾加 “\\n” 换行符，我们想显示在一行，可以将默认参数 end 赋值为 “ ” 空格。\n",
    "\n",
    "还有一个很简单的形式， 使用 “*” 星号也一样可以遍历列表中的每个元素。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 23 liang xian sen\n"
     ]
    }
   ],
   "source": [
    "print(*list_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 命名规则\n",
    "\n",
    "- 变量只能包含字母、数字和下划线。变量名可以以字母或下划线开始,但不能以数字开始。\n",
    "- 在变量名称不能有空格,所以我们可以用下划线代替空格。例如,使用student_name代替“学生姓名”。\n",
    "- 你也不能使用[Python关键字](https://docs.python.org/3/reference/lexical_analysis.html#keywords)\n",
    "- 变量名应该是描述性的,而且不宜太长。例如\"mc_wheels\"和“wheels”来表示number_of_wheels_on_a_motorycle。\n",
    "- 格外小心使用小写字母l和大写字母O的地方他们可能会与数字1和0混淆。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "liangxiansen 18\n"
     ]
    }
   ],
   "source": [
    "# 单词之间下划线\n",
    "user_name = 'liangxiansen'\n",
    "user_age = 18\n",
    "\n",
    "print(user_name, user_age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "liangxiansen 18\n"
     ]
    }
   ],
   "source": [
    "# 驼峰命名规则\n",
    "UserName = 'liangxiansen'\n",
    "UserAge = 18\n",
    "\n",
    "print(UserName, UserAge)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 格式化输出\n",
    "像上面输出都在一行，没有什么阅读性，我们可以使用格式化输出：\n",
    "\n",
    "Python的字符串格式化有两种方式: 百分号方式、format方式\n",
    "\n",
    "百分号的方式相对来说比较老，而format方式则是比较先进的方式，企图替换古老的方式，目前两者并存。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### \"%\" 百分号格式化\n",
    "\n",
    "> %[(name)][flags][width].[precision]typecode\n",
    "\n",
    "**(name)**      可选，用于选择指定的key\n",
    "\n",
    "**flags**          可选，可供选择的值有:\n",
    "- \\+,       右对齐；正数前加正好，负数前加负号；\n",
    "- \\-,        左对齐；正数前无符号，负数前加负号；\n",
    "- 空格,    右对齐；正数前加空格，负数前加负号；\n",
    "- 0,        右对齐；正数前无符号，负数前加负号；用0填充空白处\n",
    "\n",
    "**width**         可选，占有宽度\n",
    "\n",
    "**.precision**   可选，小数点后保留的位数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**typecode**    必选\n",
    "- s，获取传入对象的__str__方法的返回值，并将其格式化到指定位置\n",
    "- r，获取传入对象的__repr__方法的返回值，并将其格式化到指定位置\n",
    "- c，整数：将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符：将字符添加到指定位置\n",
    "- o，将整数转换成 八  进制表示，并将其格式化到指定位置\n",
    "- x，将整数转换成十六进制表示，并将其格式化到指定位置\n",
    "- d，将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置\n",
    "- e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）\n",
    "- E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）\n",
    "- f，将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）\n",
    "- F，同上\n",
    "- g，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）\n",
    "- G，自动调整将整数、浮点数转换成 浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）\n",
    "- %，当字符串中存在格式化标志时，需要用 %%表示一个百分号"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Infomation of user 'liangxiansen':\n",
      "-------------------\n",
      "Name:   liangxiansen\n",
      "Age :   18\n",
      "Job :   programmer\n",
      "---------End-------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "name = \"liangxiansen\"\n",
    "age = 18\n",
    "job =\"programmer\"\n",
    "\n",
    "msg = \"\"\"\n",
    "Infomation of user %r:\n",
    "-------------------\n",
    "Name:   %s\n",
    "Age :   %d\n",
    "Job :   %s\n",
    "---------End-------\n",
    "\"\"\"\n",
    " \n",
    "print(msg % (name, name, age, job))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "接下来具体介绍 **typecode** 都有哪些用法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My name is liangxiansen.'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"My name is %s.\" % name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "通过上面的几个例子可以看到 “%” 百分号那个位置都被字符串 % 后面的变量所替代了\n",
    "\n",
    "事实上，使用百分号的格式就是这样：\n",
    "\n",
    "你需要被格式化的字符串 % 需要用来格式化的元素，如果是多个，用括号包住。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"My name is liangxiansen, I'm 18 years old.\""
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"My name is %s, I'm %d years old.\" % (name, age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**%s** —— 获取传入对象的str方法的返回值，并将其格式化到指定位置\n",
    "\n",
    "**%d** —— 将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'percent: 99.88%'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"percent: %.2f%%\" % 99.87557"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**.precision** —— 可选，小数点后保留的位数\n",
    "\n",
    "**%f** —— 将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'percent: 9.987557e+01%'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'percent: 9.987557E+01%'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"percent: %e%%\" % 99.87557\n",
    "\"percent: %E%%\" % 99.87557"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**%e** —— 将整数、浮点数转换成科学计数法，并将其格式化到指定位置\n",
    "\n",
    "**%E** —— 将整数、浮点数转换成科学计数法，并将其格式化到指定位置"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'oct nummber: 121'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'hex number: 51'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"oct nummber: %o\" % 81\n",
    "\"hex number: %x\" % 81"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**%o** —— 将整数转换成 八 进制表示，并将其格式化到指定位置\n",
    "\n",
    "**%x** —— 将整数转换成十六进制表示，并将其格式化到指定位置"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "接下来看看非必须标记符，怎么辅助必须标记符 **typecode** 实现不同的工作："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Infomation of user liangxiansen:\n",
      "-------------------\n",
      "Name:   liangxiansen\n",
      "Age :   18\n",
      "Job :   programmer\n",
      "---------End-------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "msg1 = \"\"\"\n",
    "Infomation of user %(name)s:\n",
    "-------------------\n",
    "Name:   %(name)s\n",
    "Age :   %(age)d\n",
    "Job :   %(job)s\n",
    "---------End-------\n",
    "\"\"\"\n",
    "\n",
    "print(msg1 % {\"name\": name, \"age\": age, \"job\": job})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "当在很大一长串字符串里面需要格式格式化的地方特别多的时候，你写很多%s ,%d ...  等，然后再最后需要格式化的时候，需要在 %( ) 里面写一大堆内容，而且要排序对应好往里面添加的时候是不是感觉特别不友好，很容易出问题，对应不上整个内容就出更期望的不一样了，如果数据类型和字符串中的标识位不一样将会程序出错。\n",
    "\n",
    "**For example:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "%d format: a number is required, not str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-18-718e1695c103>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m\"This is number : %d\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: %d format: a number is required, not str"
     ]
    }
   ],
   "source": [
    "\"This is number : %d\" % name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "看报错信息，**%d** 标识符需要一个 number 来格式化，但是却得到了一个str？ 所以它看不懂了，一懵逼就报错。\n",
    "\n",
    "So， 上面使用百分号格式化添加 **(name)** 标记, 在未格式化之前也能很清晰的知道哪个位置是什么；\n",
    "\n",
    "在格式化的时候 % 后面接受一个 **dict**， **key** 是（name）标记位的名称， **value** 就是需要用来格式化的内容。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**flags** And **width** ："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is string : liangxiansen        '"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'This is string :         liangxiansen'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'This is number :                75.68'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'This is number :               +75.68'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'This is number :               -75.68'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'This is number : 00000000000000075.68'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"This is string : %(name)-20s\" % {\"name\": name}\n",
    "\"This is string : %(name)+20s\" % {\"name\": name}\n",
    "\"This is number : %(num) 20.2f\" % {\"num\": 75.678}\n",
    "\"This is number : %(num)+20.2f\" % {\"num\": 75.678}\n",
    "\"This is number : %(num)20.2f\" % {\"num\": -75.678}\n",
    "\"This is number : %(num)020.2f\" % {\"num\": 75.678}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "看上面例子：\n",
    "\n",
    "**width** 用来设置宽度， \n",
    "- 在格式化字符的时候，设置字符串的宽度\n",
    "- 在格式化数字的时候，也可以用来设置数字位数\n",
    "\n",
    "**flags** 在不同的情况增加表现形式，\n",
    "\n",
    "- 在格式化字符的时候，**\\-** , **\\+** ，表示左右对齐， **0** 和 **空格** 则没有用处。\n",
    "- 在格式化数字的时候， **\\-**,  **\\+** ， 和 **空格** 为了满足正负数在格式化时候的不同表现， **0** 用来给数字填充默认位数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Format 格式化\n",
    "> [[fill]align][sign][#][0][width][,][.precision][type]\n",
    "\n",
    "**fill**           【可选】空白处填充的字符\n",
    "\n",
    "**align**        【可选】对齐方式（需配合width使用）\n",
    "\n",
    "- <，内容左对齐\n",
    "- \\>，内容右对齐(默认)\n",
    "- ＝，内容右对齐，将符号放置在填充字符的左侧，且只对数字类型有效。 即使：符号+填充物+数字\n",
    "- ^，内容居中"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**sign**         【可选】有无符号数字\n",
    "\n",
    "- \\+，正号加正，负号加负；\n",
    "- \\-，正号不变，负号加负；\n",
    "- 空格 ，正号空格，负号加负；\n",
    "\n",
    "**\\#**          【可选】对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示\n",
    "\n",
    "**，**            【可选】为数字添加分隔符，如：1,000,000\n",
    "\n",
    "**width**       【可选】格式化位所占宽度\n",
    "\n",
    "**.precision** 【可选】小数位保留精度"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**type**         【可选】格式化类型\n",
    "\n",
    "\n",
    "- 传入” 字符串类型 “的参数\n",
    "- - s，格式化字符串类型数据\n",
    "- - 空白，未指定类型，则默认是None，同s\n",
    "\n",
    "\n",
    "- 传入“ 整数类型 ”的参数\n",
    "- - b，将10进制整数自动转换成2进制表示然后格式化\n",
    "- - c，将10进制整数自动转换为其对应的unicode字符\n",
    "- - d，十进制整数\n",
    "- - o，将10进制整数自动转换成8进制表示然后格式化；\n",
    "- - x，将10进制整数自动转换成16进制表示然后格式化（小写x）\n",
    "- - X，将10进制整数自动转换成16进制表示然后格式化（大写X）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- 传入“ 浮点型或小数类型 ”的参数\n",
    "- - e， 转换为科学计数法（小写e）表示，然后格式化；\n",
    "- - E， 转换为科学计数法（大写E）表示，然后格式化;\n",
    "- - f ， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；\n",
    "- - F， 转换为浮点型（默认小数点后保留6位）表示，然后格式化；\n",
    "- - g， 自动在e和f中切换\n",
    "- - G， 自动在E和F中切换\n",
    "- - %，显示百分比（默认显示小数点后6位）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**最简单的使用：**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"I'm Kevin, 18 years old, I like watching movies.\""
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"I'm {}, {} years old, I like {}.\".format(\"Kevin\", 18, 'watching movies')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "这么写是不太规范的，虽然现在运行没有问题，但是可能在低版本的python上可能会报错，所以我这里写出来。\n",
    "\n",
    "使用format格式化的时候，在需要格式化的字符串里面写上一对花括号 **{ }** , 然后使用 **.format()** 方法。 将需要用来格式化的对象以参数的形式传给format方法\n",
    "\n",
    "但是标准的方法是下面的，在每个 **{ }** 里面加上序号。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"I'm Kevin, 18 years old, I like watching movies.\""
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"I'm {0}, {1} years old, I like {2}.\".format(\"Kevin\", 18, 'watching movies')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "当然还有更优雅的方式，给每个需要格式化的地方加个名字，然后每个名字就是format方法的 **key** ，格式化的时候使用指定的key传 **value**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"I'm Kevin, 18 years old, I like watching movies.\""
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"I'm {name}, {age} years old, I like {hobbies}.\".format(name=\"Kevin\", age=18, hobbies=\"watching movies\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "还有高级用法，既然format接受key，value 的形式，那我们可以传一个 **dict** ，或者序列化一个json，都是可以的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"I'm Kevin, 18 years old, I like watching movies.\""
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"I'm {name}, {age} years old, I like {hobbies}.\".format(**{\"name\": \"Kevin\", \"age\": 18, \"hobbies\": \"watching movies\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "你会看到 **\\*\\*{dict}** 是不是联想到上面 **\\*[list]** 的用法。是的！\n",
    "\n",
    "事实上，**\\*\\*{dict}** 也会遍历dict中的内容以 **（key=value，...）** 的形式返回"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**list** 的使用："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'i am 1, age 2, really 3'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"i am {0}, age {1}, really {2}\".format(*[1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'i am 1, age 22, really 3'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"i am {0[0]}, age {1[1]}, really {0[2]}\".format([1, 2, 3], [11, 22, 33])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**整数类型格式化：**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'numbers: 1111,\\x0f,15,17,f,F'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"numbers: {num:b},{num:c},{num:d},{num:o},{num:x},{num:X}\".format(num=15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'numbers: 0b1111,\\x0f,15,0o17,0xf,0XF'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"numbers: {num:#b},{num:c},{num:#d},{num:#o},{num:#x},{num:#X}\".format(num=15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "b，将10进制整数自动转换成2进制表示然后格式化\n",
    "\n",
    "c，将10进制整数自动转换为其对应的unicode字符\n",
    "\n",
    "d，十进制整数\n",
    "\n",
    "o，将10进制整数自动转换成8进制表示然后格式化；\n",
    "\n",
    "x，将10进制整数自动转换成16进制表示然后格式化（小写x）\n",
    "\n",
    "X，将10进制整数自动转换成16进制表示然后格式化（大写X）\n",
    "\n",
    "\\#，对于二进制、八进制、十六进制，如果加上#，会显示 0b/0o/0x，否则不显示"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'number: 1,000,000,000'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"number: {0:,d}\".format(1000000000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**,** 为数字添加分隔符"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**浮点数格式化：**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float:\n",
      "e:9.769345e+01\n",
      "E:9.769345E+01\n",
      "f:97.69\n",
      "F:97.69\n",
      "g:97.6934\n",
      "G:97.6934\n"
     ]
    }
   ],
   "source": [
    "print(\"float:\\ne:{float:e}\\nE:{float:E}\\nf:{float:.2f}\\nF:{float:.2F}\\ng:{float:g}\\nG:{float:G}\".format(float=97.69345))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'97.123%'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{0:.3%}\".format(0.971234)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'*********liangxiansen*********'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'liangxiansen******************'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'******************liangxiansen'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'000000000000000000000000000010'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{name:*^30}\".format(name='liangxiansen')\n",
    "\"{name:*<30}\".format(name='liangxiansen')\n",
    "\"{name:*>30}\".format(name='liangxiansen')\n",
    "\"{num:=030}\".format(num=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "这里使用了 **fill**， **align**， **width**；\n",
    "\n",
    "上面实例中：\n",
    "\n",
    "**30**，表示设置30宽度，\n",
    "\n",
    "**<,^,\\>**，分别为左对齐，居中对齐，右对齐，\n",
    "\n",
    "**\\***，填充空白区域\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "更多 **format** 使用方法详见[官网](https://docs.python.org/3/library/string.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 终端输出彩色字体\n",
    "\n",
    "在Linux终端中，使用转义序列来进行彩色文字的显示，转义序列以ESC开头，即ASCII码下的\\033，其格式为：\n",
    "> \\033[显示方式;前景色;背景色m\n",
    "\n",
    "显示方式、前景色、背景色至少一个存在即可。 \n",
    "\n",
    "**for example:**\n",
    "\n",
    "    \\033[1;31;40m   1-高亮显示 31-前景色红色  40-背景色黑色\n",
    "    \\033[0m         结尾采用终端默认设置，即取消颜色设置"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1;31;0m Hello World! \u001b[0m\n",
      "\u001b[1;31;1m Hello World! \u001b[0m\n",
      "\u001b[1;31;2m Hello World! \u001b[0m\n",
      "\u001b[1;31;4m Hello World! \u001b[0m\n",
      "\u001b[1;31;5m Hello World! \u001b[0m\n",
      "\u001b[1;31;7m Hello World! \u001b[0m\n"
     ]
    }
   ],
   "source": [
    "print(\"\\033[1;31;0m Hello World! \\033[0m\")\n",
    "print(\"\\033[1;31;1m Hello World! \\033[0m\")\n",
    "print(\"\\033[1;31;2m Hello World! \\033[0m\")\n",
    "print(\"\\033[1;31;4m Hello World! \\033[0m\")\n",
    "print(\"\\033[1;31;5m Hello World! \\033[0m\")\n",
    "print(\"\\033[1;31;7m Hello World! \\033[0m\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "\"\\033[0;31;0m\"，  无颜色         \n",
    "\n",
    "\"\\033[0;31;1m\"，  显示 \\033[0;31 的颜色  当前为红色\n",
    "\n",
    "\"\\033[0;31;2m\"，  显示 \\033[0;31 的稍浅的颜色  当前为浅红色\n",
    "\n",
    "\"\\033[0;31;4m\"，  显示 \\033[0;31 的稍浅的颜色加下划线  当前为浅红色下划线\n",
    "\n",
    "\"\\033[0;31;5m\"，  显示 \\033[0;31 的稍浅的颜色并闪烁  当前为浅红色闪烁\n",
    "\n",
    "\"\\033[0;31;7m\"，  显示 \\033[0;31 的全填充颜色  当前为红色填充"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "| 前景色  |  颜色  | 背景色  |  颜色  |\n",
    "| :--: | :--: | :--: | :--: |\n",
    "|  30  |  黑色  |  40  |  黑色  |\n",
    "|  31  |  红色  |  41  |  红色  |\n",
    "|  32  |  绿色  |  42  |  绿色  |\n",
    "|  33  |  黄色  |  43  |  黄色  |\n",
    "|  34  |  蓝色  |  44  |  蓝色  |\n",
    "|  35  |  紫色  |  45  |  紫色  |\n",
    "|  36  |  青色  |  46  |  青色  |\n",
    "|  37  |  白色  |  47  |  白色  |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1;30;1m Hello World! \u001b[0m \u001b[1;30;47m Hello World! \u001b[0m\n",
      "\u001b[1;31;1m Hello World! \u001b[0m \u001b[1;30;41m Hello World! \u001b[0m\n",
      "\u001b[1;32;1m Hello World! \u001b[0m \u001b[1;30;42m Hello World! \u001b[0m\n",
      "\u001b[1;33;1m Hello World! \u001b[0m \u001b[1;30;43m Hello World! \u001b[0m\n",
      "\u001b[1;34;1m Hello World! \u001b[0m \u001b[1;30;44m Hello World! \u001b[0m\n",
      "\u001b[1;35;1m Hello World! \u001b[0m \u001b[1;30;45m Hello World! \u001b[0m\n",
      "\u001b[1;36;1m Hello World! \u001b[0m \u001b[1;30;46m Hello World! \u001b[0m\n",
      "\u001b[1;37;1m Hello World! \u001b[0m \u001b[1;30;40m Hello World! \u001b[0m\n"
     ]
    }
   ],
   "source": [
    "print(\"\\033[1;30;1m Hello World! \\033[0m\", \"\\033[1;30;47m Hello World! \\033[0m\")\n",
    "print(\"\\033[1;31;1m Hello World! \\033[0m\", \"\\033[1;30;41m Hello World! \\033[0m\")\n",
    "print(\"\\033[1;32;1m Hello World! \\033[0m\", \"\\033[1;30;42m Hello World! \\033[0m\")\n",
    "print(\"\\033[1;33;1m Hello World! \\033[0m\", \"\\033[1;30;43m Hello World! \\033[0m\")\n",
    "print(\"\\033[1;34;1m Hello World! \\033[0m\", \"\\033[1;30;44m Hello World! \\033[0m\")\n",
    "print(\"\\033[1;35;1m Hello World! \\033[0m\", \"\\033[1;30;45m Hello World! \\033[0m\")\n",
    "print(\"\\033[1;36;1m Hello World! \\033[0m\", \"\\033[1;30;46m Hello World! \\033[0m\")\n",
    "print(\"\\033[1;37;1m Hello World! \\033[0m\", \"\\033[1;30;40m Hello World! \\033[0m\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 用户输入\n",
    "通过Python 内置函数 **input** 实现用户的输入操作。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What's your name:Kevin\n",
      "Hello , Kevin\n"
     ]
    }
   ],
   "source": [
    "your_name = input(\"What's your name:\")\n",
    "print(\"Hello , %s\" % your_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">>>123\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(type(input(\">>>\")))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">>>abc\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(type(input(\">>>\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "用户输入的不管你是数字还是字符串或者什么，都是字符串的形式保存。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**根据用户输入自动生成表格：**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input your name:Kevin\n",
      "input your age:18\n",
      "input your jobe:programmer\n",
      "\n",
      "Infomation of user Kevin:\n",
      "-------------------\n",
      "Name:   Kevin\n",
      "Age :   18\n",
      "Job :   programmer\n",
      "---------End-------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "user_name = input(\"input your name:\")\n",
    "user_age = input(\"input your age:\")\n",
    "user_jobe = input(\"input your jobe:\")\n",
    "\n",
    "message = \"\"\"\n",
    "Infomation of user {name}:\n",
    "-------------------\n",
    "Name:   {name}\n",
    "Age :   {age}\n",
    "Job :   {job}\n",
    "---------End-------\n",
    "\"\"\"\n",
    "\n",
    "print(message.format(name=user_name, age=user_age, job=user_jobe))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 密文输入\n",
    "用户如果输入密码这样隐私得东西，不应该在屏幕上显示输入得内容，可以使用python内建 getpass模块的 **getpass** 函数来实现"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please input your name:liangxiansen\n",
      "Please input your password:········\n",
      "your name is :liangxiansen\n",
      "password is :123456\n"
     ]
    }
   ],
   "source": [
    "from getpass import getpass\n",
    "\n",
    "UserName = input(\"Please input your name:\")\n",
    "Password = getpass(\"Please input your password:\")\n",
    "\n",
    "print(\"your name is :%s\\npassword is :%s\" % (UserName, Password))"
   ]
  }
 ],
 "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.6.2"
  },
  "toc": {
   "colors": {
    "hover_highlight": "#DAA520",
    "navigate_num": "#000000",
    "navigate_text": "#333333",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700",
    "sidebar_border": "#EEEEEE",
    "wrapper_background": "#FFFFFF"
   },
   "moveMenuLeft": true,
   "nav_menu": {
    "height": "30px",
    "width": "252px"
   },
   "navigate_menu": true,
   "number_sections": false,
   "sideBar": true,
   "threshold": 4,
   "toc_cell": true,
   "toc_position": {
    "height": "630px",
    "left": "0px",
    "right": "20px",
    "top": "106px",
    "width": "189px"
   },
   "toc_section_display": "block",
   "toc_window_display": false,
   "widenNotebook": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}