Hello World

[1]:
print('Hello World')
Hello World
[2]:
s = 'Mississippi'
print(s)
Mississippi
[3]:
s
[3]:
'Mississippi'
[4]:
s.count('ss')
[4]:
2
[5]:
s.index('ss')
[5]:
2
[6]:
import json
[7]:
d = {'eins': 1,
    'zwei': 2}
d['eins']
[7]:
1
[8]:
d_as_str = json.dumps(d)
[9]:
d_as_str
[9]:
'{"eins": 1, "zwei": 2}'
[10]:
received_d = json.loads(d_as_str)
[11]:
received_d
[11]:
{'eins': 1, 'zwei': 2}
[12]:
import subprocess
[13]:
subprocess.run(['ls', '-l'])
total 160
-rw-rw-r--. 1 jfasch jfasch   4926 Mar 30 10:57 index.rst
-rw-rw-r--. 1 jfasch jfasch   1939 Mar  1 17:00 index.rst.~1~
-rw-rw-r--. 1 jfasch jfasch 145415 Mar 30 11:16 Notebook.ipynb
-rw-rw-r--. 1 jfasch jfasch     72 Mar  1 16:38 notebook-wrapper.rst
[13]:
CompletedProcess(args=['ls', '-l'], returncode=0)
[14]:
i = 42
[15]:
print(i)
42
[16]:
type(i)
[16]:
int
[17]:
i = [1, 2, 3]
[18]:
type(i)
[18]:
list
[19]:
f = open('/etc/passwd')
[20]:
for line in f:
    line = line.rstrip('\n')
    fields = line.split(':')
    print(fields[0])
root
bin
daemon
adm
lp
sync
shutdown
halt
mail
operator
games
ftp
nobody
apache
systemd-network
systemd-coredump
systemd-resolve
systemd-oom
systemd-timesync
tss
dbus
polkitd
avahi
unbound
dnsmasq
nm-openconnect
usbmuxd
gluster
rtkit
pipewire
geoclue
chrony
saslauth
radvd
rpc
qemu
openvpn
nm-openvpn
colord
rpcuser
abrt
flatpak
gdm
gnome-initial-setup
vboxadd
sshd
tcpdump
jfasch
mosquitto
someone-else
[21]:
s
[21]:
'Mississippi'
[22]:
help(str)
Help on class str in module builtins:

class str(object)
 |  str(object='') -> str
 |  str(bytes_or_buffer[, encoding[, errors]]) -> str
 |
 |  Create a new string object from the given object. If encoding or
 |  errors is specified, then the object must expose a data buffer
 |  that will be decoded using the given encoding and error handler.
 |  Otherwise, returns the result of object.__str__() (if defined)
 |  or repr(object).
 |  encoding defaults to sys.getdefaultencoding().
 |  errors defaults to 'strict'.
 |
 |  Methods defined here:
 |
 |  __add__(self, value, /)
 |      Return self+value.
 |
 |  __contains__(self, key, /)
 |      Return key in self.
 |
 |  __eq__(self, value, /)
 |      Return self==value.
 |
 |  __format__(self, format_spec, /)
 |      Return a formatted version of the string as described by format_spec.
 |
 |  __ge__(self, value, /)
 |      Return self>=value.
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __getitem__(self, key, /)
 |      Return self[key].
 |
 |  __getnewargs__(...)
 |
 |  __gt__(self, value, /)
 |      Return self>value.
 |
 |  __hash__(self, /)
 |      Return hash(self).
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __le__(self, value, /)
 |      Return self<=value.
 |
 |  __len__(self, /)
 |      Return len(self).
 |
 |  __lt__(self, value, /)
 |      Return self<value.
 |
 |  __mod__(self, value, /)
 |      Return self%value.
 |
 |  __mul__(self, value, /)
 |      Return self*value.
 |
 |  __ne__(self, value, /)
 |      Return self!=value.
 |
 |  __repr__(self, /)
 |      Return repr(self).
 |
 |  __rmod__(self, value, /)
 |      Return value%self.
 |
 |  __rmul__(self, value, /)
 |      Return value*self.
 |
 |  __sizeof__(self, /)
 |      Return the size of the string in memory, in bytes.
 |
 |  __str__(self, /)
 |      Return str(self).
 |
 |  capitalize(self, /)
 |      Return a capitalized version of the string.
 |
 |      More specifically, make the first character have upper case and the rest lower
 |      case.
 |
 |  casefold(self, /)
 |      Return a version of the string suitable for caseless comparisons.
 |
 |  center(self, width, fillchar=' ', /)
 |      Return a centered string of length width.
 |
 |      Padding is done using the specified fill character (default is a space).
 |
 |  count(...)
 |      S.count(sub[, start[, end]]) -> int
 |
 |      Return the number of non-overlapping occurrences of substring sub in
 |      string S[start:end].  Optional arguments start and end are
 |      interpreted as in slice notation.
 |
 |  encode(self, /, encoding='utf-8', errors='strict')
 |      Encode the string using the codec registered for encoding.
 |
 |      encoding
 |        The encoding in which to encode the string.
 |      errors
 |        The error handling scheme to use for encoding errors.
 |        The default is 'strict' meaning that encoding errors raise a
 |        UnicodeEncodeError.  Other possible values are 'ignore', 'replace' and
 |        'xmlcharrefreplace' as well as any other name registered with
 |        codecs.register_error that can handle UnicodeEncodeErrors.
 |
 |  endswith(...)
 |      S.endswith(suffix[, start[, end]]) -> bool
 |
 |      Return True if S ends with the specified suffix, False otherwise.
 |      With optional start, test S beginning at that position.
 |      With optional end, stop comparing S at that position.
 |      suffix can also be a tuple of strings to try.
 |
 |  expandtabs(self, /, tabsize=8)
 |      Return a copy where all tab characters are expanded using spaces.
 |
 |      If tabsize is not given, a tab size of 8 characters is assumed.
 |
 |  find(...)
 |      S.find(sub[, start[, end]]) -> int
 |
 |      Return the lowest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Return -1 on failure.
 |
 |  format(...)
 |      S.format(*args, **kwargs) -> str
 |
 |      Return a formatted version of S, using substitutions from args and kwargs.
 |      The substitutions are identified by braces ('{' and '}').
 |
 |  format_map(...)
 |      S.format_map(mapping) -> str
 |
 |      Return a formatted version of S, using substitutions from mapping.
 |      The substitutions are identified by braces ('{' and '}').
 |
 |  index(...)
 |      S.index(sub[, start[, end]]) -> int
 |
 |      Return the lowest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Raises ValueError when the substring is not found.
 |
 |  isalnum(self, /)
 |      Return True if the string is an alpha-numeric string, False otherwise.
 |
 |      A string is alpha-numeric if all characters in the string are alpha-numeric and
 |      there is at least one character in the string.
 |
 |  isalpha(self, /)
 |      Return True if the string is an alphabetic string, False otherwise.
 |
 |      A string is alphabetic if all characters in the string are alphabetic and there
 |      is at least one character in the string.
 |
 |  isascii(self, /)
 |      Return True if all characters in the string are ASCII, False otherwise.
 |
 |      ASCII characters have code points in the range U+0000-U+007F.
 |      Empty string is ASCII too.
 |
 |  isdecimal(self, /)
 |      Return True if the string is a decimal string, False otherwise.
 |
 |      A string is a decimal string if all characters in the string are decimal and
 |      there is at least one character in the string.
 |
 |  isdigit(self, /)
 |      Return True if the string is a digit string, False otherwise.
 |
 |      A string is a digit string if all characters in the string are digits and there
 |      is at least one character in the string.
 |
 |  isidentifier(self, /)
 |      Return True if the string is a valid Python identifier, False otherwise.
 |
 |      Call keyword.iskeyword(s) to test whether string s is a reserved identifier,
 |      such as "def" or "class".
 |
 |  islower(self, /)
 |      Return True if the string is a lowercase string, False otherwise.
 |
 |      A string is lowercase if all cased characters in the string are lowercase and
 |      there is at least one cased character in the string.
 |
 |  isnumeric(self, /)
 |      Return True if the string is a numeric string, False otherwise.
 |
 |      A string is numeric if all characters in the string are numeric and there is at
 |      least one character in the string.
 |
 |  isprintable(self, /)
 |      Return True if the string is printable, False otherwise.
 |
 |      A string is printable if all of its characters are considered printable in
 |      repr() or if it is empty.
 |
 |  isspace(self, /)
 |      Return True if the string is a whitespace string, False otherwise.
 |
 |      A string is whitespace if all characters in the string are whitespace and there
 |      is at least one character in the string.
 |
 |  istitle(self, /)
 |      Return True if the string is a title-cased string, False otherwise.
 |
 |      In a title-cased string, upper- and title-case characters may only
 |      follow uncased characters and lowercase characters only cased ones.
 |
 |  isupper(self, /)
 |      Return True if the string is an uppercase string, False otherwise.
 |
 |      A string is uppercase if all cased characters in the string are uppercase and
 |      there is at least one cased character in the string.
 |
 |  join(self, iterable, /)
 |      Concatenate any number of strings.
 |
 |      The string whose method is called is inserted in between each given string.
 |      The result is returned as a new string.
 |
 |      Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
 |
 |  ljust(self, width, fillchar=' ', /)
 |      Return a left-justified string of length width.
 |
 |      Padding is done using the specified fill character (default is a space).
 |
 |  lower(self, /)
 |      Return a copy of the string converted to lowercase.
 |
 |  lstrip(self, chars=None, /)
 |      Return a copy of the string with leading whitespace removed.
 |
 |      If chars is given and not None, remove characters in chars instead.
 |
 |  partition(self, sep, /)
 |      Partition the string into three parts using the given separator.
 |
 |      This will search for the separator in the string.  If the separator is found,
 |      returns a 3-tuple containing the part before the separator, the separator
 |      itself, and the part after it.
 |
 |      If the separator is not found, returns a 3-tuple containing the original string
 |      and two empty strings.
 |
 |  removeprefix(self, prefix, /)
 |      Return a str with the given prefix string removed if present.
 |
 |      If the string starts with the prefix string, return string[len(prefix):].
 |      Otherwise, return a copy of the original string.
 |
 |  removesuffix(self, suffix, /)
 |      Return a str with the given suffix string removed if present.
 |
 |      If the string ends with the suffix string and that suffix is not empty,
 |      return string[:-len(suffix)]. Otherwise, return a copy of the original
 |      string.
 |
 |  replace(self, old, new, count=-1, /)
 |      Return a copy with all occurrences of substring old replaced by new.
 |
 |        count
 |          Maximum number of occurrences to replace.
 |          -1 (the default value) means replace all occurrences.
 |
 |      If the optional argument count is given, only the first count occurrences are
 |      replaced.
 |
 |  rfind(...)
 |      S.rfind(sub[, start[, end]]) -> int
 |
 |      Return the highest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Return -1 on failure.
 |
 |  rindex(...)
 |      S.rindex(sub[, start[, end]]) -> int
 |
 |      Return the highest index in S where substring sub is found,
 |      such that sub is contained within S[start:end].  Optional
 |      arguments start and end are interpreted as in slice notation.
 |
 |      Raises ValueError when the substring is not found.
 |
 |  rjust(self, width, fillchar=' ', /)
 |      Return a right-justified string of length width.
 |
 |      Padding is done using the specified fill character (default is a space).
 |
 |  rpartition(self, sep, /)
 |      Partition the string into three parts using the given separator.
 |
 |      This will search for the separator in the string, starting at the end. If
 |      the separator is found, returns a 3-tuple containing the part before the
 |      separator, the separator itself, and the part after it.
 |
 |      If the separator is not found, returns a 3-tuple containing two empty strings
 |      and the original string.
 |
 |  rsplit(self, /, sep=None, maxsplit=-1)
 |      Return a list of the words in the string, using sep as the delimiter string.
 |
 |        sep
 |          The delimiter according which to split the string.
 |          None (the default value) means split according to any whitespace,
 |          and discard empty strings from the result.
 |        maxsplit
 |          Maximum number of splits to do.
 |          -1 (the default value) means no limit.
 |
 |      Splits are done starting at the end of the string and working to the front.
 |
 |  rstrip(self, chars=None, /)
 |      Return a copy of the string with trailing whitespace removed.
 |
 |      If chars is given and not None, remove characters in chars instead.
 |
 |  split(self, /, sep=None, maxsplit=-1)
 |      Return a list of the words in the string, using sep as the delimiter string.
 |
 |      sep
 |        The delimiter according which to split the string.
 |        None (the default value) means split according to any whitespace,
 |        and discard empty strings from the result.
 |      maxsplit
 |        Maximum number of splits to do.
 |        -1 (the default value) means no limit.
 |
 |  splitlines(self, /, keepends=False)
 |      Return a list of the lines in the string, breaking at line boundaries.
 |
 |      Line breaks are not included in the resulting list unless keepends is given and
 |      true.
 |
 |  startswith(...)
 |      S.startswith(prefix[, start[, end]]) -> bool
 |
 |      Return True if S starts with the specified prefix, False otherwise.
 |      With optional start, test S beginning at that position.
 |      With optional end, stop comparing S at that position.
 |      prefix can also be a tuple of strings to try.
 |
 |  strip(self, chars=None, /)
 |      Return a copy of the string with leading and trailing whitespace removed.
 |
 |      If chars is given and not None, remove characters in chars instead.
 |
 |  swapcase(self, /)
 |      Convert uppercase characters to lowercase and lowercase characters to uppercase.
 |
 |  title(self, /)
 |      Return a version of the string where each word is titlecased.
 |
 |      More specifically, words start with uppercased characters and all remaining
 |      cased characters have lower case.
 |
 |  translate(self, table, /)
 |      Replace each character in the string using the given translation table.
 |
 |        table
 |          Translation table, which must be a mapping of Unicode ordinals to
 |          Unicode ordinals, strings, or None.
 |
 |      The table must implement lookup/indexing via __getitem__, for instance a
 |      dictionary or list.  If this operation raises LookupError, the character is
 |      left untouched.  Characters mapped to None are deleted.
 |
 |  upper(self, /)
 |      Return a copy of the string converted to uppercase.
 |
 |  zfill(self, width, /)
 |      Pad a numeric string with zeros on the left, to fill a field of the given width.
 |
 |      The string is never truncated.
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |
 |  maketrans(...)
 |      Return a translation table usable for str.translate().
 |
 |      If there is only one argument, it must be a dictionary mapping Unicode
 |      ordinals (integers) or characters to Unicode ordinals, strings or None.
 |      Character keys will be then converted to ordinals.
 |      If there are two arguments, they must be strings of equal length, and
 |      in the resulting dictionary, each character in x will be mapped to the
 |      character at the same position in y. If there is a third argument, it
 |      must be a string, whose characters will be mapped to None in the result.

