Ch03-2-Functions-Library.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3 Python Standard Libraries\n",
    "\n",
    "<a href=\"https://colab.research.google.com/github/rambasnet/FDSPython-Notebooks/blob/master/Ch03-2-Functions-Library.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
    "\n",
    "## Topics\n",
    "- Python standard libraries\n",
    "- import and use libraries\n",
    "\n",
    "## 3.1 Standard libraries\n",
    "\n",
    "- Python has several standard libraries (modules) you can readily import\n",
    "- one can use the names (functions and data/constants) defined in those imported modules\n",
    "- list of all the Python standard libraries:\n",
    "https://docs.python.org/3/library/index.html\n",
    "\n",
    "- syntax\n",
    "\n",
    "```python\n",
    "# first import library\n",
    "import libraryName\n",
    "import awesomeLibrary\n",
    "import libraryName1 as mylib\n",
    "from libraryName2 import func1, func2 # okay!\n",
    "\n",
    "# use data and functions provided by the library\n",
    "libraryName.data\n",
    "libraryName.function()\n",
    "func1()\n",
    "mylib.someFunction()\n",
    "func2()\n",
    "```\n",
    "\n",
    "- according to PEP 8 Guildelines, each import must be on each line\n",
    "- importing comma separated multiple names from the same library is ok"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 math library\n",
    "https://docs.python.org/3/library/math.html\n",
    "\n",
    "- an important library that provides mathematical functions\n",
    "- run help(moduleName) to get more information about the module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module math:\n",
      "\n",
      "NAME\n",
      "    math\n",
      "\n",
      "MODULE REFERENCE\n",
      "    https://docs.python.org/3.7/library/math\n",
      "    \n",
      "    The following documentation is automatically generated from the Python\n",
      "    source files.  It may be incomplete, incorrect or include features that\n",
      "    are considered implementation detail and may vary between Python\n",
      "    implementations.  When in doubt, consult the module reference at the\n",
      "    location listed above.\n",
      "\n",
      "DESCRIPTION\n",
      "    This module is always available.  It provides access to the\n",
      "    mathematical functions defined by the C standard.\n",
      "\n",
      "FUNCTIONS\n",
      "    acos(x, /)\n",
      "        Return the arc cosine (measured in radians) of x.\n",
      "    \n",
      "    acosh(x, /)\n",
      "        Return the inverse hyperbolic cosine of x.\n",
      "    \n",
      "    asin(x, /)\n",
      "        Return the arc sine (measured in radians) of x.\n",
      "    \n",
      "    asinh(x, /)\n",
      "        Return the inverse hyperbolic sine of x.\n",
      "    \n",
      "    atan(x, /)\n",
      "        Return the arc tangent (measured in radians) of x.\n",
      "    \n",
      "    atan2(y, x, /)\n",
      "        Return the arc tangent (measured in radians) of y/x.\n",
      "        \n",
      "        Unlike atan(y/x), the signs of both x and y are considered.\n",
      "    \n",
      "    atanh(x, /)\n",
      "        Return the inverse hyperbolic tangent of x.\n",
      "    \n",
      "    ceil(x, /)\n",
      "        Return the ceiling of x as an Integral.\n",
      "        \n",
      "        This is the smallest integer >= x.\n",
      "    \n",
      "    copysign(x, y, /)\n",
      "        Return a float with the magnitude (absolute value) of x but the sign of y.\n",
      "        \n",
      "        On platforms that support signed zeros, copysign(1.0, -0.0)\n",
      "        returns -1.0.\n",
      "    \n",
      "    cos(x, /)\n",
      "        Return the cosine of x (measured in radians).\n",
      "    \n",
      "    cosh(x, /)\n",
      "        Return the hyperbolic cosine of x.\n",
      "    \n",
      "    degrees(x, /)\n",
      "        Convert angle x from radians to degrees.\n",
      "    \n",
      "    erf(x, /)\n",
      "        Error function at x.\n",
      "    \n",
      "    erfc(x, /)\n",
      "        Complementary error function at x.\n",
      "    \n",
      "    exp(x, /)\n",
      "        Return e raised to the power of x.\n",
      "    \n",
      "    expm1(x, /)\n",
      "        Return exp(x)-1.\n",
      "        \n",
      "        This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.\n",
      "    \n",
      "    fabs(x, /)\n",
      "        Return the absolute value of the float x.\n",
      "    \n",
      "    factorial(x, /)\n",
      "        Find x!.\n",
      "        \n",
      "        Raise a ValueError if x is negative or non-integral.\n",
      "    \n",
      "    floor(x, /)\n",
      "        Return the floor of x as an Integral.\n",
      "        \n",
      "        This is the largest integer <= x.\n",
      "    \n",
      "    fmod(x, y, /)\n",
      "        Return fmod(x, y), according to platform C.\n",
      "        \n",
      "        x % y may differ.\n",
      "    \n",
      "    frexp(x, /)\n",
      "        Return the mantissa and exponent of x, as pair (m, e).\n",
      "        \n",
      "        m is a float and e is an int, such that x = m * 2.**e.\n",
      "        If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.\n",
      "    \n",
      "    fsum(seq, /)\n",
      "        Return an accurate floating point sum of values in the iterable seq.\n",
      "        \n",
      "        Assumes IEEE-754 floating point arithmetic.\n",
      "    \n",
      "    gamma(x, /)\n",
      "        Gamma function at x.\n",
      "    \n",
      "    gcd(x, y, /)\n",
      "        greatest common divisor of x and y\n",
      "    \n",
      "    hypot(x, y, /)\n",
      "        Return the Euclidean distance, sqrt(x*x + y*y).\n",
      "    \n",
      "    isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)\n",
      "        Determine whether two floating point numbers are close in value.\n",
      "        \n",
      "          rel_tol\n",
      "            maximum difference for being considered \"close\", relative to the\n",
      "            magnitude of the input values\n",
      "          abs_tol\n",
      "            maximum difference for being considered \"close\", regardless of the\n",
      "            magnitude of the input values\n",
      "        \n",
      "        Return True if a is close in value to b, and False otherwise.\n",
      "        \n",
      "        For the values to be considered close, the difference between them\n",
      "        must be smaller than at least one of the tolerances.\n",
      "        \n",
      "        -inf, inf and NaN behave similarly to the IEEE 754 Standard.  That\n",
      "        is, NaN is not close to anything, even itself.  inf and -inf are\n",
      "        only close to themselves.\n",
      "    \n",
      "    isfinite(x, /)\n",
      "        Return True if x is neither an infinity nor a NaN, and False otherwise.\n",
      "    \n",
      "    isinf(x, /)\n",
      "        Return True if x is a positive or negative infinity, and False otherwise.\n",
      "    \n",
      "    isnan(x, /)\n",
      "        Return True if x is a NaN (not a number), and False otherwise.\n",
      "    \n",
      "    ldexp(x, i, /)\n",
      "        Return x * (2**i).\n",
      "        \n",
      "        This is essentially the inverse of frexp().\n",
      "    \n",
      "    lgamma(x, /)\n",
      "        Natural logarithm of absolute value of Gamma function at x.\n",
      "    \n",
      "    log(...)\n",
      "        log(x, [base=math.e])\n",
      "        Return the logarithm of x to the given base.\n",
      "        \n",
      "        If the base not specified, returns the natural logarithm (base e) of x.\n",
      "    \n",
      "    log10(x, /)\n",
      "        Return the base 10 logarithm of x.\n",
      "    \n",
      "    log1p(x, /)\n",
      "        Return the natural logarithm of 1+x (base e).\n",
      "        \n",
      "        The result is computed in a way which is accurate for x near zero.\n",
      "    \n",
      "    log2(x, /)\n",
      "        Return the base 2 logarithm of x.\n",
      "    \n",
      "    modf(x, /)\n",
      "        Return the fractional and integer parts of x.\n",
      "        \n",
      "        Both results carry the sign of x and are floats.\n",
      "    \n",
      "    pow(x, y, /)\n",
      "        Return x**y (x to the power of y).\n",
      "    \n",
      "    radians(x, /)\n",
      "        Convert angle x from degrees to radians.\n",
      "    \n",
      "    remainder(x, y, /)\n",
      "        Difference between x and the closest integer multiple of y.\n",
      "        \n",
      "        Return x - n*y where n*y is the closest integer multiple of y.\n",
      "        In the case where x is exactly halfway between two multiples of\n",
      "        y, the nearest even value of n is used. The result is always exact.\n",
      "    \n",
      "    sin(x, /)\n",
      "        Return the sine of x (measured in radians).\n",
      "    \n",
      "    sinh(x, /)\n",
      "        Return the hyperbolic sine of x.\n",
      "    \n",
      "    sqrt(x, /)\n",
      "        Return the square root of x.\n",
      "    \n",
      "    tan(x, /)\n",
      "        Return the tangent of x (measured in radians).\n",
      "    \n",
      "    tanh(x, /)\n",
      "        Return the hyperbolic tangent of x.\n",
      "    \n",
      "    trunc(x, /)\n",
      "        Truncates the Real x to the nearest Integral toward 0.\n",
      "        \n",
      "        Uses the __trunc__ magic method.\n",
      "\n",
      "DATA\n",
      "    e = 2.718281828459045\n",
      "    inf = inf\n",
      "    nan = nan\n",
      "    pi = 3.141592653589793\n",
      "    tau = 6.283185307179586\n",
      "\n",
      "FILE\n",
      "    /Users/rbasnet/anaconda3/lib/python3.7/lib-dynload/math.cpython-37m-darwin.so\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "num = 10.5\n",
    "# math.ceil(x) - return the ceiling (or round up) of x,\n",
    "# the smallest integer greater than or equal to x\n",
    "print(math.ceil(num))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "# math.floor(x)\n",
    "# return the floor (or round down) of x, the largest integer less than or equal to x\n",
    "print(math.floor(num))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# math.gcd(a, b)\n",
    "# return the greatest common divisor of the integers a and b\n",
    "# if both and b are 0, returns 0\n",
    "print(math.gcd(0, 0))\n",
    "print(math.gcd(10, 20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1024.0\n"
     ]
    }
   ],
   "source": [
    "# math.pow(x, y)\n",
    "# returns x raised to the power y\n",
    "print(math.pow(2, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.0\n"
     ]
    }
   ],
   "source": [
    "# math.sqrt(x, y)\n",
    "# returns the square root of x\n",
    "print(math.sqrt(100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# math.radians(x)\n",
    "# convert and return angle x in degrees to radians\n",
    "rad = math.radians(90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "# math.sin(x)\n",
    "# return the sine of x radians\n",
    "print(math.sin(rad))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Some constants/data defined in math module\n",
    "math.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "inf"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.inf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.718281828459045"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3 Other common libraries\n",
    "\n",
    "- all Python libraries: https://docs.python.org/3/library/index.html\n",
    "- some libraries we'll explore\n",
    "    - **os** - operating system related\n",
    "    - **time** - time access and conversion\n",
    "    - **random** - generate pseudo-random numbers\n",
    "    - **sys** - system specific data and functions\n",
    "    - **string** - common string operations and data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module random:\n",
      "\n",
      "NAME\n",
      "    random - Random variable generators.\n",
      "\n",
      "MODULE REFERENCE\n",
      "    https://docs.python.org/3.7/library/random\n",
      "    \n",
      "    The following documentation is automatically generated from the Python\n",
      "    source files.  It may be incomplete, incorrect or include features that\n",
      "    are considered implementation detail and may vary between Python\n",
      "    implementations.  When in doubt, consult the module reference at the\n",
      "    location listed above.\n",
      "\n",
      "DESCRIPTION\n",
      "        integers\n",
      "        --------\n",
      "               uniform within range\n",
      "    \n",
      "        sequences\n",
      "        ---------\n",
      "               pick random element\n",
      "               pick random sample\n",
      "               pick weighted random sample\n",
      "               generate random permutation\n",
      "    \n",
      "        distributions on the real line:\n",
      "        ------------------------------\n",
      "               uniform\n",
      "               triangular\n",
      "               normal (Gaussian)\n",
      "               lognormal\n",
      "               negative exponential\n",
      "               gamma\n",
      "               beta\n",
      "               pareto\n",
      "               Weibull\n",
      "    \n",
      "        distributions on the circle (angles 0 to 2pi)\n",
      "        ---------------------------------------------\n",
      "               circular uniform\n",
      "               von Mises\n",
      "    \n",
      "    General notes on the underlying Mersenne Twister core generator:\n",
      "    \n",
      "    * The period is 2**19937-1.\n",
      "    * It is one of the most extensively tested generators in existence.\n",
      "    * The random() method is implemented in C, executes in a single Python step,\n",
      "      and is, therefore, threadsafe.\n",
      "\n",
      "CLASSES\n",
      "    _random.Random(builtins.object)\n",
      "        Random\n",
      "            SystemRandom\n",
      "    \n",
      "    class Random(_random.Random)\n",
      "     |  Random(x=None)\n",
      "     |  \n",
      "     |  Random number generator base class used by bound module functions.\n",
      "     |  \n",
      "     |  Used to instantiate instances of Random to get generators that don't\n",
      "     |  share state.\n",
      "     |  \n",
      "     |  Class Random can also be subclassed if you want to use a different basic\n",
      "     |  generator of your own devising: in that case, override the following\n",
      "     |  methods:  random(), seed(), getstate(), and setstate().\n",
      "     |  Optionally, implement a getrandbits() method so that randrange()\n",
      "     |  can cover arbitrarily large ranges.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      Random\n",
      "     |      _random.Random\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getstate__(self)\n",
      "     |      # Issue 17489: Since __reduce__ was defined to fix #759889 this is no\n",
      "     |      # longer called; we leave it here because it has been here since random was\n",
      "     |      # rewritten back in 2001 and why risk breaking something.\n",
      "     |  \n",
      "     |  __init__(self, x=None)\n",
      "     |      Initialize an instance.\n",
      "     |      \n",
      "     |      Optional argument x controls seeding, as for Random.seed().\n",
      "     |  \n",
      "     |  __reduce__(self)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __setstate__(self, state)\n",
      "     |  \n",
      "     |  betavariate(self, alpha, beta)\n",
      "     |      Beta distribution.\n",
      "     |      \n",
      "     |      Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "     |      Returned values range between 0 and 1.\n",
      "     |  \n",
      "     |  choice(self, seq)\n",
      "     |      Choose a random element from a non-empty sequence.\n",
      "     |  \n",
      "     |  choices(self, population, weights=None, *, cum_weights=None, k=1)\n",
      "     |      Return a k sized list of population elements chosen with replacement.\n",
      "     |      \n",
      "     |      If the relative weights or cumulative weights are not specified,\n",
      "     |      the selections are made with equal probability.\n",
      "     |  \n",
      "     |  expovariate(self, lambd)\n",
      "     |      Exponential distribution.\n",
      "     |      \n",
      "     |      lambd is 1.0 divided by the desired mean.  It should be\n",
      "     |      nonzero.  (The parameter would be called \"lambda\", but that is\n",
      "     |      a reserved word in Python.)  Returned values range from 0 to\n",
      "     |      positive infinity if lambd is positive, and from negative\n",
      "     |      infinity to 0 if lambd is negative.\n",
      "     |  \n",
      "     |  gammavariate(self, alpha, beta)\n",
      "     |      Gamma distribution.  Not the gamma function!\n",
      "     |      \n",
      "     |      Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "     |      \n",
      "     |      The probability distribution function is:\n",
      "     |      \n",
      "     |                  x ** (alpha - 1) * math.exp(-x / beta)\n",
      "     |        pdf(x) =  --------------------------------------\n",
      "     |                    math.gamma(alpha) * beta ** alpha\n",
      "     |  \n",
      "     |  gauss(self, mu, sigma)\n",
      "     |      Gaussian distribution.\n",
      "     |      \n",
      "     |      mu is the mean, and sigma is the standard deviation.  This is\n",
      "     |      slightly faster than the normalvariate() function.\n",
      "     |      \n",
      "     |      Not thread-safe without a lock around calls.\n",
      "     |  \n",
      "     |  getstate(self)\n",
      "     |      Return internal state; can be passed to setstate() later.\n",
      "     |  \n",
      "     |  lognormvariate(self, mu, sigma)\n",
      "     |      Log normal distribution.\n",
      "     |      \n",
      "     |      If you take the natural logarithm of this distribution, you'll get a\n",
      "     |      normal distribution with mean mu and standard deviation sigma.\n",
      "     |      mu can have any value, and sigma must be greater than zero.\n",
      "     |  \n",
      "     |  normalvariate(self, mu, sigma)\n",
      "     |      Normal distribution.\n",
      "     |      \n",
      "     |      mu is the mean, and sigma is the standard deviation.\n",
      "     |  \n",
      "     |  paretovariate(self, alpha)\n",
      "     |      Pareto distribution.  alpha is the shape parameter.\n",
      "     |  \n",
      "     |  randint(self, a, b)\n",
      "     |      Return random integer in range [a, b], including both end points.\n",
      "     |  \n",
      "     |  randrange(self, start, stop=None, step=1, _int=<class 'int'>)\n",
      "     |      Choose a random item from range(start, stop[, step]).\n",
      "     |      \n",
      "     |      This fixes the problem with randint() which includes the\n",
      "     |      endpoint; in Python this is usually not what you want.\n",
      "     |  \n",
      "     |  sample(self, population, k)\n",
      "     |      Chooses k unique random elements from a population sequence or set.\n",
      "     |      \n",
      "     |      Returns a new list containing elements from the population while\n",
      "     |      leaving the original population unchanged.  The resulting list is\n",
      "     |      in selection order so that all sub-slices will also be valid random\n",
      "     |      samples.  This allows raffle winners (the sample) to be partitioned\n",
      "     |      into grand prize and second place winners (the subslices).\n",
      "     |      \n",
      "     |      Members of the population need not be hashable or unique.  If the\n",
      "     |      population contains repeats, then each occurrence is a possible\n",
      "     |      selection in the sample.\n",
      "     |      \n",
      "     |      To choose a sample in a range of integers, use range as an argument.\n",
      "     |      This is especially fast and space efficient for sampling from a\n",
      "     |      large population:   sample(range(10000000), 60)\n",
      "     |  \n",
      "     |  seed(self, a=None, version=2)\n",
      "     |      Initialize internal state from hashable object.\n",
      "     |      \n",
      "     |      None or no argument seeds from current time or from an operating\n",
      "     |      system specific randomness source if available.\n",
      "     |      \n",
      "     |      If *a* is an int, all bits are used.\n",
      "     |      \n",
      "     |      For version 2 (the default), all of the bits are used if *a* is a str,\n",
      "     |      bytes, or bytearray.  For version 1 (provided for reproducing random\n",
      "     |      sequences from older versions of Python), the algorithm for str and\n",
      "     |      bytes generates a narrower range of seeds.\n",
      "     |  \n",
      "     |  setstate(self, state)\n",
      "     |      Restore internal state from object returned by getstate().\n",
      "     |  \n",
      "     |  shuffle(self, x, random=None)\n",
      "     |      Shuffle list x in place, and return None.\n",
      "     |      \n",
      "     |      Optional argument random is a 0-argument function returning a\n",
      "     |      random float in [0.0, 1.0); if it is the default None, the\n",
      "     |      standard random.random will be used.\n",
      "     |  \n",
      "     |  triangular(self, low=0.0, high=1.0, mode=None)\n",
      "     |      Triangular distribution.\n",
      "     |      \n",
      "     |      Continuous distribution bounded by given lower and upper limits,\n",
      "     |      and having a given mode value in-between.\n",
      "     |      \n",
      "     |      http://en.wikipedia.org/wiki/Triangular_distribution\n",
      "     |  \n",
      "     |  uniform(self, a, b)\n",
      "     |      Get a random number in the range [a, b) or [a, b] depending on rounding.\n",
      "     |  \n",
      "     |  vonmisesvariate(self, mu, kappa)\n",
      "     |      Circular data distribution.\n",
      "     |      \n",
      "     |      mu is the mean angle, expressed in radians between 0 and 2*pi, and\n",
      "     |      kappa is the concentration parameter, which must be greater than or\n",
      "     |      equal to zero.  If kappa is equal to zero, this distribution reduces\n",
      "     |      to a uniform random angle over the range 0 to 2*pi.\n",
      "     |  \n",
      "     |  weibullvariate(self, alpha, beta)\n",
      "     |      Weibull distribution.\n",
      "     |      \n",
      "     |      alpha is the scale parameter and beta is the shape parameter.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  VERSION = 3\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from _random.Random:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  getrandbits(...)\n",
      "     |      getrandbits(k) -> x.  Generates an int with k random bits.\n",
      "     |  \n",
      "     |  random(...)\n",
      "     |      random() -> x in the interval [0, 1).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods inherited from _random.Random:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class SystemRandom(Random)\n",
      "     |  SystemRandom(x=None)\n",
      "     |  \n",
      "     |  Alternate random number generator using sources provided\n",
      "     |  by the operating system (such as /dev/urandom on Unix or\n",
      "     |  CryptGenRandom on Windows).\n",
      "     |  \n",
      "     |   Not available on all systems (see os.urandom() for details).\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      SystemRandom\n",
      "     |      Random\n",
      "     |      _random.Random\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  getrandbits(self, k)\n",
      "     |      getrandbits(k) -> x.  Generates an int with k random bits.\n",
      "     |  \n",
      "     |  getstate = _notimplemented(self, *args, **kwds)\n",
      "     |  \n",
      "     |  random(self)\n",
      "     |      Get the next random number in the range [0.0, 1.0).\n",
      "     |  \n",
      "     |  seed(self, *args, **kwds)\n",
      "     |      Stub method.  Not used for a system random number generator.\n",
      "     |  \n",
      "     |  setstate = _notimplemented(self, *args, **kwds)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from Random:\n",
      "     |  \n",
      "     |  __getstate__(self)\n",
      "     |      # Issue 17489: Since __reduce__ was defined to fix #759889 this is no\n",
      "     |      # longer called; we leave it here because it has been here since random was\n",
      "     |      # rewritten back in 2001 and why risk breaking something.\n",
      "     |  \n",
      "     |  __init__(self, x=None)\n",
      "     |      Initialize an instance.\n",
      "     |      \n",
      "     |      Optional argument x controls seeding, as for Random.seed().\n",
      "     |  \n",
      "     |  __reduce__(self)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __setstate__(self, state)\n",
      "     |  \n",
      "     |  betavariate(self, alpha, beta)\n",
      "     |      Beta distribution.\n",
      "     |      \n",
      "     |      Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "     |      Returned values range between 0 and 1.\n",
      "     |  \n",
      "     |  choice(self, seq)\n",
      "     |      Choose a random element from a non-empty sequence.\n",
      "     |  \n",
      "     |  choices(self, population, weights=None, *, cum_weights=None, k=1)\n",
      "     |      Return a k sized list of population elements chosen with replacement.\n",
      "     |      \n",
      "     |      If the relative weights or cumulative weights are not specified,\n",
      "     |      the selections are made with equal probability.\n",
      "     |  \n",
      "     |  expovariate(self, lambd)\n",
      "     |      Exponential distribution.\n",
      "     |      \n",
      "     |      lambd is 1.0 divided by the desired mean.  It should be\n",
      "     |      nonzero.  (The parameter would be called \"lambda\", but that is\n",
      "     |      a reserved word in Python.)  Returned values range from 0 to\n",
      "     |      positive infinity if lambd is positive, and from negative\n",
      "     |      infinity to 0 if lambd is negative.\n",
      "     |  \n",
      "     |  gammavariate(self, alpha, beta)\n",
      "     |      Gamma distribution.  Not the gamma function!\n",
      "     |      \n",
      "     |      Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "     |      \n",
      "     |      The probability distribution function is:\n",
      "     |      \n",
      "     |                  x ** (alpha - 1) * math.exp(-x / beta)\n",
      "     |        pdf(x) =  --------------------------------------\n",
      "     |                    math.gamma(alpha) * beta ** alpha\n",
      "     |  \n",
      "     |  gauss(self, mu, sigma)\n",
      "     |      Gaussian distribution.\n",
      "     |      \n",
      "     |      mu is the mean, and sigma is the standard deviation.  This is\n",
      "     |      slightly faster than the normalvariate() function.\n",
      "     |      \n",
      "     |      Not thread-safe without a lock around calls.\n",
      "     |  \n",
      "     |  lognormvariate(self, mu, sigma)\n",
      "     |      Log normal distribution.\n",
      "     |      \n",
      "     |      If you take the natural logarithm of this distribution, you'll get a\n",
      "     |      normal distribution with mean mu and standard deviation sigma.\n",
      "     |      mu can have any value, and sigma must be greater than zero.\n",
      "     |  \n",
      "     |  normalvariate(self, mu, sigma)\n",
      "     |      Normal distribution.\n",
      "     |      \n",
      "     |      mu is the mean, and sigma is the standard deviation.\n",
      "     |  \n",
      "     |  paretovariate(self, alpha)\n",
      "     |      Pareto distribution.  alpha is the shape parameter.\n",
      "     |  \n",
      "     |  randint(self, a, b)\n",
      "     |      Return random integer in range [a, b], including both end points.\n",
      "     |  \n",
      "     |  randrange(self, start, stop=None, step=1, _int=<class 'int'>)\n",
      "     |      Choose a random item from range(start, stop[, step]).\n",
      "     |      \n",
      "     |      This fixes the problem with randint() which includes the\n",
      "     |      endpoint; in Python this is usually not what you want.\n",
      "     |  \n",
      "     |  sample(self, population, k)\n",
      "     |      Chooses k unique random elements from a population sequence or set.\n",
      "     |      \n",
      "     |      Returns a new list containing elements from the population while\n",
      "     |      leaving the original population unchanged.  The resulting list is\n",
      "     |      in selection order so that all sub-slices will also be valid random\n",
      "     |      samples.  This allows raffle winners (the sample) to be partitioned\n",
      "     |      into grand prize and second place winners (the subslices).\n",
      "     |      \n",
      "     |      Members of the population need not be hashable or unique.  If the\n",
      "     |      population contains repeats, then each occurrence is a possible\n",
      "     |      selection in the sample.\n",
      "     |      \n",
      "     |      To choose a sample in a range of integers, use range as an argument.\n",
      "     |      This is especially fast and space efficient for sampling from a\n",
      "     |      large population:   sample(range(10000000), 60)\n",
      "     |  \n",
      "     |  shuffle(self, x, random=None)\n",
      "     |      Shuffle list x in place, and return None.\n",
      "     |      \n",
      "     |      Optional argument random is a 0-argument function returning a\n",
      "     |      random float in [0.0, 1.0); if it is the default None, the\n",
      "     |      standard random.random will be used.\n",
      "     |  \n",
      "     |  triangular(self, low=0.0, high=1.0, mode=None)\n",
      "     |      Triangular distribution.\n",
      "     |      \n",
      "     |      Continuous distribution bounded by given lower and upper limits,\n",
      "     |      and having a given mode value in-between.\n",
      "     |      \n",
      "     |      http://en.wikipedia.org/wiki/Triangular_distribution\n",
      "     |  \n",
      "     |  uniform(self, a, b)\n",
      "     |      Get a random number in the range [a, b) or [a, b] depending on rounding.\n",
      "     |  \n",
      "     |  vonmisesvariate(self, mu, kappa)\n",
      "     |      Circular data distribution.\n",
      "     |      \n",
      "     |      mu is the mean angle, expressed in radians between 0 and 2*pi, and\n",
      "     |      kappa is the concentration parameter, which must be greater than or\n",
      "     |      equal to zero.  If kappa is equal to zero, this distribution reduces\n",
      "     |      to a uniform random angle over the range 0 to 2*pi.\n",
      "     |  \n",
      "     |  weibullvariate(self, alpha, beta)\n",
      "     |      Weibull distribution.\n",
      "     |      \n",
      "     |      alpha is the scale parameter and beta is the shape parameter.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors inherited from Random:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes inherited from Random:\n",
      "     |  \n",
      "     |  VERSION = 3\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from _random.Random:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods inherited from _random.Random:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "\n",
      "FUNCTIONS\n",
      "    betavariate(alpha, beta) method of Random instance\n",
      "        Beta distribution.\n",
      "        \n",
      "        Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "        Returned values range between 0 and 1.\n",
      "    \n",
      "    choice(seq) method of Random instance\n",
      "        Choose a random element from a non-empty sequence.\n",
      "    \n",
      "    choices(population, weights=None, *, cum_weights=None, k=1) method of Random instance\n",
      "        Return a k sized list of population elements chosen with replacement.\n",
      "        \n",
      "        If the relative weights or cumulative weights are not specified,\n",
      "        the selections are made with equal probability.\n",
      "    \n",
      "    expovariate(lambd) method of Random instance\n",
      "        Exponential distribution.\n",
      "        \n",
      "        lambd is 1.0 divided by the desired mean.  It should be\n",
      "        nonzero.  (The parameter would be called \"lambda\", but that is\n",
      "        a reserved word in Python.)  Returned values range from 0 to\n",
      "        positive infinity if lambd is positive, and from negative\n",
      "        infinity to 0 if lambd is negative.\n",
      "    \n",
      "    gammavariate(alpha, beta) method of Random instance\n",
      "        Gamma distribution.  Not the gamma function!\n",
      "        \n",
      "        Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "        \n",
      "        The probability distribution function is:\n",
      "        \n",
      "                    x ** (alpha - 1) * math.exp(-x / beta)\n",
      "          pdf(x) =  --------------------------------------\n",
      "                      math.gamma(alpha) * beta ** alpha\n",
      "    \n",
      "    gauss(mu, sigma) method of Random instance\n",
      "        Gaussian distribution.\n",
      "        \n",
      "        mu is the mean, and sigma is the standard deviation.  This is\n",
      "        slightly faster than the normalvariate() function.\n",
      "        \n",
      "        Not thread-safe without a lock around calls.\n",
      "    \n",
      "    getrandbits(...) method of Random instance\n",
      "        getrandbits(k) -> x.  Generates an int with k random bits.\n",
      "    \n",
      "    getstate() method of Random instance\n",
      "        Return internal state; can be passed to setstate() later.\n",
      "    \n",
      "    lognormvariate(mu, sigma) method of Random instance\n",
      "        Log normal distribution.\n",
      "        \n",
      "        If you take the natural logarithm of this distribution, you'll get a\n",
      "        normal distribution with mean mu and standard deviation sigma.\n",
      "        mu can have any value, and sigma must be greater than zero.\n",
      "    \n",
      "    normalvariate(mu, sigma) method of Random instance\n",
      "        Normal distribution.\n",
      "        \n",
      "        mu is the mean, and sigma is the standard deviation.\n",
      "    \n",
      "    paretovariate(alpha) method of Random instance\n",
      "        Pareto distribution.  alpha is the shape parameter.\n",
      "    \n",
      "    randint(a, b) method of Random instance\n",
      "        Return random integer in range [a, b], including both end points.\n",
      "    \n",
      "    random(...) method of Random instance\n",
      "        random() -> x in the interval [0, 1).\n",
      "    \n",
      "    randrange(start, stop=None, step=1, _int=<class 'int'>) method of Random instance\n",
      "        Choose a random item from range(start, stop[, step]).\n",
      "        \n",
      "        This fixes the problem with randint() which includes the\n",
      "        endpoint; in Python this is usually not what you want.\n",
      "    \n",
      "    sample(population, k) method of Random instance\n",
      "        Chooses k unique random elements from a population sequence or set.\n",
      "        \n",
      "        Returns a new list containing elements from the population while\n",
      "        leaving the original population unchanged.  The resulting list is\n",
      "        in selection order so that all sub-slices will also be valid random\n",
      "        samples.  This allows raffle winners (the sample) to be partitioned\n",
      "        into grand prize and second place winners (the subslices).\n",
      "        \n",
      "        Members of the population need not be hashable or unique.  If the\n",
      "        population contains repeats, then each occurrence is a possible\n",
      "        selection in the sample.\n",
      "        \n",
      "        To choose a sample in a range of integers, use range as an argument.\n",
      "        This is especially fast and space efficient for sampling from a\n",
      "        large population:   sample(range(10000000), 60)\n",
      "    \n",
      "    seed(a=None, version=2) method of Random instance\n",
      "        Initialize internal state from hashable object.\n",
      "        \n",
      "        None or no argument seeds from current time or from an operating\n",
      "        system specific randomness source if available.\n",
      "        \n",
      "        If *a* is an int, all bits are used.\n",
      "        \n",
      "        For version 2 (the default), all of the bits are used if *a* is a str,\n",
      "        bytes, or bytearray.  For version 1 (provided for reproducing random\n",
      "        sequences from older versions of Python), the algorithm for str and\n",
      "        bytes generates a narrower range of seeds.\n",
      "    \n",
      "    setstate(state) method of Random instance\n",
      "        Restore internal state from object returned by getstate().\n",
      "    \n",
      "    shuffle(x, random=None) method of Random instance\n",
      "        Shuffle list x in place, and return None.\n",
      "        \n",
      "        Optional argument random is a 0-argument function returning a\n",
      "        random float in [0.0, 1.0); if it is the default None, the\n",
      "        standard random.random will be used.\n",
      "    \n",
      "    triangular(low=0.0, high=1.0, mode=None) method of Random instance\n",
      "        Triangular distribution.\n",
      "        \n",
      "        Continuous distribution bounded by given lower and upper limits,\n",
      "        and having a given mode value in-between.\n",
      "        \n",
      "        http://en.wikipedia.org/wiki/Triangular_distribution\n",
      "    \n",
      "    uniform(a, b) method of Random instance\n",
      "        Get a random number in the range [a, b) or [a, b] depending on rounding.\n",
      "    \n",
      "    vonmisesvariate(mu, kappa) method of Random instance\n",
      "        Circular data distribution.\n",
      "        \n",
      "        mu is the mean angle, expressed in radians between 0 and 2*pi, and\n",
      "        kappa is the concentration parameter, which must be greater than or\n",
      "        equal to zero.  If kappa is equal to zero, this distribution reduces\n",
      "        to a uniform random angle over the range 0 to 2*pi.\n",
      "    \n",
      "    weibullvariate(alpha, beta) method of Random instance\n",
      "        Weibull distribution.\n",
      "        \n",
      "        alpha is the scale parameter and beta is the shape parameter.\n",
      "\n",
      "DATA\n",
      "    __all__ = ['Random', 'seed', 'random', 'uniform', 'randint', 'choice',...\n",
      "\n",
      "FILE\n",
      "    /Users/rbasnet/anaconda3/lib/python3.7/random.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(random)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "randint(0, 20) # Return a random integer between (a, b) inclusive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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",
      "MODULE REFERENCE\n",
      "    https://docs.python.org/3.8/library/os\n",
      "    \n",
      "    The following documentation is automatically generated from the Python\n",
      "    source files.  It may be incomplete, incorrect or include features that\n",
      "    are considered implementation detail and may vary between Python\n",
      "    implementations.  When in doubt, consult the module reference at the\n",
      "    location listed above.\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",
      "        posix.DirEntry\n",
      "    builtins.tuple(builtins.object)\n",
      "        stat_result\n",
      "        statvfs_result\n",
      "        terminal_size\n",
      "        posix.times_result\n",
      "        posix.uname_result\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",
      "     |  Built-in subclasses:\n",
      "     |      BlockingIOError\n",
      "     |      ChildProcessError\n",
      "     |      ConnectionError\n",
      "     |      FileExistsError\n",
      "     |      ... and 7 other subclasses\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",
      "     |  ----------------------------------------------------------------------\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_birthtime\n",
      "     |      time of creation\n",
      "     |  \n",
      "     |  st_blksize\n",
      "     |      blocksize for filesystem I/O\n",
      "     |  \n",
      "     |  st_blocks\n",
      "     |      number of blocks allocated\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_flags\n",
      "     |      user defined flags for file\n",
      "     |  \n",
      "     |  st_gen\n",
      "     |      generation number\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_rdev\n",
      "     |      device type (if inode device)\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 = 22\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",
      "    WCOREDUMP(status, /)\n",
      "        Return True if the process returning status was dumped to a core file.\n",
      "    \n",
      "    WEXITSTATUS(status)\n",
      "        Return the process return code from status.\n",
      "    \n",
      "    WIFCONTINUED(status)\n",
      "        Return True if a particular process was continued from a job control stop.\n",
      "        \n",
      "        Return True if the process returning status was continued from a\n",
      "        job control stop.\n",
      "    \n",
      "    WIFEXITED(status)\n",
      "        Return True if the process returning status exited via the exit() system call.\n",
      "    \n",
      "    WIFSIGNALED(status)\n",
      "        Return True if the process returning status was terminated by a signal.\n",
      "    \n",
      "    WIFSTOPPED(status)\n",
      "        Return True if the process returning status was stopped.\n",
      "    \n",
      "    WSTOPSIG(status)\n",
      "        Return the signal that stopped the process that provided the status value.\n",
      "    \n",
      "    WTERMSIG(status)\n",
      "        Return the signal that terminated the process that provided the status value.\n",
      "    \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",
      "    chflags(path, flags, follow_symlinks=True)\n",
      "        Set file flags.\n",
      "        \n",
      "        If follow_symlinks is False, and the last element of the path is a symbolic\n",
      "          link, chflags will change flags on the symbolic link itself instead of the\n",
      "          file the link points to.\n",
      "        follow_symlinks may not be implemented on your platform.  If it is\n",
      "        unavailable, using it will raise a NotImplementedError.\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",
      "    chown(path, uid, gid, *, dir_fd=None, follow_symlinks=True)\n",
      "        Change the owner and group id of path to the numeric uid and gid.\\\n",
      "        \n",
      "          path\n",
      "            Path to be examined; can be string, bytes, a path-like object, or 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 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",
      "            stat will examine the symbolic link itself instead of the file\n",
      "            the link points to.\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",
      "        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, chown 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 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",
      "    chroot(path)\n",
      "        Change root directory to path.\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",
      "    confstr(name, /)\n",
      "        Return a string-valued system configuration variable.\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",
      "    ctermid()\n",
      "        Return the name of the controlling terminal for this process.\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",
      "    fchdir(fd)\n",
      "        Change to the directory of the given file descriptor.\n",
      "        \n",
      "        fd must be opened on a directory, not a file.\n",
      "        Equivalent to os.chdir(fd).\n",
      "    \n",
      "    fchmod(fd, mode)\n",
      "        Change the access permissions of the file given by file descriptor fd.\n",
      "        \n",
      "        Equivalent to os.chmod(fd, mode).\n",
      "    \n",
      "    fchown(fd, uid, gid)\n",
      "        Change the owner and group id of the file specified by file descriptor.\n",
      "        \n",
      "        Equivalent to os.chown(fd, uid, gid).\n",
      "    \n",
      "    fdopen(fd, *args, **kwargs)\n",
      "        # Supply os.fdopen()\n",
      "    \n",
      "    fork()\n",
      "        Fork a child process.\n",
      "        \n",
      "        Return 0 to child process and PID of child to parent process.\n",
      "    \n",
      "    forkpty()\n",
      "        Fork a new process with a new pseudo-terminal as controlling tty.\n",
      "        \n",
      "        Returns a tuple of (pid, master_fd).\n",
      "        Like fork(), return pid of 0 to the child process,\n",
      "        and pid of child to the parent process.\n",
      "        To both, return fd of newly opened pseudo-terminal.\n",
      "    \n",
      "    fpathconf(fd, name, /)\n",
      "        Return the configuration limit name for the file descriptor fd.\n",
      "        \n",
      "        If there is no limit, return -1.\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",
      "    fstatvfs(fd, /)\n",
      "        Perform an fstatvfs system call on the given fd.\n",
      "        \n",
      "        Equivalent to statvfs(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",
      "    fwalk(top='.', topdown=True, onerror=None, *, follow_symlinks=False, dir_fd=None)\n",
      "        Directory tree generator.\n",
      "        \n",
      "        This behaves exactly like walk(), except that it yields a 4-tuple\n",
      "        \n",
      "            dirpath, dirnames, filenames, dirfd\n",
      "        \n",
      "        `dirpath`, `dirnames` and `filenames` are identical to walk() output,\n",
      "        and `dirfd` is a file descriptor referring to the directory `dirpath`.\n",
      "        \n",
      "        The advantage of fwalk() over walk() is that it's safe against symlink\n",
      "        races (when follow_symlinks is False).\n",
      "        \n",
      "        If dir_fd is not None, it should be a file descriptor open to a directory,\n",
      "          and top should be relative; top will then be relative to that directory.\n",
      "          (dir_fd is always supported for fwalk.)\n",
      "        \n",
      "        Caution:\n",
      "        Since fwalk() yields file descriptors, those are only valid until the\n",
      "        next iteration step, so you should dup() them if you want to keep them\n",
      "        for a longer period.\n",
      "        \n",
      "        Example:\n",
      "        \n",
      "        import os\n",
      "        for root, dirs, files, rootfd in os.fwalk('python/Lib/email'):\n",
      "            print(root, \"consumes\", end=\"\")\n",
      "            print(sum(os.stat(name, dir_fd=rootfd).st_size for name in files),\n",
      "                  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",
      "    get_blocking(fd, /)\n",
      "        Get the blocking mode of the file descriptor.\n",
      "        \n",
      "        Return False if the O_NONBLOCK flag is set, True if the flag is cleared.\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_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",
      "    getegid()\n",
      "        Return the current process's effective group id.\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",
      "    getenvb(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 bytes.\n",
      "    \n",
      "    geteuid()\n",
      "        Return the current process's effective user id.\n",
      "    \n",
      "    getgid()\n",
      "        Return the current process's group id.\n",
      "    \n",
      "    getgrouplist(...)\n",
      "        getgrouplist(user, group) -> list of groups to which a user belongs\n",
      "        \n",
      "        Returns a list of groups to which a user belongs.\n",
      "        \n",
      "            user: username to lookup\n",
      "            group: base group id of the user\n",
      "    \n",
      "    getgroups()\n",
      "        Return list of supplemental group IDs for the process.\n",
      "    \n",
      "    getloadavg()\n",
      "        Return average recent system load information.\n",
      "        \n",
      "        Return the number of processes in the system run queue averaged over\n",
      "        the last 1, 5, and 15 minutes as a tuple of three floats.\n",
      "        Raises OSError if the load average was unobtainable.\n",
      "    \n",
      "    getlogin()\n",
      "        Return the actual login name.\n",
      "    \n",
      "    getpgid(pid)\n",
      "        Call the system call getpgid(), and return the result.\n",
      "    \n",
      "    getpgrp()\n",
      "        Return the current process group id.\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",
      "    getpriority(which, who)\n",
      "        Return program scheduling priority.\n",
      "    \n",
      "    getsid(pid, /)\n",
      "        Call the system call getsid(pid) and return the result.\n",
      "    \n",
      "    getuid()\n",
      "        Return the current process's user id.\n",
      "    \n",
      "    initgroups(...)\n",
      "        initgroups(username, gid) -> None\n",
      "        \n",
      "        Call the system initgroups() to initialize the group access list with all of\n",
      "        the groups of which the specified username is a member, plus the specified\n",
      "        group id.\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",
      "    killpg(pgid, signal, /)\n",
      "        Kill a process group with a signal.\n",
      "    \n",
      "    lchflags(path, flags)\n",
      "        Set file flags.\n",
      "        \n",
      "        This function will not follow symbolic links.\n",
      "        Equivalent to chflags(path, flags, follow_symlinks=False).\n",
      "    \n",
      "    lchmod(path, mode)\n",
      "        Change the access permissions of a file, without following symbolic links.\n",
      "        \n",
      "        If path is a symlink, this affects the link itself rather than the target.\n",
      "        Equivalent to chmod(path, mode, follow_symlinks=False).\"\n",
      "    \n",
      "    lchown(path, uid, gid)\n",
      "        Change the owner and group id of path to the numeric uid and gid.\n",
      "        \n",
      "        This function will not follow symbolic links.\n",
      "        Equivalent to os.chown(path, uid, gid, follow_symlinks=False).\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",
      "    lockf(fd, command, length, /)\n",
      "        Apply, test or remove a POSIX lock on an open file descriptor.\n",
      "        \n",
      "        fd\n",
      "          An open file descriptor.\n",
      "        command\n",
      "          One of F_LOCK, F_TLOCK, F_ULOCK or F_TEST.\n",
      "        length\n",
      "          The number of bytes to lock, starting at the current position.\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",
      "    major(device, /)\n",
      "        Extracts a device major number from a raw device number.\n",
      "    \n",
      "    makedev(major, minor, /)\n",
      "        Composes a raw device number from the major and minor device numbers.\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",
      "    minor(device, /)\n",
      "        Extracts a device minor number from a raw device number.\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",
      "    mkfifo(path, mode=438, *, dir_fd=None)\n",
      "        Create a \"fifo\" (a POSIX named pipe).\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",
      "    mknod(path, mode=384, device=0, *, dir_fd=None)\n",
      "        Create a node in the file system.\n",
      "        \n",
      "        Create a node in the file system (file, device special file or named pipe)\n",
      "        at path.  mode specifies both the permissions to use and the\n",
      "        type of node to be created, being combined (bitwise OR) with one of\n",
      "        S_IFREG, S_IFCHR, S_IFBLK, and S_IFIFO.  If S_IFCHR or S_IFBLK is set on mode,\n",
      "        device defines the newly created device special file (probably using\n",
      "        os.makedev()).  Otherwise device is ignored.\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",
      "    nice(increment, /)\n",
      "        Add increment to the priority of process and return the new priority.\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",
      "    openpty()\n",
      "        Open a pseudo-terminal.\n",
      "        \n",
      "        Return a tuple of (master_fd, slave_fd) containing open file descriptors\n",
      "        for both the master and slave ends.\n",
      "    \n",
      "    pathconf(path, name)\n",
      "        Return the configuration limit name for the file or directory path.\n",
      "        \n",
      "        If there is no limit, return -1.\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",
      "    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",
      "    posix_spawn(...)\n",
      "        Execute the program specified by path in a new 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",
      "        file_actions\n",
      "          A sequence of file action tuples.\n",
      "        setpgroup\n",
      "          The pgroup to use with the POSIX_SPAWN_SETPGROUP flag.\n",
      "        resetids\n",
      "          If the value is `true` the POSIX_SPAWN_RESETIDS will be activated.\n",
      "        setsid\n",
      "          If the value is `true` the POSIX_SPAWN_SETSID or POSIX_SPAWN_SETSID_NP will be activated.\n",
      "        setsigmask\n",
      "          The sigmask to use with the POSIX_SPAWN_SETSIGMASK flag.\n",
      "        setsigdef\n",
      "          The sigmask to use with the POSIX_SPAWN_SETSIGDEF flag.\n",
      "        scheduler\n",
      "          A tuple with the scheduler policy (optional) and parameters.\n",
      "    \n",
      "    posix_spawnp(...)\n",
      "        Execute the program specified by path in a new 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",
      "        file_actions\n",
      "          A sequence of file action tuples.\n",
      "        setpgroup\n",
      "          The pgroup to use with the POSIX_SPAWN_SETPGROUP flag.\n",
      "        resetids\n",
      "          If the value is `True` the POSIX_SPAWN_RESETIDS will be activated.\n",
      "        setsid\n",
      "          If the value is `True` the POSIX_SPAWN_SETSID or POSIX_SPAWN_SETSID_NP will be activated.\n",
      "        setsigmask\n",
      "          The sigmask to use with the POSIX_SPAWN_SETSIGMASK flag.\n",
      "        setsigdef\n",
      "          The sigmask to use with the POSIX_SPAWN_SETSIGDEF flag.\n",
      "        scheduler\n",
      "          A tuple with the scheduler policy (optional) and parameters.\n",
      "    \n",
      "    pread(fd, length, offset, /)\n",
      "        Read a number of bytes from a file descriptor starting at a particular offset.\n",
      "        \n",
      "        Read length bytes from file descriptor fd, starting at offset bytes from\n",
      "        the beginning of the file.  The file offset remains unchanged.\n",
      "    \n",
      "    putenv(name, value, /)\n",
      "        Change or add an environment variable.\n",
      "    \n",
      "    pwrite(fd, buffer, offset, /)\n",
      "        Write bytes to a file descriptor starting at a particular offset.\n",
      "        \n",
      "        Write buffer to fd, starting at offset bytes from the beginning of\n",
      "        the file.  Returns the number of bytes writte.  Does not change the\n",
      "        current file offset.\n",
      "    \n",
      "    read(fd, length, /)\n",
      "        Read from a file descriptor.  Returns a bytes object.\n",
      "    \n",
      "    readlink(path, *, dir_fd=None)\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",
      "        \n",
      "        dir_fd may not be implemented on your platform.  If it is unavailable,\n",
      "        using it will raise a NotImplementedError.\n",
      "    \n",
      "    readv(fd, buffers, /)\n",
      "        Read from a file descriptor fd into an iterable of buffers.\n",
      "        \n",
      "        The buffers should be mutable buffers accepting bytes.\n",
      "        readv will transfer data into each buffer until it is full\n",
      "        and then move on to the next buffer in the sequence to hold\n",
      "        the rest of the data.\n",
      "        \n",
      "        readv returns the total number of bytes read,\n",
      "        which may be less than the total capacity of all the buffers.\n",
      "    \n",
      "    register_at_fork(...)\n",
      "        Register callables to be called when forking a new process.\n",
      "        \n",
      "          before\n",
      "            A callable to be called in the parent before the fork() syscall.\n",
      "          after_in_child\n",
      "            A callable to be called in the child after fork().\n",
      "          after_in_parent\n",
      "            A callable to be called in the parent after fork().\n",
      "        \n",
      "        'before' callbacks are called in reverse order.\n",
      "        'after_in_child' and 'after_in_parent' callbacks are called in order.\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",
      "    sched_get_priority_max(policy)\n",
      "        Get the maximum scheduling priority for policy.\n",
      "    \n",
      "    sched_get_priority_min(policy)\n",
      "        Get the minimum scheduling priority for policy.\n",
      "    \n",
      "    sched_yield()\n",
      "        Voluntarily relinquish the CPU.\n",
      "    \n",
      "    sendfile(...)\n",
      "        sendfile(out, in, offset, count) -> byteswritten\n",
      "        sendfile(out, in, offset, count[, headers][, trailers], flags=0)\n",
      "                    -> byteswritten\n",
      "        Copy count bytes from file descriptor in to file descriptor out.\n",
      "    \n",
      "    set_blocking(fd, blocking, /)\n",
      "        Set the blocking mode of the specified file descriptor.\n",
      "        \n",
      "        Set the O_NONBLOCK flag if blocking is False,\n",
      "        clear the O_NONBLOCK flag otherwise.\n",
      "    \n",
      "    set_inheritable(fd, inheritable, /)\n",
      "        Set the inheritable flag of the specified file descriptor.\n",
      "    \n",
      "    setegid(egid, /)\n",
      "        Set the current process's effective group id.\n",
      "    \n",
      "    seteuid(euid, /)\n",
      "        Set the current process's effective user id.\n",
      "    \n",
      "    setgid(gid, /)\n",
      "        Set the current process's group id.\n",
      "    \n",
      "    setgroups(groups, /)\n",
      "        Set the groups of the current process to list.\n",
      "    \n",
      "    setpgid(pid, pgrp, /)\n",
      "        Call the system call setpgid(pid, pgrp).\n",
      "    \n",
      "    setpgrp()\n",
      "        Make the current process the leader of its process group.\n",
      "    \n",
      "    setpriority(which, who, priority)\n",
      "        Set program scheduling priority.\n",
      "    \n",
      "    setregid(rgid, egid, /)\n",
      "        Set the current process's real and effective group ids.\n",
      "    \n",
      "    setreuid(ruid, euid, /)\n",
      "        Set the current process's real and effective user ids.\n",
      "    \n",
      "    setsid()\n",
      "        Call the system call setsid().\n",
      "    \n",
      "    setuid(uid, /)\n",
      "        Set the current process's user id.\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",
      "    spawnlp(mode, file, *args)\n",
      "        spawnlp(mode, file, *args) -> integer\n",
      "        \n",
      "        Execute file (which is looked for along $PATH) with arguments from\n",
      "        args in a subprocess with the 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",
      "    spawnlpe(mode, file, *args)\n",
      "        spawnlpe(mode, file, *args, env) -> integer\n",
      "        \n",
      "        Execute file (which is looked for along $PATH) with arguments from\n",
      "        args in a subprocess with the 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, file, args)\n",
      "        spawnv(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",
      "    spawnve(mode, file, args, env)\n",
      "        spawnve(mode, file, args, env) -> integer\n",
      "        \n",
      "        Execute file with arguments from args in a subprocess with the\n",
      "        specified 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",
      "    spawnvp(mode, file, args)\n",
      "        spawnvp(mode, file, args) -> integer\n",
      "        \n",
      "        Execute file (which is looked for along $PATH) with arguments from\n",
      "        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",
      "    spawnvpe(mode, file, args, env)\n",
      "        spawnvpe(mode, file, args, env) -> integer\n",
      "        \n",
      "        Execute file (which is looked for along $PATH) with arguments from\n",
      "        args in a subprocess with the 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",
      "    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",
      "    statvfs(path)\n",
      "        Perform a statvfs system call on the given 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",
      "    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",
      "    sync()\n",
      "        Force write of everything to disk.\n",
      "    \n",
      "    sysconf(name, /)\n",
      "        Return an integer-valued system configuration variable.\n",
      "    \n",
      "    system(command)\n",
      "        Execute the command in a subshell.\n",
      "    \n",
      "    tcgetpgrp(fd, /)\n",
      "        Return the process group associated with the terminal specified by fd.\n",
      "    \n",
      "    tcsetpgrp(fd, pgid, /)\n",
      "        Set the process group associated with the terminal specified by fd.\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",
      "    ttyname(fd, /)\n",
      "        Return the name of the terminal device connected to 'fd'.\n",
      "        \n",
      "        fd\n",
      "          Integer file descriptor handle.\n",
      "    \n",
      "    umask(mask, /)\n",
      "        Set the current numeric umask and return the previous umask.\n",
      "    \n",
      "    uname()\n",
      "        Return an object identifying the current operating system.\n",
      "        \n",
      "        The object behaves like a named tuple with the following fields:\n",
      "          (sysname, nodename, release, version, machine)\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",
      "    unsetenv(name, /)\n",
      "        Delete an environment variable.\n",
      "    \n",
      "    urandom(size, /)\n",
      "        Return a bytes object containing random bytes suitable for cryptographic use.\n",
      "    \n",
      "    utime(...)\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",
      "    wait()\n",
      "        Wait for completion of a child process.\n",
      "        \n",
      "        Returns a tuple of information about the child process:\n",
      "            (pid, status)\n",
      "    \n",
      "    wait3(options)\n",
      "        Wait for completion of a child process.\n",
      "        \n",
      "        Returns a tuple of information about the child process:\n",
      "          (pid, status, rusage)\n",
      "    \n",
      "    wait4(pid, options)\n",
      "        Wait for completion of a specific child process.\n",
      "        \n",
      "        Returns a tuple of information about the child process:\n",
      "          (pid, status, rusage)\n",
      "    \n",
      "    waitpid(pid, options, /)\n",
      "        Wait for completion of a given child process.\n",
      "        \n",
      "        Returns a tuple of information regarding the child process:\n",
      "            (pid, status)\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",
      "    writev(fd, buffers, /)\n",
      "        Iterate over buffers, and write the contents of each to a file descriptor.\n",
      "        \n",
      "        Returns the total number of bytes written.\n",
      "        buffers must be a sequence of bytes-like objects.\n",
      "\n",
      "DATA\n",
      "    CLD_CONTINUED = 6\n",
      "    CLD_DUMPED = 3\n",
      "    CLD_EXITED = 1\n",
      "    CLD_TRAPPED = 4\n",
      "    EX_CANTCREAT = 73\n",
      "    EX_CONFIG = 78\n",
      "    EX_DATAERR = 65\n",
      "    EX_IOERR = 74\n",
      "    EX_NOHOST = 68\n",
      "    EX_NOINPUT = 66\n",
      "    EX_NOPERM = 77\n",
      "    EX_NOUSER = 67\n",
      "    EX_OK = 0\n",
      "    EX_OSERR = 71\n",
      "    EX_OSFILE = 72\n",
      "    EX_PROTOCOL = 76\n",
      "    EX_SOFTWARE = 70\n",
      "    EX_TEMPFAIL = 75\n",
      "    EX_UNAVAILABLE = 69\n",
      "    EX_USAGE = 64\n",
      "    F_LOCK = 1\n",
      "    F_OK = 0\n",
      "    F_TEST = 3\n",
      "    F_TLOCK = 2\n",
      "    F_ULOCK = 0\n",
      "    NGROUPS_MAX = 16\n",
      "    O_ACCMODE = 3\n",
      "    O_APPEND = 8\n",
      "    O_ASYNC = 64\n",
      "    O_CLOEXEC = 16777216\n",
      "    O_CREAT = 512\n",
      "    O_DIRECTORY = 1048576\n",
      "    O_DSYNC = 4194304\n",
      "    O_EXCL = 2048\n",
      "    O_EXLOCK = 32\n",
      "    O_NDELAY = 4\n",
      "    O_NOCTTY = 131072\n",
      "    O_NOFOLLOW = 256\n",
      "    O_NONBLOCK = 4\n",
      "    O_RDONLY = 0\n",
      "    O_RDWR = 2\n",
      "    O_SHLOCK = 16\n",
      "    O_SYNC = 128\n",
      "    O_TRUNC = 1024\n",
      "    O_WRONLY = 1\n",
      "    POSIX_SPAWN_CLOSE = 1\n",
      "    POSIX_SPAWN_DUP2 = 2\n",
      "    POSIX_SPAWN_OPEN = 0\n",
      "    PRIO_PGRP = 1\n",
      "    PRIO_PROCESS = 0\n",
      "    PRIO_USER = 2\n",
      "    P_ALL = 0\n",
      "    P_NOWAIT = 1\n",
      "    P_NOWAITO = 1\n",
      "    P_PGID = 2\n",
      "    P_PID = 1\n",
      "    P_WAIT = 0\n",
      "    RTLD_GLOBAL = 8\n",
      "    RTLD_LAZY = 1\n",
      "    RTLD_LOCAL = 4\n",
      "    RTLD_NODELETE = 128\n",
      "    RTLD_NOLOAD = 16\n",
      "    RTLD_NOW = 2\n",
      "    R_OK = 4\n",
      "    SCHED_FIFO = 4\n",
      "    SCHED_OTHER = 1\n",
      "    SCHED_RR = 2\n",
      "    SEEK_CUR = 1\n",
      "    SEEK_END = 2\n",
      "    SEEK_SET = 0\n",
      "    ST_NOSUID = 2\n",
      "    ST_RDONLY = 1\n",
      "    TMP_MAX = 308915776\n",
      "    WCONTINUED = 16\n",
      "    WEXITED = 4\n",
      "    WNOHANG = 1\n",
      "    WNOWAIT = 32\n",
      "    WSTOPPED = 8\n",
      "    WUNTRACED = 2\n",
      "    W_OK = 2\n",
      "    X_OK = 1\n",
      "    __all__ = ['altsep', 'curdir', 'pardir', 'sep', 'pathsep', 'linesep', ...\n",
      "    altsep = None\n",
      "    confstr_names = {'CS_PATH': 1, 'CS_XBS5_ILP32_OFF32_CFLAGS': 20, 'CS_X...\n",
      "    curdir = '.'\n",
      "    defpath = '/bin:/usr/bin'\n",
      "    devnull = '/dev/null'\n",
      "    environ = environ({'TERM_PROGRAM': 'Apple_Terminal', 'SHEL...END': 'mo...\n",
      "    environb = environ({b'TERM_PROGRAM': b'Apple_Terminal', b'S...ND': b'm...\n",
      "    extsep = '.'\n",
      "    linesep = '\\n'\n",
      "    name = 'posix'\n",
      "    pardir = '..'\n",
      "    pathconf_names = {'PC_ALLOC_SIZE_MIN': 16, 'PC_ASYNC_IO': 17, 'PC_CHOW...\n",
      "    pathsep = ':'\n",
      "    sep = '/'\n",
      "    supports_bytes_environ = True\n",
      "    sysconf_names = {'SC_2_CHAR_TERM': 20, 'SC_2_C_BIND': 18, 'SC_2_C_DEV'...\n",
      "\n",
      "FILE\n",
      "    /Users/rbasnet/miniconda3/lib/python3.8/os.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(os)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.sep"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create someDir in current folder\n",
    "os.mkdir('someDir')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# remove directory and its contents\n",
    "os.rmdir('someDir')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in module time:\n",
      "\n",
      "NAME\n",
      "    time - This module provides various functions to manipulate time values.\n",
      "\n",
      "DESCRIPTION\n",
      "    There are two standard representations of time.  One is the number\n",
      "    of seconds since the Epoch, in UTC (a.k.a. GMT).  It may be an integer\n",
      "    or a floating point number (to represent fractions of seconds).\n",
      "    The Epoch is system-defined; on Unix, it is generally January 1st, 1970.\n",
      "    The actual value can be retrieved by calling gmtime(0).\n",
      "    \n",
      "    The other representation is a tuple of 9 integers giving local time.\n",
      "    The tuple items are:\n",
      "      year (including century, e.g. 1998)\n",
      "      month (1-12)\n",
      "      day (1-31)\n",
      "      hours (0-23)\n",
      "      minutes (0-59)\n",
      "      seconds (0-59)\n",
      "      weekday (0-6, Monday is 0)\n",
      "      Julian day (day in the year, 1-366)\n",
      "      DST (Daylight Savings Time) flag (-1, 0 or 1)\n",
      "    If the DST flag is 0, the time is given in the regular time zone;\n",
      "    if it is 1, the time is given in the DST time zone;\n",
      "    if it is -1, mktime() should guess based on the date and time.\n",
      "\n",
      "CLASSES\n",
      "    builtins.tuple(builtins.object)\n",
      "        struct_time\n",
      "    \n",
      "    class struct_time(builtins.tuple)\n",
      "     |  struct_time(iterable=(), /)\n",
      "     |  \n",
      "     |  The time value as returned by gmtime(), localtime(), and strptime(), and\n",
      "     |  accepted by asctime(), mktime() and strftime().  May be considered as a\n",
      "     |  sequence of 9 integers.\n",
      "     |  \n",
      "     |  Note that several fields' values are not the same as those defined by\n",
      "     |  the C language standard for struct tm.  For example, the value of the\n",
      "     |  field tm_year is the actual year, not year - 1900.  See individual\n",
      "     |  fields' descriptions for details.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      struct_time\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",
      "     |  tm_gmtoff\n",
      "     |      offset from UTC in seconds\n",
      "     |  \n",
      "     |  tm_hour\n",
      "     |      hours, range [0, 23]\n",
      "     |  \n",
      "     |  tm_isdst\n",
      "     |      1 if summer time is in effect, 0 if not, and -1 if unknown\n",
      "     |  \n",
      "     |  tm_mday\n",
      "     |      day of month, range [1, 31]\n",
      "     |  \n",
      "     |  tm_min\n",
      "     |      minutes, range [0, 59]\n",
      "     |  \n",
      "     |  tm_mon\n",
      "     |      month of year, range [1, 12]\n",
      "     |  \n",
      "     |  tm_sec\n",
      "     |      seconds, range [0, 61])\n",
      "     |  \n",
      "     |  tm_wday\n",
      "     |      day of week, range [0, 6], Monday is 0\n",
      "     |  \n",
      "     |  tm_yday\n",
      "     |      day of year, range [1, 366]\n",
      "     |  \n",
      "     |  tm_year\n",
      "     |      year, for example, 1993\n",
      "     |  \n",
      "     |  tm_zone\n",
      "     |      abbreviation of timezone name\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  n_fields = 11\n",
      "     |  \n",
      "     |  n_sequence_fields = 9\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",
      "    asctime(...)\n",
      "        asctime([tuple]) -> string\n",
      "        \n",
      "        Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.\n",
      "        When the time tuple is not present, current time as returned by localtime()\n",
      "        is used.\n",
      "    \n",
      "    ctime(...)\n",
      "        ctime(seconds) -> string\n",
      "        \n",
      "        Convert a time in seconds since the Epoch to a string in local time.\n",
      "        This is equivalent to asctime(localtime(seconds)). When the time tuple is\n",
      "        not present, current time as returned by localtime() is used.\n",
      "    \n",
      "    get_clock_info(...)\n",
      "        get_clock_info(name: str) -> dict\n",
      "        \n",
      "        Get information of the specified clock.\n",
      "    \n",
      "    gmtime(...)\n",
      "        gmtime([seconds]) -> (tm_year, tm_mon, tm_mday, tm_hour, tm_min,\n",
      "                               tm_sec, tm_wday, tm_yday, tm_isdst)\n",
      "        \n",
      "        Convert seconds since the Epoch to a time tuple expressing UTC (a.k.a.\n",
      "        GMT).  When 'seconds' is not passed in, convert the current time instead.\n",
      "        \n",
      "        If the platform supports the tm_gmtoff and tm_zone, they are available as\n",
      "        attributes only.\n",
      "    \n",
      "    localtime(...)\n",
      "        localtime([seconds]) -> (tm_year,tm_mon,tm_mday,tm_hour,tm_min,\n",
      "                                  tm_sec,tm_wday,tm_yday,tm_isdst)\n",
      "        \n",
      "        Convert seconds since the Epoch to a time tuple expressing local time.\n",
      "        When 'seconds' is not passed in, convert the current time instead.\n",
      "    \n",
      "    mktime(...)\n",
      "        mktime(tuple) -> floating point number\n",
      "        \n",
      "        Convert a time tuple in local time to seconds since the Epoch.\n",
      "        Note that mktime(gmtime(0)) will not generally return zero for most\n",
      "        time zones; instead the returned value will either be equal to that\n",
      "        of the timezone or altzone attributes on the time module.\n",
      "    \n",
      "    monotonic(...)\n",
      "        monotonic() -> float\n",
      "        \n",
      "        Monotonic clock, cannot go backward.\n",
      "    \n",
      "    monotonic_ns(...)\n",
      "        monotonic_ns() -> int\n",
      "        \n",
      "        Monotonic clock, cannot go backward, as nanoseconds.\n",
      "    \n",
      "    perf_counter(...)\n",
      "        perf_counter() -> float\n",
      "        \n",
      "        Performance counter for benchmarking.\n",
      "    \n",
      "    perf_counter_ns(...)\n",
      "        perf_counter_ns() -> int\n",
      "        \n",
      "        Performance counter for benchmarking as nanoseconds.\n",
      "    \n",
      "    process_time(...)\n",
      "        process_time() -> float\n",
      "        \n",
      "        Process time for profiling: sum of the kernel and user-space CPU time.\n",
      "    \n",
      "    process_time_ns(...)\n",
      "        process_time() -> int\n",
      "        \n",
      "        Process time for profiling as nanoseconds:\n",
      "        sum of the kernel and user-space CPU time.\n",
      "    \n",
      "    sleep(...)\n",
      "        sleep(seconds)\n",
      "        \n",
      "        Delay execution for a given number of seconds.  The argument may be\n",
      "        a floating point number for subsecond precision.\n",
      "    \n",
      "    strftime(...)\n",
      "        strftime(format[, tuple]) -> string\n",
      "        \n",
      "        Convert a time tuple to a string according to a format specification.\n",
      "        See the library reference manual for formatting codes. When the time tuple\n",
      "        is not present, current time as returned by localtime() is used.\n",
      "        \n",
      "        Commonly used format codes:\n",
      "        \n",
      "        %Y  Year with century as a decimal number.\n",
      "        %m  Month as a decimal number [01,12].\n",
      "        %d  Day of the month as a decimal number [01,31].\n",
      "        %H  Hour (24-hour clock) as a decimal number [00,23].\n",
      "        %M  Minute as a decimal number [00,59].\n",
      "        %S  Second as a decimal number [00,61].\n",
      "        %z  Time zone offset from UTC.\n",
      "        %a  Locale's abbreviated weekday name.\n",
      "        %A  Locale's full weekday name.\n",
      "        %b  Locale's abbreviated month name.\n",
      "        %B  Locale's full month name.\n",
      "        %c  Locale's appropriate date and time representation.\n",
      "        %I  Hour (12-hour clock) as a decimal number [01,12].\n",
      "        %p  Locale's equivalent of either AM or PM.\n",
      "        \n",
      "        Other codes may be available on your platform.  See documentation for\n",
      "        the C library strftime function.\n",
      "    \n",
      "    strptime(...)\n",
      "        strptime(string, format) -> struct_time\n",
      "        \n",
      "        Parse a string to a time tuple according to a format specification.\n",
      "        See the library reference manual for formatting codes (same as\n",
      "        strftime()).\n",
      "        \n",
      "        Commonly used format codes:\n",
      "        \n",
      "        %Y  Year with century as a decimal number.\n",
      "        %m  Month as a decimal number [01,12].\n",
      "        %d  Day of the month as a decimal number [01,31].\n",
      "        %H  Hour (24-hour clock) as a decimal number [00,23].\n",
      "        %M  Minute as a decimal number [00,59].\n",
      "        %S  Second as a decimal number [00,61].\n",
      "        %z  Time zone offset from UTC.\n",
      "        %a  Locale's abbreviated weekday name.\n",
      "        %A  Locale's full weekday name.\n",
      "        %b  Locale's abbreviated month name.\n",
      "        %B  Locale's full month name.\n",
      "        %c  Locale's appropriate date and time representation.\n",
      "        %I  Hour (12-hour clock) as a decimal number [01,12].\n",
      "        %p  Locale's equivalent of either AM or PM.\n",
      "        \n",
      "        Other codes may be available on your platform.  See documentation for\n",
      "        the C library strftime function.\n",
      "    \n",
      "    time(...)\n",
      "        time() -> floating point number\n",
      "        \n",
      "        Return the current time in seconds since the Epoch.\n",
      "        Fractions of a second may be present if the system clock provides them.\n",
      "    \n",
      "    time_ns(...)\n",
      "        time_ns() -> int\n",
      "        \n",
      "        Return the current time in nanoseconds since the Epoch.\n",
      "    \n",
      "    tzset(...)\n",
      "        tzset()\n",
      "        \n",
      "        Initialize, or reinitialize, the local timezone to the value stored in\n",
      "        os.environ['TZ']. The TZ environment variable should be specified in\n",
      "        standard Unix timezone format as documented in the tzset man page\n",
      "        (eg. 'US/Eastern', 'Europe/Amsterdam'). Unknown timezones will silently\n",
      "        fall back to UTC. If the TZ environment variable is not set, the local\n",
      "        timezone is set to the systems best guess of wallclock time.\n",
      "        Changing the TZ environment variable without calling tzset *may* change\n",
      "        the local timezone used by methods such as localtime, but this behaviour\n",
      "        should not be relied on.\n",
      "\n",
      "DATA\n",
      "    altzone = 21600\n",
      "    daylight = 1\n",
      "    timezone = 25200\n",
      "    tzname = ('MST', 'MDT')\n",
      "\n",
      "FILE\n",
      "    (built-in)\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "time.struct_time(tm_year=2021, tm_mon=9, tm_mday=7, tm_hour=21, tm_min=15, tm_sec=5, tm_wday=1, tm_yday=250, tm_isdst=1)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "time.localtime()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in module sys:\n",
      "\n",
      "NAME\n",
      "    sys\n",
      "\n",
      "MODULE REFERENCE\n",
      "    https://docs.python.org/3.8/library/sys\n",
      "    \n",
      "    The following documentation is automatically generated from the Python\n",
      "    source files.  It may be incomplete, incorrect or include features that\n",
      "    are considered implementation detail and may vary between Python\n",
      "    implementations.  When in doubt, consult the module reference at the\n",
      "    location listed above.\n",
      "\n",
      "DESCRIPTION\n",
      "    This module provides access to some objects used or maintained by the\n",
      "    interpreter and to functions that interact strongly with the interpreter.\n",
      "    \n",
      "    Dynamic objects:\n",
      "    \n",
      "    argv -- command line arguments; argv[0] is the script pathname if known\n",
      "    path -- module search path; path[0] is the script directory, else ''\n",
      "    modules -- dictionary of loaded modules\n",
      "    \n",
      "    displayhook -- called to show results in an interactive session\n",
      "    excepthook -- called to handle any uncaught exception other than SystemExit\n",
      "      To customize printing in an interactive session or to install a custom\n",
      "      top-level exception handler, assign other functions to replace these.\n",
      "    \n",
      "    stdin -- standard input file object; used by input()\n",
      "    stdout -- standard output file object; used by print()\n",
      "    stderr -- standard error object; used for error messages\n",
      "      By assigning other file objects (or objects that behave like files)\n",
      "      to these, it is possible to redirect all of the interpreter's I/O.\n",
      "    \n",
      "    last_type -- type of last uncaught exception\n",
      "    last_value -- value of last uncaught exception\n",
      "    last_traceback -- traceback of last uncaught exception\n",
      "      These three are only available in an interactive session after a\n",
      "      traceback has been printed.\n",
      "    \n",
      "    Static objects:\n",
      "    \n",
      "    builtin_module_names -- tuple of module names built into this interpreter\n",
      "    copyright -- copyright notice pertaining to this interpreter\n",
      "    exec_prefix -- prefix used to find the machine-specific Python library\n",
      "    executable -- absolute path of the executable binary of the Python interpreter\n",
      "    float_info -- a named tuple with information about the float implementation.\n",
      "    float_repr_style -- string indicating the style of repr() output for floats\n",
      "    hash_info -- a named tuple with information about the hash algorithm.\n",
      "    hexversion -- version information encoded as a single integer\n",
      "    implementation -- Python implementation information.\n",
      "    int_info -- a named tuple with information about the int implementation.\n",
      "    maxsize -- the largest supported length of containers.\n",
      "    maxunicode -- the value of the largest Unicode code point\n",
      "    platform -- platform identifier\n",
      "    prefix -- prefix used to find the Python library\n",
      "    thread_info -- a named tuple with information about the thread implementation.\n",
      "    version -- the version of this interpreter as a string\n",
      "    version_info -- version information as a named tuple\n",
      "    __stdin__ -- the original stdin; don't touch!\n",
      "    __stdout__ -- the original stdout; don't touch!\n",
      "    __stderr__ -- the original stderr; don't touch!\n",
      "    __displayhook__ -- the original displayhook; don't touch!\n",
      "    __excepthook__ -- the original excepthook; don't touch!\n",
      "    \n",
      "    Functions:\n",
      "    \n",
      "    displayhook() -- print an object to the screen, and save it in builtins._\n",
      "    excepthook() -- print an exception and its traceback to sys.stderr\n",
      "    exc_info() -- return thread-safe information about the current exception\n",
      "    exit() -- exit the interpreter by raising SystemExit\n",
      "    getdlopenflags() -- returns flags to be used for dlopen() calls\n",
      "    getprofile() -- get the global profiling function\n",
      "    getrefcount() -- return the reference count for an object (plus one :-)\n",
      "    getrecursionlimit() -- return the max recursion depth for the interpreter\n",
      "    getsizeof() -- return the size of an object in bytes\n",
      "    gettrace() -- get the global debug tracing function\n",
      "    setcheckinterval() -- control how often the interpreter checks for events\n",
      "    setdlopenflags() -- set the flags to be used for dlopen() calls\n",
      "    setprofile() -- set the global profiling function\n",
      "    setrecursionlimit() -- set the max recursion depth for the interpreter\n",
      "    settrace() -- set the global debug tracing function\n",
      "\n",
      "FUNCTIONS\n",
      "    __breakpointhook__ = breakpointhook(...)\n",
      "        breakpointhook(*args, **kws)\n",
      "        \n",
      "        This hook function is called by built-in breakpoint().\n",
      "    \n",
      "    __displayhook__ = displayhook(object, /)\n",
      "        Print an object to sys.stdout and also save it in builtins._\n",
      "    \n",
      "    __excepthook__ = excepthook(exctype, value, traceback, /)\n",
      "        Handle an exception by displaying it with a traceback on sys.stderr.\n",
      "    \n",
      "    __unraisablehook__ = unraisablehook(unraisable, /)\n",
      "        Handle an unraisable exception.\n",
      "        \n",
      "        The unraisable argument has the following attributes:\n",
      "        \n",
      "        * exc_type: Exception type.\n",
      "        * exc_value: Exception value, can be None.\n",
      "        * exc_traceback: Exception traceback, can be None.\n",
      "        * err_msg: Error message, can be None.\n",
      "        * object: Object causing the exception, can be None.\n",
      "    \n",
      "    addaudithook(hook)\n",
      "        Adds a new audit hook callback.\n",
      "    \n",
      "    audit(...)\n",
      "        audit(event, *args)\n",
      "        \n",
      "        Passes the event to any audit hooks that are attached.\n",
      "    \n",
      "    breakpointhook(...)\n",
      "        breakpointhook(*args, **kws)\n",
      "        \n",
      "        This hook function is called by built-in breakpoint().\n",
      "    \n",
      "    call_tracing(func, args, /)\n",
      "        Call func(*args), while tracing is enabled.\n",
      "        \n",
      "        The tracing state is saved, and restored afterwards.  This is intended\n",
      "        to be called from a debugger from a checkpoint, to recursively debug\n",
      "        some other code.\n",
      "    \n",
      "    callstats()\n",
      "        Return a tuple of function call statistics.\n",
      "        \n",
      "        A tuple is returned only if CALL_PROFILE was defined when Python was\n",
      "        built.  Otherwise, this returns None.\n",
      "        \n",
      "        When enabled, this function returns detailed, implementation-specific\n",
      "        details about the number of function calls executed. The return value\n",
      "        is a 11-tuple where the entries in the tuple are counts of:\n",
      "        0. all function calls\n",
      "        1. calls to PyFunction_Type objects\n",
      "        2. PyFunction calls that do not create an argument tuple\n",
      "        3. PyFunction calls that do not create an argument tuple\n",
      "           and bypass PyEval_EvalCodeEx()\n",
      "        4. PyMethod calls\n",
      "        5. PyMethod calls on bound methods\n",
      "        6. PyType calls\n",
      "        7. PyCFunction calls\n",
      "        8. generator calls\n",
      "        9. All other calls\n",
      "        10. Number of stack pops performed by call_function()\n",
      "    \n",
      "    exc_info()\n",
      "        Return current exception information: (type, value, traceback).\n",
      "        \n",
      "        Return information about the most recent exception caught by an except\n",
      "        clause in the current stack frame or in an older stack frame.\n",
      "    \n",
      "    exit(status=None, /)\n",
      "        Exit the interpreter by raising SystemExit(status).\n",
      "        \n",
      "        If the status is omitted or None, it defaults to zero (i.e., success).\n",
      "        If the status is an integer, it will be used as the system exit status.\n",
      "        If it is another kind of object, it will be printed and the system\n",
      "        exit status will be one (i.e., failure).\n",
      "    \n",
      "    get_asyncgen_hooks()\n",
      "        Return the installed asynchronous generators hooks.\n",
      "        \n",
      "        This returns a namedtuple of the form (firstiter, finalizer).\n",
      "    \n",
      "    get_coroutine_origin_tracking_depth()\n",
      "        Check status of origin tracking for coroutine objects in this thread.\n",
      "    \n",
      "    getallocatedblocks()\n",
      "        Return the number of memory blocks currently allocated.\n",
      "    \n",
      "    getcheckinterval()\n",
      "        Return the current check interval; see sys.setcheckinterval().\n",
      "    \n",
      "    getdefaultencoding()\n",
      "        Return the current default encoding used by the Unicode implementation.\n",
      "    \n",
      "    getdlopenflags()\n",
      "        Return the current value of the flags that are used for dlopen calls.\n",
      "        \n",
      "        The flag constants are defined in the os module.\n",
      "    \n",
      "    getfilesystemencodeerrors()\n",
      "        Return the error mode used Unicode to OS filename conversion.\n",
      "    \n",
      "    getfilesystemencoding()\n",
      "        Return the encoding used to convert Unicode filenames to OS filenames.\n",
      "    \n",
      "    getprofile()\n",
      "        Return the profiling function set with sys.setprofile.\n",
      "        \n",
      "        See the profiler chapter in the library manual.\n",
      "    \n",
      "    getrecursionlimit()\n",
      "        Return the current value of the recursion limit.\n",
      "        \n",
      "        The recursion limit is the maximum depth of the Python interpreter\n",
      "        stack.  This limit prevents infinite recursion from causing an overflow\n",
      "        of the C stack and crashing Python.\n",
      "    \n",
      "    getrefcount(object, /)\n",
      "        Return the reference count of object.\n",
      "        \n",
      "        The count returned is generally one higher than you might expect,\n",
      "        because it includes the (temporary) reference as an argument to\n",
      "        getrefcount().\n",
      "    \n",
      "    getsizeof(...)\n",
      "        getsizeof(object [, default]) -> int\n",
      "        \n",
      "        Return the size of object in bytes.\n",
      "    \n",
      "    getswitchinterval()\n",
      "        Return the current thread switch interval; see sys.setswitchinterval().\n",
      "    \n",
      "    gettrace()\n",
      "        Return the global debug tracing function set with sys.settrace.\n",
      "        \n",
      "        See the debugger chapter in the library manual.\n",
      "    \n",
      "    intern(string, /)\n",
      "        ``Intern'' the given string.\n",
      "        \n",
      "        This enters the string in the (global) table of interned strings whose\n",
      "        purpose is to speed up dictionary lookups. Return the string itself or\n",
      "        the previously interned string object with the same value.\n",
      "    \n",
      "    is_finalizing()\n",
      "        Return True if Python is exiting.\n",
      "    \n",
      "    set_asyncgen_hooks(...)\n",
      "        set_asyncgen_hooks(* [, firstiter] [, finalizer])\n",
      "        \n",
      "        Set a finalizer for async generators objects.\n",
      "    \n",
      "    set_coroutine_origin_tracking_depth(depth)\n",
      "        Enable or disable origin tracking for coroutine objects in this thread.\n",
      "        \n",
      "        Coroutine objects will track 'depth' frames of traceback information\n",
      "        about where they came from, available in their cr_origin attribute.\n",
      "        \n",
      "        Set a depth of 0 to disable.\n",
      "    \n",
      "    setcheckinterval(n, /)\n",
      "        Set the async event check interval to n instructions.\n",
      "        \n",
      "        This tells the Python interpreter to check for asynchronous events\n",
      "        every n instructions.\n",
      "        \n",
      "        This also affects how often thread switches occur.\n",
      "    \n",
      "    setdlopenflags(flags, /)\n",
      "        Set the flags used by the interpreter for dlopen calls.\n",
      "        \n",
      "        This is used, for example, when the interpreter loads extension\n",
      "        modules. Among other things, this will enable a lazy resolving of\n",
      "        symbols when importing a module, if called as sys.setdlopenflags(0).\n",
      "        To share symbols across extension modules, call as\n",
      "        sys.setdlopenflags(os.RTLD_GLOBAL).  Symbolic names for the flag\n",
      "        modules can be found in the os module (RTLD_xxx constants, e.g.\n",
      "        os.RTLD_LAZY).\n",
      "    \n",
      "    setprofile(...)\n",
      "        setprofile(function)\n",
      "        \n",
      "        Set the profiling function.  It will be called on each function call\n",
      "        and return.  See the profiler chapter in the library manual.\n",
      "    \n",
      "    setrecursionlimit(limit, /)\n",
      "        Set the maximum depth of the Python interpreter stack to n.\n",
      "        \n",
      "        This limit prevents infinite recursion from causing an overflow of the C\n",
      "        stack and crashing Python.  The highest possible limit is platform-\n",
      "        dependent.\n",
      "    \n",
      "    setswitchinterval(interval, /)\n",
      "        Set the ideal thread switching delay inside the Python interpreter.\n",
      "        \n",
      "        The actual frequency of switching threads can be lower if the\n",
      "        interpreter executes long sequences of uninterruptible code\n",
      "        (this is implementation-specific and workload-dependent).\n",
      "        \n",
      "        The parameter must represent the desired switching delay in seconds\n",
      "        A typical value is 0.005 (5 milliseconds).\n",
      "    \n",
      "    settrace(...)\n",
      "        settrace(function)\n",
      "        \n",
      "        Set the global debug tracing function.  It will be called on each\n",
      "        function call.  See the debugger chapter in the library manual.\n",
      "    \n",
      "    unraisablehook(unraisable, /)\n",
      "        Handle an unraisable exception.\n",
      "        \n",
      "        The unraisable argument has the following attributes:\n",
      "        \n",
      "        * exc_type: Exception type.\n",
      "        * exc_value: Exception value, can be None.\n",
      "        * exc_traceback: Exception traceback, can be None.\n",
      "        * err_msg: Error message, can be None.\n",
      "        * object: Object causing the exception, can be None.\n",
      "\n",
      "DATA\n",
      "    __stderr__ = <_io.TextIOWrapper name='<stderr>' mode='w' encoding='utf...\n",
      "    __stdin__ = <_io.TextIOWrapper name='<stdin>' mode='r' encoding='utf-8...\n",
      "    __stdout__ = <_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf...\n",
      "    abiflags = ''\n",
      "    api_version = 1013\n",
      "    argv = ['/Users/rbasnet/miniconda3/lib/python3.8/site-packages/ipykern...\n",
      "    base_exec_prefix = '/Users/rbasnet/miniconda3'\n",
      "    base_prefix = '/Users/rbasnet/miniconda3'\n",
      "    builtin_module_names = ('_abc', '_ast', '_codecs', '_collections', '_f...\n",
      "    byteorder = 'little'\n",
      "    copyright = 'Copyright (c) 2001-2021 Python Software Foundati...ematis...\n",
      "    displayhook = <ipykernel.displayhook.ZMQShellDisplayHook object>\n",
      "    dont_write_bytecode = False\n",
      "    exec_prefix = '/Users/rbasnet/miniconda3'\n",
      "    executable = '/Users/rbasnet/miniconda3/bin/python'\n",
      "    flags = sys.flags(debug=0, inspect=0, interactive=0, opt...ation=1, is...\n",
      "    float_info = sys.float_info(max=1.7976931348623157e+308, max_...epsilo...\n",
      "    float_repr_style = 'short'\n",
      "    hash_info = sys.hash_info(width=64, modulus=2305843009213693...iphash2...\n",
      "    hexversion = 50858992\n",
      "    implementation = namespace(_multiarch='darwin', cache_tag='cpytho...no...\n",
      "    int_info = sys.int_info(bits_per_digit=30, sizeof_digit=4)\n",
      "    last_value = FileExistsError(17, 'File exists')\n",
      "    maxsize = 9223372036854775807\n",
      "    maxunicode = 1114111\n",
      "    meta_path = [<class '_frozen_importlib.BuiltinImporter'>, <class '_fro...\n",
      "    modules = {'IPython': <module 'IPython' from '/Users/rbasnet/miniconda...\n",
      "    path = ['/Users/rbasnet/CMU/projects/Python-Fundamentals', '/Users/rba...\n",
      "    path_hooks = [<class 'zipimport.zipimporter'>, <function FileFinder.pa...\n",
      "    path_importer_cache = {'/Users/rbasnet/.ipython': FileFinder('/Users/r...\n",
      "    platform = 'darwin'\n",
      "    prefix = '/Users/rbasnet/miniconda3'\n",
      "    ps1 = 'In : '\n",
      "    ps2 = '...: '\n",
      "    ps3 = 'Out: '\n",
      "    pycache_prefix = None\n",
      "    stderr = <ipykernel.iostream.OutStream object>\n",
      "    stdin = <_io.TextIOWrapper name='<stdin>' mode='r' encoding='utf-8'>\n",
      "    stdout = <ipykernel.iostream.OutStream object>\n",
      "    thread_info = sys.thread_info(name='pthread', lock='mutex+cond', versi...\n",
      "    version = '3.8.11 (default, Aug  6 2021, 08:56:27) \\n[Clang 10.0.0 ]'\n",
      "    version_info = sys.version_info(major=3, minor=8, micro=11, releaselev...\n",
      "    warnoptions = []\n",
      "\n",
      "FILE\n",
      "    (built-in)\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module string:\n",
      "\n",
      "NAME\n",
      "    string - A collection of string constants.\n",
      "\n",
      "MODULE REFERENCE\n",
      "    https://docs.python.org/3.8/library/string\n",
      "    \n",
      "    The following documentation is automatically generated from the Python\n",
      "    source files.  It may be incomplete, incorrect or include features that\n",
      "    are considered implementation detail and may vary between Python\n",
      "    implementations.  When in doubt, consult the module reference at the\n",
      "    location listed above.\n",
      "\n",
      "DESCRIPTION\n",
      "    Public module variables:\n",
      "    \n",
      "    whitespace -- a string containing all ASCII whitespace\n",
      "    ascii_lowercase -- a string containing all ASCII lowercase letters\n",
      "    ascii_uppercase -- a string containing all ASCII uppercase letters\n",
      "    ascii_letters -- a string containing all ASCII letters\n",
      "    digits -- a string containing all ASCII decimal digits\n",
      "    hexdigits -- a string containing all ASCII hexadecimal digits\n",
      "    octdigits -- a string containing all ASCII octal digits\n",
      "    punctuation -- a string containing all ASCII punctuation characters\n",
      "    printable -- a string containing all ASCII characters considered printable\n",
      "\n",
      "CLASSES\n",
      "    builtins.object\n",
      "        Formatter\n",
      "        Template\n",
      "    \n",
      "    class Formatter(builtins.object)\n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  check_unused_args(self, used_args, args, kwargs)\n",
      "     |  \n",
      "     |  convert_field(self, value, conversion)\n",
      "     |  \n",
      "     |  format(self, format_string, /, *args, **kwargs)\n",
      "     |  \n",
      "     |  format_field(self, value, format_spec)\n",
      "     |  \n",
      "     |  get_field(self, field_name, args, kwargs)\n",
      "     |      # given a field_name, find the object it references.\n",
      "     |      #  field_name:   the field being looked up, e.g. \"0.name\"\n",
      "     |      #                 or \"lookup[3]\"\n",
      "     |      #  used_args:    a set of which args have been used\n",
      "     |      #  args, kwargs: as passed in to vformat\n",
      "     |  \n",
      "     |  get_value(self, key, args, kwargs)\n",
      "     |  \n",
      "     |  parse(self, format_string)\n",
      "     |      # returns an iterable that contains tuples of the form:\n",
      "     |      # (literal_text, field_name, format_spec, conversion)\n",
      "     |      # literal_text can be zero length\n",
      "     |      # field_name can be None, in which case there's no\n",
      "     |      #  object to format and output\n",
      "     |      # if field_name is not None, it is looked up, formatted\n",
      "     |      #  with format_spec and conversion and then used\n",
      "     |  \n",
      "     |  vformat(self, format_string, args, kwargs)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "    \n",
      "    class Template(builtins.object)\n",
      "     |  Template(template)\n",
      "     |  \n",
      "     |  A string class for supporting $-substitutions.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __init__(self, template)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  safe_substitute(self, mapping={}, /, **kws)\n",
      "     |  \n",
      "     |  substitute(self, mapping={}, /, **kws)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  braceidpattern = None\n",
      "     |  \n",
      "     |  delimiter = '$'\n",
      "     |  \n",
      "     |  flags = re.IGNORECASE\n",
      "     |  \n",
      "     |  idpattern = '(?a:[_a-z][_a-z0-9]*)'\n",
      "     |  \n",
      "     |  pattern = re.compile('\\n    \\\\$(?:\\n      (?P<escaped>\\\\$)...ced>(?a:[...\n",
      "\n",
      "FUNCTIONS\n",
      "    capwords(s, sep=None)\n",
      "        capwords(s [,sep]) -> string\n",
      "        \n",
      "        Split the argument into words using split, capitalize each\n",
      "        word using capitalize, and join the capitalized words using\n",
      "        join.  If the optional second argument sep is absent or None,\n",
      "        runs of whitespace characters are replaced by a single space\n",
      "        and leading and trailing whitespace are removed, otherwise\n",
      "        sep is used to split and join the words.\n",
      "\n",
      "DATA\n",
      "    __all__ = ['ascii_letters', 'ascii_lowercase', 'ascii_uppercase', 'cap...\n",
      "    ascii_letters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'\n",
      "    ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'\n",
      "    ascii_uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'\n",
      "    digits = '0123456789'\n",
      "    hexdigits = '0123456789abcdefABCDEF'\n",
      "    octdigits = '01234567'\n",
      "    printable = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTU...\n",
      "    punctuation = '!\"#$%&\\'()*+,-./:;<=>?@[\\\\]^_`{|}~'\n",
      "    whitespace = ' \\t\\n\\r\\x0b\\x0c'\n",
      "\n",
      "FILE\n",
      "    /Users/rbasnet/miniconda3/lib/python3.8/string.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "string.ascii_letters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}