{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## open函数\n",
    "\n",
    "\n",
    "Python的`open`函数用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出`OSError`。\n",
    "\n",
    "<b><font color=blue>注意：使用`open`函数一定要保证关闭文件对象，即使用完文件对象`f`后，一定要调用`close`函数。</font></b>\n",
    "\n",
    "open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。\n",
    "\n",
    "基本用法为`file_object = open(file, mode)`\n",
    "\n",
    " - `file`是参数必需指定，表示文件路径（**相对**或者**绝对**路径）；\n",
    " - `mode`是可选参数，表示文件打开模式，默认取值为r，表示只读模式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 指定windows平台下Python运行时的默认编码类型为UTF-8\n",
    "import _locale\n",
    "_locale._getdefaultlocale = (lambda *args: ['zh_CN', 'utf8'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><font color=Chocolate>拓展学习：</font></b>\n",
    "\n",
    "<a href=\"https://blog.csdn.net/blmoistawinde/article/details/87717065\" target=\"_blank\">从根本解决python3 open的UnicodeDecodeError: 'gbk' codec问题</a>\n",
    "\n",
    "<a href=\"https://juejin.cn/post/6844903700079575047\" target=\"_blank\">解决Python在windows平台默认编码(encoding)为gbk所导致的open()函数报错及其他编码问题</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 打开和该jupyter notebook在同一文件夹下的文本文件，r表示以只读方式打开\n",
    "f = open('./text.txt','r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 将文件中的内容全部读取并保存到变量content中\n",
    "content = f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 将文件对象关闭\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看content的类型\n",
    "type(content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "从明天起，做一个幸福的人\n",
      "喂马、劈柴、周游世界\n",
      "从明天起，关心粮食和蔬菜\n",
      "我有一所房子，面朝大海，春暖花开\n",
      "\n",
      "从明天起，和每一个亲人通信\n",
      "告诉他们我的幸福\n",
      "那幸福的闪电告诉我的\n",
      "我将告诉每一个人\n",
      "\n",
      "给\n"
     ]
    }
   ],
   "source": [
    "# 打印输出字符串content的前100个字符\n",
    "print(content[:100])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "们我的幸福\n",
      "那幸福的闪电告诉我的\n",
      "我将告诉每一个人\n",
      "\n",
      "给每一条河每一座山取一个温暖的名字\n",
      "陌生人，我也为你祝福\n",
      "愿你有一个灿烂的前程\n",
      "愿你有情人终成眷属\n",
      "愿你在尘世获得幸福\n",
      "我只愿面朝大海，春暖花开\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 打印输出字符串content的后100个字符\n",
    "print(content[-100:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**文件路径名**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**绝对路径名**：是从盘符开始直到文件本身的文件名。\n",
    "\n",
    "例如，Windows操作系统下：\n",
    "\n",
    "```\n",
    "D:\\programming_basics\\index.html\n",
    "D:\\anaconda3\\LICENSE.txt\n",
    "```\n",
    "\n",
    "例如，Linux操作系统下：\n",
    "\n",
    "```\n",
    "/home/zjz/programming_basics/index.html\n",
    "/usr/local/anaconda3/LICENSE.txt\n",
    "```\n",
    "\n",
    "Mac操作系统与Linux操作系统类似。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**相对路径名**：是从**当前目录**到文件本身的文件名。例如，当前目录是`lecture_9`，要打开的文件是这个目录下`lecture_9.ipynb`，则相对路径文件名就是`lecture_9.ipynb`。\n",
    "\n",
    "在表示相对路径时，`.`可以表示当前目录名，`..`可以表示当前目录的上一级目录名。\n",
    "\n",
    "例如，下面是`codes`文件夹的目录树，假如当前文件夹为`lecture_9`："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "├── lecture_1\n",
    "│   ├── BMI_calculation.ipynb\n",
    "│   ├── BMI_calculation.py\n",
    "│   ├── imgs\n",
    "│   │   ├── bit_byte.jpg\n",
    "│   │   ├── maiyouweng.jpg\n",
    "│   │   ├── while.gif\n",
    "│   │   └── while.jpg\n",
    "│   └── lecture_1.ipynb\n",
    "├── lecture_2\n",
    "│   └── lecture_2.ipynb\n",
    "└── lecture_9\n",
    "    ├── poems.txt\n",
    "    ├── lyrics.txt\n",
    "    └── lecture_9.ipynb\n",
    "\n",
    "4 directories, 11 files\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "文件`lecture_9.ipynb`的相对路径可以表示为`./lecture_9.ipynb`（Linux和Mac中）或者`.\\lecture_9.ipynb`（Windows中）。\n",
    "\n",
    "文件`lecture_2.ipynb`的相对路径可以表示为`../lecture_2/lecture_2.ipynb`（Linux和Mac中）或者`..\\lecture_2\\lecture_2.ipynb`（Windows中）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><font color=red>思考题：</font></b>根据上面的`codes`文件夹的目录树，思考一下，假如当前文件夹为`lecture_2`，文件`bit_byte.jpg`的相对路径如何表示。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**打开模式**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`mode`：表示打开文件的访问模式，常用的模式有只读`r`、写入`w`和追加`a`，其缺省值是只读`r`，更严谨地，其缺省值为`rt`。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "mode参数主要包括两个部分：**读写模式**,**文件格式**。`mode`参数取值完整列表如下："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table>\n",
    "<tbody><tr><th style=\"width:10%\">文件格式</th><th>描述</th></tr>\n",
    "<tr><td>t</td><td>文本模式 (默认)。</td></tr>\n",
    "<tr><td>b</td><td>二进制模式。</td></tr>\n",
    "<tr><th style=\"width:10%\">读写模式</th><th>描述</th></tr>\n",
    "<tr><td>x</td><td>写模式，新建一个文件，如果该文件已存在则会报错。</td></tr>\n",
    "<tr><td>+</td><td>打开一个文件进行更新(可读可写)。</td></tr>\n",
    "<tr><td>U</td><td>通用换行模式（不推荐）。</td></tr>\n",
    "<tr><td>r</td><td>以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。</td></tr>\n",
    "<tr><td>rb</td><td>以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。</td></tr>\n",
    "<tr><td>r+</td><td>打开一个文件用于读写。文件指针将会放在文件的开头。</td></tr>\n",
    "<tr><td>rb+</td><td>以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。</td></tr>\n",
    "<tr><td>w</td><td>打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。</td></tr>\n",
    "<tr><td>wb</td><td>以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。</td></tr>\n",
    "<tr><td>w+</td><td>打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。</td></tr> \n",
    "<tr><td>wb+</td><td>以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。</td></tr>\n",
    "\n",
    "\n",
    "<tr><td>a</td><td>打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。</td></tr> \n",
    "<tr><td>ab</td><td>以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。</td></tr> \n",
    "<tr><td>a+</td><td>打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。</td></tr> \n",
    "<tr><td>ab+</td><td>以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。</td></tr>\n",
    "</tbody>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><font color=blue>注意：`mode`参数的默认文件格式为`t`，即文本模式，如果要以二进制模式打开，需要在读写模式后加上`b`</font></b>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "例如，下面打开文本文件`2020年12月四级真题第3套.txt`的两行代码是等价的：\n",
    "\n",
    "- `f = open('./text.txt','r')`\n",
    "- `f = open('./text.txt','rt')`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><font color=blue>思考题：</font></b>\n",
    "\n",
    "下面两行代码等价吗：\n",
    "\n",
    "- `f = open('/home/zjz/programming_basics/files/codes/lecture_1/imgs/maiyouweng.jpg','r')`\n",
    "- `f = open('/home/zjz/programming_basics/files/codes/lecture_1/imgs/maiyouweng.jpg','rb')`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><font color=Chocolate>拓展学习：</font></b>\n",
    "<a href=\"http://c.biancheng.net/view/2175.html\" target=\"_blank\">Python bytes类型及用法</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**常用的文件打开模式**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `r`\t只读\n",
    "- `w`\t全新写入，文件不存在则创建\n",
    "- `a`\t追加，**文件不存在则创建**\n",
    "- `+`\t可读可写\n",
    "- `b`\t二进制格式，对于图片和视频需要设置`b`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "文件访问模式的组合：`r/w/a[b][+]`，`r`,`w`,`a`设定基本模式，读、写或是追加\n",
    "\n",
    "- `b`和`+`可选，`b`表示二进制文件格式，`+`表示在原有基础上可读可写"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "例如：`rb+`表示以二进制打开一个文件，可读可写，若文件不存在不会创建，`wb+`，表示以二进制形式打开一个文件，可读可写，若文件不存在则创建一个。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 文件读写"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**读文件**\n",
    "\n",
    "- `read`方法用来直接读取字节到字符串中，最多读取给定数目个字节. 如果没有给定`size`参数(默认值为 -1)或者`size`值为负, 文件将被读取直至末尾；\n",
    "\n",
    "- `readline`方法读取打开文件的一行（读取下个行结束符之前的所有字节）， 然后，把整行内容（包括行结束符）作为字符串返回，和`read`类似, 它也有一个可选的`size`参数, 默认为-1，代表读至行结束符，如果提供了该参数，当size小于行的长度时，返回长度为size的内容，如果size大于行的长度，则返回一行的内容（包括行结束符）。\n",
    "\n",
    "- `readlines`方法并不像其它两个输入方法一样返回一个字符串，它会读取所有（剩余的）行然后把它们作为一个**字符串列表**返回，列表中每个元素对应文件中的一行内容。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**写文件**\n",
    "\n",
    "- `write`方法、功能与`read`和`readline`相反，它把含有文本数据或二进制数据块的字符串写入到文件中去；\n",
    "\n",
    "- `writelines`提高效率，将列表元素拼接后写入文件；\n",
    "\n",
    "- 没有对应的`writeline`的函数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**读文件练习**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面以海子的抒情诗《面朝大海，春暖花开》为例，演示文件操作，当前文件夹中的文本文件`text.txt`保存诗歌文本。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 打开文本文件，全部读取并赋值给变量content\n",
    "f = open('./text.txt') # f = open('./text.txt','r') 或 f = open('./text.txt', 'rt')\n",
    "content = f.read()\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看content的类型\n",
    "type(content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "从明天起，做一个幸福的人\n",
      "喂马、劈柴、周游世界\n",
      "从明天起，关心粮食和蔬菜\n",
      "我有一所房子，面朝大海，春暖花开\n",
      "\n",
      "从明天起，和每一个亲人通信\n",
      "告诉他们我的幸福\n",
      "那幸福的闪电告诉我的\n",
      "我将告诉每一个人\n",
      "\n",
      "给每一条河每一座山取一个温暖的名字\n",
      "陌生人，我也为你祝福\n",
      "愿你有一个灿烂的前程\n",
      "愿你有情人终成眷属\n",
      "愿你在尘世获得幸福\n",
      "我只愿面朝大海，春暖花开\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 打印输出content的内容\n",
    "print(content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 打开文本文件，读取指定长度的字符串，并赋值给变量content\n",
    "# 思考一下这里的size参数单位是什么\n",
    "f = open('./text.txt','r')\n",
    "content = f.read(10)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'从明天起，做一个幸福'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看content的内容\n",
    "content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看content的长度\n",
    "len(content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 打开文本文件，读取指定大小的字节串（in bytes），并赋值给变量content\n",
    "f = open('./text.txt','rb')\n",
    "content = f.read(98)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'\\xe4\\xbb\\x8e\\xe6\\x98\\x8e\\xe5\\xa4\\xa9\\xe8\\xb5\\xb7\\xef\\xbc\\x8c\\xe5\\x81\\x9a\\xe4\\xb8\\x80\\xe4\\xb8\\xaa\\xe5\\xb9\\xb8\\xe7\\xa6\\x8f\\xe7\\x9a\\x84\\xe4\\xba\\xba\\n\\xe5\\x96\\x82\\xe9\\xa9\\xac\\xe3\\x80\\x81\\xe5\\x8a\\x88\\xe6\\x9f\\xb4\\xe3\\x80\\x81\\xe5\\x91\\xa8\\xe6\\xb8\\xb8\\xe4\\xb8\\x96\\xe7\\x95\\x8c\\n\\xe4\\xbb\\x8e\\xe6\\x98\\x8e\\xe5\\xa4\\xa9\\xe8\\xb5\\xb7\\xef\\xbc\\x8c\\xe5\\x85\\xb3\\xe5\\xbf\\x83\\xe7\\xb2\\xae\\xe9\\xa3\\x9f\\xe5\\x92\\x8c'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看content的内容\n",
    "content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bytes"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看content的类型\n",
    "type(content)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面的结果中`b`表示`bytes`类型，`\\x`表示十六进制。回忆一下，Python中十六进制数以什么符号开头。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 将字节串转换为字符串\n",
    "content_str = content.decode('UTF-8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'从明天起，做一个幸福的人\\n喂马、劈柴、周游世界\\n从明天起，关心粮食和'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看字符串content_str的内容\n",
    "content_str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看字符串content_str的类型\n",
    "type(content_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "34"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看字符串content_str的长度\n",
    "len(content_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`UTF-8`规定英文字母系列用1个字节（byte）表示，汉字用3个字节。`content_str`中包含两个英文字符`\\n`,`\\n`和32个中文字符，因此，$32 \\times 3 + 2 = 98$，如果读取长度为100的字节串，则字节串转按照以`UTF-8`编码转化为字符串时会出错。执行如下代码试试："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`size`参数的单位取决于文件格式参数，文件格式为`t`则`size`的单位为字符，文件格式为`b`，`size`的单位是字节（bytes）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# f = open('./text.txt','rb')\n",
    "# content = f.read(100)\n",
    "# f.close()\n",
    "# content_str = content.decode('UTF-8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "142"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看变量content_str占用内存空间的大小\n",
    "import sys\n",
    "sys.getsizeof(content_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><font color=Chocolate>拓展学习：</font></b>\n",
    "<a href=\"https://blog.csdn.net/lyb3b3b/article/details/74993327\" target=\"_blank\">Python3中的bytes和str类型</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "回忆一下lecture_1中讲到的`sys.getsizeof`函数，它用于获取python对象占用内存空间的大小，注意区分：\n",
    "\n",
    "- 142 bytes是字符串变量`content_str`在内存中占用空间的大小；\n",
    "- 98 bytes是UTF-8编码的字符串`从明天起，做一个幸福的人\\n喂马、劈柴、周游世界\\n从明天起，关心粮食和`的大小。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 打开文本文件，读取一行并赋值给变量content\n",
    "f = open('./text.txt','r')\n",
    "content = f.readline()\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "从明天起，做一个幸福的人\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 打印输出content的内容\n",
    "print(content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'从明天起，做一个幸福的人\\n'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 注意content字符串包含换行符\\n\n",
    "content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 打开文本文件，读取一行内容（指定size参数值）并赋值给变量content\n",
    "f = open('./text.txt','r')\n",
    "# size值不超过行的长度\n",
    "content = f.readline(5)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'从明天起，'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 查看content的内容\n",
    "content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 打开文本文件，读取一行内容（指定size参数值）并赋值给变量content\n",
    "f = open('./text.txt','r')\n",
    "# size值超过行的长度\n",
    "content = f.readline(500)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'从明天起，做一个幸福的人\\n'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 打开文本文件，读取全部内容，并以列表形式返回结果\n",
    "# 列表中的每一个元素表示文件中的一行\n",
    "# 将返回的列表赋值给变量content\n",
    "f = open('./text.txt','r')\n",
    "content = f.readlines()\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "从明天起，做一个幸福的人\n",
      "\n",
      "喂马、劈柴、周游世界\n",
      "\n",
      "从明天起，关心粮食和蔬菜\n",
      "\n",
      "我有一所房子，面朝大海，春暖花开\n",
      "\n",
      "\n",
      "\n",
      "从明天起，和每一个亲人通信\n",
      "\n",
      "告诉他们我的幸福\n",
      "\n",
      "那幸福的闪电告诉我的\n",
      "\n",
      "我将告诉每一个人\n",
      "\n",
      "\n",
      "\n",
      "给每一条河每一座山取一个温暖的名字\n",
      "\n",
      "陌生人，我也为你祝福\n",
      "\n",
      "愿你有一个灿烂的前程\n",
      "\n",
      "愿你有情人终成眷属\n",
      "\n",
      "愿你在尘世获得幸福\n",
      "\n",
      "我只愿面朝大海，春暖花开\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 遍历并打印出列表content中的全部内容\n",
    "for line in content:\n",
    "    print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "↓↓↓↓↓↓↓↓↓↓<b><font color=red>以下内容了解即可</font></b>↓↓↓↓↓↓↓↓↓↓"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面使用`open`函数读取图片、音频、视频文件，mode参数要加上`b`，以二进制格式读取文件内容，否则，以文本格式读取文件内容会出错，因为这些非文本格式的文件的二进制表示无法被正确地转换为任何一种有效的字符编码（如UTF-8，UTF-16，GBK等）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><font color=red>注意：</font></b>通常使用专门的包（package）处理（读取、写入、修改等）图片、音频、视频等文件，而不显式地直接使用`open`方法，下面使用`open`方法读取图片和音视频的代码仅用于深入理解`open`函数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 读取图片文件\n",
    "f = open('./image.jpeg', 'rb')\n",
    "img_content = f.readline()\n",
    "f.close()\n",
    "# img_content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bytes"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(img_content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 读取图片文件\n",
    "f = open('./image.jpeg', 'rb')\n",
    "img_content = f.readlines()\n",
    "f.close()\n",
    "# img_content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 读取图片文件\n",
    "f = open('./image.jpeg', 'rb')\n",
    "img_content = f.read()\n",
    "f.close()\n",
    "# img_content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 读取音频文件\n",
    "f = open('./audio.mp3', 'rb')\n",
    "audio_content = f.read()\n",
    "f.close()\n",
    "# audio_content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 读取音频文件\n",
    "f = open('./audio.mp3', 'rb')\n",
    "audio_content = f.readline()\n",
    "f.close()\n",
    "# audio_content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 读取音频文件\n",
    "f = open('./audio.mp3', 'rb')\n",
    "audio_content = f.readlines()\n",
    "f.close()\n",
    "# audio_content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 读取视频文件\n",
    "f = open('./video.mp4', 'rb')\n",
    "video_content = f.read()\n",
    "f.close()\n",
    "# video_content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 读取视频文件\n",
    "f = open('./video.mp4', 'rb')\n",
    "video_content = f.readline()\n",
    "f.close()\n",
    "# video_content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 读取视频文件\n",
    "f = open('./video.mp4', 'rb')\n",
    "video_content = f.readlines()\n",
    "f.close()\n",
    "# video_content"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**图像处理**：常用的处理图像的Python包有：`Pillow`，`Matplotlib`，`opencv-python`，`scikit-image`。有些包Anaconda中未包含，需要使用`pip`命令安装。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f2d3c2edd60>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用matplotlib显示图像\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.image as mpimg\n",
    "import numpy as np\n",
    "I = mpimg.imread('./image.jpeg')\n",
    "plt.imshow(I)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><font color=Chocolate>拓展学习：</font></b>\n",
    "<a href=\"https://blog.csdn.net/hjxu2016/article/details/79104607\" target=\"_blank\">python读取图像的几种方法</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><font color=red>思考题</font></b>：通过查询网络资料，了解常用的图像、音频、视频处理Python包，了解其各个包的优缺点和应用领域，了解各个包的基本用法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**音频处理**：常用的处理音频的Python包有：`librosa`，`soundfile`，`wave`，`pydub`。有些包Anaconda中未包含，需要使用`pip`命令安装。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><font color=Chocolate>拓展学习：</font></b>\n",
    "\n",
    "<a href=\"https://segmentfault.com/a/1190000020905581\" target=\"_blank\">Python3.7 读取 mp3 音频文件生成波形图</a>\n",
    "\n",
    "<a href=\"https://blog.csdn.net/lujian1989/article/details/110479941\" target=\"_blank\">python读写音频文件小结</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**视频处理**：常用的处理音频的Python包有：`imageio`，`opencv-python`。有些包Anaconda中未包含，需要使用`pip`命令安装。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><font color=Chocolate>拓展学习：</font></b>\n",
    "<a href=\"https://blog.csdn.net/aa846555831/article/details/52382173\" target=\"_blank\">Python: 读取视频的两种方法（imageio和cv2）</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "↑↑↑↑↑↑↑↑↑↑<b><font color=red>以上内容了解即可</font></b>↑↑↑↑↑↑↑↑↑↑"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**写文件练习**\n",
    "\n",
    "下面，以文本文件为例，练习文件的写入方法`write`和`writelines`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><font color=red>`w`模式会覆盖掉文件中的已有内容，一旦成功运行，文件中的内容就没了，对于重要文件，采用`w`模式打开前一定备份，备份，备份！！！</font></b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用haizi_intro变量保存海子生平简介\n",
    "haizi_intro = '''海子出生于安徽省怀宁县的高河镇查湾村。在农村度过了少年时代。1979年以15岁之龄进入北京大学法律系[1]，1983年毕业后任教于中国政法大学。在极其朴素的生活中坚持写诗，只有部分得以发表。海子最好的作品，大多是在死后才发表的。'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'海子出生于安徽省怀宁县的高河镇查湾村。在农村度过了少年时代。1979年以15岁之龄进入北京大学法律系[1]，1983年毕业后任教于中国政法大学。在极其朴素的生活中坚持写诗，只有部分得以发表。海子最好的作品，大多是在死后才发表的。'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "haizi_intro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# w表示写入模式\n",
    "# 如果文件已经存在，新内容会覆盖文件中原有内容\n",
    "# 如果文件不存在，新建文件，并将内容写入\n",
    "\n",
    "# 将海子的生平简介写入新文件intro.txt\n",
    "f = open('./intro.txt','w')\n",
    "f.write(haizi_intro)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用列表poems保存海子的作品，每个元素表示一个作品，类型为字符串\n",
    "poems = [\n",
    "    '《小站》',\n",
    "    '《河流》',\n",
    "    '《麦地之瓮》',\n",
    "    '《海子诗全集》'\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 将海子的作品列表一次性写入新文件poems\n",
    "f = open('./poems.txt','a')\n",
    "f.writelines(poems) # 相当于 f.write(''.join(poems))\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "lyrics = '''我怀念的是无话不说\n",
    "\n",
    "我怀念的是一起作梦\n",
    "\n",
    "我怀念的是争吵以后\n",
    "\n",
    "还是想要爱你的冲动'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'我怀念的是无话不说\\n\\n我怀念的是一起作梦\\n\\n我怀念的是争吵以后\\n\\n还是想要爱你的冲动'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lyrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a表示追加模式\n",
    "# 如果文件已经存在，新内容会追加在文件中已有内容之后\n",
    "# 如果文件不存在，新建文件，并将内容写入\n",
    "\n",
    "# 使用追加模式，将歌词lyrics写入文件lyrics.txt\n",
    "f = open('./lyrics.txt','a')\n",
    "f.write(lyrics)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><font color=red>思考题</font></b>：在`lyrics.txt`中新加一行`姚若龙 作词`，代码怎么写。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 下面代码能正确运行吗\n",
    "# f = open('./lyrics.txt','r')\n",
    "# f.write(lyrics)\n",
    "# f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 下面代码能正确运行吗\n",
    "# f = open('./new_lyrics.txt','r+')\n",
    "# f.write(lyrics)\n",
    "# f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 下面代码能正确运行吗\n",
    "# f = open('./new_lyrics.txt','a+')\n",
    "# f.write(lyrics)\n",
    "# f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 下面代码能正确运行吗\n",
    "# f = open('./new_lyrics.txt','r+')\n",
    "# f.write(lyrics)\n",
    "# f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 下面代码能正确运行吗，new_lyrics.txt文件有变化吗\n",
    "# f = open('./new_lyrics.txt','w')\n",
    "# f.read()\n",
    "# f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 下面代码能正确运行吗，new_lyrics.txt文件有变化吗\n",
    "# f = open('./new_lyrics.txt','a')\n",
    "# f.read()\n",
    "# f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`+`表示可读可写，`r`只读不能写，`w`、`a`只写不能读。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**文件迭代**\n",
    "\n",
    "一行一行访问文件:\n",
    "\n",
    "```for eachLine in f:\n",
    "\tdo something```\n",
    "    \n",
    "在这个循环里，`eachLine` 代表文本文件的**一行**（包括末尾的行结束符），你可以使用它做任何想做的事情。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "从明天起，做一个幸福的人\n",
      "\n",
      "喂马、劈柴、周游世界\n",
      "\n",
      "从明天起，关心粮食和蔬菜\n",
      "\n",
      "我有一所房子，面朝大海，春暖花开\n",
      "\n",
      "\n",
      "\n",
      "从明天起，和每一个亲人通信\n",
      "\n",
      "告诉他们我的幸福\n",
      "\n",
      "那幸福的闪电告诉我的\n",
      "\n",
      "我将告诉每一个人\n",
      "\n",
      "\n",
      "\n",
      "给每一条河每一座山取一个温暖的名字\n",
      "\n",
      "陌生人，我也为你祝福\n",
      "\n",
      "愿你有一个灿烂的前程\n",
      "\n",
      "愿你有情人终成眷属\n",
      "\n",
      "愿你在尘世获得幸福\n",
      "\n",
      "我只愿面朝大海，春暖花开\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 打开保存有《面朝大海，春暖花开》的文本文件./text.txt\n",
    "# 逐行访问，并打印输出\n",
    "f = open('./text.txt')\n",
    "for line in f:\n",
    "    print(line)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><font color=red>\n",
    "对文件进行读写操作时，一定要在处理完之后关闭文件对象，即`f.close()`    \n",
    "</font></b>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><font color=red>\n",
    "如果担心会忘记关闭文件对象，强烈建议，强烈建议，强烈建议，使用如下`with`语句打开文件，`with`中的语句执行完毕后会自动关闭文件对象，老师再也不用担心我忘记关闭文件对象了，^_^。\n",
    "</font></b>\n",
    "\n",
    "```\n",
    "with open(file, mode) as f:\n",
    "  do something\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "从明天起，做一个幸福的人\n",
      "\n",
      "喂马、劈柴、周游世界\n",
      "\n",
      "从明天起，关心粮食和蔬菜\n",
      "\n",
      "我有一所房子，面朝大海，春暖花开\n",
      "\n",
      "\n",
      "\n",
      "从明天起，和每一个亲人通信\n",
      "\n",
      "告诉他们我的幸福\n",
      "\n",
      "那幸福的闪电告诉我的\n",
      "\n",
      "我将告诉每一个人\n",
      "\n",
      "\n",
      "\n",
      "给每一条河每一座山取一个温暖的名字\n",
      "\n",
      "陌生人，我也为你祝福\n",
      "\n",
      "愿你有一个灿烂的前程\n",
      "\n",
      "愿你有情人终成眷属\n",
      "\n",
      "愿你在尘世获得幸福\n",
      "\n",
      "我只愿面朝大海，春暖花开\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 使用with语句迭代打印文件中每行文本\n",
    "with open('./text.txt') as f:\n",
    "    for line in f:\n",
    "        print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><font color=red>思考题</font></b>：把上面使用`f = open(file, mode)`写的代码，全部用with语句重写一遍。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 文件内移动游标"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**获取读写位置**\n",
    "\n",
    "文件内游标移动以字节（byte）为单位，如果操作成功，则返回新的文件位置，如果操作失败，则函数返回-1。\n",
    "\n",
    "- `f.tell()`, 获取文件内读写位置\n",
    "- `f.seek(offset, [whence])`，文件内读写位置移动：\n",
    "  - `offset`：偏移量，也就是代表需要移动偏移的字节数；\n",
    "  - `whence`：给`offset`参数一个定义，表示要从哪个位置开始偏移；0代表从文件开头开始算起，1代表从当前位置开始算起，2代表从文件末尾算起。`whence`值默认为0。`t`模式时，只能为0，不能为1和2，`b`模式可以取0、1、2。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "从明天起，做一个幸福的人\n",
      " length: 13 offset: 37\n"
     ]
    }
   ],
   "source": [
    "# 使用with语句打开文本文件text.txt，读取一行\n",
    "# 打印输出这一行，这一行的长度，以及当前的游标位置\n",
    "with open('./text.txt') as f:\n",
    "    line1 = f.readline()\n",
    "    print(line1, 'length: {}'.format(len(line1)), 'offset: {}'.format(f.tell()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'从明天起，做一个幸福的人\\n'"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('./text.txt') as f:\n",
    "    content = f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'从明天起，做一个幸福的人\\n'"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "content[:13]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><font color=red>思考题</font></b>：为什么上面的代码中`line1`的长度（length）为13，但是`f.tell()`的值为37。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用二进制模式打开文本文件text.txt\n",
    "f = open('./text.txt', 'rb')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "37"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 移动游标位置到第 37 byte\n",
    "f.seek(37)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 读取一行内容\n",
    "line1 = f.readline()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'喂马、劈柴、周游世界\\n'"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用UTF-8编码将这一行的bytes类型的内容解码为字符串，并查看其内容\n",
    "line1.decode('utf-8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "105"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 把游标从当前位置向前移动37 bytes\n",
    "f.seek(37, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'我有一所房子，面朝大海，春暖花开\\n'"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 这一行的代码，运行结果是什么\n",
    "line2 = f.readline()\n",
    "line2.decode('utf-8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 记得一定要关闭文件对象f哦\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'喂马、劈柴、周游世界\\n'"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 不使用b模式，游标只能从文件头开始移动\n",
    "with open('./text.txt', 'r') as f:\n",
    "    f.seek(37)\n",
    "    line = f.readline()\n",
    "line    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b''\n"
     ]
    }
   ],
   "source": [
    "# 从文件头开始，移动100000 bytes\n",
    "with open('./text.txt', 'rb') as f:\n",
    "    f.seek(100000, 0)\n",
    "    print(f.read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b''\n"
     ]
    }
   ],
   "source": [
    "# 从文件末开始，移动0 byte\n",
    "with open('./text.txt', 'rb') as f:\n",
    "    f.seek(0, 2)\n",
    "    print(f.read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b''\n"
     ]
    }
   ],
   "source": [
    "# 从当前位置开始，移动100000 bytes\n",
    "with open('./text.txt', 'rb') as f:\n",
    "    f.seek(100000, 1)\n",
    "    print(f.read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'从明天起，做一个幸福的人\\n'"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 从当前位置开始，移动0 bytes\n",
    "with open('./text.txt', 'rb') as f:\n",
    "    f.seek(0, 0)\n",
    "    content = f.readline()\n",
    "content.decode('utf-8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'喂马、劈柴、周游世界\\n从明天起，关心粮食和蔬菜\\n我有一所房子，面朝大海，春暖花开\\n\\n从明天起，和每一个亲人通信\\n告诉他们我的幸福\\n那幸福的闪电告诉我的\\n我将告诉每一个人\\n\\n给每一条河每一座山取一个温暖的名字\\n陌生人，我也为你祝福\\n愿你有一个灿烂的前程\\n愿你有情人终成眷属\\n愿你在尘世获得幸福\\n我只愿面朝大海，春暖花开\\n'"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 从当前位置开始，移动0 bytes\n",
    "with open('./text.txt', 'r') as f:\n",
    "    f.seek(37)\n",
    "    content = f.read()\n",
    "content"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 文件读写实例"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**将`print`的结果写入到文件**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 设定print函数的file参数为文件对象f\n",
    "# 将print的object参数值写入到文件，此时屏幕是不输出object的内容的\n",
    "with open('./wu.txt', 'w') as f:\n",
    "    print('为你写诗，为你静止，为你做不可能的事', file = f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('./wu.txt', 'r') as f:\n",
    "    content = f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'为你写诗，为你静止，为你做不可能的事\\n'"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 设定print的end参数值，用来设定以什么结尾。\n",
    "# end参数的默认值是换行符 \\n，我们可以换成其他字符，此处换为#结尾\n",
    "with open('./wu.txt', 'w') as f:\n",
    "    print('为你写诗，为你静止，为你做不可能的事', end = '#', file = f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('./wu.txt', 'r') as f:\n",
    "    content = f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'为你写诗，为你静止，为你做不可能的事#'"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "为你写诗，为你静止，为你做不可能的事\n"
     ]
    }
   ],
   "source": [
    "print('为你写诗，为你静止，为你做不可能的事')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "为你写诗，为你静止，为你做不可能的事#"
     ]
    }
   ],
   "source": [
    "print('为你写诗，为你静止，为你做不可能的事', end = '#')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`end`参数用来设定以什么结尾。默认值是换行符`\\n`，我们可以换成其他字符串。文件中换行符是不可见的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**示例**：接收键盘输入，屏幕输出，并写入文件"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "上联是：南通州，北通州，南北通州通南北，请您赐下联： 东当铺，西当铺，东西当铺当东西\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "我的上联是：南通州，北通州，南北通州通南北\n",
      "您的下联是：东当铺，西当铺，东西当铺当东西\n"
     ]
    }
   ],
   "source": [
    "# 给出一个上联，使用input函数接收键盘输入下联，并将上下联写入文件duilian.txt\n",
    "left_text = '南通州，北通州，南北通州通南北' # 东当铺，西当铺，东西当铺当东西\n",
    "right_text = input('上联是：{}，请您赐下联：'.format(left_text))\n",
    "with open('./duilian.txt', 'w') as f:\n",
    "    print('我的上联是：{}'.format(left_text))\n",
    "    print(left_text, file = f)\n",
    "    print('您的下联是：{}'.format(right_text))\n",
    "    print(right_text, file = f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><font color=red>思考题</font></b>：修改上面代码，使得文件中的对联呈竖形，如下：\n",
    "\n",
    "![竖形对联](https://raw.githubusercontent.com/zhangjianzhang/programming_basics/master/files/codes/lecture_9/dui_lian.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**文件内置属性**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('./text.txt') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 是否关闭\n",
    "f.closed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'UTF-8'"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 编码方式\n",
    "f.encoding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'r'"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 打开模式\n",
    "f.mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'./text.txt'"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 文件名\n",
    "f.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 一定要记住关闭，关闭，关闭，文件对象\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b><font color=red>思考题</font></b>：当前目录中的`grades.txt`文件中有如下各个同学的语文和数学成绩：\n",
    "\n",
    "<br>\n",
    "<div align=center>\n",
    "<img width=\"350\" height=\"550\" src=\"https://raw.githubusercontent.com/zhangjianzhang/programming_basics/master/files/codes/imgs/grade.png?raw=true\">\n",
    "\n",
    "<p><center><font>单科成绩单</font></center></p>\n",
    "</div>\n",
    "\n",
    "请编程计算各个同学的平均成绩并输入到当前目录的`average.txt`文件中，格式如下：\n",
    "\n",
    "<br>\n",
    "<div align=center>\n",
    "<img width=\"150\" height=\"250\" src=\"https://raw.githubusercontent.com/zhangjianzhang/programming_basics/master/files/codes/imgs/avg.jpg?raw=true\">\n",
    "\n",
    "<p><center><font>平均分成绩单</font></center></p>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. 将grades.txt文件中的内容读取到列表lines中\n",
    "with open('./grades.txt') as f:\n",
    "    lines = f.readlines()\n",
    "\n",
    "# 另一种读取方式    \n",
    "# with open('./grades.txt') as f:\n",
    "#     lines = f.read().strip().split('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['姓名 语文 数学\\n',\n",
       " '张三 88 64\\n',\n",
       " '李四 90 78\\n',\n",
       " '王五 65 45\\n',\n",
       " '赵六 43 66\\n',\n",
       " '冯七 62 56\\n',\n",
       " '刘八 90 42\\n',\n",
       " '阮九 68 36\\n',\n",
       " '陆十 86 46\\n']"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['张三', '88', '64'],\n",
       " ['李四', '90', '78'],\n",
       " ['王五', '65', '45'],\n",
       " ['赵六', '43', '66'],\n",
       " ['冯七', '62', '56'],\n",
       " ['刘八', '90', '42'],\n",
       " ['阮九', '68', '36'],\n",
       " ['陆十', '86', '46']]"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 2. 将成绩内容转换为list(list)\n",
    "score_list = []\n",
    "\n",
    "for line in lines[1:]:\n",
    "    score_list.append(line.strip().split())\n",
    "\n",
    "score_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['姓名', '平均分'],\n",
       " ['张三', '76.0'],\n",
       " ['李四', '84.0'],\n",
       " ['王五', '55.0'],\n",
       " ['赵六', '54.5'],\n",
       " ['冯七', '59.0'],\n",
       " ['刘八', '66.0'],\n",
       " ['阮九', '52.0'],\n",
       " ['陆十', '66.0']]"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 3. 计算平均分\n",
    "\n",
    "avg_list = []\n",
    "\n",
    "for line in score_list:\n",
    "    avg_line = [line[0], str(sum(map(float, line[1:]))/len(line[1:]))]\n",
    "    avg_list.append(avg_line)\n",
    "\n",
    "[['姓名', '平均分']] + avg_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 4. 把avg_list写入文件average.txt中\n",
    "\n",
    "with open('./average.txt','w') as f:\n",
    "    result = '\\n'.join([' '.join(line) for line in [['姓名', '平均分']] + avg_list])\n",
    "    f.writelines(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "END\n"
     ]
    }
   ],
   "source": [
    "print('END')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}