[23]:
s.center(50)
[23]:
'                   Mississippi                    '
[24]:
def add(l, r):
    '''
    Diese extrem komplexe Funktion nimmt die beiden Parameter l und r her,
    und bildet mit einem numerischen Algorithmus die Summe aus beiden.

    Diese Summe ist dann der Wert des Aufrufs.
    '''
    return l+r
[25]:
add(1, 2)
[25]:
3
[26]:
add.__doc__
[26]:
'\n    Diese extrem komplexe Funktion nimmt die beiden Parameter l und r her,\n    und bildet mit einem numerischen Algorithmus die Summe aus beiden.\n    \n    Diese Summe ist dann der Wert des Aufrufs.\n    '
[27]:
help(add)
Help on function add in module __main__:

add(l, r)
    Diese extrem komplexe Funktion nimmt die beiden Parameter l und r her,
    und bildet mit einem numerischen Algorithmus die Summe aus beiden.

    Diese Summe ist dann der Wert des Aufrufs.

[28]:
json
[28]:
<module 'json' from '/usr/lib64/python3.9/json/__init__.py'>
[29]:
help(json)
Help on package json:

NAME
    json

MODULE REFERENCE
    https://docs.python.org/3.9/library/json

    The following documentation is automatically generated from the Python
    source files.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations.  When in doubt, consult the module reference at the
    location listed above.

DESCRIPTION
    JSON (JavaScript Object Notation) <http://json.org> is a subset of
    JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data
    interchange format.

    :mod:`json` exposes an API familiar to users of the standard library
    :mod:`marshal` and :mod:`pickle` modules.  It is derived from a
    version of the externally maintained simplejson library.

    Encoding basic Python object hierarchies::

        >>> import json
        >>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
        '["foo", {"bar": ["baz", null, 1.0, 2]}]'
        >>> print(json.dumps("\"foo\bar"))
        "\"foo\bar"
        >>> print(json.dumps('\u1234'))
        "\u1234"
        >>> print(json.dumps('\\'))
        "\\"
        >>> print(json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True))
        {"a": 0, "b": 0, "c": 0}
        >>> from io import StringIO
        >>> io = StringIO()
        >>> json.dump(['streaming API'], io)
        >>> io.getvalue()
        '["streaming API"]'

    Compact encoding::

        >>> import json
        >>> mydict = {'4': 5, '6': 7}
        >>> json.dumps([1,2,3,mydict], separators=(',', ':'))
        '[1,2,3,{"4":5,"6":7}]'

    Pretty printing::

        >>> import json
        >>> print(json.dumps({'4': 5, '6': 7}, sort_keys=True, indent=4))
        {
            "4": 5,
            "6": 7
        }

    Decoding JSON::

        >>> import json
        >>> obj = ['foo', {'bar': ['baz', None, 1.0, 2]}]
        >>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]') == obj
        True
        >>> json.loads('"\\"foo\\bar"') == '"foo\x08ar'
        True
        >>> from io import StringIO
        >>> io = StringIO('["streaming API"]')
        >>> json.load(io)[0] == 'streaming API'
        True

    Specializing JSON object decoding::

        >>> import json
        >>> def as_complex(dct):
        ...     if '__complex__' in dct:
        ...         return complex(dct['real'], dct['imag'])
        ...     return dct
        ...
        >>> json.loads('{"__complex__": true, "real": 1, "imag": 2}',
        ...     object_hook=as_complex)
        (1+2j)
        >>> from decimal import Decimal
        >>> json.loads('1.1', parse_float=Decimal) == Decimal('1.1')
        True

    Specializing JSON object encoding::

        >>> import json
        >>> def encode_complex(obj):
        ...     if isinstance(obj, complex):
        ...         return [obj.real, obj.imag]
        ...     raise TypeError(f'Object of type {obj.__class__.__name__} '
        ...                     f'is not JSON serializable')
        ...
        >>> json.dumps(2 + 1j, default=encode_complex)
        '[2.0, 1.0]'
        >>> json.JSONEncoder(default=encode_complex).encode(2 + 1j)
        '[2.0, 1.0]'
        >>> ''.join(json.JSONEncoder(default=encode_complex).iterencode(2 + 1j))
        '[2.0, 1.0]'


    Using json.tool from the shell to validate and pretty-print::

        $ echo '{"json":"obj"}' | python -m json.tool
        {
            "json": "obj"
        }
        $ echo '{ 1.2:3.4}' | python -m json.tool
        Expecting property name enclosed in double quotes: line 1 column 3 (char 2)

PACKAGE CONTENTS
    decoder
    encoder
    scanner
    tool

CLASSES
    builtins.ValueError(builtins.Exception)
        json.decoder.JSONDecodeError
    builtins.object
        json.decoder.JSONDecoder
        json.encoder.JSONEncoder

    class JSONDecodeError(builtins.ValueError)
     |  JSONDecodeError(msg, doc, pos)
     |
     |  Subclass of ValueError with the following additional properties:
     |
     |  msg: The unformatted error message
     |  doc: The JSON document being parsed
     |  pos: The start index of doc where parsing failed
     |  lineno: The line corresponding to pos
     |  colno: The column corresponding to pos
     |
     |  Method resolution order:
     |      JSONDecodeError
     |      builtins.ValueError
     |      builtins.Exception
     |      builtins.BaseException
     |      builtins.object
     |
     |  Methods defined here:
     |
     |  __init__(self, msg, doc, pos)
     |      Initialize self.  See help(type(self)) for accurate signature.
     |
     |  __reduce__(self)
     |      Helper for pickle.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  ----------------------------------------------------------------------
     |  Static methods inherited from builtins.ValueError:
     |
     |  __new__(*args, **kwargs) from builtins.type
     |      Create and return a new object.  See help(type) for accurate signature.
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from builtins.BaseException:
     |
     |  __delattr__(self, name, /)
     |      Implement delattr(self, name).
     |
     |  __getattribute__(self, name, /)
     |      Return getattr(self, name).
     |
     |  __repr__(self, /)
     |      Return repr(self).
     |
     |  __setattr__(self, name, value, /)
     |      Implement setattr(self, name, value).
     |
     |  __setstate__(...)
     |
     |  __str__(self, /)
     |      Return str(self).
     |
     |  with_traceback(...)
     |      Exception.with_traceback(tb) --
     |      set self.__traceback__ to tb and return self.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from builtins.BaseException:
     |
     |  __cause__
     |      exception cause
     |
     |  __context__
     |      exception context
     |
     |  __dict__
     |
     |  __suppress_context__
     |
     |  __traceback__
     |
     |  args

    class JSONDecoder(builtins.object)
     |  JSONDecoder(*, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, strict=True, object_pairs_hook=None)
     |
     |  Simple JSON <http://json.org> decoder
     |
     |  Performs the following translations in decoding by default:
     |
     |  +---------------+-------------------+
     |  | JSON          | Python            |
     |  +===============+===================+
     |  | object        | dict              |
     |  +---------------+-------------------+
     |  | array         | list              |
     |  +---------------+-------------------+
     |  | string        | str               |
     |  +---------------+-------------------+
     |  | number (int)  | int               |
     |  +---------------+-------------------+
     |  | number (real) | float             |
     |  +---------------+-------------------+
     |  | true          | True              |
     |  +---------------+-------------------+
     |  | false         | False             |
     |  +---------------+-------------------+
     |  | null          | None              |
     |  +---------------+-------------------+
     |
     |  It also understands ``NaN``, ``Infinity``, and ``-Infinity`` as
     |  their corresponding ``float`` values, which is outside the JSON spec.
     |
     |  Methods defined here:
     |
     |  __init__(self, *, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, strict=True, object_pairs_hook=None)
     |      ``object_hook``, if specified, will be called with the result
     |      of every JSON object decoded and its return value will be used in
     |      place of the given ``dict``.  This can be used to provide custom
     |      deserializations (e.g. to support JSON-RPC class hinting).
     |
     |      ``object_pairs_hook``, if specified will be called with the result of
     |      every JSON object decoded with an ordered list of pairs.  The return
     |      value of ``object_pairs_hook`` will be used instead of the ``dict``.
     |      This feature can be used to implement custom decoders.
     |      If ``object_hook`` is also defined, the ``object_pairs_hook`` takes
     |      priority.
     |
     |      ``parse_float``, if specified, will be called with the string
     |      of every JSON float to be decoded. By default this is equivalent to
     |      float(num_str). This can be used to use another datatype or parser
     |      for JSON floats (e.g. decimal.Decimal).
     |
     |      ``parse_int``, if specified, will be called with the string
     |      of every JSON int to be decoded. By default this is equivalent to
     |      int(num_str). This can be used to use another datatype or parser
     |      for JSON integers (e.g. float).
     |
     |      ``parse_constant``, if specified, will be called with one of the
     |      following strings: -Infinity, Infinity, NaN.
     |      This can be used to raise an exception if invalid JSON numbers
     |      are encountered.
     |
     |      If ``strict`` is false (true is the default), then control
     |      characters will be allowed inside strings.  Control characters in
     |      this context are those with character codes in the 0-31 range,
     |      including ``'\t'`` (tab), ``'\n'``, ``'\r'`` and ``'\0'``.
     |
     |  decode(self, s, _w=<built-in method match of re.Pattern object at 0x7f99fff1bb70>)
     |      Return the Python representation of ``s`` (a ``str`` instance
     |      containing a JSON document).
     |
     |  raw_decode(self, s, idx=0)
     |      Decode a JSON document from ``s`` (a ``str`` beginning with
     |      a JSON document) and return a 2-tuple of the Python
     |      representation and the index in ``s`` where the document ended.
     |
     |      This can be used to decode a JSON document from a string that may
     |      have extraneous data at the end.
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)

    class JSONEncoder(builtins.object)
     |  JSONEncoder(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)
     |
     |  Extensible JSON <http://json.org> encoder for Python data structures.
     |
     |  Supports the following objects and types by default:
     |
     |  +-------------------+---------------+
     |  | Python            | JSON          |
     |  +===================+===============+
     |  | dict              | object        |
     |  +-------------------+---------------+
     |  | list, tuple       | array         |
     |  +-------------------+---------------+
     |  | str               | string        |
     |  +-------------------+---------------+
     |  | int, float        | number        |
     |  +-------------------+---------------+
     |  | True              | true          |
     |  +-------------------+---------------+
     |  | False             | false         |
     |  +-------------------+---------------+
     |  | None              | null          |
     |  +-------------------+---------------+
     |
     |  To extend this to recognize other objects, subclass and implement a
     |  ``.default()`` method with another method that returns a serializable
     |  object for ``o`` if possible, otherwise it should call the superclass
     |  implementation (to raise ``TypeError``).
     |
     |  Methods defined here:
     |
     |  __init__(self, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)
     |      Constructor for JSONEncoder, with sensible defaults.
     |
     |      If skipkeys is false, then it is a TypeError to attempt
     |      encoding of keys that are not str, int, float or None.  If
     |      skipkeys is True, such items are simply skipped.
     |
     |      If ensure_ascii is true, the output is guaranteed to be str
     |      objects with all incoming non-ASCII characters escaped.  If
     |      ensure_ascii is false, the output can contain non-ASCII characters.
     |
     |      If check_circular is true, then lists, dicts, and custom encoded
     |      objects will be checked for circular references during encoding to
     |      prevent an infinite recursion (which would cause an RecursionError).
     |      Otherwise, no such check takes place.
     |
     |      If allow_nan is true, then NaN, Infinity, and -Infinity will be
     |      encoded as such.  This behavior is not JSON specification compliant,
     |      but is consistent with most JavaScript based encoders and decoders.
     |      Otherwise, it will be a ValueError to encode such floats.
     |
     |      If sort_keys is true, then the output of dictionaries will be
     |      sorted by key; this is useful for regression tests to ensure
     |      that JSON serializations can be compared on a day-to-day basis.
     |
     |      If indent is a non-negative integer, then JSON array
     |      elements and object members will be pretty-printed with that
     |      indent level.  An indent level of 0 will only insert newlines.
     |      None is the most compact representation.
     |
     |      If specified, separators should be an (item_separator, key_separator)
     |      tuple.  The default is (', ', ': ') if *indent* is ``None`` and
     |      (',', ': ') otherwise.  To get the most compact JSON representation,
     |      you should specify (',', ':') to eliminate whitespace.
     |
     |      If specified, default is a function that gets called for objects
     |      that can't otherwise be serialized.  It should return a JSON encodable
     |      version of the object or raise a ``TypeError``.
     |
     |  default(self, o)
     |      Implement this method in a subclass such that it returns
     |      a serializable object for ``o``, or calls the base implementation
     |      (to raise a ``TypeError``).
     |
     |      For example, to support arbitrary iterators, you could
     |      implement default like this::
     |
     |          def default(self, o):
     |              try:
     |                  iterable = iter(o)
     |              except TypeError:
     |                  pass
     |              else:
     |                  return list(iterable)
     |              # Let the base class default method raise the TypeError
     |              return JSONEncoder.default(self, o)
     |
     |  encode(self, o)
     |      Return a JSON string representation of a Python data structure.
     |
     |      >>> from json.encoder import JSONEncoder
     |      >>> JSONEncoder().encode({"foo": ["bar", "baz"]})
     |      '{"foo": ["bar", "baz"]}'
     |
     |  iterencode(self, o, _one_shot=False)
     |      Encode the given object and yield each string
     |      representation as available.
     |
     |      For example::
     |
     |          for chunk in JSONEncoder().iterencode(bigobject):
     |              mysocket.write(chunk)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
     |
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |
     |  item_separator = ', '
     |
     |  key_separator = ': '

