Please enable JavaScript.

Coggle requires JavaScript to display documents.

Python - Automate Boring Stuff - Coggle Diagram

- - - - Expression: 2+2 or 4
        
        value: 2
        
        Operator
        
        ** Exponent
        
        % Modulus/remainder
        
        // Integer division/floored quotient
        
        / Division
        
        .* Multiplication
        
        Subtraction
        
        Addition
    - - Integers: -2, -1, 0, 1, 2, 3
      - Floats: -1.25, -1.0 0.0 1.0 1.25
      - Strings: 'a', 'aa', 'Hello', '11 cats'
    - - 'Alice' + 'Bob' = 'AliceBob'
      - 'Alice' * 5 = AliceAliceAliceAliceAlice
    - - Assignment Statements
        
        ex: spam = 42 ex: egg = 3
        
        spam/egg is a variable
        
        42 or 3 is integer value of the variable spam or egg
        
        spam + egg = 45
        
        spam = spam +2 >> spam = 44
      - Variable names
        
        Can be only one word with no spaces
        
        IT can use only letters, numbers,
        and underscore character
        
        It can't begin with a number
        
        Case-sensitive
    - - Comment: start with #
        Commenting out code: start with # at beginning of code line
      - print() function
        
        an Argument: the value that is passed to a function
        
        print out String or integer or floats value
      - input() function
        
        Wait for user to type some text on the keyboard and press ENTER
      - len() function
        
        can pass a string value in ()
        
        or can pass a variable containing a string in () ex: print(len(myname))
      - str(), int(), float() functions
  - - - data type: True
      - data type: False
    - - == Equal to
      - != Not equal to
      - < Less than
      - .> Greater than
      - <= Less than or equal to
      - = Greater than or equal to
    - - and
        
        True and True = True
        
        True and False = False
        
        False and True = False
        
        False and False = False
      - or
        
        True or False = True
        
        True or True = True
        
        False and True = True
        
        False or False = False
      - not
        
        not True = False
        
        not False = True
    - - Conditions
      - Blocks of Code
        
        Blocks begin when the indentation increase
        
        Block can contain other blocks
        
        Blocks end when the indentation decreases to zero or to a containing block's indentation
    - - If statements
        
        the If keyword
        
        A condition ( that is, an expression that evaluates to True or False)
        
        A colon :
        
        Starting on the next line, an indented block of code (called the if clause)
      - else Statements
        
        The else keyword
        
        A colon :
        
        Starting on the next line, an indented block of code ( called the else clause)
      - elif Statements
        
        The elif keyword
        
        A condition ( that is, an expression that evaluates to True or False)
        
        A colon
        
        Starting on the next line, an intended block of code ( called the elif clause)
      - while Loop Statements
        
        the while keyword
        
        A Condition ( that is, an expression that evaluates to True or False)
        
        A colon
        
        Starting on the next line, an indented block of code (called the while clause)
        
        break Statements
        
        beak keyword: breaking out the while loop's clause early
        
        continue Statements
      - for Loops and the range() Function
        
        the for keyword
        
        A variable name
        
        The in keyword
        
        A call to the range() method with up to three integers passed to it
        
        A colon
        
        Starting on the next line, an intended block of code ( called the for clause)
    - - Import keyword
      - the Name of the module ( ex:math, random)
      - Optionally, more module names, as long as they are separated by commas
    - - ex: from random import*
      - Calls to functions in random will not need the random. prefix
    - - import sys
      - sys.exit()
  - - - Define: to define a function is to create it
      - Call: the sayHell('Al') calls the now-created function, sending the execution to the top of the function's code
      - Pass: this function call is also known as passing the string value 'Al' to the function
      - Argument: A value being passed to a function in a function call is an Argument. the argument 'Al' is assigned to a local variable named name
      - Parameter: Variables that have arguments assigned to them are parameters.
    - - sep=''
      - end =
    - - Code in global scope, outside of all functions, cannot use any local variables
      - However, code in a local scope can access global variables
      - Code in a functions's local scope cannot use variables in any other local scopes
      - Can use same name for different variables if they are in different scopes. That is, there can be a local variable named spam and a global variable also named spam
    - - If a variable is being used in the global scope, then it is always a global variable
      - If there is a global statement for that variable in a function, it is a global variable
      - Otherwise, if the variable is used in an assignment statement in the function, it is a local variable
      - But if the variable is not used in an assignment statement, it is a global variable
  - - - Getting Individual Values in a List with Indexes
        
        'index' is the integer inside the square brackets that follows the list
        ex: spam = ['cat', 'bat', 'rat', 'elephent']
        spam[0] would evaluate to 'cat'
        spam[1] would evaluate to 'bat'
        
        negative index
        ex: spam[-1] evaluate to elephent
      - Getting a List from Another List with Slice
        
        spam[2] is a list with an index (one integer)
        
        spam[0:4] is a list with a slice (two integer)
      - Getting a List's Length with the len() Function
        
        spam = ['cat','dog','bat'] -> len(spam) = 3
      - Changing Values in a List with indexes
        
        spam=['cat','bat','rat','elephent']
        spam[0]= 'Mouse'
        spam
        ['Mouse', 'bat', 'rat', 'elephent']
      - List Concatenation and List Replication
        
        Input: [1,2,3] + ['a','b','c']
        Out: [1, 2, 3, 'a', 'b', 'c']
        
        Input: ['x','y','z']*3
        Out: ['x', 'y', 'z', 'x', 'y', 'z', 'x', 'y', 'z']
      - Removing Values from Lists with del Statements
        
        spam = ['cat','bat','rat','elephent']
        del spam[2]
        spam
        ['cat', 'bat', 'elephent']
        del spam[2]
        spam
        ['cat', 'bat']
    - - catNames = []
        while True:
        print('Enter the name of cat ' + str(len(catNames) + 1) + '(Or enter nothing to stop.):')
        name = input()
        if name == '':
        break
        catNames = catNames +[name] # list concatenation
        print(catNames)
        for name in catNames:
        print(' ' + name)
      - Using for loops with lists
        
        supplies = ['pen',' staplers', 'flamethrowers', 'binders']
        for i in range(len(supplies)):
        print('Index ' + str(i) + ' in supplies is: ' + supplies[i])
        Index 0 in supplies is: pen
        Index 1 in supplies is: staplers
        Index 2 in supplies is: flamethrowers
        Index 3 in supplies is: binders
      - The in and not in Operator
        
        in and not in are used in expressions and connect two values: a value to look for in a list and the list where it may be found. These expressions will evaluate to a Boolean value.
        
        Ex:
        'howdy' in ['hello','hi','howdy','heyas']
        Out[1]: True
        spam = ['hello','hi','howdy','heyas']
        'cat' in spam
        Out[3]: False
      - Using the enumerate() function with List
        Ex:
        supplies = ['pen','stapler','flamethrowers','binders']
        for index, item in enumerate(supplies):
        ........print('Index ' + str(index) + ' in supplies is: ' + item)
      - The Multiple Assignment Trick:
        Ex:
        myPets = ['Zophie','Pooka','Fat-tail'
        ]good,normal,sick = myPets
      - Using the random.choice() and random.shuffle() Functions with List
    - - Finding a Value in a
        List with the index() Method
        
        Ex:
        spam = ['hello','hi','howdy','heyas']
        spam.index('hello')
        0
        spam.index('howdy')
        2
      - Adding Values to Lists with the
        append() and insert() Methods
        
        ex:
        spam=['cat','dog','bat']
        spam.append('moose')
        spam
        ['cat', 'dog', 'bat', 'moose']
        
        ex:
        spam=['cat', 'dog', 'bat', 'moose']
        spam.insert(1,'chicken')
        spam
        Out[5]: ['cat', 'chicken', 'dog', 'bat', 'moose']
        
        Method belongs to a single data Type.
        the append() and insert() methods are list methods
      - Removing Values from
        List with the remove() Method
        
        Ex:
        spam = ['cat','bat','rat','elephant']
        spam.remove('bat')
        spam
        spam = ['cat','rat','elephant']
      - Sorting the Values in a List with the sort() Method
        
        Ex:
        spam = [2,5,3.14,1,-7]
        spam.sort()
        spam
        Out[3]: [-7, 1, 2, 3.14, 5]
        
        Ex:
        spam=['ants','cats','dogs','badger','elephant']
        spam.sort()
        spam
        ['ants', 'badger', 'cats', 'dogs', 'elephant']
        
        spam=['ants', 'badger', 'cats', 'dogs', 'elephant']
        spam.sort(reverse=True)
        spam
        Out[5]: ['elephant', 'dogs', 'cats', 'badger', 'ants']
        
        spam=['Ants', 'badger', 'Cats', 'dogs', 'Elephant']
        spam.sort()
        spam
        ['Ants','Cats','Elephant', 'badger', 'dogs']
        
        spam=['a','z','A','Z']
        spam.sort(key=str.lower)
        spam
        spam=['a','A','z','Z']
      - reversing the Value in a List with the reverse() Method
        
        spam=['cat','dog','bat']
        spam.reverse()
        spam
        ['bat', 'dog', 'cat']
    - - name = 'Zophie'
        name[0]
        'Z'
        name[0:4]
        'Zoph'
        'Zo' in name
        True
      - Mutable and Immutable Data Type
        
        List value is Mutable Data TYPE: It can have values added, removed, or changed
        
        A string is immutable Data Type: It can not be changed
      - The Tuple Data Type
        
        tuples are typed with parentheses, (and)
        Ex: eggs = ('hello',42,0.5)
        eggs[0]
        'hello'
        
        tuple are immutable
        
        type(('hello',))
        Out[1]: tuple
        
        type('hello')
        Out[2]: str
      - Converting Types with the list() and tuple() Functions
    - - the value of variable is stored in
        Computer's memory
      - the spam = [0,1,2] stores a reference to a list, not the actual list
      - Python variables technically contain references to values,
        People often casually say that the variable contains the value
    - - id('howdy')
        Out[1]: 2491944493360
      - id(bacon)
        Out[3]: 2491944393200
        bacon += 'World'
        id(bacon)
        Out[5]: 2491944133104
      - "Modifying object in-place with append() method
        eggs = ['cat','dog']
        id(eggs)
        Out[2]: 2159396349376
        eggs.append('moose')
        id(eggs)
        Out[4]: 2159396349376
      - append(), extend(), remove(),sort(), reverse(), and other list methods modify their lists in place
    - - def eggs(someParameter):
        someParameter.append('Hello')
        spam = [1,2,3]
        eggs(spam)
        print(spam)
        
        [1, 2, 3, 'Hello']
    - - Can copy of a mutable value like a list or dictionary
        not just copy of a reference
      - import copy
        spam = ['A','B','C','D']
        id(spam)
        Out[3]: 2214493120256
        cheese = copy.copy(spam)
        id(cheese)
        Out[5]: 2214493120000
        cheese[1]=42
        spam
        Out[9]: ['A', 'B', 'C', 'D']
        In [10]: cheese
        Out[10]: ['A', 42, 'C', 'D']
  - - - Dictionary is a mutable collection of many values
      - Unlike indexes for lists, indexes for dictionaries can use many different data types, not just integers.
      - Indexes for dictionaries are called "keys"
        key with its associated value is called a key-value pair
      - In code, dictionary is typed with braces {}
        ex: myCat = {'size': 'fat', 'color': 'gray','disposition': 'loud'}
        
        The dictionary's keys are 'size', 'color' and 'disposition'
        
        The values for those keys are 'fat', 'gray' and 'loud'
        ex:
        In: myCat['color']
        Out: 'gray'
      - Dictionary can still use integer as keys
        spam = {12345: 'Luggage Combination', 42: 'the Answer'}
    - - Dictionaries are unordered
        ex:
        spam = ['cat','dog','moose']
        bacon = ['dog','moose','cat']
        spam == bacon
        Out[3]: False
        eggs={'name': 'Zophie', 'species': 'cat', 'age': '8'}
        ham = {'species': 'cat','age': '8', 'name': 'Zophie'}
        eggs == ham
        Out[6]: True
    - - keys: key()
        values: values()
        keys and values: items()
      - The values returned by these methods
        are not true lists: they cannot be modified & don't have append() method.
      - These data types ( dict_keys, dict_values, dict_items) can be used in for loops
      - Ex:
        spam = {'color': 'red', 'age': 42}
        for v in spam.values():
        print(v)
        [output]
        red
        42
      - Ex:
        spam = {'color': 'red', 'age': 42}
        for v in spam.keys():
        Output:
        color
        age
      - Ex:
        spam = {'color': 'red', 'age': 42}
        for i in spam.items():
        --- print(i)
        Output:
        ('color', 'red')
        ('age', 42)
      - if we want a true list from one of these methods, pass it list-like return value to the list() function.
        Ex:
        spam = {'color': 'red', 'age': 42}
        spam.keys()
        Out[2]: dict_keys(['color', 'age'])
        list(spam.keys())
        Out[3]: ['color', 'age']
      - Use multiple assignment trick in a for loop to assign key and value to separate variables.
        ex:
        spam = {'color': 'red', 'age': 42}
        for k, v in spam.items():
        ---- print('Key: ' + k + ' Value: ' +str(v))
        Key: color Value: red
        Key: age Value: 42
    - - spam = {'name': 'Zophie', 'age': 7}
        'name' in spam.keys()
        Out: True
        OR
        'name' in spam
        Out[7]: True
      - spam = {'name': 'Zophie', 'age': 7}
        'Zophie' in spam.values()
        Out[6]: True
    - - get() method that takes two arguments
        
        the key of the value to retrieve
        
        a fallback value to return if that key does not exist
      - picnicItems = {'apples': 5, 'cups':2}
        ' I am bringing ' + str(picnicItems.get('cups', 0)) + ' cups.'
        Out[2]: ' I am bringing 2 cups.'
        ' I am bringing ' + str(picnicItems.get('eggs', 0)) + ' cups.'
        Out[3]: ' I am bringing 0 cups.'
    - - Without using get() method
        spam = {'name': 'Pooka', 'age': 5}
        if 'color' not in spam:
        ...: spam['color'] = 'black'
        spam
        Out[4]: {'name': 'Pooka', 'age': 5, 'color': 'black'}
      - Using get() method:
        spam = {'name': 'Pooka', 'age': 5}
        spam.setdefault('color','black')
        Out[2]: 'black'
        spam
        Out[3]: {'name': 'Pooka', 'age': 5, 'color': 'black'}
        spam.setdefault('color','white')
        Out[4]: 'black'
        In [5]: spam
        Out[5]: {'name': 'Pooka', 'age': 5, 'color': 'black'}
    - - import pprint
        message = ' It was a bright cold day in April, and the clocks were striking thirteen'
        count={}
        for character in message:
        ----count.setdefault(character,0)
        ----count[character] = count[character] + 1
        pprint.pprint(count)
    - - We might need dictionaries and lists that contain other dictionaries and lists for a complicated thing
      - Lists are useful to contain an ordered series of values
        Dictionaries are useful for associating keys with values.
      - allGuests = {'Alice': {'apples':5, 'pretzels':12},'Bob': {'ham sandwiches':3,'apples':2},'Carol':{'cups':3,'apple pies':1}}
        def totalBrought(guests, item):
        -----numBrought = 0
        -----for k, v in guests.items():
        --------numBrought = numBrought +v.get(item,0)
        -----return numBrought
        print('Number of things being brought:')
        print(' - Apples ' + str(totalBrought(allGuests, 'apples')))
        print(' - Cups ' + str(totalBrought(allGuests, 'cups')))
        print(' - Cakes ' + str(totalBrought(allGuests, 'cakes')))
        print(' - Ham Sandwiches ' + str(totalBrought(allGuests, 'ham sandwiches')))
        print(' - Apple Pies ' + str(totalBrought(allGuests, 'apple pies')))
        Number of things being brought:
        
        Apples 7
        
        Cups 3
        
        Cakes 0
        
        Ham Sandwiches 3
        
        Apple Pies 1
  - - - String Literals
        Ex: Typing 'that is Alice's cat' won't work
        because Python thinks the string ends after Alice
        
        Double Quotes
        Ex: spam = "That is Alice's cat."
        
        Escape Character: If you need to use both single quotes and double quotes in the string, you'll need to use escape characters.
        Ex:
        spam = 'Say hi to Bob\'s mother.'
        spam
        Out[2]: "Say hi to Bob's mother."
        Escape Characters:
        \' Single quote
        \" Double quote
        \t Tab
        \n Newline(line break)
        \ Backslash
        Ex:
        print("Hello there!\nHow are you?\nI\'m doing fine.")
        Hello there!
        How are you?
        I'm doing fine.
        
        Raw strings
        it completely ignores all escape characters and prints any backslash that appears in the string.
        Ex:
        print(r'that is Carol\'s cat.')
        that is Carol\'s cat.
        
        Multiline strings with Triple Quotes
        While we can use \n escape character to put a newline into a string, it is often easier to use multiline strings.
        Ex:
        print(''' Dear Alice,
        ...: Eve's cat has been arrested for catnapping, cat burglary, and extortion.
        ...: Sincerely,
        ...: Bob''')
        the output will be
        Dear Alice,
        Eve's cat has been arrested for catnapping, cat burglary, and extortion.
        Sincerely,
        Bob
        
        Multiline Comment
        """ this is a test python program.
        Written by AI sweigart
        this program was design for Python 3, not Python 2."""
      - Indexing and Slicing Strings
        
        String use indexes and slices the same way lists do
        
        spam = 'Hello, world!'
        spam[0]
        'H'
        spam[0:5]
        'Hello'
        spam[:5]
        'Hello'
        spam[7:]
        'world!'
        
        spam = 'Hello, world!'
        fizz = spam[0:5]
        fzz
        'Hello'
      - The In and not in Operators with String
        
        The in and not in operators can be used with strings just like with list and values
        
        spam = 'Hello, world!'
        'Hello' in spam
        Out[18]: True
        
        spam = 'Hello, world!'
        'HELLO' in spam
        Out[19]: False
      - Putting Strings inside Other String
        
        String interpolation
        Ex:
        name = 'Al'
        age = 4000
        'My name is %s, I am %s years old.' %(name,age)
        Out[3]: 'My name is Al, I am 4000 years old.'
        
        Python 3.6 introduced f-strings
        Ex:
        name = 'Al'
        age = 4000
        f'My name is {name}. Next year I will be {age +1}.'
        'My name is Al. Next year I will be 4001.'
    - - The upper(), Lower(), isupper(), islower() Methods
        
        spam = 'Hello, world!'
        spam = spam.upper()
        spam
        Out[3]: 'HELLO, WORLD!'
        spam = spam.lower()
        spam
        Out[5]: 'hello, world!'
        
        isupper() and islower() methods will return a Boolean True value if the string has at least one letter and all the letters are uppercase or lowercase, respectively.
        Ex: spam = 'Hello, world!'
        spam.isupper()
        Out[3]: False
        spam.islower()
        Out[4]: False
        'HELLO'.isupper()
        Out[6]: True
        'abc1234'.islower()
        Out[8]: True
        '1234'.islower()
        Out[9]: False
        '1234'.isupper()
        Out[10]: False
        
        'Hello'.upper()
        Out[1]: 'HELLO'
        'Hello'.upper().lower()
        Out[2]: 'hello'
        'Hello'.upper().lower().upper()
        Out[3]: 'HELLO'
        'HELLO'.lower().islower()
        Out[4]: True
      - The isX() Methods
        
        isalpha(): Return True if the string consists only of letters and isn't blank
        isalnum() Returns True if the string consists only of letters ang numbers and if not blank
        isdecimal() returns True if the string consists only of numeric characters and is not blank
        isspace() returns True if the string consists only of spaces, tabs, and newlines and is not blank.
        istitle() Returns True if the string consists only of words that begin with an uppercase letter followed by only lowercase letters
        
        while True:
        ----print(' Enter your age:')
        ----age = input()
        ----if age.isdecimal():
        --------break
        ----print('Please enter a number for your age.')
      - The startswith() and endswith() Methods
        
        The startswith() and endswith() methods return True value if the string value they are called on begins or ends ( respectively) with the string passed to the method.
        
        'Hello, world!' .startswith('Hello')
        Out[1]: True
        'Hello, world!' .endswith('world')
        Out[4]: False
      - The join() and split() Methods
        
        ', '.join(['cat', 'rat', 'bats'])
        Out[5]: 'cat, rat, bats'
        
        ' '.join(['My', 'name', 'is', 'Simon'])
        Out[7]: 'My name is Simon'
        
        'ABC'.join(['My', 'name', 'is', 'Simon'])
        Out[8]: 'MyABCnameABCisABCSimon'
        
        'My name is Simon'.split()
        Out[9]: ['My', 'name', 'is', 'Simon']
        
        'MyABCnameABCisABCSimon'.split('ABC')
        Out[13]: ['My', 'name', 'is', 'Simon']
        
        spam = '''Dear Alice,
        ...: How have you been? I am fine.
        ...: There is a container in the fridge
        ...: that is labled ""milk experiment."
        ...: Please do not drink it.
        ...: Sincerely,
        ...: Boob'''
        spam.split('\n')
        Out[15]:
        ['Dear Alice,','How have you been? I am fine.','There is a container in the fridge','that is labled ""milk experiment."','','Place do not drink it.','Sincerely,','Boob']
      - Splitting strings with the partition() Method
        
        'Hello, world!'.partition('w')
        Out[1]: ('Hello, ', 'w', 'orld!')
        
        'Hello, world!'.partition('o')
        Out[2]: ('Hell', 'o', ', world!')
        
        'Hello, world!'.partition('XYZ')
        Out[3]: ('Hello, world!', '', '')
        
        before, sep, after = 'Hello, world!'.partition(' ')
        before
        Out[5]: 'Hello,'
        after
        Out[7]: 'world!'
      - Justifying Text with the rjust(), ljust(), and center() Methods
        
        'Hello'.rjust(10)
        Out[8]: ' Hello'
        
        'Hello'.ljust(20)
        Out[10]: 'Hello '
        
        'Hello'.rjust(10,'')
        Out[11]: '**Hello'
        
        'Hello'.center(20,'')
        Out[12]: '**Hello**'
        
        def printPicnic(itemsDict, leftWidth, rightWidth):
        -----print('PICNIC ITEMS'.center(leftWidth + rightWidth, '-'))
        -----for k, v in itemsDict.items():
        -----------print(k.ljust(leftWidth, '.') + str(v).rjust(rightWidth))
        picnicItems = {'sandwiches':4, 'apples': 12, 'cups':4, 'cookies': 8000}
        printPicnic(picnicItems,12,5)
        printPicnic(picnicItems,20,6)
        ---PICNIC ITEMS--
        sandwiches.. 4
        apples...... 12
        cups........ 4
        cookies..... 8000
        -------PICNIC ITEMS-------
        sandwiches.......... 4
        apples.............. 12
        cups................ 4
        cookies............. 8000
      - Removing Whitespace with the strip(), rstrip(), and Istrip() Methods
        
        spam = ' Hello, World '
        spam.strip()
        Out[2]: 'Hello, World'
        spam.lstrip()
        Out[10]: 'Hello, World '
        spam.rstrip()
        Out[11]: ' Hello, World'
        
        spam = 'SpamSpamBaconSpamEggsSpamSpam'
        spam.strip('ampS')
        Out[15]: 'BaconSpamEggs'
      - Numeric Values of Characters with the ord() and chr() Functions
        
        Every text character has a corresponding numeric value called a Unicode code point
        
        ord('A')
        Out[1]: 65
        ord('4')
        Out[2]: 52
        ord('!')
        Out[3]: 33
        chr(65)
        Out[4]: 'A'
        
        ord('A') < ord('B')
        Out[7]: True
        chr(ord('A') + 1)
        Out[9]: 'B'
      - Copying and Pasting Strings with the piyperclip Module
        
        import pyperclip
        pyperclip.copy('Hello, world!')
        pyperclip.paste()
        'Hello, world'