Please enable JavaScript.

Coggle requires JavaScript to display documents.

Programming (python) - Coggle Diagram

- - - - The round() function returns a floating point number that is a rounded version of the given number – with the specified number of decimals
        
        round(5.76543, 2)
        5.77
        
        The defult number of decimals is 0, if you dont specify the number of decimals
        
        Python also round 0.5 donw to zero. This is because of s follows a rounding rule called round half to even which is also affectionately known as banker’s rounding. This how the function round() is defined
  - - - ' and " can be use interchangably but only use one of them. You can also make int in to strings by using these. "5"
        
        The length of a string can be obtained by using len()
        
        multiple line string can be done by using three qutations """
        
        Strings are immutable, which means that you can't change a character in a string but you can change the entire string to something else
        
        slicing strings, sring[start:stop] # from start to stop-1, string[start:] # from start to the rest of the string , string[:stop] # from the beginning to stop-1 , string[:] # a copy of the whole string , string[start:stop:step] # from start to stop-1 by step
        
        Escape sequences
        
        These sequences will be translated in to a command when they appear in a string
        
        These alwasys strart with \
        \ : backslash, \' : Single quote, \" : Double quote, \n : Line break, \t : tab
        
        String indexes
        
        Ech string's character corresponds to an index number, that strats from 0
        
        It can also be accessed from the opposite direction, starting from -1
        
        f-strings are a simple way to format strings in Python. An f-string starts with an f (or F) followed by a pair of curly brackets {}. • Inside the curly brackets, you can place expressions that will be evaluated and inserted into the string
  - - - This is the most common type of error in the program. It happens when the code does not follow the correct
        syntax or grammar rules of Python
        
        To fix it, check the code for any gramatical or spelling errors
  - - - These are normaly used with comparison operators, like = and inequalites.
        
        ==: equals to, <=: smaller or equal to, !=: not equal to
        
        Ofcourse these comparissons can be done with numbers but it can also be done with strings. Strings are compared by comparing its characters one-by-one from the
        beginning.
        
        When different characters are found, their Unicode values are
        compared and the character with smaller Unicode value is smaller.
        
        eg: "apple" < "ananas" is False
        The first characters are "a" and "a", which are equal. The second characters are "p" and "n". The Unicode value of "p" (112) is
        greater than the Unicode value of "n" (110)
        
        Keyword in.
        Python has the keyword in which can be used for testing whether
        a value is present in a sequence. It returns:
        True if the value is found in a sequence
        False if the value is not found if a sequence.
        
        "a" in "car"
        True
        "b" in "car"
        False
        
        Boolean operators
        
        Boolean operators are essential for controlling the flow of a
        program, especially in conditional statements and loops
        
        Python has Boolean operators: not, or,and.
        They all return boolean data
        
        Short-circuiting in boolean operators is a concept where the evaluation of a logical expression stops as soon as the result is determined
        
        1 more item...
  - - - If you pass a mutable object as a parameter to a function and
        change its value inside the function, the object will change.
- - - - HOW TO CREATE A DICTIONARY:
        person = {
        "name": "John",
        "age": 30,
        "city": "New York"
        }
        
        person
        {'name': 'John', 'age': 30, 'city': 'New York'}
        person['age'] = 31 # Modify a value
        person
        {'name': 'John', 'age': 31, 'city': 'New York'}
        
        HOW TO ITERATE OVER A DICTIONARY:
        my_dict = {"a": 1, "b": 2, "c": 3}
        for key in my_dict:
        print(key) # prints the keys: a, b, c
        for key in my_dict:
        print(my_dict[key]) # prints the values: 1, 2, 3
        
        DICTIONARY METHODS:
        .pop(key) # Remove the item with the key name and return it
        .popitem() # Removes the last item and returns it
        .clear() # Clears the entire dictionary
        
        SHALLOW COPY VS. DEEPCOPY:
        A shallow copy is a copy of an object that is not a complete, independent copy. A shallow copy is a copy of an object that is not a complete, independent copy.
        A deep copy is a new object that is a completely independent copy of the original object, including
        all of its elements or nested objects, and their elements, and so on.
        
        deepcopy() is a function of the copy module that creates a deep copy of an object.
  - - - import json
        Open the JSON file
        file = open("books.json")
        Load the file into a list of dictionaries
        books = json.load(file)
        file.close()
- - - - Notice that after writing the condition, there is a colon. Colon (:) indicates the start of the block of code that will run if the
        condition is true
        
        Indentation means the spaces at the beginning of a code line. Where in other programming languages the indentation in code is for readability only, the indentation in Python is part of the language
    - - Keyword else, is self explanatory. elif on the other is a short hand for else if. This allows you to check additional
        conditions if the previous if or elif conditions were false
  - - - There are two loops:
        for: used to iterate over a sequence of elements, such as a list or a range of numbers.
        while: used to iterate over a block of code if a certain condition is
        met.
        
        For: The loop variable is assigned the first item in the sequence, and the loop block is executed. Then it's assigned the next item in the list. This porcess is repeated unt il the last itemis assigned
        
        for (variable) in (sequence):
        Sequence can be a list, a range of numbers, or any iterable object
        
        an exampole, you can use the function range(start:stop:step), to create a list of numbers
        list(range(1:11)
        
        While: If the condition is True, the code block inside the loop is executed. After each execution of the code block, Python re-evaluates the condition. If the condition is still true, then is runs the code block agains and if it isn't then the loop is terminated and moves to the next line
        
        while (condition):
        
        Nested for loops are used when you need to iterate through elements in multiple dimensions or perform repetitive tasks with nested data structures, like 2D arrays or matrices.
        
        Having loops inside loops makes computer programs slow. Optimization of code is a more advanced topic, but bad programming can make an
        easy task VERY SLOW
      - Controling loops
        
        Break: If the break-command is encountered, the iteration is terminated.
        
        If there are several nested iterations, loop within a loop, the innermost loop is ended.
        
        Continues: The idea of continue is that it skips the rest of the iteration before starting a new round.
        continue cannot exist outside iterative loop.
  - - - A function can be called from any other part of the program. It is
        even possible that a function calls itself. This is called recursion.
        
        Built-in Functions: These are pre-defined functions that come with Python installation. They can be used directly in a Python program without importing external libraries.
        
        Some examples are:
        print(), input(), float(), etc
        
        Built-in Functions: These are pre-defined functions that come
        with Python installation. They can be used directly in a Python program without importing external libraries.
        
        To define a function you have to write:
        def function_name(parameters):
        Function body
        return result
        
        Name should be in lowercase, with words separated by underscores (whitespaces in the name are not possible – as in the case of variables).
        
        Parameters: These are inputs to the function. Parameters are enclosed in parentheses and separated by commas. Parameters are input values to the function.
        
        Function body: Function is a "program inside a program". The function body contains the code that defines the behavior of the
        function.
        
        1 more item...
        
        A function must be called with the correct number of values: if your function has 2 parameters, you have to call the function with 2 values, not more, and not less
        
        1 more item...
        
        The None type in Python represents the absence of a value. It's often used as a default value for variables, function return values, or dictionary keys.
        
        For intance, the function round() takes two parameters. The second parameter has the default parameter None. This means that round(7.89) is the same as
        round(7.89, None).
- - - - PYTHON’S BUILT-IN FUNCTIONS ON LIST:
        len(L) gives the number of elements in L
        sorted(L) takes a list L and returns a new sorted list, leaving the original list L unchanged.
        min(L) returns the smallest element in the list.
        max(L) returns the largest element in the list.
        sum(L) returns the sum of all elements in the lis
        
        Note: The elements in the list should be compatible with comparison operations. Also the sum(L) requires the element to be numbers
        
        List also a class. Individual lists are objects belonging to the list class. The list class defines numerous methods that allow you to perform operations on lists, such as adding or removing elements, sorting, searching, and more. This method does not return a new list but rather sorts the existing list L directly.
        
        List Methods:
        
        Unlike strings, lists are mutable, meaning they can be changed after creation.
        L = [1,2,3]
        L[1] = 5
        L
        [1, 5, 3]
- - - - import module_name
        The simplest way to import a module. Allows you to access everything in the module by using the dot notation, such as
        module_name.function_name or module_name.variable_name
        
        from module_name import item_name
        Allows you to import a specific item from a module, such as a function, a class, or a variable. You can then use the item directly in your code without the dot notation.
        Eg: from math import pi
        now you can use pi in your code
        
        from module_name import item_name as alias
        Allows you to import a specific item from a module and give it a shorter or different name. This can be useful if the item name is long or conflicts with another name in your
        code. Just don’t overdo this and generally a good practise is not to make up your own names for existing modules.
        
        GETTING HELP: You can get help on modules by writing help("module_name")
        
        Math Modules:
        math.ceil(x)
        math.floor(x)
        math.factorial(x)
        math.exp(x)
        math.log(x, base)
        math.sqrt(x)
        
        MODULES: RANDOM
        random.randrange(stop)
        random.randint(a, b)
        random.choise(s)
        random.seed()
        
        MODULES: DATETIME
        provides classes
        and functions for working with dates and times. It is a powerful module for handling various aspects of date and time
        representation, manipulation, and formatting.
        
        DATE CLASS: Represents a date (year, month, and day)
        
        from datetime import date
        today = date.today()
        print(today)
        2023-10-30
        yesterday = date(2023, 10, 29)
        print(yesterday)
        2023-10-29
        
        TIMEDELTA CLASS: Represents a duration or time interval. Useful for performing arithmetic operations with dates and times.
        
        from datetime import timedelta, date
        today = date.today()
        time_difference = timedelta(days=7)
        future_date = today + time_difference
        print(future_date)
        
        FORMATING DATETIME: The strptime() is used for converting a string representing a date and time into
        a datetime object.
        
        The syntax for strptime() is the following:
        datetime.datetime.strptime(date_string, format)
        date_string is the input string that you want to parse.
        format is a "format string" specifying how the date and time components are interpreted in the date_string.
        
        Format codes: are placeholders in the format string that indicate the format of date
        and time components. For example:
        
        %Y: Year with century as a decimal number (e.g., 2023)
        %m: Month as a zero-padded decimal number (01 to 12).
        %d: Day of the month as a zero-padded decimal number (01 to 31).
        %H: Hour (24-hour clock) as a zero-padded decimal number (00 to 23).
        %M: Minute as a zero-padded decimal number (00 to 59).
        %S: Second as a zero-padded decimal number (00 to 59)
        
        1 more item...
        
        TIME MODULE: import time
        Represents a time (hour, minute, second, microsecond) without a date component. Useful for working with time intervals and timing events.
        
        time.time(): Returns the current time in seconds since the epoch (January 1, 1970, at 00:00:00 UTC).
        time.sleep(N): Pause for N seconds
        time.perf_counter(): returns a floating-point number representing the time inseconds, with the highest available resolution for measuring small time intervals.
    - - CREATING OWN MODULES:
        Create a file with a .py extension and give it a name that is valid as a Python identifier. For example, mymodule.py
        Write the code that you want to include in the module. You can define functions, classes\ and variables.
        
        Save the file in a location that is accessible by the Python interpreter. Easiest is to use the current working directory.
        Import the module in another program using the import statement. You can then use this
        module as other modules.
        
        PYCACHE: pycache is a folder that Python creates. It contains compiled bytecode, which are low-level instructions that can be executed by the interpreter.
        
        The purpose of pycache is to speed up the loading of modules, as the interpreter does not have to recompile the source code every time it imports a module.
        
        Bytecode is not meant to be human-readable. You can ignore or delete the pycache folder, as it does not affect the functionality of your code.
        
        If you want to distribute your code to other people, it is a good practice to remove the pycache folder, as it is not necessary and may cause compatibility issues
        
        1 more item...
  - - - To install a package, you would use a command:
        pip install package_name
        To uninstall a package, use a command:
        pip uninstall package_name
        To update a package, use a command:
        pip install --upgrade package_name
        
        Introducing NumPy: • In this week, we install package NumPy, which does not belong to the standard distribution. • NumPy, short for Numerical Python, is a fundamental library for
        scientific computing in Python.
        
        Updating pip: • Open a Terminal window by right-clicking on your desktop or in a file explorer window and selecting "Open Terminal".
        You can see the version number of pip by typing:
        pip --version or pip –V
        But you can update pip by typing the command:
        pip install --upgrade pip
        
        When we use pip to install a package like NumPy, it retrieves the
        package from the Python Package Index (PyPI).
        
        NumPy arrays are optimized for numerical operations. They are stored in contiguous memory blocks, enabling efficient element access and faster mathematical computations. NumPy arrays have fixed sizes at creation. Their size and shape
        can be changed with methods like reshape.
        
        NumPy arrays offer a wide range of mathematical functions and operations, such as linear algebra, statistical operations, and Fourier transforms, making them powerful for scientific computing
        
        1 more item...
- - - - • Division by zero: 10 / 0
        • Type error: "hello" + 5
        • Name error: variable is not (yet) defined
        • Index error
        
        FileNotFoundError: Raised when a file or directory is requested but doesn’t exist
        
        ImportError: Occurs when the interpreter cannot find the module you’re trying to import. This usually happens if the module doesn’t exist, is misspelled, or is not installed.
        
        Understand error messages:
        
        Traceback indicates the path of function calls that led to the error:
        line 4, in <module>: The error originated from line 4 in the within the main program block (<module>).
        
        print(divide(7,0)): This line caused the error. It calls the divide
        function with parameters 7 and 0.
        
        line 2, in divide: The error occurred during the execution of the
        divide function on line 2
        
        return x / y: This is the line in the divide function where the division by zero happens
        
        1 more item...
    - - Incorrect conditions: Writing a condition that is never True or does
        not match the intended purpose.
        
        Debugging: To identify and fix errors, programmers employ various debugging
        techniques:
        
        Insert print statements to display variable values at specific
        points in the code can help trace the program's execution flow
        
        Debuggers are specialized tools that allow you to step through
        code line by line, inspect variables, and set breakpoints.
        
        Have other programmers review your code can help identify
        potential errors and improve code quality. You can also ask AI.
        
        Use unit testing by writing small tests for individual code
        components can help isolate and fix errors
      - Error in loops: Miscounting iterations by one in loops can cause
        missing or extra iterations.
      - Incorrect variable initialization: Setting a variable to an incorrect
        starting value.
      - Incorrect operator usage: Using the wrong operator, for example
        
        instead of +, in calculations.
  - - - When an error occurs, Python creates an exception object that contains information about the error, such as its type and message.
        
        The exception object usually contains a message that provides more details about the error. This message can be accessed and printed to help understand what went wrong.
        
        In Python, except Exception as e is used to catch exceptions and assign the caught exception to a variable (e in this case).
        
        This allows you to access the exception object and its attributes
        within the except
        
        To catch different types of errors in Python, you can use multiple
        except blocks, each handling a specific type of exception.
        
        This allows you to provide different handling logic for different errors.
        
        3 more items...
- - - - You can create a tuple by placing items inside parentheses,
        separated by commas:
        my_tuple = (42,"hello", 3.14, [1, 2, 3], {"key: :value"}, (5, 6))
        
        Tuples vs Lists:
        Tuples: Immutable, you cannot change their contents (add, remove, or modify elements)
        Lists: Mutable, allowing you to modify them.
        
        Tuples: Defined using parentheses ().
        Lists: Defined using square brackets [].
        
        Tuples: Generally faster than lists for iteration and access due to their immutability. They usually also use less space than lists.
        Lists: Slightly slower because of the overhead of mutability.
        
        Methods of tuples: Tuples have a very limited number of built-in methods:
        count(), it counts how of the inputed element are there in the tuple
        index() , it counts the index of the element
- - - - Python sets are implemented as hash tables. This means that when you add an element to a set, Python computes a hash value for that element, which allows for efficient storage and retrieval.
        
        This is the reason why the elements of a set must be immutable.
        The hash function used for sets is based on the built-in hash()
        function
        
        Set methods:
        
        Set methods (as shorthands):
- - - - It's perform with the +. Notice that the result of 1.0 + 2 is 3.0, which is a float. Anytime
        a float is added to a number, the result is another float
    - - This is done the -. You can subtract with minus number, you can put brackets to make clearer
    - - This can be done with *
    - - This can be done with /. Division always gives answers as floats. Dividing be zero is undefined.
        
        2 / 0
        Traceback (most recent call last):
        File "<pyshell#36>", line 1, in <module>
        2/0
        ZeroDivisionError: division by zero
      - Interger divison
        
        The "//" operator first divides the number on the left by the number on the right and then round down to an integer. This might not give the value that you expect
        
        For example, -3 // 2 returns -2. First, -3 is divided by 2 to get -1.5. Then -1.5 is rounded down to -2. On the other hand, 3 // 2 returns 1 because 1.5 is rounded down to 1
        
        The operation "//" returns a floating-point number when one of the operands is a float. This is why 9 // 3 returns the integer 3, and 5.0 // 2 returns the float 2.0.
    - - Fore exponents you use **, the exponents don't have to be int, the can be a float number. This does give the naswer as a float
    - - It returns the remainder of dividing the
        left operand by the right operand, to do this you use %
        
        5 % 3
        2
        
        This applies to both int and float data
    - - Think about Bidmaths when thinking about which process is the strongest
        
        Use parenthesis when writin expressions just in case
- - - - Avoid using x, y, z, a, b, c and this kind of names which
        does not tell anything about the "nature" of the variable
    - - In many languages, you need to first to introduce a variable by
        defining its type. Python is more flexible, it is a dynamically typed language which means that you don't need to define the data type
- - - - Conversions between strings, integers and floats can be made with the functions:
        int() returns an integer
        float() returns a decimal number
        str() returns a string
    - - You can use spe to separate arguments, the defult is whitespace ' '.
        Eg: print('11', '09', '2024', sep='-'
        11-09-2024
        
        end dgines what happens at the end of the string, by defult it's \n
    - - We can use the command round(x) to get x rounded to the closest integer.
        We can use int(x) to convert float to integer. In this case, the decimal is just left out
- - - - Python is an objected-oriented programming language, where everything in python is an object that belongs to a class
        
        Attributes are variables defined within the class, representing object properties
        Methods are functions defined within the class, representing object behavior.
        
        DOT NOTATION: In Python, dot notation is a way to access attributes and methods of an object. It involves using a dot (.) followed by the attribute or method name to access or
        modify the attributes and call methods associated with a particular object.
        
        Accessing attributes:
        object.attribute
        car.year, car.model, car.max_speed
        Calling methods:
        object.method()
        car.start_engine(), car.stop(), car.brake(), car.accelerate()
        
        CREATING OBJECTS WITH CONSTRUCTOR:()init() is a special method in Python classes. It is called a constructor, a constructor is automatically called when an object is created. Using a constructor, you can set the attributes of an object.
        
        In Python, when you want to call anything belonging to the class,
        you need to use the word self to refer to that instance.
- - - - Binary Files: Binary files store data in a format that is not human-readable. The data is stored as a sequence of bits in a "raw" format. Data in binary file can be directly interpreted by the computer’s hardware or software.
        Common extensions include .bin, .exe, .jpg, .png, .dat, etc.
    - - Reading from a file: Use the open() function to open a file.
        You need to specify the file name and the mode in which you
        want to open the file (read, write, append).
        Example. file = open("Example.txt", "r")
        
        The command gives an error message if the file does not exist:
        No such file or directory: 'example.txt'
        
        The readline() method reads one line at a time from the file.
        This is useful if you want to process the file line by line.
        If there are no more lines to read, readline() will return an
        empty string: '' (two quotation marks)
        
        The strip() method in Python is used to remove any leading
        and trailing whitespace characters from a string. This includes spaces, tabs, and newline characters.
        
        In Python, the readlines() method reads all lines from a file
        and returns them as a list of strings. Each string in the list represents a line from the file, including the newline character \n at the end of each line. The last line of the file may not have a newline character.
      - Writing to a file: Using open("file.txt", "w") in opens the file named file.txt for writing.
        If file.txt does not exist, it will be created. If file.txt already exists, its content will be erased, and the
        file will be treated as a new empty file.
        
        write() method takes a string as input and appends it to the
        end of the file's content.
        
        The writelines() method is used to write a list of strings to a file. Also with writelines() method one needs to add newline symbols
        to the end of strings
      - Appending to a file: Appending to a file means adding new content to the end of an existing file without overwriting its original contents. To append to a file, you use the open() method with the mode 'a'.
        
        This mode opens the file for appending, creating a new file if it does not exist.
        
        Then add text to the file normally using write() or writelines()
        methods.
        Remember to close the file afterwards.
    - - Each piece of data is separated by a comma.
        For example: name,age,city.
        Each line in the file represents a row, and each comma-separated
        value represents a column. The first row often contains headers, which describe the data in each
        column. The header row can be also missing.
        
        CSV files are widely supported by many applications, including
        spreadsheet programs like Microsoft Excel and Google Sheets.
        
        The split() method is the most common way to split a string
        into a list in Python. This method splits a string into substrings based on a delimiter and returns a list of these substrings.
        
        text = "apple,banana,orange,grape"
        fruit = text.split(",")
        print(fruit)
        • Output: ['apple', 'banana', 'orange', 'grape']
- - - - Just call the file you want to run, e.g (pythonmy _code.py). We can also pass command line arguments to the code. (python my_code.py value1 value2 value3)