FUNCTIONS
    dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)
        Serialize ``obj`` as a JSON formatted stream to ``fp`` (a
        ``.write()``-supporting file-like object).

        If ``skipkeys`` is true then ``dict`` keys that are not basic types
        (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped
        instead of raising a ``TypeError``.

        If ``ensure_ascii`` is false, then the strings written to ``fp`` can
        contain non-ASCII characters if they appear in strings contained in
        ``obj``. Otherwise, all such characters are escaped in JSON strings.

        If ``check_circular`` is false, then the circular reference check
        for container types will be skipped and a circular reference will
        result in an ``RecursionError`` (or worse).

        If ``allow_nan`` is false, then it will be a ``ValueError`` to
        serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``)
        in strict compliance of the JSON specification, instead of using the
        JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).

        If ``indent`` is a non-negative integer, then JSON array elements and
        object members will be pretty-printed with that indent level. An indent
        level of 0 will only insert newlines. ``None`` is the most compact
        representation.

        If specified, ``separators`` should be an ``(item_separator, key_separator)``
        tuple.  The default is ``(', ', ': ')`` if *indent* is ``None`` and
        ``(',', ': ')`` otherwise.  To get the most compact JSON representation,
        you should specify ``(',', ':')`` to eliminate whitespace.

        ``default(obj)`` is a function that should return a serializable version
        of obj or raise TypeError. The default simply raises TypeError.

        If *sort_keys* is true (default: ``False``), then the output of
        dictionaries will be sorted by key.

        To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
        ``.default()`` method to serialize additional types), specify it with
        the ``cls`` kwarg; otherwise ``JSONEncoder`` is used.

    dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)
        Serialize ``obj`` to a JSON formatted ``str``.

        If ``skipkeys`` is true then ``dict`` keys that are not basic types
        (``str``, ``int``, ``float``, ``bool``, ``None``) will be skipped
        instead of raising a ``TypeError``.

        If ``ensure_ascii`` is false, then the return value can contain non-ASCII
        characters if they appear in strings contained in ``obj``. Otherwise, all
        such characters are escaped in JSON strings.

        If ``check_circular`` is false, then the circular reference check
        for container types will be skipped and a circular reference will
        result in an ``RecursionError`` (or worse).

        If ``allow_nan`` is false, then it will be a ``ValueError`` to
        serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in
        strict compliance of the JSON specification, instead of using the
        JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).

        If ``indent`` is a non-negative integer, then JSON array elements and
        object members will be pretty-printed with that indent level. An indent
        level of 0 will only insert newlines. ``None`` is the most compact
        representation.

        If specified, ``separators`` should be an ``(item_separator, key_separator)``
        tuple.  The default is ``(', ', ': ')`` if *indent* is ``None`` and
        ``(',', ': ')`` otherwise.  To get the most compact JSON representation,
        you should specify ``(',', ':')`` to eliminate whitespace.

        ``default(obj)`` is a function that should return a serializable version
        of obj or raise TypeError. The default simply raises TypeError.

        If *sort_keys* is true (default: ``False``), then the output of
        dictionaries will be sorted by key.

        To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
        ``.default()`` method to serialize additional types), specify it with
        the ``cls`` kwarg; otherwise ``JSONEncoder`` is used.

    load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)
        Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
        a JSON document) to a Python object.

        ``object_hook`` is an optional function that will be called with the
        result of any object literal decode (a ``dict``). The return value of
        ``object_hook`` will be used instead of the ``dict``. This feature
        can be used to implement custom decoders (e.g. JSON-RPC class hinting).

        ``object_pairs_hook`` is an optional function that will be called with the
        result of any object literal decoded with an ordered list of pairs.  The
        return value of ``object_pairs_hook`` will be used instead of the ``dict``.
        This feature can be used to implement custom decoders.  If ``object_hook``
        is also defined, the ``object_pairs_hook`` takes priority.

        To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
        kwarg; otherwise ``JSONDecoder`` is used.

    loads(s, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)
        Deserialize ``s`` (a ``str``, ``bytes`` or ``bytearray`` instance
        containing a JSON document) to a Python object.

        ``object_hook`` is an optional function that will be called with the
        result of any object literal decode (a ``dict``). The return value of
        ``object_hook`` will be used instead of the ``dict``. This feature
        can be used to implement custom decoders (e.g. JSON-RPC class hinting).

        ``object_pairs_hook`` is an optional function that will be called with the
        result of any object literal decoded with an ordered list of pairs.  The
        return value of ``object_pairs_hook`` will be used instead of the ``dict``.
        This feature can be used to implement custom decoders.  If ``object_hook``
        is also defined, the ``object_pairs_hook`` takes priority.

        ``parse_float``, if specified, will be called with the string
        of every JSON float to be decoded. By default this is equivalent to
        float(num_str). This can be used to use another datatype or parser
        for JSON floats (e.g. decimal.Decimal).

        ``parse_int``, if specified, will be called with the string
        of every JSON int to be decoded. By default this is equivalent to
        int(num_str). This can be used to use another datatype or parser
        for JSON integers (e.g. float).

        ``parse_constant``, if specified, will be called with one of the
        following strings: -Infinity, Infinity, NaN.
        This can be used to raise an exception if invalid JSON numbers
        are encountered.

        To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
        kwarg; otherwise ``JSONDecoder`` is used.

