Please enable JavaScript.

Coggle requires JavaScript to display documents.

Python PART1 - Coggle Diagram

- - - - def ask_ok(prompt, retries=4, reminder='Please try again!'):
      - The default value is evaluated only once. But This makes a difference when the default is a mutable object such as a list, dictionary, or instances of most classes
        
        def f(a, L=[]):
        L.append(a)
        return L
        print(f(1))
        print(f(2))
        print(f(3))
        => [1]
        [1, 2]
        [1, 2, 3]
        
        If you don’t want the default to be shared between subsequent calls, you can write the function like this instead:
        def f(a, L=None):
        if L is None:
        L = []
        L.append(a)
        return L
    - - def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
      - parrot(1000) # 1 positional argument
        parrot(voltage=1000) # 1 keyword argument
        parrot(voltage=1000000, action='VOOOOOM') # 2 keyword arguments
        parrot(action='VOOOOOM', voltage=1000000) # 2 keyword arguments
        parrot('a million', 'bereft of life', 'jump') # 3 positional arguments
        parrot('a thousand', state='pushing up the daisies') # 1 positional, 1 keyword
      - parrot() # required argument missing
        parrot(voltage=5.0, 'dead') # non-keyword argument after a keyword argument
        parrot(110, voltage=220) # duplicate value for the same argument
        parrot(actor='John Cleese') # unknown keyword argument
      - All the keyword arguments passed must match one of the arguments accepted
      - No argument may receive a value more than once
      - **name: it receives a dictionary containing all keyword arguments except for those corresponding to a formal parameter
      - *name: which receives a tuple containing the positional arguments beyond the formal parameter list.
      - *name must occur before **name.
    - - def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
        ----------- ---------- ---------- | | | | Positional or keyword | | - Keyword only -- Positional only
    - - write the function call with the *-operator to unpack the arguments out of a list or tuple
        
        args = [3, 6]
        list(range(*args)) # call with arguments unpacked from a list
        [3, 4, 5]
      - dictionaries can deliver keyword arguments with the **-operator:
        
        def parrot(voltage, state='a stiff', action='voom'):
        ... print("-- This parrot wouldn't", action, end=' ')
        ... print("if you put", voltage, "volts through it.", end=' ')
        ... print("E's", state, "!")
        ...
        => d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
        => parrot(**d)
    - - Like nested function definitions, lambda functions can reference variables from the containing scope
      - They are syntactically restricted to a single expression
      - def make_incrementor(n):
        ... return lambda x: x + n
        ...
        
        f = make_incrementor(42)
        f(0)
        42
        f(1)
        43
    - - def my_function():
        ... """Do nothing, but document it.
        ...
        ... No, really, it doesn't do anything.
        ... """
        ... pass
        ...
        print(my_function.doc)
    - - Function annotations are completely optional metadata information about the types used by user-defined functions
        
        def f(ham: str, eggs: str = 'eggs') -> str:
        ... print("Annotations:", f.annotations)
        ... print("Arguments:", ham, eggs)
        ... return ham + ' and ' + eggs
        ...
        f('spam')
        Annotations: {'ham': <class 'str'>, 'return': <class 'str'>, 'eggs': <class 'str'>}
        Arguments: spam eggs
        'spam and eggs'
- - - - stack = [3, 4, 5]
        stack.append(6)
        stack.append(7)
        stack
        [3, 4, 5, 6, 7]
        stack.pop()
        7
        stack
        [3, 4, 5, 6]
        stack.pop()
        6
        stack.pop()
        5
        stack
        [3, 4]
    - - >>> from collections import deque
        queue = deque(["Eric", "John", "Michael"])
        
        queue.append("Terry") # Terry arrives
        queue.append("Graham") # Graham arrives
        queue.popleft() # The first to arrive now leaves
        'Eric'
        queue.popleft() # The second to arrive now leaves
        'John'
        queue # Remaining queue in order of arrival
        deque(['Michael', 'Terry', 'Graham'])
    - - A list comprehension consists of brackets containing an expression followed by a for clause, then zero or more for or if clauses
        
        [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
        [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
    - - [[row[i] for row in matrix] for i in range(4)]
      - matrix = [
        ... [1, 2, 3, 4],
        ... [5, 6, 7, 8],
        ... [9, 10, 11, 12],
        ... ]
  - - - knights = {'gallahad': 'the pure', 'robin': 'the brave'}
        for k, v in knights.items():
        ... print(k, v)
        ...
        gallahad the pure
        robin the brave
    - - for i, v in enumerate(['tic', 'tac', 'toe']):
        ... print(i, v)
        ...
        0 tic
        1 tac
        2 toe
    - - questions = ['name', 'quest', 'favorite color']
        answers = ['lancelot', 'the holy grail', 'blue']
        for q, a in zip(questions, answers):
        ... print('What is your {0}? It is {1}.'.format(q, a))
        ...
        What is your name? It is lancelot.
        What is your quest? It is the holy grail.
        What is your favorite color? It is blue.