Ch08.텍스트와 바이너리 파일.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8.3 파일/디렉터리 시스템"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module os:\n",
      "\n",
      "NAME\n",
      "    os - OS routines for NT or Posix depending on what system we're on.\n",
      "\n",
      "DESCRIPTION\n",
      "    This exports:\n",
      "      - all functions from posix or nt, e.g. unlink, stat, etc.\n",
      "      - os.path is either posixpath or ntpath\n",
      "      - os.name is either 'posix' or 'nt'\n",
      "      - os.curdir is a string representing the current directory (always '.')\n",
      "      - os.pardir is a string representing the parent directory (always '..')\n",
      "      - os.sep is the (or a most common) pathname separator ('/' or '\\\\')\n",
      "      - os.extsep is the extension separator (always '.')\n",
      "      - os.altsep is the alternate pathname separator (None or '/')\n",
      "      - os.pathsep is the component separator used in $PATH etc\n",
      "      - os.linesep is the line separator in text files ('\\r' or '\\n' or '\\r\\n')\n",
      "      - os.defpath is the default search path for executables\n",
      "      - os.devnull is the file path of the null device ('/dev/null', etc.)\n",
      "    \n",
      "    Programs that import and use 'os' stand a better chance of being\n",
      "    portable between different platforms.  Of course, they must then\n",
      "    only use functions that are defined by all platforms (e.g., unlink\n",
      "    and opendir), and leave all pathname manipulation to os.path\n",
      "    (e.g., split and join).\n",
      "\n",
      "CLASSES\n",
      "    builtins.Exception(builtins.BaseException)\n",
      "        builtins.OSError\n",
      "    builtins.object\n",
      "        nt.DirEntry\n",
      "    builtins.tuple(builtins.object)\n",
      "        nt.times_result\n",
      "        nt.uname_result\n",
      "        stat_result\n",
      "        statvfs_result\n",
      "        terminal_size\n",
      "    \n",
      "    class DirEntry(builtins.object)\n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __fspath__(self, /)\n",
      "     |      Returns the path for the entry.\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  inode(self, /)\n",
      "     |      Return inode of the entry; cached per entry.\n",
      "     |  \n",
      "     |  is_dir(self, /, *, follow_symlinks=True)\n",
      "     |      Return True if the entry is a directory; cached per entry.\n",
      "     |  \n",
      "     |  is_file(self, /, *, follow_symlinks=True)\n",
      "     |      Return True if the entry is a file; cached per entry.\n",
      "     |  \n",
      "     |  is_symlink(self, /)\n",
      "     |      Return True if the entry is a symbolic link; cached per entry.\n",
      "     |  \n",
      "     |  stat(self, /, *, follow_symlinks=True)\n",
      "     |      Return stat_result object for the entry; cached per entry.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  name\n",
      "     |      the entry's base filename, relative to scandir() \"path\" argument\n",
      "     |  \n",
      "     |  path\n",
      "     |      the entry's full path name; equivalent to os.path.join(scandir_path, entry.name)\n",
      "    \n",
      "    error = class OSError(Exception)\n",
      "     |  Base class for I/O related errors.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      OSError\n",
      "     |      Exception\n",
      "     |      BaseException\n",
      "     |      object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __init__(self, /, *args, **kwargs)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __str__(self, /)\n",
      "     |      Return str(self).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  characters_written\n",
      "     |  \n",
      "     |  errno\n",
      "     |      POSIX exception code\n",
      "     |  \n",
      "     |  filename\n",
      "     |      exception filename\n",
      "     |  \n",
      "     |  filename2\n",
      "     |      second exception filename\n",
      "     |  \n",
      "     |  strerror\n",
      "     |      exception strerror\n",
      "     |  \n",
      "     |  winerror\n",
      "     |      Win32 exception code\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from BaseException:\n",
      "     |  \n",
      "     |  __delattr__(self, name, /)\n",
      "     |      Implement delattr(self, name).\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  __setattr__(self, name, value, /)\n",
      "     |      Implement setattr(self, name, value).\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |  \n",
      "     |  with_traceback(...)\n",
      "     |      Exception.with_traceback(tb) --\n",
      "     |      set self.__traceback__ to tb and return self.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors inherited from BaseException:\n",
      "     |  \n",
      "     |  __cause__\n",
      "     |      exception cause\n",
      "     |  \n",
      "     |  __context__\n",
      "     |      exception context\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |  \n",
      "     |  __suppress_context__\n",
      "     |  \n",
      "     |  __traceback__\n",
      "     |  \n",
      "     |  args\n",
      "    \n",
      "    class stat_result(builtins.tuple)\n",
      "     |  stat_result(iterable=(), /)\n",
      "     |  \n",
      "     |  stat_result: Result from stat, fstat, or lstat.\n",
      "     |  \n",
      "     |  This object may be accessed either as a tuple of\n",
      "     |    (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime)\n",
      "     |  or via the attributes st_mode, st_ino, st_dev, st_nlink, st_uid, and so on.\n",
      "     |  \n",
      "     |  Posix/windows: If your platform supports st_blksize, st_blocks, st_rdev,\n",
      "     |  or st_flags, they are available as attributes only.\n",
      "     |  \n",
      "     |  See os.stat for more information.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      stat_result\n",
      "     |      builtins.tuple\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  st_atime\n",
      "     |      time of last access\n",
      "     |  \n",
      "     |  st_atime_ns\n",
      "     |      time of last access in nanoseconds\n",
      "     |  \n",
      "     |  st_ctime\n",
      "     |      time of last change\n",
      "     |  \n",
      "     |  st_ctime_ns\n",
      "     |      time of last change in nanoseconds\n",
      "     |  \n",
      "     |  st_dev\n",
      "     |      device\n",
      "     |  \n",
      "     |  st_file_attributes\n",
      "     |      Windows file attribute bits\n",
      "     |  \n",
      "     |  st_gid\n",
      "     |      group ID of owner\n",
      "     |  \n",
      "     |  st_ino\n",
      "     |      inode\n",
      "     |  \n",
      "     |  st_mode\n",
      "     |      protection bits\n",
      "     |  \n",
      "     |  st_mtime\n",
      "     |      time of last modification\n",
      "     |  \n",
      "     |  st_mtime_ns\n",
      "     |      time of last modification in nanoseconds\n",
      "     |  \n",
      "     |  st_nlink\n",
      "     |      number of hard links\n",
      "     |  \n",
      "     |  st_size\n",
      "     |      total size, in bytes\n",
      "     |  \n",
      "     |  st_uid\n",
      "     |      user ID of owner\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  n_fields = 17\n",
      "     |  \n",
      "     |  n_sequence_fields = 10\n",
      "     |  \n",
      "     |  n_unnamed_fields = 3\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from builtins.tuple:\n",
      "     |  \n",
      "     |  __add__(self, value, /)\n",
      "     |      Return self+value.\n",
      "     |  \n",
      "     |  __contains__(self, key, /)\n",
      "     |      Return key in self.\n",
      "     |  \n",
      "     |  __eq__(self, value, /)\n",
      "     |      Return self==value.\n",
      "     |  \n",
      "     |  __ge__(self, value, /)\n",
      "     |      Return self>=value.\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __getitem__(self, key, /)\n",
      "     |      Return self[key].\n",
      "     |  \n",
      "     |  __getnewargs__(self, /)\n",
      "     |  \n",
      "     |  __gt__(self, value, /)\n",
      "     |      Return self>value.\n",
      "     |  \n",
      "     |  __hash__(self, /)\n",
      "     |      Return hash(self).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __le__(self, value, /)\n",
      "     |      Return self<=value.\n",
      "     |  \n",
      "     |  __len__(self, /)\n",
      "     |      Return len(self).\n",
      "     |  \n",
      "     |  __lt__(self, value, /)\n",
      "     |      Return self<value.\n",
      "     |  \n",
      "     |  __mul__(self, value, /)\n",
      "     |      Return self*value.\n",
      "     |  \n",
      "     |  __ne__(self, value, /)\n",
      "     |      Return self!=value.\n",
      "     |  \n",
      "     |  __rmul__(self, value, /)\n",
      "     |      Return value*self.\n",
      "     |  \n",
      "     |  count(self, value, /)\n",
      "     |      Return number of occurrences of value.\n",
      "     |  \n",
      "     |  index(self, value, start=0, stop=9223372036854775807, /)\n",
      "     |      Return first index of value.\n",
      "     |      \n",
      "     |      Raises ValueError if the value is not present.\n",
      "    \n",
      "    class statvfs_result(builtins.tuple)\n",
      "     |  statvfs_result(iterable=(), /)\n",
      "     |  \n",
      "     |  statvfs_result: Result from statvfs or fstatvfs.\n",
      "     |  \n",
      "     |  This object may be accessed either as a tuple of\n",
      "     |    (bsize, frsize, blocks, bfree, bavail, files, ffree, favail, flag, namemax),\n",
      "     |  or via the attributes f_bsize, f_frsize, f_blocks, f_bfree, and so on.\n",
      "     |  \n",
      "     |  See os.statvfs for more information.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      statvfs_result\n",
      "     |      builtins.tuple\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  f_bavail\n",
      "     |  \n",
      "     |  f_bfree\n",
      "     |  \n",
      "     |  f_blocks\n",
      "     |  \n",
      "     |  f_bsize\n",
      "     |  \n",
      "     |  f_favail\n",
      "     |  \n",
      "     |  f_ffree\n",
      "     |  \n",
      "     |  f_files\n",
      "     |  \n",
      "     |  f_flag\n",
      "     |  \n",
      "     |  f_frsize\n",
      "     |  \n",
      "     |  f_fsid\n",
      "     |  \n",
      "     |  f_namemax\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  n_fields = 11\n",
      "     |  \n",
      "     |  n_sequence_fields = 10\n",
      "     |  \n",
      "     |  n_unnamed_fields = 0\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from builtins.tuple:\n",
      "     |  \n",
      "     |  __add__(self, value, /)\n",
      "     |      Return self+value.\n",
      "     |  \n",
      "     |  __contains__(self, key, /)\n",
      "     |      Return key in self.\n",
      "     |  \n",
      "     |  __eq__(self, value, /)\n",
      "     |      Return self==value.\n",
      "     |  \n",
      "     |  __ge__(self, value, /)\n",
      "     |      Return self>=value.\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __getitem__(self, key, /)\n",
      "     |      Return self[key].\n",
      "     |  \n",
      "     |  __getnewargs__(self, /)\n",
      "     |  \n",
      "     |  __gt__(self, value, /)\n",
      "     |      Return self>value.\n",
      "     |  \n",
      "     |  __hash__(self, /)\n",
      "     |      Return hash(self).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __le__(self, value, /)\n",
      "     |      Return self<=value.\n",
      "     |  \n",
      "     |  __len__(self, /)\n",
      "     |      Return len(self).\n",
      "     |  \n",
      "     |  __lt__(self, value, /)\n",
      "     |      Return self<value.\n",
      "     |  \n",
      "     |  __mul__(self, value, /)\n",
      "     |      Return self*value.\n",
      "     |  \n",
      "     |  __ne__(self, value, /)\n",
      "     |      Return self!=value.\n",
      "     |  \n",
      "     |  __rmul__(self, value, /)\n",
      "     |      Return value*self.\n",
      "     |  \n",
      "     |  count(self, value, /)\n",
      "     |      Return number of occurrences of value.\n",
      "     |  \n",
      "     |  index(self, value, start=0, stop=9223372036854775807, /)\n",
      "     |      Return first index of value.\n",
      "     |      \n",
      "     |      Raises ValueError if the value is not present.\n",
      "    \n",
      "    class terminal_size(builtins.tuple)\n",
      "     |  terminal_size(iterable=(), /)\n",
      "     |  \n",
      "     |  A tuple of (columns, lines) for holding terminal window size\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      terminal_size\n",
      "     |      builtins.tuple\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  columns\n",
      "     |      width of the terminal window in characters\n",
      "     |  \n",
      "     |  lines\n",
      "     |      height of the terminal window in characters\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  n_fields = 2\n",
      "     |  \n",
      "     |  n_sequence_fields = 2\n",
      "     |  \n",
      "     |  n_unnamed_fields = 0\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from builtins.tuple:\n",
      "     |  \n",
      "     |  __add__(self, value, /)\n",
      "     |      Return self+value.\n",
      "     |  \n",
      "     |  __contains__(self, key, /)\n",
      "     |      Return key in self.\n",
      "     |  \n",
      "     |  __eq__(self, value, /)\n",
      "     |      Return self==value.\n",
      "     |  \n",
      "     |  __ge__(self, value, /)\n",
      "     |      Return self>=value.\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __getitem__(self, key, /)\n",
      "     |      Return self[key].\n",
      "     |  \n",
      "     |  __getnewargs__(self, /)\n",
      "     |  \n",
      "     |  __gt__(self, value, /)\n",
      "     |      Return self>value.\n",
      "     |  \n",
      "     |  __hash__(self, /)\n",
      "     |      Return hash(self).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __le__(self, value, /)\n",
      "     |      Return self<=value.\n",
      "     |  \n",
      "     |  __len__(self, /)\n",
      "     |      Return len(self).\n",
      "     |  \n",
      "     |  __lt__(self, value, /)\n",
      "     |      Return self<value.\n",
      "     |  \n",
      "     |  __mul__(self, value, /)\n",
      "     |      Return self*value.\n",
      "     |  \n",
      "     |  __ne__(self, value, /)\n",
      "     |      Return self!=value.\n",
      "     |  \n",
      "     |  __rmul__(self, value, /)\n",
      "     |      Return value*self.\n",
      "     |  \n",
      "     |  count(self, value, /)\n",
      "     |      Return number of occurrences of value.\n",
      "     |  \n",
      "     |  index(self, value, start=0, stop=9223372036854775807, /)\n",
      "     |      Return first index of value.\n",
      "     |      \n",
      "     |      Raises ValueError if the value is not present.\n",
      "    \n",
      "    class times_result(builtins.tuple)\n",
      "     |  times_result(iterable=(), /)\n",
      "     |  \n",
      "     |  times_result: Result from os.times().\n",
      "     |  \n",
      "     |  This object may be accessed either as a tuple of\n",
      "     |    (user, system, children_user, children_system, elapsed),\n",
      "     |  or via the attributes user, system, children_user, children_system,\n",
      "     |  and elapsed.\n",
      "     |  \n",
      "     |  See os.times for more information.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      times_result\n",
      "     |      builtins.tuple\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  children_system\n",
      "     |      system time of children\n",
      "     |  \n",
      "     |  children_user\n",
      "     |      user time of children\n",
      "     |  \n",
      "     |  elapsed\n",
      "     |      elapsed time since an arbitrary point in the past\n",
      "     |  \n",
      "     |  system\n",
      "     |      system time\n",
      "     |  \n",
      "     |  user\n",
      "     |      user time\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  n_fields = 5\n",
      "     |  \n",
      "     |  n_sequence_fields = 5\n",
      "     |  \n",
      "     |  n_unnamed_fields = 0\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from builtins.tuple:\n",
      "     |  \n",
      "     |  __add__(self, value, /)\n",
      "     |      Return self+value.\n",
      "     |  \n",
      "     |  __contains__(self, key, /)\n",
      "     |      Return key in self.\n",
      "     |  \n",
      "     |  __eq__(self, value, /)\n",
      "     |      Return self==value.\n",
      "     |  \n",
      "     |  __ge__(self, value, /)\n",
      "     |      Return self>=value.\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __getitem__(self, key, /)\n",
      "     |      Return self[key].\n",
      "     |  \n",
      "     |  __getnewargs__(self, /)\n",
      "     |  \n",
      "     |  __gt__(self, value, /)\n",
      "     |      Return self>value.\n",
      "     |  \n",
      "     |  __hash__(self, /)\n",
      "     |      Return hash(self).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __le__(self, value, /)\n",
      "     |      Return self<=value.\n",
      "     |  \n",
      "     |  __len__(self, /)\n",
      "     |      Return len(self).\n",
      "     |  \n",
      "     |  __lt__(self, value, /)\n",
      "     |      Return self<value.\n",
      "     |  \n",
      "     |  __mul__(self, value, /)\n",
      "     |      Return self*value.\n",
      "     |  \n",
      "     |  __ne__(self, value, /)\n",
      "     |      Return self!=value.\n",
      "     |  \n",
      "     |  __rmul__(self, value, /)\n",
      "     |      Return value*self.\n",
      "     |  \n",
      "     |  count(self, value, /)\n",
      "     |      Return number of occurrences of value.\n",
      "     |  \n",
      "     |  index(self, value, start=0, stop=9223372036854775807, /)\n",
      "     |      Return first index of value.\n",
      "     |      \n",
      "     |      Raises ValueError if the value is not present.\n",
      "    \n",
      "    class uname_result(builtins.tuple)\n",
      "     |  uname_result(iterable=(), /)\n",
      "     |  \n",
      "     |  uname_result: Result from os.uname().\n",
      "     |  \n",
      "     |  This object may be accessed either as a tuple of\n",
      "     |    (sysname, nodename, release, version, machine),\n",
      "     |  or via the attributes sysname, nodename, release, version, and machine.\n",
      "     |  \n",
      "     |  See os.uname for more information.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      uname_result\n",
      "     |      builtins.tuple\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  machine\n",
      "     |      hardware identifier\n",
      "     |  \n",
      "     |  nodename\n",
      "     |      name of machine on network (implementation-defined)\n",
      "     |  \n",
      "     |  release\n",
      "     |      operating system release\n",
      "     |  \n",
      "     |  sysname\n",
      "     |      operating system name\n",
      "     |  \n",
      "     |  version\n",
      "     |      operating system version\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  n_fields = 5\n",
      "     |  \n",
      "     |  n_sequence_fields = 5\n",
      "     |  \n",
      "     |  n_unnamed_fields = 0\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from builtins.tuple:\n",
      "     |  \n",
      "     |  __add__(self, value, /)\n",
      "     |      Return self+value.\n",
      "     |  \n",
      "     |  __contains__(self, key, /)\n",
      "     |      Return key in self.\n",
      "     |  \n",
      "     |  __eq__(self, value, /)\n",
      "     |      Return self==value.\n",
      "     |  \n",
      "     |  __ge__(self, value, /)\n",
      "     |      Return self>=value.\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __getitem__(self, key, /)\n",
      "     |      Return self[key].\n",
      "     |  \n",
      "     |  __getnewargs__(self, /)\n",
      "     |  \n",
      "     |  __gt__(self, value, /)\n",
      "     |      Return self>value.\n",
      "     |  \n",
      "     |  __hash__(self, /)\n",
      "     |      Return hash(self).\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __le__(self, value, /)\n",
      "     |      Return self<=value.\n",
      "     |  \n",
      "     |  __len__(self, /)\n",
      "     |      Return len(self).\n",
      "     |  \n",
      "     |  __lt__(self, value, /)\n",
      "     |      Return self<value.\n",
      "     |  \n",
      "     |  __mul__(self, value, /)\n",
      "     |      Return self*value.\n",
      "     |  \n",
      "     |  __ne__(self, value, /)\n",
      "     |      Return self!=value.\n",
      "     |  \n",
      "     |  __rmul__(self, value, /)\n",
      "     |      Return value*self.\n",
      "     |  \n",
      "     |  count(self, value, /)\n",
      "     |      Return number of occurrences of value.\n",
      "     |  \n",
      "     |  index(self, value, start=0, stop=9223372036854775807, /)\n",
      "     |      Return first index of value.\n",
      "     |      \n",
      "     |      Raises ValueError if the value is not present.\n",
      "\n",
      "FUNCTIONS\n",
      "    _exit(status)\n",
      "        Exit to the system with specified status, without normal exit processing.\n",
      "    \n",
      "    abort()\n",
      "        Abort the interpreter immediately.\n",
      "        \n",
      "        This function 'dumps core' or otherwise fails in the hardest way possible\n",
      "        on the hosting operating system.  This function never returns.\n",
      "    \n",
      "    access(path, mode, *, dir_fd=None, effective_ids=False, follow_symlinks=True)\n",
      "        Use the real uid/gid to test for access to a path.\n",
      "        \n",
      "          path\n",
      "            Path to be tested; can be string, bytes, or a path-like object.\n",
      "          mode\n",
      "            Operating-system mode bitfield.  Can be F_OK to test existence,\n",
      "            or the inclusive-OR of R_OK, W_OK, and X_OK.\n",
      "          dir_fd\n",
      "            If not None, it should be a file descriptor open to a directory,\n",
      "            and path should be relative; path will then be relative to that\n",
      "            directory.\n",
      "          effective_ids\n",
      "            If True, access will use the effective uid/gid instead of\n",
      "            the real uid/gid.\n",
      "          follow_symlinks\n",
      "            If False, and the last element of the path is a symbolic link,\n",
      "            access will examine the symbolic link itself instead of the file\n",
      "            the link points to.\n",
      "        \n",
      "        dir_fd, effective_ids, and follow_symlinks may not be implemented\n",
      "          on your platform.  If they are unavailable, using them will raise a\n",
      "          NotImplementedError.\n",
      "        \n",
      "        Note that most operations will use the effective uid/gid, therefore this\n",
      "          routine can be used in a suid/sgid environment to test if the invoking user\n",
      "          has the specified access to the path.\n",
      "    \n",
      "    chdir(path)\n",
      "        Change the current working directory to the specified path.\n",
      "        \n",
      "        path may always be specified as a string.\n",
      "        On some platforms, path may also be specified as an open file descriptor.\n",
      "          If this functionality is unavailable, using it raises an exception.\n",
      "    \n",
      "    chmod(path, mode, *, dir_fd=None, follow_symlinks=True)\n",
      "        Change the access permissions of a file.\n",
      "        \n",
      "          path\n",
      "            Path to be modified.  May always be specified as a str, bytes, or a path-like object.\n",
      "            On some platforms, path may also be specified as an open file descriptor.\n",
      "            If this functionality is unavailable, using it raises an exception.\n",
      "          mode\n",
      "            Operating-system mode bitfield.\n",
      "          dir_fd\n",
      "            If not None, it should be a file descriptor open to a directory,\n",
      "            and path should be relative; path will then be relative to that\n",
      "            directory.\n",
      "          follow_symlinks\n",
      "            If False, and the last element of the path is a symbolic link,\n",
      "            chmod will modify the symbolic link itself instead of the file\n",
      "            the link points to.\n",
      "        \n",
      "        It is an error to use dir_fd or follow_symlinks when specifying path as\n",
      "          an open file descriptor.\n",
      "        dir_fd and follow_symlinks may not be implemented on your platform.\n",
      "          If they are unavailable, using them will raise a NotImplementedError.\n",
      "    \n",
      "    close(fd)\n",
      "        Close a file descriptor.\n",
      "    \n",
      "    closerange(fd_low, fd_high, /)\n",
      "        Closes all file descriptors in [fd_low, fd_high), ignoring errors.\n",
      "    \n",
      "    cpu_count()\n",
      "        Return the number of CPUs in the system; return None if indeterminable.\n",
      "        \n",
      "        This number is not equivalent to the number of CPUs the current process can\n",
      "        use.  The number of usable CPUs can be obtained with\n",
      "        ``len(os.sched_getaffinity(0))``\n",
      "    \n",
      "    device_encoding(fd)\n",
      "        Return a string describing the encoding of a terminal's file descriptor.\n",
      "        \n",
      "        The file descriptor must be attached to a terminal.\n",
      "        If the device is not a terminal, return None.\n",
      "    \n",
      "    dup(fd, /)\n",
      "        Return a duplicate of a file descriptor.\n",
      "    \n",
      "    dup2(fd, fd2, inheritable=True)\n",
      "        Duplicate file descriptor.\n",
      "    \n",
      "    execl(file, *args)\n",
      "        execl(file, *args)\n",
      "        \n",
      "        Execute the executable file with argument list args, replacing the\n",
      "        current process.\n",
      "    \n",
      "    execle(file, *args)\n",
      "        execle(file, *args, env)\n",
      "        \n",
      "        Execute the executable file with argument list args and\n",
      "        environment env, replacing the current process.\n",
      "    \n",
      "    execlp(file, *args)\n",
      "        execlp(file, *args)\n",
      "        \n",
      "        Execute the executable file (which is searched for along $PATH)\n",
      "        with argument list args, replacing the current process.\n",
      "    \n",
      "    execlpe(file, *args)\n",
      "        execlpe(file, *args, env)\n",
      "        \n",
      "        Execute the executable file (which is searched for along $PATH)\n",
      "        with argument list args and environment env, replacing the current\n",
      "        process.\n",
      "    \n",
      "    execv(path, argv, /)\n",
      "        Execute an executable path with arguments, replacing current process.\n",
      "        \n",
      "        path\n",
      "          Path of executable file.\n",
      "        argv\n",
      "          Tuple or list of strings.\n",
      "    \n",
      "    execve(path, argv, env)\n",
      "        Execute an executable path with arguments, replacing current process.\n",
      "        \n",
      "        path\n",
      "          Path of executable file.\n",
      "        argv\n",
      "          Tuple or list of strings.\n",
      "        env\n",
      "          Dictionary of strings mapping to strings.\n",
      "    \n",
      "    execvp(file, args)\n",
      "        execvp(file, args)\n",
      "        \n",
      "        Execute the executable file (which is searched for along $PATH)\n",
      "        with argument list args, replacing the current process.\n",
      "        args may be a list or tuple of strings.\n",
      "    \n",
      "    execvpe(file, args, env)\n",
      "        execvpe(file, args, env)\n",
      "        \n",
      "        Execute the executable file (which is searched for along $PATH)\n",
      "        with argument list args and environment env, replacing the\n",
      "        current process.\n",
      "        args may be a list or tuple of strings.\n",
      "    \n",
      "    fdopen(fd, *args, **kwargs)\n",
      "        # Supply os.fdopen()\n",
      "    \n",
      "    fsdecode(filename)\n",
      "        Decode filename (an os.PathLike, bytes, or str) from the filesystem\n",
      "        encoding with 'surrogateescape' error handler, return str unchanged. On\n",
      "        Windows, use 'strict' error handler if the file system encoding is\n",
      "        'mbcs' (which is the default encoding).\n",
      "    \n",
      "    fsencode(filename)\n",
      "        Encode filename (an os.PathLike, bytes, or str) to the filesystem\n",
      "        encoding with 'surrogateescape' error handler, return bytes unchanged.\n",
      "        On Windows, use 'strict' error handler if the file system encoding is\n",
      "        'mbcs' (which is the default encoding).\n",
      "    \n",
      "    fspath(path)\n",
      "        Return the file system path representation of the object.\n",
      "        \n",
      "        If the object is str or bytes, then allow it to pass through as-is. If the\n",
      "        object defines __fspath__(), then return the result of that method. All other\n",
      "        types raise a TypeError.\n",
      "    \n",
      "    fstat(fd)\n",
      "        Perform a stat system call on the given file descriptor.\n",
      "        \n",
      "        Like stat(), but for an open file descriptor.\n",
      "        Equivalent to os.stat(fd).\n",
      "    \n",
      "    fsync(fd)\n",
      "        Force write of fd to disk.\n",
      "    \n",
      "    ftruncate(fd, length, /)\n",
      "        Truncate a file, specified by file descriptor, to a specific length.\n",
      "    \n",
      "    get_exec_path(env=None)\n",
      "        Returns the sequence of directories that will be searched for the\n",
      "        named executable (similar to a shell) when launching a process.\n",
      "        \n",
      "        *env* must be an environment variable dict or None.  If *env* is None,\n",
      "        os.environ will be used.\n",
      "    \n",
      "    get_handle_inheritable(handle, /)\n",
      "        Get the close-on-exe flag of the specified file descriptor.\n",
      "    \n",
      "    get_inheritable(fd, /)\n",
      "        Get the close-on-exe flag of the specified file descriptor.\n",
      "    \n",
      "    get_terminal_size(...)\n",
      "        Return the size of the terminal window as (columns, lines).\n",
      "        \n",
      "        The optional argument fd (default standard output) specifies\n",
      "        which file descriptor should be queried.\n",
      "        \n",
      "        If the file descriptor is not connected to a terminal, an OSError\n",
      "        is thrown.\n",
      "        \n",
      "        This function will only be defined if an implementation is\n",
      "        available for this system.\n",
      "        \n",
      "        shutil.get_terminal_size is the high-level function which should \n",
      "        normally be used, os.get_terminal_size is the low-level implementation.\n",
      "    \n",
      "    getcwd()\n",
      "        Return a unicode string representing the current working directory.\n",
      "    \n",
      "    getcwdb()\n",
      "        Return a bytes string representing the current working directory.\n",
      "    \n",
      "    getenv(key, default=None)\n",
      "        Get an environment variable, return None if it doesn't exist.\n",
      "        The optional second argument can specify an alternate default.\n",
      "        key, default and the result are str.\n",
      "    \n",
      "    getlogin()\n",
      "        Return the actual login name.\n",
      "    \n",
      "    getpid()\n",
      "        Return the current process id.\n",
      "    \n",
      "    getppid()\n",
      "        Return the parent's process id.\n",
      "        \n",
      "        If the parent process has already exited, Windows machines will still\n",
      "        return its id; others systems will return the id of the 'init' process (1).\n",
      "    \n",
      "    isatty(fd, /)\n",
      "        Return True if the fd is connected to a terminal.\n",
      "        \n",
      "        Return True if the file descriptor is an open file descriptor\n",
      "        connected to the slave end of a terminal.\n",
      "    \n",
      "    kill(pid, signal, /)\n",
      "        Kill a process with a signal.\n",
      "    \n",
      "    link(src, dst, *, src_dir_fd=None, dst_dir_fd=None, follow_symlinks=True)\n",
      "        Create a hard link to a file.\n",
      "        \n",
      "        If either src_dir_fd or dst_dir_fd is not None, it should be a file\n",
      "          descriptor open to a directory, and the respective path string (src or dst)\n",
      "          should be relative; the path will then be relative to that directory.\n",
      "        If follow_symlinks is False, and the last element of src is a symbolic\n",
      "          link, link will create a link to the symbolic link itself instead of the\n",
      "          file the link points to.\n",
      "        src_dir_fd, dst_dir_fd, and follow_symlinks may not be implemented on your\n",
      "          platform.  If they are unavailable, using them will raise a\n",
      "          NotImplementedError.\n",
      "    \n",
      "    listdir(path=None)\n",
      "        Return a list containing the names of the files in the directory.\n",
      "        \n",
      "        path can be specified as either str, bytes, or a path-like object.  If path is bytes,\n",
      "          the filenames returned will also be bytes; in all other circumstances\n",
      "          the filenames returned will be str.\n",
      "        If path is None, uses the path='.'.\n",
      "        On some platforms, path may also be specified as an open file descriptor;\\\n",
      "          the file descriptor must refer to a directory.\n",
      "          If this functionality is unavailable, using it raises NotImplementedError.\n",
      "        \n",
      "        The list is in arbitrary order.  It does not include the special\n",
      "        entries '.' and '..' even if they are present in the directory.\n",
      "    \n",
      "    lseek(fd, position, how, /)\n",
      "        Set the position of a file descriptor.  Return the new position.\n",
      "        \n",
      "        Return the new cursor position in number of bytes\n",
      "        relative to the beginning of the file.\n",
      "    \n",
      "    lstat(path, *, dir_fd=None)\n",
      "        Perform a stat system call on the given path, without following symbolic links.\n",
      "        \n",
      "        Like stat(), but do not follow symbolic links.\n",
      "        Equivalent to stat(path, follow_symlinks=False).\n",
      "    \n",
      "    makedirs(name, mode=511, exist_ok=False)\n",
      "        makedirs(name [, mode=0o777][, exist_ok=False])\n",
      "        \n",
      "        Super-mkdir; create a leaf directory and all intermediate ones.  Works like\n",
      "        mkdir, except that any intermediate path segment (not just the rightmost)\n",
      "        will be created if it does not exist. If the target directory already\n",
      "        exists, raise an OSError if exist_ok is False. Otherwise no exception is\n",
      "        raised.  This is recursive.\n",
      "    \n",
      "    mkdir(path, mode=511, *, dir_fd=None)\n",
      "        Create a directory.\n",
      "        \n",
      "        If dir_fd is not None, it should be a file descriptor open to a directory,\n",
      "          and path should be relative; path will then be relative to that directory.\n",
      "        dir_fd may not be implemented on your platform.\n",
      "          If it is unavailable, using it will raise a NotImplementedError.\n",
      "        \n",
      "        The mode argument is ignored on Windows.\n",
      "    \n",
      "    open(path, flags, mode=511, *, dir_fd=None)\n",
      "        Open a file for low level IO.  Returns a file descriptor (integer).\n",
      "        \n",
      "        If dir_fd is not None, it should be a file descriptor open to a directory,\n",
      "          and path should be relative; path will then be relative to that directory.\n",
      "        dir_fd may not be implemented on your platform.\n",
      "          If it is unavailable, using it will raise a NotImplementedError.\n",
      "    \n",
      "    pipe()\n",
      "        Create a pipe.\n",
      "        \n",
      "        Returns a tuple of two file descriptors:\n",
      "          (read_fd, write_fd)\n",
      "    \n",
      "    popen(cmd, mode='r', buffering=-1)\n",
      "        # Supply os.popen()\n",
      "    \n",
      "    putenv(name, value, /)\n",
      "        Change or add an environment variable.\n",
      "    \n",
      "    read(fd, length, /)\n",
      "        Read from a file descriptor.  Returns a bytes object.\n",
      "    \n",
      "    readlink(...)\n",
      "        readlink(path, *, dir_fd=None) -> path\n",
      "        \n",
      "        Return a string representing the path to which the symbolic link points.\n",
      "        \n",
      "        If dir_fd is not None, it should be a file descriptor open to a directory,\n",
      "          and path should be relative; path will then be relative to that directory.\n",
      "        dir_fd may not be implemented on your platform.\n",
      "          If it is unavailable, using it will raise a NotImplementedError.\n",
      "    \n",
      "    remove(path, *, dir_fd=None)\n",
      "        Remove a file (same as unlink()).\n",
      "        \n",
      "        If dir_fd is not None, it should be a file descriptor open to a directory,\n",
      "          and path should be relative; path will then be relative to that directory.\n",
      "        dir_fd may not be implemented on your platform.\n",
      "          If it is unavailable, using it will raise a NotImplementedError.\n",
      "    \n",
      "    removedirs(name)\n",
      "        removedirs(name)\n",
      "        \n",
      "        Super-rmdir; remove a leaf directory and all empty intermediate\n",
      "        ones.  Works like rmdir except that, if the leaf directory is\n",
      "        successfully removed, directories corresponding to rightmost path\n",
      "        segments will be pruned away until either the whole path is\n",
      "        consumed or an error occurs.  Errors during this latter phase are\n",
      "        ignored -- they generally mean that a directory was not empty.\n",
      "    \n",
      "    rename(src, dst, *, src_dir_fd=None, dst_dir_fd=None)\n",
      "        Rename a file or directory.\n",
      "        \n",
      "        If either src_dir_fd or dst_dir_fd is not None, it should be a file\n",
      "          descriptor open to a directory, and the respective path string (src or dst)\n",
      "          should be relative; the path will then be relative to that directory.\n",
      "        src_dir_fd and dst_dir_fd, may not be implemented on your platform.\n",
      "          If they are unavailable, using them will raise a NotImplementedError.\n",
      "    \n",
      "    renames(old, new)\n",
      "        renames(old, new)\n",
      "        \n",
      "        Super-rename; create directories as necessary and delete any left\n",
      "        empty.  Works like rename, except creation of any intermediate\n",
      "        directories needed to make the new pathname good is attempted\n",
      "        first.  After the rename, directories corresponding to rightmost\n",
      "        path segments of the old name will be pruned until either the\n",
      "        whole path is consumed or a nonempty directory is found.\n",
      "        \n",
      "        Note: this function can fail with the new directory structure made\n",
      "        if you lack permissions needed to unlink the leaf directory or\n",
      "        file.\n",
      "    \n",
      "    replace(src, dst, *, src_dir_fd=None, dst_dir_fd=None)\n",
      "        Rename a file or directory, overwriting the destination.\n",
      "        \n",
      "        If either src_dir_fd or dst_dir_fd is not None, it should be a file\n",
      "          descriptor open to a directory, and the respective path string (src or dst)\n",
      "          should be relative; the path will then be relative to that directory.\n",
      "        src_dir_fd and dst_dir_fd, may not be implemented on your platform.\n",
      "          If they are unavailable, using them will raise a NotImplementedError.\n",
      "    \n",
      "    rmdir(path, *, dir_fd=None)\n",
      "        Remove a directory.\n",
      "        \n",
      "        If dir_fd is not None, it should be a file descriptor open to a directory,\n",
      "          and path should be relative; path will then be relative to that directory.\n",
      "        dir_fd may not be implemented on your platform.\n",
      "          If it is unavailable, using it will raise a NotImplementedError.\n",
      "    \n",
      "    scandir(path=None)\n",
      "        Return an iterator of DirEntry objects for given path.\n",
      "        \n",
      "        path can be specified as either str, bytes, or a path-like object.  If path\n",
      "        is bytes, the names of yielded DirEntry objects will also be bytes; in\n",
      "        all other circumstances they will be str.\n",
      "        \n",
      "        If path is None, uses the path='.'.\n",
      "    \n",
      "    set_handle_inheritable(handle, inheritable, /)\n",
      "        Set the inheritable flag of the specified handle.\n",
      "    \n",
      "    set_inheritable(fd, inheritable, /)\n",
      "        Set the inheritable flag of the specified file descriptor.\n",
      "    \n",
      "    spawnl(mode, file, *args)\n",
      "        spawnl(mode, file, *args) -> integer\n",
      "        \n",
      "        Execute file with arguments from args in a subprocess.\n",
      "        If mode == P_NOWAIT return the pid of the process.\n",
      "        If mode == P_WAIT return the process's exit code if it exits normally;\n",
      "        otherwise return -SIG, where SIG is the signal that killed it.\n",
      "    \n",
      "    spawnle(mode, file, *args)\n",
      "        spawnle(mode, file, *args, env) -> integer\n",
      "        \n",
      "        Execute file with arguments from args in a subprocess with the\n",
      "        supplied environment.\n",
      "        If mode == P_NOWAIT return the pid of the process.\n",
      "        If mode == P_WAIT return the process's exit code if it exits normally;\n",
      "        otherwise return -SIG, where SIG is the signal that killed it.\n",
      "    \n",
      "    spawnv(mode, path, argv, /)\n",
      "        Execute the program specified by path in a new process.\n",
      "        \n",
      "        mode\n",
      "          Mode of process creation.\n",
      "        path\n",
      "          Path of executable file.\n",
      "        argv\n",
      "          Tuple or list of strings.\n",
      "    \n",
      "    spawnve(mode, path, argv, env, /)\n",
      "        Execute the program specified by path in a new process.\n",
      "        \n",
      "        mode\n",
      "          Mode of process creation.\n",
      "        path\n",
      "          Path of executable file.\n",
      "        argv\n",
      "          Tuple or list of strings.\n",
      "        env\n",
      "          Dictionary of strings mapping to strings.\n",
      "    \n",
      "    startfile(filepath, operation=None)\n",
      "        startfile(filepath [, operation])\n",
      "        \n",
      "        Start a file with its associated application.\n",
      "        \n",
      "        When \"operation\" is not specified or \"open\", this acts like\n",
      "        double-clicking the file in Explorer, or giving the file name as an\n",
      "        argument to the DOS \"start\" command: the file is opened with whatever\n",
      "        application (if any) its extension is associated.\n",
      "        When another \"operation\" is given, it specifies what should be done with\n",
      "        the file.  A typical operation is \"print\".\n",
      "        \n",
      "        startfile returns as soon as the associated application is launched.\n",
      "        There is no option to wait for the application to close, and no way\n",
      "        to retrieve the application's exit status.\n",
      "        \n",
      "        The filepath is relative to the current directory.  If you want to use\n",
      "        an absolute path, make sure the first character is not a slash (\"/\");\n",
      "        the underlying Win32 ShellExecute function doesn't work if it is.\n",
      "    \n",
      "    stat(path, *, dir_fd=None, follow_symlinks=True)\n",
      "        Perform a stat system call on the given path.\n",
      "        \n",
      "          path\n",
      "            Path to be examined; can be string, bytes, a path-like object or\n",
      "            open-file-descriptor int.\n",
      "          dir_fd\n",
      "            If not None, it should be a file descriptor open to a directory,\n",
      "            and path should be a relative string; path will then be relative to\n",
      "            that directory.\n",
      "          follow_symlinks\n",
      "            If False, and the last element of the path is a symbolic link,\n",
      "            stat will examine the symbolic link itself instead of the file\n",
      "            the link points to.\n",
      "        \n",
      "        dir_fd and follow_symlinks may not be implemented\n",
      "          on your platform.  If they are unavailable, using them will raise a\n",
      "          NotImplementedError.\n",
      "        \n",
      "        It's an error to use dir_fd or follow_symlinks when specifying path as\n",
      "          an open file descriptor.\n",
      "    \n",
      "    strerror(code, /)\n",
      "        Translate an error code to a message string.\n",
      "    \n",
      "    symlink(src, dst, target_is_directory=False, *, dir_fd=None)\n",
      "        Create a symbolic link pointing to src named dst.\n",
      "        \n",
      "        target_is_directory is required on Windows if the target is to be\n",
      "          interpreted as a directory.  (On Windows, symlink requires\n",
      "          Windows 6.0 or greater, and raises a NotImplementedError otherwise.)\n",
      "          target_is_directory is ignored on non-Windows platforms.\n",
      "        \n",
      "        If dir_fd is not None, it should be a file descriptor open to a directory,\n",
      "          and path should be relative; path will then be relative to that directory.\n",
      "        dir_fd may not be implemented on your platform.\n",
      "          If it is unavailable, using it will raise a NotImplementedError.\n",
      "    \n",
      "    system(command)\n",
      "        Execute the command in a subshell.\n",
      "    \n",
      "    times()\n",
      "        Return a collection containing process timing information.\n",
      "        \n",
      "        The object returned behaves like a named tuple with these fields:\n",
      "          (utime, stime, cutime, cstime, elapsed_time)\n",
      "        All fields are floating point numbers.\n",
      "    \n",
      "    truncate(path, length)\n",
      "        Truncate a file, specified by path, to a specific length.\n",
      "        \n",
      "        On some platforms, path may also be specified as an open file descriptor.\n",
      "          If this functionality is unavailable, using it raises an exception.\n",
      "    \n",
      "    umask(mask, /)\n",
      "        Set the current numeric umask and return the previous umask.\n",
      "    \n",
      "    unlink(path, *, dir_fd=None)\n",
      "        Remove a file (same as remove()).\n",
      "        \n",
      "        If dir_fd is not None, it should be a file descriptor open to a directory,\n",
      "          and path should be relative; path will then be relative to that directory.\n",
      "        dir_fd may not be implemented on your platform.\n",
      "          If it is unavailable, using it will raise a NotImplementedError.\n",
      "    \n",
      "    urandom(size, /)\n",
      "        Return a bytes object containing random bytes suitable for cryptographic use.\n",
      "    \n",
      "    utime(path, times=None, *, ns=None, dir_fd=None, follow_symlinks=True)\n",
      "        Set the access and modified time of path.\n",
      "        \n",
      "        path may always be specified as a string.\n",
      "        On some platforms, path may also be specified as an open file descriptor.\n",
      "          If this functionality is unavailable, using it raises an exception.\n",
      "        \n",
      "        If times is not None, it must be a tuple (atime, mtime);\n",
      "            atime and mtime should be expressed as float seconds since the epoch.\n",
      "        If ns is specified, it must be a tuple (atime_ns, mtime_ns);\n",
      "            atime_ns and mtime_ns should be expressed as integer nanoseconds\n",
      "            since the epoch.\n",
      "        If times is None and ns is unspecified, utime uses the current time.\n",
      "        Specifying tuples for both times and ns is an error.\n",
      "        \n",
      "        If dir_fd is not None, it should be a file descriptor open to a directory,\n",
      "          and path should be relative; path will then be relative to that directory.\n",
      "        If follow_symlinks is False, and the last element of the path is a symbolic\n",
      "          link, utime will modify the symbolic link itself instead of the file the\n",
      "          link points to.\n",
      "        It is an error to use dir_fd or follow_symlinks when specifying path\n",
      "          as an open file descriptor.\n",
      "        dir_fd and follow_symlinks may not be available on your platform.\n",
      "          If they are unavailable, using them will raise a NotImplementedError.\n",
      "    \n",
      "    waitpid(pid, options, /)\n",
      "        Wait for completion of a given process.\n",
      "        \n",
      "        Returns a tuple of information regarding the process:\n",
      "            (pid, status << 8)\n",
      "        \n",
      "        The options argument is ignored on Windows.\n",
      "    \n",
      "    walk(top, topdown=True, onerror=None, followlinks=False)\n",
      "        Directory tree generator.\n",
      "        \n",
      "        For each directory in the directory tree rooted at top (including top\n",
      "        itself, but excluding '.' and '..'), yields a 3-tuple\n",
      "        \n",
      "            dirpath, dirnames, filenames\n",
      "        \n",
      "        dirpath is a string, the path to the directory.  dirnames is a list of\n",
      "        the names of the subdirectories in dirpath (excluding '.' and '..').\n",
      "        filenames is a list of the names of the non-directory files in dirpath.\n",
      "        Note that the names in the lists are just names, with no path components.\n",
      "        To get a full path (which begins with top) to a file or directory in\n",
      "        dirpath, do os.path.join(dirpath, name).\n",
      "        \n",
      "        If optional arg 'topdown' is true or not specified, the triple for a\n",
      "        directory is generated before the triples for any of its subdirectories\n",
      "        (directories are generated top down).  If topdown is false, the triple\n",
      "        for a directory is generated after the triples for all of its\n",
      "        subdirectories (directories are generated bottom up).\n",
      "        \n",
      "        When topdown is true, the caller can modify the dirnames list in-place\n",
      "        (e.g., via del or slice assignment), and walk will only recurse into the\n",
      "        subdirectories whose names remain in dirnames; this can be used to prune the\n",
      "        search, or to impose a specific order of visiting.  Modifying dirnames when\n",
      "        topdown is false has no effect on the behavior of os.walk(), since the\n",
      "        directories in dirnames have already been generated by the time dirnames\n",
      "        itself is generated. No matter the value of topdown, the list of\n",
      "        subdirectories is retrieved before the tuples for the directory and its\n",
      "        subdirectories are generated.\n",
      "        \n",
      "        By default errors from the os.scandir() call are ignored.  If\n",
      "        optional arg 'onerror' is specified, it should be a function; it\n",
      "        will be called with one argument, an OSError instance.  It can\n",
      "        report the error to continue with the walk, or raise the exception\n",
      "        to abort the walk.  Note that the filename is available as the\n",
      "        filename attribute of the exception object.\n",
      "        \n",
      "        By default, os.walk does not follow symbolic links to subdirectories on\n",
      "        systems that support them.  In order to get this functionality, set the\n",
      "        optional argument 'followlinks' to true.\n",
      "        \n",
      "        Caution:  if you pass a relative pathname for top, don't change the\n",
      "        current working directory between resumptions of walk.  walk never\n",
      "        changes the current directory, and assumes that the client doesn't\n",
      "        either.\n",
      "        \n",
      "        Example:\n",
      "        \n",
      "        import os\n",
      "        from os.path import join, getsize\n",
      "        for root, dirs, files in os.walk('python/Lib/email'):\n",
      "            print(root, \"consumes\", end=\"\")\n",
      "            print(sum([getsize(join(root, name)) for name in files]), end=\"\")\n",
      "            print(\"bytes in\", len(files), \"non-directory files\")\n",
      "            if 'CVS' in dirs:\n",
      "                dirs.remove('CVS')  # don't visit CVS directories\n",
      "    \n",
      "    write(fd, data, /)\n",
      "        Write a bytes object to a file descriptor.\n",
      "\n",
      "DATA\n",
      "    F_OK = 0\n",
      "    O_APPEND = 8\n",
      "    O_BINARY = 32768\n",
      "    O_CREAT = 256\n",
      "    O_EXCL = 1024\n",
      "    O_NOINHERIT = 128\n",
      "    O_RANDOM = 16\n",
      "    O_RDONLY = 0\n",
      "    O_RDWR = 2\n",
      "    O_SEQUENTIAL = 32\n",
      "    O_SHORT_LIVED = 4096\n",
      "    O_TEMPORARY = 64\n",
      "    O_TEXT = 16384\n",
      "    O_TRUNC = 512\n",
      "    O_WRONLY = 1\n",
      "    P_DETACH = 4\n",
      "    P_NOWAIT = 1\n",
      "    P_NOWAITO = 3\n",
      "    P_OVERLAY = 2\n",
      "    P_WAIT = 0\n",
      "    R_OK = 4\n",
      "    SEEK_CUR = 1\n",
      "    SEEK_END = 2\n",
      "    SEEK_SET = 0\n",
      "    TMP_MAX = 2147483647\n",
      "    W_OK = 2\n",
      "    X_OK = 1\n",
      "    __all__ = ['altsep', 'curdir', 'pardir', 'sep', 'pathsep', 'linesep', ...\n",
      "    altsep = '/'\n",
      "    curdir = '.'\n",
      "    defpath = r'.;C:\\bin'\n",
      "    devnull = 'nul'\n",
      "    environ = environ({'ALLUSERSPROFILE': 'C:\\\\ProgramData', '...END': 'mo...\n",
      "    extsep = '.'\n",
      "    linesep = '\\r\\n'\n",
      "    name = 'nt'\n",
      "    pardir = '..'\n",
      "    pathsep = ';'\n",
      "    sep = r'\\'\n",
      "    supports_bytes_environ = False\n",
      "\n",
      "FILE\n",
      "    c:\\users\\swkim\\anaconda3\\lib\\os.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "help(os)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C:\\\\Users\\\\SwKim\\\\SuperchargedPython'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.isfile('pythag.py')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['.gitignore',\n",
       " '.ipynb_checkpoints',\n",
       " 'Ch01.파이썬 기초 돌아보기.ipynb',\n",
       " 'Ch02.고급 문자열 기능.ipynb',\n",
       " 'Ch03.고급 리스트 기능.ipynb',\n",
       " 'Ch04.지름길, 커맨드, 라인, 그리고 패키지.ipynb',\n",
       " 'Ch05.정밀하게 텍스트 포매팅하기.ipynb',\n",
       " 'Ch06.정규표현식, 파트 I.ipynb',\n",
       " 'Ch07.정규표현식, 파트 II.ipynb',\n",
       " 'Ch08.텍스트와 바이너리 파일.ipynb']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.listdir()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8.4 파일을 열 때 발생하는 예외 다루기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter file to read:file\n",
      "File file not found. Terminating.\n"
     ]
    }
   ],
   "source": [
    " try:\n",
    "    fname = input('Enter file to read:')\n",
    "    f = open(fname, 'r')\n",
    "    print(f.read())\n",
    "except FileNotFoundError:\n",
    "    print('File', fname, 'not found. Terminating.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter file to read:file\n",
      "File could not be found. Re-enter.\n",
      "Enter file to read:\n"
     ]
    }
   ],
   "source": [
    " while True:\n",
    "    fname = input('Enter file to read:')\n",
    "    if not fname:\n",
    "        break\n",
    "    try:\n",
    "        f = open(fname, 'r')\n",
    "    except FileNotFoundError:\n",
    "        print('File could not be found. Re-enter.')\n",
    "    else:\n",
    "        print(f.read())\n",
    "        f.close()\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8.5 'with' 키워드 사용하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "with open('stuff.txt', 'r') as f:\n",
    "    lst = f.readlines()\n",
    "    for thing in lst:\n",
    "        print(thing, end=' ')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8.7 텍스트 파일 작업 상세하게 알아보기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To be or not to be\n",
      "That is the question.\n",
      "Whether tis nobler in the mind\n",
      "To suffer the slings and arrows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with open('file.txt', 'w') as f:\n",
    "    f.write('To be or not to be\\n')\n",
    "    f.write('That is the question.\\n')\n",
    "    f.write('Whether tis nobler in the mind\\n')\n",
    "    f.write('To suffer the slings and arrows\\n')\n",
    "\n",
    "with open('file.txt', 'r') as f:\n",
    "    print(f.read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To be or not to be\n",
      "\n",
      "That is the question.\n",
      "\n",
      "Whether tis nobler in the mind\n",
      "\n",
      "To suffer the slings and arrows\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with open('file.txt', 'r') as f:\n",
    "    s = ' '  # 빈칸으로 초기화한다.\n",
    "    while s:\n",
    "        s = f.readline()\n",
    "        print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To be or not to be\n",
      "That is the question.\n",
      "Whether tis nobler in the mind\n",
      "To suffer the slings and arrows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with open('file.txt', 'r') as f:\n",
    "    s = ' '\n",
    "    while s:\n",
    "        s = f.readline()\n",
    "        s = s.rstrip('\\n')\n",
    "        print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To be or not to be\n",
      " That is the question.\n",
      " Whether tis nobler in the mind\n",
      " To suffer the slings and arrows\n",
      " "
     ]
    }
   ],
   "source": [
    "with open('file.txt', 'r') as f:\n",
    "    str_list = f.readlines()\n",
    "    for s in str_list:\n",
    "        print(s, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8.8 파일 포인터('seek') 사용하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "파일_객체.seek(0, 0)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "file_obj.seek(rec_size * rec_nmu, 0)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "file_pointer = file_obj.tell()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8.9 RPN 프로젝트 안에서 텍스트 읽기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.9.1 현재까지의 RPN 번역기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter RPN line: 25 4 *\n",
      "100.0\n",
      "Enter RPN line: 25 4 * 50.75-\n",
      "49.25\n",
      "Enter RPN line: 3 3* 4 4* + .5^\n",
      "5.0\n",
      "Enter RPN line: \n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "import operator\n",
    "\n",
    "stack = []    # 값을 보관하기 위한 스택\n",
    "\n",
    "# 스캐너 객체. 각 토큰을 고립시키고, 상황에 맞는\n",
    "# 다음 작업을 수행한다. 숫자 값을 스택에 넣거나(push), \n",
    "# 연산자를 찾는 경우 스택 젤 위 항목 2개의\n",
    "# 연산을 수행한다.\n",
    "\n",
    "scanner = re.Scanner([\n",
    "    (r\"[ \\t\\n]\", lambda s, t: None),\n",
    "    (r\"-?(\\d*\\.)?\\d+\", lambda s, t:\n",
    "    stack.append(float(t))),\n",
    "    (r\"\\d+\", lambda s, t: stack.append(int(t))),\n",
    "    (r\"[+]\", lambda s, t: bin_op(operator.add)),\n",
    "    (r\"[-]\", lambda s, t: bin_op(operator.sub)),\n",
    "    (r\"[*]\", lambda s, t: bin_op(operator.mul)),\n",
    "    (r\"[/]\", lambda s, t: bin_op(operator.truediv)),\n",
    "    (r\"[\\^]\", lambda s, t: bin_op(operator.pow)),\n",
    "])\n",
    "\n",
    "# 바이너리 연산자 함수. 스택에서 2개 항목을 추출(pop)하고, \n",
    "# 연산 처리 결과를 다시 스택에 넣는다(push).\n",
    "\n",
    "def bin_op(action):\n",
    "    op2, op1 = stack.pop(), stack.pop()\n",
    "    stack.append(action(op1, op2))\n",
    "\n",
    "def main():\n",
    "    while True:\n",
    "        input_str = input('Enter RPN line: ')\n",
    "        if not input_str:\n",
    "            break\n",
    "        try:\n",
    "            tokens, unknown = scanner.scan(input_str)\n",
    "            if unknown:\n",
    "                print('Unrecognized input:', unknown)\n",
    "            else:\n",
    "                print(str(stack[-1]))\n",
    "        except IndexError:\n",
    "            print('Stack underflow.')\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.9.2 텍스트 파일의 RPN 읽기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter RPN source: rpnn.txt\n",
      "File not found. Re-enter.\n",
      "Enter RPN source: rpn.txt\n",
      "5.0\n",
      "1.4142135623730951\n"
     ]
    }
   ],
   "source": [
    "import re\n",
    "import operator\n",
    "\n",
    "stack = []    # 값을 보관하기 위한 스택\n",
    "\n",
    "# 스캐너 객체. 각 토큰을 고립시키고, 상황에 맞는\n",
    "# 다음 작업을 수행한다. 숫자 값을 스택에 넣거나(push), \n",
    "# 연산자를 찾는 경우 스택 젤 위 항목 2개의\n",
    "# 연산을 수행한다.\n",
    "\n",
    "scanner = re.Scanner([\n",
    "    (r\"[ \\t\\n]\", lambda s, t: None),\n",
    "    (r\"-?(\\d*\\.)?\\d+\", lambda s, t:\n",
    "    stack.append(float(t))),\n",
    "    (r\"\\d+\", lambda s, t: stack.append(int(t))),\n",
    "    (r\"[+]\", lambda s, t: bin_op(operator.add)),\n",
    "    (r\"[-]\", lambda s, t: bin_op(operator.sub)),\n",
    "    (r\"[*]\", lambda s, t: bin_op(operator.mul)),\n",
    "    (r\"[/]\", lambda s, t: bin_op(operator.truediv)),\n",
    "    (r\"[\\^]\", lambda s, t: bin_op(operator.pow)),\n",
    "])\n",
    "\n",
    "# 바이너리 연산자 함수. 스택에서 2개 항목을 추출(pop)하고, \n",
    "# 연산 처리 결과를 다시 스택에 넣는다(push).\n",
    "\n",
    "def bin_op(action):\n",
    "    op2, op1 = stack.pop(), stack.pop()\n",
    "    stack.append(action(op1, op2))\n",
    "\n",
    "def main():\n",
    "    a_list = open_rpn_file()\n",
    "    if not a_list:\n",
    "        print('Bye!')\n",
    "        return\n",
    "    \n",
    "    for a_line in a_list:\n",
    "        a_line = a_line.strip()\n",
    "        if a_line:\n",
    "            tokens, unknown = scanner.scan(a_line)\n",
    "            if unknown:\n",
    "                print('Unrecognized input:', unknown)\n",
    "            else:\n",
    "                print(str(stack[-1]))\n",
    "    \n",
    "def open_rpn_file():\n",
    "    '''소스-파일-열기 함수. 주어진 이름으로\n",
    "    파일을 열고, 반환된 줄을 리스트에 담는다.\n",
    "    '''\n",
    "    while True:\n",
    "        try:\n",
    "            fname = input('Enter RPN source: ')\n",
    "            f = open(fname, 'r')\n",
    "            if not f:\n",
    "                return None\n",
    "            else:\n",
    "                break\n",
    "        except:\n",
    "            print('File not found. Re-enter.')\n",
    "    a_list = f.readlines()\n",
    "    return a_list\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.9.3 RPN에 대입 연산자 추가하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "sym_tab = { }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "scanner = re.Scanner([\n",
    "    (r\"[ \\t\\n]\", lambda s, t: None),\n",
    "    (r\"[+-]*(\\d\\.)?\\d+\", lambda s, t:\n",
    "    stack.append(float(t))),\n",
    "    (r\"\\d+\", lambda s, t: stack.append(int(t))),\n",
    "    (r\"[a-zA-Z_][a-zA-Z_0-9]*\", lambda s, t:\n",
    "        stack. append (t)),\n",
    "    (r\"[+]\", lambda s, t: bin_op(operator.add)),\n",
    "    (r\"[-]\", lambda s, t: bin_op(operator.sub)),\n",
    "    (r\"[*]\", lambda s, t: bin_op(operator.mul)),\n",
    "    (r\"[/]\", lambda s, t: bin_op(operator.truediv)),\n",
    "    (r\"[\\^]\", lambda s, t: bin_op(operator.pow)),\n",
    "    (r\"[=]\", lambda s, t: assign_op()),\n",
    "])\n",
    "\n",
    "def assign_op():\n",
    "    op2, op1 = stack,pop(), stack.pop()\n",
    "    if type(op2) == str:    # op2 출처가 또 다른 변수일 수도 있음!\n",
    "        op2 = sym_tab[op2]\n",
    "    sym_tab[op1] = op2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bin_op(action):\n",
    "    op2, op1 = stack.pop(), stack.pop()\n",
    "    if type(op1) == str:\n",
    "        op1 = sym_tab[op1]\n",
    "    if type(op2) == str:\n",
    "        op2 = sym_tab[op2]\n",
    "    stack.append(action(op1, op2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter RPN source: rpn2.txt\n",
      "50.0\n"
     ]
    }
   ],
   "source": [
    " import re\n",
    "import operator\n",
    "\n",
    "\n",
    "# 심벌 테이블을 제공한다. 변수의 값들이 이곳에 저장된다.\n",
    "sym_tab = { }\n",
    "\n",
    "stack = []    # 값을 보관하기 위한 스택\n",
    "\n",
    "# 스캐너 객체. 각 토큰을 고립시키고, 상황에 맞는\n",
    "# 다음 작업을 수행한다. 숫자 값을 스택에 넣거나(push), \n",
    "# 연산자를 찾는 경우 스택 젤 위 항목 2개의\n",
    "# 연산을 수행한다.\n",
    "\n",
    "scanner = re.Scanner([\n",
    "    (r\"[ \\t\\n]\", lambda s, t: None),\n",
    "    (r\"[+-]*(\\d\\.)?\\d+\", lambda s, t:\n",
    "    stack.append(float(t))),\n",
    "    (r\"\\d+\", lambda s, t: stack.append(int(t))),\n",
    "    (r\"[a-zA-Z_][a-zA-Z_0-9]*\", lambda s, t:\n",
    "        stack. append (t)),\n",
    "    (r\"[+]\", lambda s, t: bin_op(operator.add)),\n",
    "    (r\"[-]\", lambda s, t: bin_op(operator.sub)),\n",
    "    (r\"[*]\", lambda s, t: bin_op(operator.mul)),\n",
    "    (r\"[/]\", lambda s, t: bin_op(operator.truediv)),\n",
    "    (r\"[\\^]\", lambda s, t: bin_op(operator.pow)),\n",
    "    (r\"[=]\", lambda s, t: assign_op()),\n",
    "])\n",
    "\n",
    "def assign_op():\n",
    "    '''대입 연산 함수: 이름과 값을 추출하여\n",
    "    심벌 테이블 항목을 만든다. op2가 문자열이면 심벌 테이블에서\n",
    "    찾아와야 한다(look up)는 것을 기억하자.\n",
    "    '''\n",
    "    op2, op1 = stack.pop(), stack.pop()\n",
    "    if type(op2) == str:    # op2 출처가 또 다른 변수일 수도 있음!\n",
    "        op2 = sym_tab[op2]\n",
    "    sym_tab[op1] = op2\n",
    "\n",
    "# 바이너리 연산자 함수. 스택에서 2개 항목을 추출(pop)하고, \n",
    "# 연산 처리 결과를 다시 스택에 넣는다(push).\n",
    "\n",
    "def bin_op(action):\n",
    "    '''바이너리 연산 계산기: 피연산자가 변수 이름이면\n",
    "    심벌 테이블에서 값을 찾아와서 연산하기 전에 값을 교체한다.'''\n",
    "    op2, op1 = stack.pop(), stack.pop()\n",
    "    if type(op1) == str:\n",
    "        op1 = sym_tab[op1]\n",
    "    if type(op2) == str:\n",
    "        op2 = sym_tab[op2]\n",
    "    stack.append(action(op1, op2))\n",
    "\n",
    "def main():\n",
    "    a_list = open_rpn_file()\n",
    "    if not a_list:\n",
    "        print('Bye!')\n",
    "        return\n",
    "    \n",
    "    for a_line in a_list:\n",
    "        a_line = a_line.strip()\n",
    "        if a_line:\n",
    "            tokens, unknown = scanner.scan(a_line)\n",
    "            if unknown:\n",
    "                print('Unrecognized input:', unknown)\n",
    "    print(str(stack[-1]))\n",
    "    \n",
    "def open_rpn_file():\n",
    "    '''소스-파일-열기 함수. 주어진 이름으로\n",
    "    파일을 열고, 반환된 줄을 리스트에 담는다.\n",
    "    '''\n",
    "    while True:\n",
    "        try:\n",
    "            fname = input('Enter RPN source: ')\n",
    "            f = open(fname, 'r')\n",
    "            if not f:\n",
    "                return None\n",
    "            else:\n",
    "                break\n",
    "        except:\n",
    "            print('File not found. Re-enter.')\n",
    "    a_list = f.readlines()\n",
    "    return a_list\n",
    "\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8.10 바이너리 직접 읽기/쓰기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('my.dat', 'wb') as f:\n",
    "    f.write(b'\\x01\\x02\\x03\\x10')\n",
    "    f.write(bytes([1, 2, 3, 0x10]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 16 1 2 3 16 "
     ]
    }
   ],
   "source": [
    "with open('my.dat', 'rb') as f:\n",
    "    bss = f.read()\n",
    "    for i in bss:\n",
    "        print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8.11 데이터를 고정-길이 필드로 변환(struct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.11.1 한번에 하나의 숫자 읽기/쓰기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "125\n"
     ]
    }
   ],
   "source": [
    "from struct import pack, unpack, calcsize\n",
    "\n",
    "def write_num(fname, n):\n",
    "    with open(fname, 'wb') as f:\n",
    "        bss = pack('h', n)\n",
    "        f.write(bss)\n",
    "        \n",
    "def read_num(fname):\n",
    "    with open(fname, 'rb') as f:\n",
    "        bss = f.read(calcsize('h'))\n",
    "        t = unpack('h', bss)\n",
    "        return t[0]\n",
    "    \n",
    "write_num('silly.dat', 125)\n",
    "print(read_num('silly.dat'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.11.2 한 번에 여러 숫자 읽기/쓰기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0 2.0 3.140000104904175\n"
     ]
    }
   ],
   "source": [
    "from struct import pack, unpack, calcsize\n",
    "\n",
    "def write_floats(fname, x, y, z):\n",
    "    with open(fname, 'wb') as f:\n",
    "        bss = pack('fff', x, y, z)\n",
    "        f.write(bss)\n",
    "        \n",
    "def read_floats(fname):\n",
    "    with open(fname, 'rb') as f:\n",
    "        bss = f.read(calcsize('fff'))\n",
    "        return unpack('fff', bss)\n",
    "    \n",
    "write_floats('silly.dat', 1, 2, 3.14)\n",
    "x, y, z = read_floats('silly.dat')\n",
    "print(x, y, z, sep=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.11.3 고정-길이 문자열 읽기/쓰기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm Henry the\n"
     ]
    }
   ],
   "source": [
    "from struct import pack, unpack, calcsize\n",
    "\n",
    "def write_fixed_str(fname, n, s):\n",
    "    with open(fname, 'wb') as f:\n",
    "        bss = pack(str(n) + 's', s.encode('utf-8'))\n",
    "        f.write(bss)\n",
    "        \n",
    "def read_fixed_str(fname, n):\n",
    "    with open(fname, 'rb') as f:\n",
    "        bss = f.read(n)\n",
    "        return bss.decode('utf-8')\n",
    "    \n",
    "write_fixed_str('king.d', 13, \"I'm Henry the VIII I am!\")\n",
    "print(read_fixed_str('king.d', 13))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.11.4 변수-길이 문자열 읽기/쓰기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm Henry the VIII I am!\n"
     ]
    }
   ],
   "source": [
    "from struct import pack, unpack, calcsize\n",
    "\n",
    "def write_var_str(fname, s):\n",
    "    with open(fname, 'wb') as f:\n",
    "        n = len(s)\n",
    "        fmt = 'h' + str(n) + 's'\n",
    "        bss = pack(fmt, n, s.encode('utf-8'))\n",
    "        f.write(bss)\n",
    "        \n",
    "def read_var_str(fname):\n",
    "    with open(fname, 'rb') as f:\n",
    "        bss = f.read(calcsize('h'))\n",
    "        n = unpack('h', bss)[0]\n",
    "        bss = f.read(n)\n",
    "        return bss.decode('utf-8')\n",
    "    \n",
    "write_var_str('silly.dat', \"I'm Henry the VIII I am!\")\n",
    "print(read_var_str('silly.dat'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.11.5 문자열과 숫자를 함께 읽기/쓰기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from struct import pack, unpack, calcsize\n",
    "\n",
    "def write_rec(fname, name, addr, rating):\n",
    "    with open(fname, 'wb') as f:\n",
    "        bname = name.encode('utf-8')\n",
    "        baddr = addr.encode('utf-8')\n",
    "        bss = pack('9s10sf', bname, baddr, rating)\n",
    "        f.write(bss)\n",
    "        \n",
    "def read_rec(fname):\n",
    "    with open(fname, 'rb') as f:\n",
    "        bss = f.read(calcsize('9s10sf'))\n",
    "        bname, baddr, rating = unpack('9s10sf', bss)\n",
    "        name = bname.decode('utf-8').rstrip('\\x00')\n",
    "        addr = baddr.decode('utf-8').rstrip('\\x00')\n",
    "        return name, addr, rating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Cleo', 'Main St.', 5.0)\n"
     ]
    }
   ],
   "source": [
    "write_rec('goofy.dat', 'Cleo', 'Main St.', 5.0)\n",
    "print(read_rec('goofy.dat'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8.11.6 저수준 상세: 빅 엔디안 vs 리틀 엔디안"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 100\n"
     ]
    }
   ],
   "source": [
    "import struct\n",
    "\n",
    "with open('junk.dat', 'wb') as f:\n",
    "    bstr = struct.pack('hhh', 1, 2, 100)\n",
    "    datalen = f.write(bstr)\n",
    "\n",
    "with open('junk.dat', 'rb') as f:\n",
    "    bstr = f.read(struct.calcsize('hhh'))\n",
    "    a, b, c = struct.unpack('hhh', bstr)\n",
    "    print(a, b, c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('junk.dat', 'wb') as f:\n",
    "    bstr = struct.pack('hhl', 1, 2, 100)\n",
    "    datalen = f.write(bstr)\n",
    "    \n",
    "with open('junk.dat', 'rb') as f:\n",
    "    bstr = f.read(struct.calcsize('hhl'))\n",
    "    a, b, c = struct.unpack('hhl', bstr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('junk.dat', 'wb') as f:\n",
    "    bstr = struct.pack('<hhl', 1, 2 ,100)\n",
    "    datalen = f.write(bstr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8.12 피클링 패키지 사용하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "import pickle\n",
    "pickle.dump(value, file_obj)  # 파일에 객체 쓰기\n",
    "value = pickle.load(file_obj) # 파일에서 객체 불러오기\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "with open('goo.dat', 'wb') as f:\n",
    "    pickle.dump([1, 2, 3], f)\n",
    "    pickle.dump('Hello!', f)\n",
    "    pickle.dump(3.141592, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'> [1, 2, 3]\n",
      "<class 'str'> Hello!\n",
      "<class 'float'> 3.141592\n"
     ]
    }
   ],
   "source": [
    "with open('goo.dat', 'rb') as f:\n",
    "    a = pickle.load(f)\n",
    "    b = pickle.load(f)\n",
    "    c = pickle.load(f)\n",
    "    print(type(a), a)\n",
    "    print(type(b), b)\n",
    "    print(type(c), c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The length of a is  3\n"
     ]
    }
   ],
   "source": [
    "if type(a) == list:\n",
    "    print('The length of a is ', len(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'> [1, 2, 3]\n",
      "<class 'str'> Hello!\n",
      "<class 'float'> 3.141592\n",
      "Loaded 3 items.\n"
     ]
    }
   ],
   "source": [
    "loaded = []\n",
    "with open('goo.dat', 'rb') as f:\n",
    "    while True:\n",
    "        try:\n",
    "            item = pickle.load(f)\n",
    "        except EOFError:\n",
    "            print('Loaded', len(loaded), 'items.')\n",
    "            break\n",
    "        print(type(item), item)\n",
    "        loaded.append(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8.13 shelve 패키지 사용하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "import shelve\n",
    "shelf_obj = shelve.open(db_name)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import shelve\n",
    "nums = shelve.open('numdb')\n",
    "nums['pi'] = (3.14192, False)\n",
    "nums['phi'] = (2.1828, False)\n",
    "nums['perfect'] = (6, True)\n",
    "nums.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pi\n",
      "phi\n",
      "perfect\n"
     ]
    }
   ],
   "source": [
    "nums = shelve.open('numdb')\n",
    "for thing in nums:\n",
    "    print(thing)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "nums.close()"
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}