DATA
    __all__ = ['dump', 'dumps', 'load', 'loads', 'JSONDecoder', 'JSONDecod...

VERSION
    2.0.9

AUTHOR
    Bob Ippolito <bob@redivi.com>

FILE
    /usr/lib64/python3.9/json/__init__.py


Blahblah

Object Oriented?

[30]:
i = 42
[31]:
type(i)
[31]:
int
[32]:
l = [1, 'eins', 1.0]
type(l)
[32]:
list
[33]:
id(l)
[33]:
140299267714496
[34]:
l1 = []
[35]:
id(l1)
[35]:
140299267930496
[36]:
l.append('blah')
[37]:
l
[37]:
[1, 'eins', 1.0, 'blah']

MQTT

[38]:
import json
[39]:
schweissparameter_aussi = {
    'strom_ma': 200004,
    'spannung_v': 10000.01,
}
[40]:
aufs_kabel = json.dumps(schweissparameter_aussi)
aufs_kabel
[40]:
'{"strom_ma": 200004, "spannung_v": 10000.01}'
[41]:
# aufs_kabel: publish() nach mqtt, topic "maschine_112"
[42]:
# vom kabel, subscribe()d an mqtt, topic "maschine_112"
[43]:
vom_kabel = aufs_kabel
[44]:
schweissparameter_eini = json.loads(vom_kabel)
[45]:
schweissparameter_eini
[45]:
{'strom_ma': 200004, 'spannung_v': 10000.01}
[46]:
try:
    schweissparameter_eini['strom_a']
except Exception as e:
    print(type(e), e)
<class 'KeyError'> 'strom_a'

Syntax etc.

[47]:
a = 43
[48]:
if a == 42:
    print('jaja, eh 42')
    print(a)
print('fertig')
fertig
[49]:
a = 42; b = 666
[50]:
a
[50]:
42
[51]:
b
[51]:
666
[52]:
print('Hello', 'World')
Hello World
[53]:
print(


    'Hello',

    'World')
Hello World
[54]:
print('Hello', 'World', sep='***')
Hello***World
[55]:
'hallo'
[55]:
'hallo'
[56]:
"hallo"
[56]:
'hallo'
[57]:
s = "hal'lo"
[58]:
s[3]
[58]:
"'"
[59]:
s = 'hal"lo'
[60]:
s[3]
[60]:
'"'
[61]:
s = 'ha"ll\''
[62]:
s[2]
[62]:
'"'
[63]:
s[5]
[63]:
"'"
[64]:
s = '''das
ist
ein
multiline
string'''
[65]:
print(s)
das
ist
ein
multiline
string

Commandline Arguments

[66]:
import sys
[67]:
help(sys)
Help on built-in module sys:

NAME
    sys

MODULE REFERENCE
    https://docs.python.org/3.9/library/sys

    The following documentation is automatically generated from the Python
    source files.  It may be incomplete, incorrect or include features that
    are considered implementation detail and may vary between Python
    implementations.  When in doubt, consult the module reference at the
    location listed above.

DESCRIPTION
    This module provides access to some objects used or maintained by the
    interpreter and to functions that interact strongly with the interpreter.

    Dynamic objects:

    argv -- command line arguments; argv[0] is the script pathname if known
    path -- module search path; path[0] is the script directory, else ''
    modules -- dictionary of loaded modules

    displayhook -- called to show results in an interactive session
    excepthook -- called to handle any uncaught exception other than SystemExit
      To customize printing in an interactive session or to install a custom
      top-level exception handler, assign other functions to replace these.

    stdin -- standard input file object; used by input()
    stdout -- standard output file object; used by print()
    stderr -- standard error object; used for error messages
      By assigning other file objects (or objects that behave like files)
      to these, it is possible to redirect all of the interpreter's I/O.

    last_type -- type of last uncaught exception
    last_value -- value of last uncaught exception
    last_traceback -- traceback of last uncaught exception
      These three are only available in an interactive session after a
      traceback has been printed.

    Static objects:

    builtin_module_names -- tuple of module names built into this interpreter
    copyright -- copyright notice pertaining to this interpreter
    exec_prefix -- prefix used to find the machine-specific Python library
    executable -- absolute path of the executable binary of the Python interpreter
    float_info -- a named tuple with information about the float implementation.
    float_repr_style -- string indicating the style of repr() output for floats
    hash_info -- a named tuple with information about the hash algorithm.
    hexversion -- version information encoded as a single integer
    implementation -- Python implementation information.
    int_info -- a named tuple with information about the int implementation.
    maxsize -- the largest supported length of containers.
    maxunicode -- the value of the largest Unicode code point
    platform -- platform identifier
    prefix -- prefix used to find the Python library
    thread_info -- a named tuple with information about the thread implementation.
    version -- the version of this interpreter as a string
    version_info -- version information as a named tuple
    __stdin__ -- the original stdin; don't touch!
    __stdout__ -- the original stdout; don't touch!
    __stderr__ -- the original stderr; don't touch!
    __displayhook__ -- the original displayhook; don't touch!
    __excepthook__ -- the original excepthook; don't touch!

    Functions:

    displayhook() -- print an object to the screen, and save it in builtins._
    excepthook() -- print an exception and its traceback to sys.stderr
    exc_info() -- return thread-safe information about the current exception
    exit() -- exit the interpreter by raising SystemExit
    getdlopenflags() -- returns flags to be used for dlopen() calls
    getprofile() -- get the global profiling function
    getrefcount() -- return the reference count for an object (plus one :-)
    getrecursionlimit() -- return the max recursion depth for the interpreter
    getsizeof() -- return the size of an object in bytes
    gettrace() -- get the global debug tracing function
    setdlopenflags() -- set the flags to be used for dlopen() calls
    setprofile() -- set the global profiling function
    setrecursionlimit() -- set the max recursion depth for the interpreter
    settrace() -- set the global debug tracing function

FUNCTIONS
    __breakpointhook__ = breakpointhook(...)
        breakpointhook(*args, **kws)

        This hook function is called by built-in breakpoint().

    __displayhook__ = displayhook(object, /)
        Print an object to sys.stdout and also save it in builtins._

    __excepthook__ = excepthook(exctype, value, traceback, /)
        Handle an exception by displaying it with a traceback on sys.stderr.

    __unraisablehook__ = unraisablehook(unraisable, /)
        Handle an unraisable exception.

        The unraisable argument has the following attributes:

        * exc_type: Exception type.
        * exc_value: Exception value, can be None.
        * exc_traceback: Exception traceback, can be None.
        * err_msg: Error message, can be None.
        * object: Object causing the exception, can be None.

    addaudithook(hook)
        Adds a new audit hook callback.

    audit(...)
        audit(event, *args)

        Passes the event to any audit hooks that are attached.

    call_tracing(func, args, /)
        Call func(*args), while tracing is enabled.

        The tracing state is saved, and restored afterwards.  This is intended
        to be called from a debugger from a checkpoint, to recursively debug
        some other code.

    exc_info()
        Return current exception information: (type, value, traceback).

        Return information about the most recent exception caught by an except
        clause in the current stack frame or in an older stack frame.

    exit(status=None, /)
        Exit the interpreter by raising SystemExit(status).

        If the status is omitted or None, it defaults to zero (i.e., success).
        If the status is an integer, it will be used as the system exit status.
        If it is another kind of object, it will be printed and the system
        exit status will be one (i.e., failure).

    get_asyncgen_hooks()
        Return the installed asynchronous generators hooks.

        This returns a namedtuple of the form (firstiter, finalizer).

    get_coroutine_origin_tracking_depth()
        Check status of origin tracking for coroutine objects in this thread.

    getallocatedblocks()
        Return the number of memory blocks currently allocated.

    getdefaultencoding()
        Return the current default encoding used by the Unicode implementation.

    getdlopenflags()
        Return the current value of the flags that are used for dlopen calls.

        The flag constants are defined in the os module.

    getfilesystemencodeerrors()
        Return the error mode used Unicode to OS filename conversion.

    getfilesystemencoding()
        Return the encoding used to convert Unicode filenames to OS filenames.

    getprofile()
        Return the profiling function set with sys.setprofile.

        See the profiler chapter in the library manual.

    getrecursionlimit()
        Return the current value of the recursion limit.

        The recursion limit is the maximum depth of the Python interpreter
        stack.  This limit prevents infinite recursion from causing an overflow
        of the C stack and crashing Python.

    getrefcount(object, /)
        Return the reference count of object.

        The count returned is generally one higher than you might expect,
        because it includes the (temporary) reference as an argument to
        getrefcount().

    getsizeof(...)
        getsizeof(object [, default]) -> int

        Return the size of object in bytes.

    getswitchinterval()
        Return the current thread switch interval; see sys.setswitchinterval().

    gettrace()
        Return the global debug tracing function set with sys.settrace.

        See the debugger chapter in the library manual.

    intern(string, /)
        ``Intern'' the given string.

        This enters the string in the (global) table of interned strings whose
        purpose is to speed up dictionary lookups. Return the string itself or
        the previously interned string object with the same value.

    is_finalizing()
        Return True if Python is exiting.

    set_asyncgen_hooks(...)
        set_asyncgen_hooks(* [, firstiter] [, finalizer])

        Set a finalizer for async generators objects.

    set_coroutine_origin_tracking_depth(depth)
        Enable or disable origin tracking for coroutine objects in this thread.

        Coroutine objects will track 'depth' frames of traceback information
        about where they came from, available in their cr_origin attribute.

        Set a depth of 0 to disable.

    setdlopenflags(flags, /)
        Set the flags used by the interpreter for dlopen calls.

        This is used, for example, when the interpreter loads extension
        modules. Among other things, this will enable a lazy resolving of
        symbols when importing a module, if called as sys.setdlopenflags(0).
        To share symbols across extension modules, call as
        sys.setdlopenflags(os.RTLD_GLOBAL).  Symbolic names for the flag
        modules can be found in the os module (RTLD_xxx constants, e.g.
        os.RTLD_LAZY).

    setprofile(...)
        setprofile(function)

        Set the profiling function.  It will be called on each function call
        and return.  See the profiler chapter in the library manual.

    setrecursionlimit(limit, /)
        Set the maximum depth of the Python interpreter stack to n.

        This limit prevents infinite recursion from causing an overflow of the C
        stack and crashing Python.  The highest possible limit is platform-
        dependent.

    setswitchinterval(interval, /)
        Set the ideal thread switching delay inside the Python interpreter.

        The actual frequency of switching threads can be lower if the
        interpreter executes long sequences of uninterruptible code
        (this is implementation-specific and workload-dependent).

        The parameter must represent the desired switching delay in seconds
        A typical value is 0.005 (5 milliseconds).

    settrace(...)
        settrace(function)

        Set the global debug tracing function.  It will be called on each
        function call.  See the debugger chapter in the library manual.

    unraisablehook(unraisable, /)
        Handle an unraisable exception.

        The unraisable argument has the following attributes:

        * exc_type: Exception type.
        * exc_value: Exception value, can be None.
        * exc_traceback: Exception traceback, can be None.
        * err_msg: Error message, can be None.
        * object: Object causing the exception, can be None.

DATA
    __stderr__ = <_io.TextIOWrapper name='<stderr>' mode='w' encoding='utf...
    __stdin__ = <_io.TextIOWrapper name='<stdin>' mode='r' encoding='utf-8...
    __stdout__ = <_io.TextIOWrapper name='<stdout>' mode='w' encoding='utf...
    abiflags = ''
    api_version = 1013
    argv = ['/home/jfasch/venv/jfasch-home/lib64/python3.9/site-packages/i...
    base_exec_prefix = '/usr'
    base_prefix = '/usr'
    builtin_module_names = ('_abc', '_ast', '_codecs', '_collections', '_f...
    byteorder = 'little'
    copyright = 'Copyright (c) 2001-2022 Python Software Foundati...ematis...
    displayhook = <ipykernel.displayhook.ZMQShellDisplayHook object>
    dont_write_bytecode = False
    exec_prefix = '/home/jfasch/venv/jfasch-home'
    executable = '/home/jfasch/venv/jfasch-home/bin/python'
    flags = sys.flags(debug=0, inspect=0, interactive=0, opt...ation=1, is...
    float_info = sys.float_info(max=1.7976931348623157e+308, max_...epsilo...
    float_repr_style = 'short'
    hash_info = sys.hash_info(width=64, modulus=2305843009213693...iphash2...
    hexversion = 50924272
    implementation = namespace(name='cpython', cache_tag='cpython-39'...xv...
    int_info = sys.int_info(bits_per_digit=30, sizeof_digit=4)
    maxsize = 9223372036854775807
    maxunicode = 1114111
    meta_path = [<class '_frozen_importlib.BuiltinImporter'>, <class '_fro...
    modules = {'IPython': <module 'IPython' from '/home/jfasch/venv/jfasch...
    path = ['/home/jfasch/work/jfasch-home/trainings/log/detail/2022-03-23...
    path_hooks = [<class 'zipimport.zipimporter'>, <function FileFinder.pa...
    path_importer_cache = {'/home/jfasch/.ipython': FileFinder('/home/jfas...
    platform = 'linux'
    platlibdir = 'lib64'
    prefix = '/home/jfasch/venv/jfasch-home'
    ps1 = 'In : '
    ps2 = '...: '
    ps3 = 'Out: '
    pycache_prefix = None
    stderr = <ipykernel.iostream.OutStream object>
    stdin = <_io.TextIOWrapper name='<stdin>' mode='r' encoding='utf-8'>
    stdout = <ipykernel.iostream.OutStream object>
    thread_info = sys.thread_info(name='pthread', lock='semaphore', versio...
    version = '3.9.10 (main, Jan 17 2022, 00:00:00) \n[GCC 11.2.1 20210728...
    version_info = sys.version_info(major=3, minor=9, micro=10, releaselev...
    warnoptions = []

FILE
    (built-in)


[68]:
sys.platform
[68]:
'linux'
[69]:
sys.executable
[69]:
'/home/jfasch/venv/jfasch-home/bin/python'
[70]:
sys.argv
[70]:
['/home/jfasch/venv/jfasch-home/lib64/python3.9/site-packages/ipykernel_launcher.py',
 '-f',
 '/home/jfasch/.local/share/jupyter/runtime/kernel-2c445fb3-6ca4-4628-b9d9-7cfbbff55326.json']

Variables

[71]:
a = 42
type(a)
[71]:
int
[72]:
a = 1.5
type(a)
[72]:
float
[73]:
a = [1, 'eins']
type(a)
[73]:
list
[74]:
try:
    doesnt_exist
except Exception as e:
    print(type(e), e)
<class 'NameError'> name 'doesnt_exist' is not defined
[75]:
_a = 42
[76]:
_a666 = 666
[77]:
a = 1
b = 2
c = 3
[78]:
a
[78]:
1
[79]:
b
[79]:
2
[80]:
# ...
[81]:
a, b, c = 1, 2, 3
[82]:
a
[82]:
1
[83]:
b
[83]:
2
[84]:
# ...
[85]:
(a, b, c) = (1, 2, 3)
[86]:
a = b = c = 1
[87]:
a, b, c
[87]:
(1, 1, 1)

Assignment Details

[88]:
a = 42
[89]:
id(a)
[89]:
140299402960464
[90]:
b = a
[91]:
b
[91]:
42
[92]:
id(b)
[92]:
140299402960464

Datatypes

[93]:
i = 666
[94]:
i = 2**32-1
[95]:
i
[95]:
4294967295
[96]:
i = 2**64 - 1
[97]:
i
[97]:
18446744073709551615
[98]:
bin(2**64)
[98]:
'0b10000000000000000000000000000000000000000000000000000000000000000'
[99]:
2**10000
[99]:
19950631168807583848837421626835850838234968318861924548520089498529438830221946631919961684036194597899331129423209124271556491349413781117593785932096323957855730046793794526765246551266059895520550086918193311542508608460618104685509074866089624888090489894838009253941633257850621568309473902556912388065225096643874441046759871626985453222868538161694315775629640762836880760732228535091641476183956381458969463899410840960536267821064621427333394036525565649530603142680234969400335934316651459297773279665775606172582031407994198179607378245683762280037302885487251900834464581454650557929601414833921615734588139257095379769119277800826957735674444123062018757836325502728323789270710373802866393031428133241401624195671690574061419654342324638801248856147305207431992259611796250130992860241708340807605932320161268492288496255841312844061536738951487114256315111089745514203313820202931640957596464756010405845841566072044962867016515061920631004186422275908670900574606417856951911456055068251250406007519842261898059237118054444788072906395242548339221982707404473162376760846613033778706039803413197133493654622700563169937455508241780972810983291314403571877524768509857276937926433221599399876886660808368837838027643282775172273657572744784112294389733810861607423253291974813120197604178281965697475898164531258434135959862784130128185406283476649088690521047580882615823961985770122407044330583075869039319604603404973156583208672105913300903752823415539745394397715257455290510212310947321610753474825740775273986348298498340756937955646638621874569499279016572103701364433135817214311791398222983845847334440270964182851005072927748364550578634501100852987812389473928699540834346158807043959118985815145779177143619698728131459483783202081474982171858011389071228250905826817436220577475921417653715687725614904582904992461028630081535583308130101987675856234343538955409175623400844887526162643568648833519463720377293240094456246923254350400678027273837755376406726898636241037491410966718557050759098100246789880178271925953381282421954028302759408448955014676668389697996886241636313376393903373455801407636741877711055384225739499110186468219696581651485130494222369947714763069155468217682876200362777257723781365331611196811280792669481887201298643660768551639860534602297871557517947385246369446923087894265948217008051120322365496288169035739121368338393591756418733850510970271613915439590991598154654417336311656936031122249937969999226781732358023111862644575299135758175008199839236284615249881088960232244362173771618086357015468484058622329792853875623486556440536962622018963571028812361567512543338303270029097668650568557157505516727518899194129711337690149916181315171544007728650573189557450920330185304847113818315407324053319038462084036421763703911550639789000742853672196280903477974533320468368795868580237952218629120080742819551317948157624448298518461509704888027274721574688131594750409732115080498190455803416826949787141316063210686391511681774304792596709376

Floor division

[100]:
3/2    # == 1 in Python 2
[100]:
1.5
[101]:
3//2
[101]:
1

Modulo: Rest bei Division

[102]:
7%3
[102]:
1
[103]:
8%3
[103]:
2

Precedence rules

[104]:
1 + 2 * 3
[104]:
7
[105]:
(1 + 2) * 3
[105]:
9
[106]:
3 * 4 % 5
[106]:
2
[107]:
(3 * 4) % 5
[107]:
2
[108]:
3 * (4 % 5)
[108]:
12

Datatype Conversions

[109]:
i = 42
type(i)
[109]:
int
[110]:
s = '42'
type(s)
[110]:
str
[111]:
i == s
[111]:
False
[112]:
s
[112]:
'42'

Explicit Conversion:

[113]:
int(s)
[113]:
42
[114]:
str(666)
[114]:
'666'
[115]:
str([1,2])
[115]:
'[1, 2]'
[116]:
try:
    int('0xdeadbeef')
except Exception as e:
    print(type(e), e)
<class 'ValueError'> invalid literal for int() with base 10: '0xdeadbeef'
[117]:
int('0xdeadbeef', 16)
[117]:
3735928559
[118]:
float('1.234')
[118]:
1.234
[119]:
try:
    float('1,234')
except Exception as e:
    print(type(e), e)
<class 'ValueError'> could not convert string to float: '1,234'

Object Lifetime

[120]:
l1 = [1,2,3]
[121]:
l2 = l1
[122]:
id(l1)
[122]:
140299327492352
[123]:
id(l2)
[123]:
140299327492352
[124]:
del l1
[125]:
del l2
[126]:
l1 = [1,2,3]
def f(l2):
    print(l2)
f(l1)
[1, 2, 3]
[127]:
del l1

Boolean, Short Circuit Evaluation

[128]:
def func_false():
    print('func_false called')
    return False
def func_true():
    print('func_true called')
    return True
[129]:
func_true() and func_false()
func_true called
func_false called
[129]:
False
[130]:
func_true() and func_true()
func_true called
func_true called
[130]:
True
[131]:
func_false() and func_true()
func_false called
[131]:
False

More String Methods

[132]:
s1 = 'abc'
s2 = 'def'
[133]:
s1 + s2
[133]:
'abcdef'
[134]:
s1 += ' hallo'
s1
[134]:
'abc hallo'

Dictionary Preview

[135]:
d = {
    'm': 'Mr.',
    'f': 'Mrs.',
    'd': 'Prs.',
}
[136]:
'm' in d
[136]:
True
[137]:
'x' in d
[137]:
False
[138]:
'x' not in d
[138]:
True
[139]:
d['m']
[139]:
'Mr.'
[140]:
try:
    d['x']
except Exception as e:
    print(type(e), e)
<class 'KeyError'> 'x'
[141]:
d
[141]:
{'m': 'Mr.', 'f': 'Mrs.', 'd': 'Prs.'}
[142]:
for element in d:
    print(element)
m
f
d
[143]:
for key in d.keys():
    print(key)
m
f
d
[144]:
for value in d.values():
    print(value)
Mr.
Mrs.
Prs.
[145]:
for element in d.items():
    print(element)
('m', 'Mr.')
('f', 'Mrs.')
('d', 'Prs.')
[146]:
for element in d.items():
    key = element[0]
    value = element[1]
    print(key, value)
m Mr.
f Mrs.
d Prs.
[147]:
for key, value in d.items():
    print(key, value)
m Mr.
f Mrs.
d Prs.
[148]:
for element in [1,2,3]:
    print(element)
1
2
3

More String Methods

[149]:
s = 'abc:1:2:def'
[150]:
fields = s.split(':')
fields
[150]:
['abc', '1', '2', 'def']
[151]:
name, uid, gid, home = fields     # <--- tuple unpacking
[152]:
print('name:', name, ', uid:', uid, ', gid:', gid, ', home:', home)
name: abc , uid: 1 , gid: 2 , home: def
[153]:
print(f'name: {name}, uid: {uid}, gid: {gid}, home: {home}')
name: abc, uid: 1, gid: 2, home: def
[154]:
sex_options = ['m', 'f', 'd']
','.join(sex_options)
[154]:
'm,f,d'

Compound Datatypes

list: Mutable

[155]:
l = [1,2,'drei']
type(l)
[155]:
list
[156]:
id(l)
[156]:
140298898107648
[157]:
l.append(4)
[158]:
l
[158]:
[1, 2, 'drei', 4]
[159]:
id(l)
[159]:
140298898107648
[160]:
l.extend([5,'sechs',7.0])
[161]:
l
[161]:
[1, 2, 'drei', 4, 5, 'sechs', 7.0]
[162]:
id(l)
[162]:
140298898107648
[163]:
l += ['acht', 9]
l
[163]:
[1, 2, 'drei', 4, 5, 'sechs', 7.0, 'acht', 9]
[164]:
l1 = [10, 11]
new_l = l + l1
new_l
[164]:
[1, 2, 'drei', 4, 5, 'sechs', 7.0, 'acht', 9, 10, 11]
[165]:
l
[165]:
[1, 2, 'drei', 4, 5, 'sechs', 7.0, 'acht', 9]
[166]:
l1
[166]:
[10, 11]
[167]:
l * 3
[167]:
[1,
 2,
 'drei',
 4,
 5,
 'sechs',
 7.0,
 'acht',
 9,
 1,
 2,
 'drei',
 4,
 5,
 'sechs',
 7.0,
 'acht',
 9,
 1,
 2,
 'drei',
 4,
 5,
 'sechs',
 7.0,
 'acht',
 9]

list(): explicit constructor

[168]:
l = ['a', 'b', 'c']
l
[168]:
['a', 'b', 'c']
[169]:
s = 'abc'
[170]:
l = []
for element in s:
    l.append(element)
l
[170]:
['a', 'b', 'c']
[171]:
l = list(s)
l
[171]:
['a', 'b', 'c']
[172]:
d = {
    'm': 'Mr.',
    'f': 'Mrs.',
    'd': 'Prs.',
}
[173]:
l = list(d)
l
[173]:
['m', 'f', 'd']
[174]:
l = list(range(24))
l
[174]:
[0,
 1,
 2,
 3,
 4,
 5,
 6,
 7,
 8,
 9,
 10,
 11,
 12,
 13,
 14,
 15,
 16,
 17,
 18,
 19,
 20,
 21,
 22,
 23]
[175]:
23 in l
[175]:
True
[176]:
10**100 in l
[176]:
False

tuple: Immutable

[177]:
t = (1,2,'drei')
type(t)
[177]:
tuple
[178]:
try:
    t.append(4)
except Exception as e:
    print(type(e), e)
<class 'AttributeError'> 'tuple' object has no attribute 'append'
[179]:
t_mit_einem_element = (1)     # <--- operator precedence
print(t_mit_einem_element)
1
[180]:
if (True):
    print('eh')
eh
[181]:
type(t_mit_einem_element)
[181]:
int
[182]:
t_mit_einem_element = (1,)
print(t_mit_einem_element)
(1,)

dict: Mutable

[183]:
d = {1:'one', 2:'two'}
type(d)
[183]:
dict
[184]:
d[1]
[184]:
'one'
[185]:
1 in d
[185]:
True
[186]:
3 in d
[186]:
False
[187]:
3 not in d
[187]:
True
[188]:
d[3] = 'three'
[189]:
3 in d
[189]:
True
[190]:
d[3]
[190]:
'three'
[191]:
try:
    d[4]
except Exception as e:
    print(type(e), e)
<class 'KeyError'> 4
[192]:
value = d.get(4)
if value is None:
    print('leider nicht')
else:
    print('supi:', value)
leider nicht
[193]:
del d[3]
[194]:
3 in d
[194]:
False

set: Mutable

[195]:
s = {1, 'zwei', 3.0}
[196]:
1 in s
[196]:
True
[197]:
'drei' not in s
[197]:
True
[198]:
'drei' in s
[198]:
False
[199]:
s.add(100)
[200]:
100 in s
[200]:
True
[201]:
s.remove(1)
[202]:
1 in s
[202]:
False
[203]:
try:
    s.remove(300)
except Exception as e:
    print(type(e), e)
<class 'KeyError'> 300
[204]:
s1 = {1, 2, 3, 4, 5}
s2 = {4, 5, 6, 7}
[205]:
s1 | s2
[205]:
{1, 2, 3, 4, 5, 6, 7}
[206]:
s1 - s2
[206]:
{1, 2, 3}
[207]:
s1 ^ s2
[207]:
{1, 2, 3, 6, 7}
[208]:
for element in s:
    print(element)
3.0
100
zwei
[209]:
for element in s:
    print(element)
3.0
100
zwei

Slicing

[210]:
l = [23, 45, 1, 8]
l[1:3]
[210]:
[45, 1]
[211]:
l[1:4]
[211]:
[45, 1, 8]
[212]:
l[1:]
[212]:
[45, 1, 8]

Comprehensions

List comprehension

[213]:
l = [3, 6, 1, 2]
squares = []
for element in l:
    squares.append(element**2)
squares
[213]:
[9, 36, 1, 4]
[214]:
def squares(nums):
    squares = []
    for element in nums:
        squares.append(element**2)
    return squares
squares(l)
[214]:
[9, 36, 1, 4]
[215]:
l
[215]:
[3, 6, 1, 2]
[216]:
[element**2 for element in l]
[216]:
[9, 36, 1, 4]

DIctionary Comprehension

[217]:
l
[217]:
[3, 6, 1, 2]
[218]:
squares_map = {}
for element in l:
    squares_map[element] = element**2
squares_map
[218]:
{3: 9, 6: 36, 1: 1, 2: 4}
[219]:
{element: element**2 for element in l}
[219]:
{3: 9, 6: 36, 1: 1, 2: 4}

Set Comprehension

[220]:
squares_set = set()
for element in l:
    squares_set.add(element**2)
squares_set
[220]:
{1, 4, 9, 36}
[221]:
{element**2 for element in l}
[221]:
{1, 4, 9, 36}

max

[222]:
max([2,3,1,5,3])
[222]:
5
[223]:
max(2,3,1,5,3)
[223]:
5

Generators

[224]:
r = range(3)
[225]:
for element in r:
    print(element)
0
1
2
[226]:
r = range(3)
type(r)
[226]:
range
[227]:
it = iter(r)
type(it)
[227]:
range_iterator
[228]:
next(it)
[228]:
0
[229]:
next(it)
[229]:
1
[230]:
next(it)
[230]:
2
[231]:
try:
    next(it)
except Exception as e:
    print(type(e), e)
<class 'StopIteration'>

while

[232]:
summe = 0
num = 1
while num <= 100:
    summe += num
    num += 1
print(summe)
5050
[233]:
summe = 0
for num in range(1, 101):
    summe += num
print(summe)
5050
[234]:
sum(range(1,101))
[234]:
5050
[235]:
import random

numtries = 0
won = False
while numtries < 6:
    numtries += 1
    eyes = random.randrange(1, 7)
    if eyes == 6:
        won = True
        break
if won:
    print('win')
else:
    print('lose')
win
[236]:
import random

numtries = 0
while numtries < 6:
    numtries += 1
    eyes = random.randrange(1, 7)
    if eyes == 6:
        print('win')
        break
else:
    print('lose')
lose

for, enumerate()

[237]:
l = ['Hallo', 'Joerg']
for element in l:
    print(element)
Hallo
Joerg
[238]:
l = ['Hallo', 'Joerg']
[print(element) for element in l]
Hallo
Joerg
[238]:
[None, None]
[239]:
l = ['Hallo', 'Joerg']
pos = 0
for element in l:
    print(pos, element)
    pos += 1
0 Hallo
1 Joerg
[240]:
l = ['Hallo', 'Joerg']
for element in enumerate(l):
    print(element)
(0, 'Hallo')
(1, 'Joerg')
[241]:
l = ['Hallo', 'Joerg']
for pos, element in enumerate(l):
    print(pos, element)
0 Hallo
1 Joerg

Functions

[246]:
def maximum(a, b):
    '''berechnet blah kompliziert blah maximum'''
    if a < b:
        return b
    else:
        return a
[247]:
type(maximum)
[247]:
function
[249]:
maximum.__doc__
[249]:
'berechnet blah kompliziert blah maximum'
[250]:
a = maximum
[251]:
a(2, 3)
[251]:
3
[253]:
maximum('abc', 'def')
[253]:
'def'
[255]:
try:
    maximum('1', 1)
except Exception as e:
    print(type(e), e)
<class 'TypeError'> '<' not supported between instances of 'str' and 'int'
[256]:
maximum(1, 1.5)
[256]:
1.5
[257]:
1 < 1.5
[257]:
True
[263]:
def greet(who, phrase='Guten Morgen'):
    print(phrase, who)
[265]:
greet('Joerg')
Guten Morgen Joerg
[269]:
greet('Joerg', phrase='Guten Morgen')
Guten Morgen Joerg

Iteratoren, Generatoren

[270]:
r = range(3)
type(r)
[270]:
range
[271]:
it = iter(r)
type(it)
[271]:
range_iterator
[272]:
next(it)
[272]:
0
[274]:
next(it)
[274]:
1
[275]:
next(it)
[275]:
2
[277]:
try:
    next(it)
except Exception as e:
    print(type(e), e)
<class 'StopIteration'>
[278]:
l = [3, 4]
it = iter(l)
next(it)
[278]:
3
[279]:
next(it)
[279]:
4
[281]:
try:
    next(it)
except Exception as e:
    print(type(e), e)
<class 'StopIteration'>
[283]:
for element in range(3):
    print(element)
0
1
2
[284]:
for element in l:
    print(element)
3
4

Generatoren

[287]:
def even_numbers(limit):
    numbers = []
    i = 0
    while i < limit:
        if i % 2 == 0:
            numbers.append(i)
        i += 1
    return numbers
[288]:
for element in even_numbers(10):
    print(element)
0
2
4
6
8
[289]:
def even_numbers(limit):
    i = 0
    while i < limit:
        if i % 2 == 0:
            yield i
        i += 1
[290]:
en = even_numbers(10)
type(en)
[290]:
generator
[291]:
it = iter(en)
type(it)
[291]:
generator
[292]:
next(it)
[292]:
0
[293]:
next(it)
[293]:
2
[294]:
next(it)
[294]:
4
[295]:
next(it)
[295]:
6
[296]:
next(it)
[296]:
8
[298]:
try:
    next(it)
except Exception as e:
    print(type(e), e)
<class 'StopIteration'>

Miscellaneous String Methods

[299]:
s = 'joerg'
[301]:
s.upper()
[301]:
'JOERG'
[302]:
s
[302]:
'joerg'
[303]:
s = s.upper()
s
[303]:
'JOERG'
[304]:
s.isupper()
[304]:
True
[305]:
s.isalnum()
[305]:
True
[307]:
s.isalpha()
[307]:
True
[309]:
s.isdigit()
[309]:
False
[310]:
s = 'mississppi'
s.count('ss')
[310]:
2
[312]:
s.find('ss')
[312]:
2
[313]:
pos = s.find('ss')
pos = s.find('ss', pos+1)
pos
[313]:
5
[314]:
s.find('xxx')
[314]:
-1
[315]:
if s.find('xxx'):
    print('jo')
else:
    print('na')
jo
[316]:
s.index('ss')
[316]:
2
[318]:
try:
    s.index('xxx')
except Exception as e:
    print(type(e), e)
<class 'ValueError'> substring not found
[319]:
'hallo du'.startswith('hallo')
[319]:
True
[320]:
'file.csv'.endswith('.csv')
[320]:
True

split und join

[321]:
line = 'joerg:faschingbauer:1037190666'
fields = line.split(':')
fields
[321]:
['joerg', 'faschingbauer', '1037190666']
[322]:
firstname, lastname, svnr = line.split(':')
[323]:
firstname
[323]:
'joerg'
[324]:
fields
[324]:
['joerg', 'faschingbauer', '1037190666']
[325]:
','.join(fields)
[325]:
'joerg,faschingbauer,1037190666'

strip()

[326]:
s = '        xxx       '
s.strip()
[326]:
'xxx'
[327]:
s.rstrip()
[327]:
'        xxx'
[328]:
s.lstrip()
[328]:
'xxx       '
[329]:
s = ' a   \t       xxxx     \n a '
s.strip(' a\t\n')
[329]:
'xxxx'
[330]:
s.rstrip(' a\t\n')
[330]:
' a   \t       xxxx'

File I/O

[331]:
f = open('/etc/passwd')
[332]:
f = open('/etc/passwd', encoding='ascii')
[333]:
f.read()
[333]:
'root:x:0:0:root:/root:/bin/bash\nbin:x:1:1:bin:/bin:/sbin/nologin\ndaemon:x:2:2:daemon:/sbin:/sbin/nologin\nadm:x:3:4:adm:/var/adm:/sbin/nologin\nlp:x:4:7:lp:/var/spool/lpd:/sbin/nologin\nsync:x:5:0:sync:/sbin:/bin/sync\nshutdown:x:6:0:shutdown:/sbin:/sbin/shutdown\nhalt:x:7:0:halt:/sbin:/sbin/halt\nmail:x:8:12:mail:/var/spool/mail:/sbin/nologin\noperator:x:11:0:operator:/root:/sbin/nologin\ngames:x:12:100:games:/usr/games:/sbin/nologin\nftp:x:14:50:FTP User:/var/ftp:/sbin/nologin\nnobody:x:65534:65534:Kernel Overflow User:/:/sbin/nologin\napache:x:48:48:Apache:/usr/share/httpd:/sbin/nologin\nsystemd-network:x:192:192:systemd Network Management:/:/sbin/nologin\nsystemd-coredump:x:999:997:systemd Core Dumper:/:/sbin/nologin\nsystemd-resolve:x:193:193:systemd Resolver:/:/sbin/nologin\nsystemd-oom:x:998:996:systemd Userspace OOM Killer:/:/sbin/nologin\nsystemd-timesync:x:997:995:systemd Time Synchronization:/:/sbin/nologin\ntss:x:59:59:Account used for TPM access:/dev/null:/sbin/nologin\ndbus:x:81:81:System message bus:/:/sbin/nologin\npolkitd:x:996:994:User for polkitd:/:/sbin/nologin\navahi:x:70:70:Avahi mDNS/DNS-SD Stack:/var/run/avahi-daemon:/sbin/nologin\nunbound:x:995:992:Unbound DNS resolver:/etc/unbound:/sbin/nologin\ndnsmasq:x:994:991:Dnsmasq DHCP and DNS server:/var/lib/dnsmasq:/sbin/nologin\nnm-openconnect:x:993:989:NetworkManager user for OpenConnect:/:/sbin/nologin\nusbmuxd:x:113:113:usbmuxd user:/:/sbin/nologin\ngluster:x:992:988:GlusterFS daemons:/run/gluster:/sbin/nologin\nrtkit:x:172:172:RealtimeKit:/proc:/sbin/nologin\npipewire:x:991:987:PipeWire System Daemon:/var/run/pipewire:/sbin/nologin\ngeoclue:x:990:986:User for geoclue:/var/lib/geoclue:/sbin/nologin\nchrony:x:989:984::/var/lib/chrony:/sbin/nologin\nsaslauth:x:988:76:Saslauthd user:/run/saslauthd:/sbin/nologin\nradvd:x:75:75:radvd user:/:/sbin/nologin\nrpc:x:32:32:Rpcbind Daemon:/var/lib/rpcbind:/sbin/nologin\nqemu:x:107:107:qemu user:/:/sbin/nologin\nopenvpn:x:987:982:OpenVPN:/etc/openvpn:/sbin/nologin\nnm-openvpn:x:986:981:Default user for running openvpn spawned by NetworkManager:/:/sbin/nologin\ncolord:x:985:980:User for colord:/var/lib/colord:/sbin/nologin\nrpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin\nabrt:x:173:173::/etc/abrt:/sbin/nologin\nflatpak:x:984:979:User for flatpak system helper:/:/sbin/nologin\ngdm:x:42:42::/var/lib/gdm:/sbin/nologin\ngnome-initial-setup:x:983:978::/run/gnome-initial-setup/:/sbin/nologin\nvboxadd:x:982:1::/var/run/vboxadd:/sbin/nologin\nsshd:x:74:74:Privilege-separated SSH:/usr/share/empty.sshd:/sbin/nologin\ntcpdump:x:72:72::/:/sbin/nologin\njfasch:x:1000:1000:Joerg Faschingbauer:/home/jfasch:/bin/bash\nmosquitto:x:981:974:Mosquitto Broker:/etc/mosquitto:/sbin/nologin\nsomeone-else:x:1001:1001::/home/someone-else:/bin/bash\n'
[334]:
f = open('/etc/passwd', encoding='ascii')
[335]:
f.read(15)
[335]:
'root:x:0:0:root'
[336]:
f = open('/etc/passwd', encoding='ascii')
[337]:
lines = f.readlines()
[339]:
lines
[339]:
['root:x:0:0:root:/root:/bin/bash\n',
 'bin:x:1:1:bin:/bin:/sbin/nologin\n',
 'daemon:x:2:2:daemon:/sbin:/sbin/nologin\n',
 'adm:x:3:4:adm:/var/adm:/sbin/nologin\n',
 'lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin\n',
 'sync:x:5:0:sync:/sbin:/bin/sync\n',
 'shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown\n',
 'halt:x:7:0:halt:/sbin:/sbin/halt\n',
 'mail:x:8:12:mail:/var/spool/mail:/sbin/nologin\n',
 'operator:x:11:0:operator:/root:/sbin/nologin\n',
 'games:x:12:100:games:/usr/games:/sbin/nologin\n',
 'ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin\n',
 'nobody:x:65534:65534:Kernel Overflow User:/:/sbin/nologin\n',
 'apache:x:48:48:Apache:/usr/share/httpd:/sbin/nologin\n',
 'systemd-network:x:192:192:systemd Network Management:/:/sbin/nologin\n',
 'systemd-coredump:x:999:997:systemd Core Dumper:/:/sbin/nologin\n',
 'systemd-resolve:x:193:193:systemd Resolver:/:/sbin/nologin\n',
 'systemd-oom:x:998:996:systemd Userspace OOM Killer:/:/sbin/nologin\n',
 'systemd-timesync:x:997:995:systemd Time Synchronization:/:/sbin/nologin\n',
 'tss:x:59:59:Account used for TPM access:/dev/null:/sbin/nologin\n',
 'dbus:x:81:81:System message bus:/:/sbin/nologin\n',
 'polkitd:x:996:994:User for polkitd:/:/sbin/nologin\n',
 'avahi:x:70:70:Avahi mDNS/DNS-SD Stack:/var/run/avahi-daemon:/sbin/nologin\n',
 'unbound:x:995:992:Unbound DNS resolver:/etc/unbound:/sbin/nologin\n',
 'dnsmasq:x:994:991:Dnsmasq DHCP and DNS server:/var/lib/dnsmasq:/sbin/nologin\n',
 'nm-openconnect:x:993:989:NetworkManager user for OpenConnect:/:/sbin/nologin\n',
 'usbmuxd:x:113:113:usbmuxd user:/:/sbin/nologin\n',
 'gluster:x:992:988:GlusterFS daemons:/run/gluster:/sbin/nologin\n',
 'rtkit:x:172:172:RealtimeKit:/proc:/sbin/nologin\n',
 'pipewire:x:991:987:PipeWire System Daemon:/var/run/pipewire:/sbin/nologin\n',
 'geoclue:x:990:986:User for geoclue:/var/lib/geoclue:/sbin/nologin\n',
 'chrony:x:989:984::/var/lib/chrony:/sbin/nologin\n',
 'saslauth:x:988:76:Saslauthd user:/run/saslauthd:/sbin/nologin\n',
 'radvd:x:75:75:radvd user:/:/sbin/nologin\n',
 'rpc:x:32:32:Rpcbind Daemon:/var/lib/rpcbind:/sbin/nologin\n',
 'qemu:x:107:107:qemu user:/:/sbin/nologin\n',
 'openvpn:x:987:982:OpenVPN:/etc/openvpn:/sbin/nologin\n',
 'nm-openvpn:x:986:981:Default user for running openvpn spawned by NetworkManager:/:/sbin/nologin\n',
 'colord:x:985:980:User for colord:/var/lib/colord:/sbin/nologin\n',
 'rpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin\n',
 'abrt:x:173:173::/etc/abrt:/sbin/nologin\n',
 'flatpak:x:984:979:User for flatpak system helper:/:/sbin/nologin\n',
 'gdm:x:42:42::/var/lib/gdm:/sbin/nologin\n',
 'gnome-initial-setup:x:983:978::/run/gnome-initial-setup/:/sbin/nologin\n',
 'vboxadd:x:982:1::/var/run/vboxadd:/sbin/nologin\n',
 'sshd:x:74:74:Privilege-separated SSH:/usr/share/empty.sshd:/sbin/nologin\n',
 'tcpdump:x:72:72::/:/sbin/nologin\n',
 'jfasch:x:1000:1000:Joerg Faschingbauer:/home/jfasch:/bin/bash\n',
 'mosquitto:x:981:974:Mosquitto Broker:/etc/mosquitto:/sbin/nologin\n',
 'someone-else:x:1001:1001::/home/someone-else:/bin/bash\n']
[340]:
for line in lines:
    print(line)
root:x:0:0:root:/root:/bin/bash

bin:x:1:1:bin:/bin:/sbin/nologin

daemon:x:2:2:daemon:/sbin:/sbin/nologin

adm:x:3:4:adm:/var/adm:/sbin/nologin

lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin

sync:x:5:0:sync:/sbin:/bin/sync

shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown

halt:x:7:0:halt:/sbin:/sbin/halt

mail:x:8:12:mail:/var/spool/mail:/sbin/nologin

operator:x:11:0:operator:/root:/sbin/nologin

games:x:12:100:games:/usr/games:/sbin/nologin

ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin

nobody:x:65534:65534:Kernel Overflow User:/:/sbin/nologin

apache:x:48:48:Apache:/usr/share/httpd:/sbin/nologin

systemd-network:x:192:192:systemd Network Management:/:/sbin/nologin

systemd-coredump:x:999:997:systemd Core Dumper:/:/sbin/nologin

systemd-resolve:x:193:193:systemd Resolver:/:/sbin/nologin

systemd-oom:x:998:996:systemd Userspace OOM Killer:/:/sbin/nologin

systemd-timesync:x:997:995:systemd Time Synchronization:/:/sbin/nologin

tss:x:59:59:Account used for TPM access:/dev/null:/sbin/nologin

dbus:x:81:81:System message bus:/:/sbin/nologin

polkitd:x:996:994:User for polkitd:/:/sbin/nologin

avahi:x:70:70:Avahi mDNS/DNS-SD Stack:/var/run/avahi-daemon:/sbin/nologin

unbound:x:995:992:Unbound DNS resolver:/etc/unbound:/sbin/nologin

dnsmasq:x:994:991:Dnsmasq DHCP and DNS server:/var/lib/dnsmasq:/sbin/nologin

nm-openconnect:x:993:989:NetworkManager user for OpenConnect:/:/sbin/nologin

usbmuxd:x:113:113:usbmuxd user:/:/sbin/nologin

gluster:x:992:988:GlusterFS daemons:/run/gluster:/sbin/nologin

rtkit:x:172:172:RealtimeKit:/proc:/sbin/nologin

pipewire:x:991:987:PipeWire System Daemon:/var/run/pipewire:/sbin/nologin

geoclue:x:990:986:User for geoclue:/var/lib/geoclue:/sbin/nologin

chrony:x:989:984::/var/lib/chrony:/sbin/nologin

saslauth:x:988:76:Saslauthd user:/run/saslauthd:/sbin/nologin

radvd:x:75:75:radvd user:/:/sbin/nologin

rpc:x:32:32:Rpcbind Daemon:/var/lib/rpcbind:/sbin/nologin

qemu:x:107:107:qemu user:/:/sbin/nologin

openvpn:x:987:982:OpenVPN:/etc/openvpn:/sbin/nologin

nm-openvpn:x:986:981:Default user for running openvpn spawned by NetworkManager:/:/sbin/nologin

colord:x:985:980:User for colord:/var/lib/colord:/sbin/nologin

rpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin

abrt:x:173:173::/etc/abrt:/sbin/nologin

flatpak:x:984:979:User for flatpak system helper:/:/sbin/nologin

gdm:x:42:42::/var/lib/gdm:/sbin/nologin

gnome-initial-setup:x:983:978::/run/gnome-initial-setup/:/sbin/nologin

vboxadd:x:982:1::/var/run/vboxadd:/sbin/nologin

sshd:x:74:74:Privilege-separated SSH:/usr/share/empty.sshd:/sbin/nologin

tcpdump:x:72:72::/:/sbin/nologin

jfasch:x:1000:1000:Joerg Faschingbauer:/home/jfasch:/bin/bash

mosquitto:x:981:974:Mosquitto Broker:/etc/mosquitto:/sbin/nologin

someone-else:x:1001:1001::/home/someone-else:/bin/bash

[341]:
f = open('/etc/passwd', encoding='ascii')
[342]:
for line in f:
    print(line)
root:x:0:0:root:/root:/bin/bash

bin:x:1:1:bin:/bin:/sbin/nologin

daemon:x:2:2:daemon:/sbin:/sbin/nologin

adm:x:3:4:adm:/var/adm:/sbin/nologin

lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin

sync:x:5:0:sync:/sbin:/bin/sync

shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown

halt:x:7:0:halt:/sbin:/sbin/halt

mail:x:8:12:mail:/var/spool/mail:/sbin/nologin

operator:x:11:0:operator:/root:/sbin/nologin

games:x:12:100:games:/usr/games:/sbin/nologin

ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin

nobody:x:65534:65534:Kernel Overflow User:/:/sbin/nologin

apache:x:48:48:Apache:/usr/share/httpd:/sbin/nologin

systemd-network:x:192:192:systemd Network Management:/:/sbin/nologin

systemd-coredump:x:999:997:systemd Core Dumper:/:/sbin/nologin

systemd-resolve:x:193:193:systemd Resolver:/:/sbin/nologin

systemd-oom:x:998:996:systemd Userspace OOM Killer:/:/sbin/nologin

systemd-timesync:x:997:995:systemd Time Synchronization:/:/sbin/nologin

tss:x:59:59:Account used for TPM access:/dev/null:/sbin/nologin

dbus:x:81:81:System message bus:/:/sbin/nologin

polkitd:x:996:994:User for polkitd:/:/sbin/nologin

avahi:x:70:70:Avahi mDNS/DNS-SD Stack:/var/run/avahi-daemon:/sbin/nologin

unbound:x:995:992:Unbound DNS resolver:/etc/unbound:/sbin/nologin

dnsmasq:x:994:991:Dnsmasq DHCP and DNS server:/var/lib/dnsmasq:/sbin/nologin

nm-openconnect:x:993:989:NetworkManager user for OpenConnect:/:/sbin/nologin

usbmuxd:x:113:113:usbmuxd user:/:/sbin/nologin

gluster:x:992:988:GlusterFS daemons:/run/gluster:/sbin/nologin

rtkit:x:172:172:RealtimeKit:/proc:/sbin/nologin

pipewire:x:991:987:PipeWire System Daemon:/var/run/pipewire:/sbin/nologin

geoclue:x:990:986:User for geoclue:/var/lib/geoclue:/sbin/nologin

chrony:x:989:984::/var/lib/chrony:/sbin/nologin

saslauth:x:988:76:Saslauthd user:/run/saslauthd:/sbin/nologin

radvd:x:75:75:radvd user:/:/sbin/nologin

rpc:x:32:32:Rpcbind Daemon:/var/lib/rpcbind:/sbin/nologin

qemu:x:107:107:qemu user:/:/sbin/nologin

openvpn:x:987:982:OpenVPN:/etc/openvpn:/sbin/nologin

nm-openvpn:x:986:981:Default user for running openvpn spawned by NetworkManager:/:/sbin/nologin

colord:x:985:980:User for colord:/var/lib/colord:/sbin/nologin

rpcuser:x:29:29:RPC Service User:/var/lib/nfs:/sbin/nologin

abrt:x:173:173::/etc/abrt:/sbin/nologin

flatpak:x:984:979:User for flatpak system helper:/:/sbin/nologin

gdm:x:42:42::/var/lib/gdm:/sbin/nologin

gnome-initial-setup:x:983:978::/run/gnome-initial-setup/:/sbin/nologin

vboxadd:x:982:1::/var/run/vboxadd:/sbin/nologin

sshd:x:74:74:Privilege-separated SSH:/usr/share/empty.sshd:/sbin/nologin

tcpdump:x:72:72::/:/sbin/nologin

jfasch:x:1000:1000:Joerg Faschingbauer:/home/jfasch:/bin/bash

mosquitto:x:981:974:Mosquitto Broker:/etc/mosquitto:/sbin/nologin

someone-else:x:1001:1001::/home/someone-else:/bin/bash

dict vs. OrderedDict

[343]:
d = {}
[344]:
d['five'] = 5
[345]:
d['three'] = 3
[346]:
for k in d.keys():
    print(k)
five
three
[348]:
import collections

od = collections.OrderedDict(d.items())
od
[348]:
OrderedDict([('five', 5), ('three', 3)])
[349]:
od['five']
[349]:
5
[351]:
found = od.get('ten')
print(found)
None
[352]:
for k in od.keys():
    print(k)
five
three
[353]:
od.move_to_end('five')
[354]:
for k in od.keys():
    print(k)
three
five

Object Oriented Programming

Duck Typing

[1]:
class ThermometerA:
    def __init__(self, t):
        self.temp = t
    def get_temperature(self):
        return self.temp
[3]:
class ThermometerB:
    def __init__(self, t):
        self.temp = t
    def get_temperature(self):
        return self.temp
[4]:
a = ThermometerA(10)
a.get_temperature()
[4]:
10
[6]:
b = ThermometerB(20)
b.get_temperature()
[6]:
20
[7]:
def get_average_temperature(th_list):
    avg = 0
    for t in th_list:
        avg += t.get_temperature()
    return avg/len(th_list)
[8]:
get_average_temperature([a, b])
[8]:
15.0

Interfaces

[23]:
class Thermometer:
    def get_temperature(self):
        assert False, 'this must be implemented'
[24]:
class ThermometerA(Thermometer):
    def __init__(self, t):
        self.temp = t
    def get_temperature(self):
        return self.temp
[25]:
class ThermometerB:
    def __init__(self, t):
        self.temp = t
    def get_temperature(self):
        return self.temp
[26]:
a = ThermometerA(10)
a.get_temperature()
[26]:
10
[28]:
b = ThermometerB(100)
b.get_temperature()
[28]:
100
[31]:
def get_average_temperature(th_list):
    avg = 0
    for t in th_list:
        if not isinstance(t, Thermometer):
            raise TypeError(f'{t} is not a Thermometer')
        avg += t.get_temperature()
    return avg/len(th_list)
[32]:
get_average_temperature([a,b])
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/tmp/ipykernel_9164/859664274.py in <module>
----> 1 get_average_temperature([a,b])

/tmp/ipykernel_9164/2942790015.py in get_average_temperature(th_list)
      3     for t in th_list:
      4         if not isinstance(t, Thermometer):
----> 5             raise TypeError(f'{t} is not a Thermometer')
      6         avg += t.get_temperature()
      7     return avg/len(th_list)

TypeError: <__main__.ThermometerB object at 0x7fac83797be0> is not a Thermometer
[34]:
issubclass(ThermometerA, Thermometer)
[34]:
True
[35]:
issubclass(ThermometerB, Thermometer)
[35]:
False
[36]:
class ThermometerB(Thermometer):
    def __init__(self, t):
        self.temp = t
    def get_temperature(self):
        return self.temp
[38]:
b = ThermometerB(1000)
[39]:
get_average_temperature([a, b])
[39]:
505.0

Implementation Inheritance

[23]:
class Thermometer:
    def get_temperature(self):
        assert False, 'this must be implemented'
[42]:
class ThermometerA(Thermometer):
    def __init__(self, name, t):
        self.name = name
        self.temp = t
    def get_temperature(self):
        return self.temp
[41]:
class ThermometerB(Thermometer):
    def __init__(self, name, t):
        self.name = name
        self.temp = t
    def get_temperature(self):
        return self.temp
[45]:
a = ThermometerA(name='Ein A Thermometer', t=10)
a.name
[45]:
'Ein A Thermometer'
[47]:
b = ThermometerB(name='Ein B Thermometer', t=1000)
b.name
[47]:
'Ein B Thermometer'

Nun aber fassen wir name in die Basisklasse

[51]:
class Thermometer:
    def __init__(self, name):
        self.name = name
    def get_temperature(self):
        assert False, 'this must be implemented'
[59]:
class ThermometerA(Thermometer):
    def __init__(self, name, t):
        super().__init__(name)
        self.temp = t
    def get_temperature(self):
        return self.temp
[63]:
class ThermometerB(Thermometer):
    def __init__(self, name, t):
        super().__init__(name)
        self.temp = t
    def get_temperature(self):
        return self.temp
[60]:
a = ThermometerA(name='Joerg', t=10)
[61]:
a.__dict__
[61]:
{'name': 'Joerg', 'temp': 10}
[64]:
a.name
[64]:
'Joerg'
[65]:
b = ThermometerB('Hansi', 100)
b.name
[65]:
'Hansi'

Method Resolution Order (MRO), and super()

[66]:
class Base:
    def f(self):
        print('Base.f')
[72]:
class Level2_1(Base):
    def f(self):
        print('Level2_1.f')
        super().f()
[74]:
l21 = Level2_1()
l21.f()
Level2_1.f
Base.f
[75]:
class Level2_2(Base):
    def f(self):
        print('level2_2.f')
        super().f()
[78]:
class Level3(Level2_1, Level2_2):
    def f(self):
        print('Level3.f')
        super().f()
[79]:
l3 = Level3()
l3.f()
Level3.f
Level2_1.f
level2_2.f
Base.f

__bases__

[80]:
Base.__bases__
[80]:
(object,)
[81]:
Level2_1.__bases__
[81]:
(__main__.Base,)
[83]:
Level2_2.__bases__
[83]:
(__main__.Base,)
[85]:
Level3.__bases__
[85]:
(__main__.Level2_1, __main__.Level2_2)

__mro__

[86]:
Level3.__mro__
[86]:
(__main__.Level3, __main__.Level2_1, __main__.Level2_2, __main__.Base, object)
[87]:
Level2_1.__mro__
[87]:
(__main__.Level2_1, __main__.Base, object)
[88]:
Base.__mro__
[88]:
(__main__.Base, object)

Object Layout (self)

[89]:
class Jedi:
    def f(self):
        self.force = 15
[94]:
class Luke(Jedi):
    def f(self):
        self.blueeyes = True
        super().f()
[97]:
luke = Luke()
luke.__dict__
[97]:
{}
[96]:
luke.f()
luke.__dict__
[96]:
{'blueeyes': True, 'force': 15}

More from OO

[111]:
class Robot:
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return 'Robot name is: ' + self.name
[112]:
class Droid(Robot):
    def __str__(self):
        return 'Droid name is: ' + self.name
[114]:
d = Droid('R2D2')
[117]:
d.name
[117]:
'R2D2'
[119]:
print(d)
Droid name is: R2D2
[120]:
d.__str__()
[120]:
'Droid name is: R2D2'
[121]:
d.__dict__
[121]:
{'name': 'R2D2'}
[122]:
d.__dict__['name']
[122]:
'R2D2'
[123]:
d.name
[123]:
'R2D2'
[124]:
type(Droid)
[124]:
type
[125]:
Droid.__dict__
[125]:
mappingproxy({'__module__': '__main__',
              '__str__': <function __main__.Droid.__str__(self)>,
              '__doc__': None})
[126]:
Droid.__bases__
[126]:
(__main__.Robot,)
[127]:
Droid.__bases__[0].__dict__
[127]:
mappingproxy({'__module__': '__main__',
              '__init__': <function __main__.Robot.__init__(self, name)>,
              '__str__': <function __main__.Robot.__str__(self)>,
              '__dict__': <attribute '__dict__' of 'Robot' objects>,
              '__weakref__': <attribute '__weakref__' of 'Robot' objects>,
              '__doc__': None})

Operator Overloading

[155]:
class Integer:
    def __init__(self, value):
        print('__init__')
        self.value = value
    def __str__(self):
        print('__str__')
        return str(self.value)
    def __lt__(self, rhs):
        if self.value < rhs.value:
            return True
        else:
            return False
    def __add__(self, rhs):
        return Integer(self.value + rhs.value)
[149]:
i = Integer(42)
print(i)
__init__
__str__
42
[150]:
j = Integer(666)
__init__
[152]:
i < j
[152]:
True
[156]:
s = i + j
print(s)
__init__
__str__
708

Calling Base Class Constructor (Many Ways)

[173]:
class Base:
    def __init__(self, val):
        print('Base.__init__')
        self.val = val
[174]:
class DerivedNoCtor(Base):
    pass
[175]:
dnoctor = DerivedNoCtor(10)
Base.__init__
[176]:
dnoctor.val
[176]:
10
[181]:
class DerivedCtorCallingSuper(Base):
    def __init__(self, val):
        print('DerivedCtorCallingSuper.__init__')
        super().__init__(val)
[180]:
o = DerivedCtorCallingSuper(666)
DerivedCtorCallingSuper.__init__
Base.__init__
[183]:
class DerivedCtorCallingBaseCtor(Base):
    def __init__(self, val):
        print('DerivedCtorCallingBaseCtor.__init__')
        Base.__init__(self, val)
[184]:
o = DerivedCtorCallingBaseCtor(42)
DerivedCtorCallingBaseCtor.__init__
Base.__init__

Name Mangling (“private” Members)

[185]:
class User:
    def __init__(self, firstname, lastname):
        self.__firstname = firstname
        self.__lastname = lastname
[188]:
try:
    u.__firstname
except Exception as e:
    print(type(e), e)
<class 'AttributeError'> 'User' object has no attribute '__firstname'
[186]:
u = User("Joerg", "Faschingbauer")
u.__dict__
[186]:
{'_User__firstname': 'Joerg', '_User__lastname': 'Faschingbauer'}
[189]:
u._User__firstname
[189]:
'Joerg'

Properties

[200]:
class User:
    def __init__(self, firstname, lastname):
        self.__firstname = firstname
        self.__lastname = lastname
    @property
    def firstname(self):
        return self.__firstname

    @property
    def lastname(self):
        return self.__lastname

    @property
    def name(self):
        return self.__firstname + ' ' + self.__lastname
[201]:
u = User("Joerg", "Faschingbauer")
u.name
[201]:
'Joerg Faschingbauer'
[202]:
u.firstname
[202]:
'Joerg'
[204]:
u.lastname
[204]:
'Faschingbauer'
[206]:
try:
    u.lastname = 'Huber'
except Exception as e:
    print(type(e), e)
<class 'AttributeError'> can't set attribute

Yet Another Example From Udemy

[286]:
class Jedi:
    LightSaber = True
[287]:
class Padawan(Jedi):
    def __init__(self, name):
        self.name = name
[288]:
issubclass(Padawan, Jedi)
[288]:
True
[289]:
p = Padawan('Joerg')
[290]:
isinstance(p, Padawan)
[290]:
True
[291]:
isinstance(p, Jedi)
[291]:
True
[292]:
p.name
[292]:
'Joerg'
[293]:
hasattr(p, 'name')
[293]:
True
[294]:
getattr(p, 'name')
[294]:
'Joerg'
[295]:
p.__dict__.get('name')
[295]:
'Joerg'
[297]:
hasattr(Jedi, 'LightSaber')
[297]:
True
[299]:
hasattr(Padawan, 'LightSaber')
[299]:
True
[300]:
Padawan.LightSaber
[300]:
True

Exception Handling

Order of except Clauses

[159]:
try:
    1/0
except ArithmeticError:
    print('ArithmeticError')
except ZeroDivisionError:
    print('ZeroDivisionError')
ArithmeticError
[160]:
issubclass(ZeroDivisionError, ArithmeticError)
[160]:
True
[161]:
try:
    1/0
except ZeroDivisionError:
    print('ZeroDivisionError')
except ArithmeticError:
    print('ArithmeticError')
ZeroDivisionError

else

[162]:
try:
    print('hallo du suesser!')
except OSError as e:
    print('WAAAH hardware abgebrannt!', e)
else:
    print('puh, hardware intakt')
hallo du suesser!
puh, hardware intakt

finally

[169]:
try:
    print('hallo du suesser!')
except OSError as e:
    print('WAAAH hardware abgebrannt!', e)
else:
    print('puh, hardware intakt')   # only if no exception
finally:
    print('wurscht, vorbei is')    # in any case
hallo du suesser!
puh, hardware intakt
wurscht, vorbei is

lambda

[213]:
def f(x):
    if x > 1:
        return 1
    else:
        return 0

[208]:
f(3)
[208]:
1
[209]:
f(1)
[209]:
0
[214]:
f = lambda x: 1 if x>1 else 0
[212]:
f(1)
[212]:
0

map(), filter()

[215]:
def square(num):
    return num**2
[216]:
l = [2, 1, 5, 3, 6]
for element in map(square, l):
    print(element)
4
1
25
9
36
[217]:
m = map(square, l)
type(m)
[217]:
map
[218]:
for element in map(lambda num: num**2, l):
    print(element)
4
1
25
9
36
[219]:
l
[219]:
[2, 1, 5, 3, 6]
[222]:
def is_even(num):
    if num%2 == 0:
        return True
    return False
[223]:
for element in filter(is_even, l):
    print(element)
2
6

Generators, Iteration Protocol

[224]:
r = range(3)
[226]:
for element in r:
    print(element)
0
1
2
[227]:
r = range(3)
[228]:
it = iter(r)
[229]:
next(it)
[229]:
0
[230]:
next(it)
[230]:
1
[231]:
next(it)
[231]:
2
[233]:
try:
    next(it)
except Exception as e:
    print(type(e), e)
<class 'StopIteration'>
[234]:
def my_range(limit):
    i = 0
    while i < limit:
        yield i
        i += 1
[235]:
for element in my_range(3):
    print(element)
0
1
2
[236]:
r = my_range(3)
[238]:
type(r)
[238]:
generator
[241]:
it = iter(r)
[242]:
next(it)
[242]:
0
[243]:
next(it)
[243]:
1
[244]:
next(it)
[244]:
2
[246]:
try:
    next(it)
except Exception as e:
    print(type(e), e)
<class 'StopIteration'>

Class Variables (as Opposed to Instance Variables)

[257]:
class Blah:
    instances = []

    def __init__(self, value):
        Blah.instances.append(self)
        self.value = value
[258]:
Blah.instances
[258]:
[]
[259]:
b = Blah(42)
[260]:
b.instances
[260]:
[<__main__.Blah at 0x7fac81f52df0>]
[261]:
b.value
[261]:
42
[262]:
c = Blah(23)
[263]:
Blah.instances
[263]:
[<__main__.Blah at 0x7fac81f52df0>, <__main__.Blah at 0x7fac81cb5700>]
[253]:
Blah.__init__
[253]:
<function __main__.Blah.__init__(self, value)>

Raw Strings

[264]:
s = 'C:\Progamme\noch ein programm\tumpfbacke'
[265]:
print(s)
C:\Progamme
och ein programm        umpfbacke
[266]:
s = 'C:\\Progamme\\noch ein programm\\tumpfbacke'
[267]:
print(s)
C:\Progamme\noch ein programm\tumpfbacke
[268]:
s = r'C:\Progamme\noch ein programm\tumpfbacke'
[269]:
print(s)
C:\Progamme\noch ein programm\tumpfbacke

File IO

[270]:
f = open('file.txt', 'rt')  # r and t are default anyway
[271]:
for line in f:
    print(line)
zeile 1

zeile 2

zeile 3

zeile 4

[273]:
f = open('file.txt', 'rt')  # r and t are default anyway
[274]:
for line in f:
    print(line, end='')
zeile 1
zeile 2
zeile 3
zeile 4
[278]:
f = open('file.txt', 'rt')  # r and t are default anyway
[279]:
wholefile = f.read()
wholefile
[279]:
'zeile 1\nzeile 2\nzeile 3\nzeile 4\n'
[280]:
print(wholefile)
zeile 1
zeile 2
zeile 3
zeile 4

[281]:
f = open('file.txt', 'rt')  # r and t are default anyway
[282]:
wholefile = f.read()
for c in wholefile:
    print(c)
z
e
i
l
e

1


z
e
i
l
e

2


z
e
i
l
e

3


z
e
i
l
e

4


[284]:
f = open('file.txt', 'rt')  # r and t are default anyway
[285]:
wholefile = f.read()
for c in wholefile:
    print(c, end='')
zeile 1
zeile 2
zeile 3
zeile 4