Study/practice updates: practiced over 600+ nuanced questions across three different Udemy mock-test courses for PCAP

Author: nrpeyton

Diff for: Functions/Introspection/isinstance(object, type).py

@@ -9,6 +9,7 @@
 isinstance(5, int) # True
 isinstance(5.0, float) # True
 isinstance("Hello", str) # True
+print(isinstance(5, (int,float) )) # True     If a tuple is used, 'OR' is applied, not 'AND'.
 
 
 class myObj:

Diff for: Functions/definitions & documentation.py

@@ -0,0 +1,106 @@
+"""ASTERISK '*' USED ALONE"""
+
+def func(a, *, b, c): # * specifies that all arguments following it must be provided as keyword arguments.
+    pass
+
+# Correct call
+func(1, b=2, c=3)
+
+
+
+"""ASTERISK '*' BEFORE A PARAMATER """
+
+def func(arg, *args): # Allows the function to accept any number of positional arguments (the first is still captured by 'arg').
+    pass
+
+# Correct call
+func(1, 2, 3, 4, 5) #  Python transforms '*args' into a tuple for use within the function:
+
+# Printed 'args':
+(2, 3, 4, 5)
+
+# [EXTRA] Unpack on calling fun:
+tuple = 1, 2, 3, 4, 5
+func(1, *tuple) # Useful if you already have a tuple, otherwise printout would be: ((2, 3, 4, 5),)
+
+
+
+"""DOUBLE ASTERISK '**' BEFORE A PARAMATER """
+
+def example_function(**kwargs): # An arbitary number of arguments received by a '**' prefixed parameter are automatically packed into a dictionary.
+    for key, value in kwargs.items():
+        print(f"{key}: {value}")
+
+example_function(arg1="Hello", arg2=42)
+
+# This is often referred to as "keyword argument unpacking".
+
+
+
+
+
+
+
+
+
+#   F U N C T I O N   R U L E S
+
+
+""" Functions Without Arguments 
+(Function checks itself first, then checks the global scope.) """
+
+
+d = 'a'
+
+def fun():
+    d += 'b'    # raises error: outside immutables are read-only
+    print(d)
+
+
+fun()
+print(d)
+
+
+
+
+d = ['a', 'b']
+
+def fun():
+    d.insert(-1, 'c')    # this works; outside mutables CAN be modified
+    print(d)
+
+
+fun()
+print(d) # prints: ['a', 'c', 'b']
+
+
+
+
+
+"""Functions With Arguments"""
+
+
+d = 'a'
+
+def fun(d):
+    d += 'b'    
+    print(d)
+
+
+fun(d)
+print(d) # prints:
+# ab
+# a
+
+
+
+""" When a variable is passed in a function call, it's not just a new copy of the value or only the value itself being passed, but a 
+reference to the original variable that is added to the function's local namespace.
+
+Mutables:
+The original (outer) variable is modified.
+
+Immutables:
+The original (outer) variable is COPIED for seperate local use within the function's local scope.
+"""
+

Diff for: Functions/definitions, documentation & rules.py

@@ -4,14 +4,39 @@ Read Mode (`r`): Opens the file for reading from the beginning. Raises errno.ENO
 
 Write Mode (`w`): Opens and truncates the file to zero length or creates a new one, starting at the beginning.
 
-Append Mode (`a`): Opens the file for appending at the end or creates a new one, starting at the beginning.
+Append Mode (`a`): Opens the file for appending at the end or creates a new one.
 
-Exclusive Creation (`x`): Creates a new file for writing, raises errno.EEXIST if it exists.
+Exclusive Creation (`x`): Creates a new file FOR WRITING, raises errno.EEXIST if it exists.
 
 Read and Write (`r+`): Opens the file for both reading and writing from the beginning. Raises errno.ENOENT if the file doesn't exist.
 
 Write and Read (`w+`): Opens the file for both reading and writing, truncating or creating it as needed, starting at the beginning.
 
-Append and Read (`a+`): Opens the file for both reading and appending at the end. Only 'reads' honour seek() changes, i.e., 'appends' only at the end.
+Append and Read (`a+`): Opens or creates the file for both reading and appending at the end.  Writes always move the file position (back) to the end.
 
-Crucial difference between w+ and r+, is with r+ the file must already exist.
++
+beside write, '+''  means read; 
+beside read, '+'' means write (aka update)
+
+# Crucial difference between w+ and r+, is with r+ the file must already exist.
+
+
+
+
+APPEND & READ (`a+`)
+
+                                        # file.txt exists and was created using the next three lines:
+# f = open('file.txt', 'w+')
+# f.write('line 1\nline 2\nline 3\nline 4')
+# f.close()
+
+f = open('file.txt', 'a+')
+f.seek(0)
+s1 = f.read() + '    ...first read'      # reads succesfully
+f.write('new line')                      # ignores seek() and (successfully) appends the string at the end
+s2 = f.read() + '    ...second read'     # nothing is read, because the 'a' mode "forced" write() to moved the head to the end before writing
+f.close()
+print(s1)
+print(s2)
+
+# Always remember to re-position the head using seek() after a write operation in 'append & read' (a+) mode.

Diff for: Functions/open().md

@@ -1,4 +1,4 @@
-from os import uname # <--- For Unix.  For windows, use `from platform import uname`
+from os import uname            # For windows, use `from platform import uname`
 
 print(uname())
 

Diff for: Functions/os.functions.py

@@ -1,3 +1,4 @@
+sorted(iterable, /, *, key=None, reverse=False)
 # sorted() function   R E T U R N S   a new sorted list.  Is NOT a method of a class, so does NOT sort the list in-place.
 
 # list.sort()   D O E S   N O T   return anything.  It DOES sort in-place.

Diff for: Functions/sorted.py

@@ -7,13 +7,15 @@ Returns 1 only if both bits are 1.                       Even n & 1, becomes 0;
 Bitwise XOR (^)
 Returns 1 if exactly one of the bits is 1, but not both. (Exclusive OR)         Even n ^ 1, just add 1;  Odd n ^ 1, minus 1.    FLIPS LEAST SIGNIFICANT BIT!
 
-Bitwise NOT (~)         NEGATES IT MINUS AN EXTRA 1!
+Bitwise NOT (~)     NEGATE N's SIGN, THEN, N -1
 n = -n - 1          5 becomes -6
 -n = n - 1          -5 becomes 4
 
-Bitwise n << 1       n = n * 2                                                  A left shift (<<) by n bits is equivalent to multiplication by pow(2, n).
+BITWISE N << 1                                                                   BITWISE N << K
+--------------                                                                   --------------
+Bitwise n << 1       x = n * 2                                                   A left shift (<<) by k bits is equivalent to:  n * pow(2, k).
 
-Bitwise n >> 1       n = n / 2                                                  A right shift (>>) by n bits is equivalent to floor division by pow(2, n).
+Bitwise n >> 1       x = n // 2                                                  A right shift (>>) by k bits is equivalent to:  n // pow(2, k).
 
 
 

Diff for: Misc/bitwise_operations.txt

@@ -7,7 +7,11 @@ NameError is raised when you try to access a local or global name (like a variab
 
 A TypeError is raised for operations on mismatched data types where the operation doesn't make sense for the data type, (like adding      TypeError                        BaseException ← Exception ← TypeError
 a string to an integer) or when inheritance structures in classes lead to an unclear hierarchy, preventing a consistent method 
-resolution order (MRO).
+resolution order (MRO).  TypeErrors also arise if the number of arguments supplied doesn't match a function's parameter signature.
+
+ModuleNotFoundError is raised if attempting to import a module that cannot be found.  For example, because the sys.path list has          ModuleNotFoundError              BaseException ← Exception ← ImportError ← ModuleNotFoundError
+not been appended, or attempting to use the 'import' keyword on its own without 'from' to import something inside a module.
+
 
 A ValueError is when the data type is correct, but the content within that data type isn't formatted or isn't appropriate for the         ValueError                       BaseException ← Exception ← ValueError
 operation being attempted.  For example, with `i = int("Hello!")` the type is correct because int() can convert other data types
@@ -184,4 +188,40 @@ BaseException
    |   +---ErrorDuringImport
    +---GeneratorExit
    +---SystemExit
-   +---KeyboardInterrupt
+   +---KeyboardInterrupt
+
+
+
+
+
+
+
+
+
+EXCEPTION HANDLING DESIGN
+Broad to Specific Handling: Exception handling is structured from more general to more specific to allow a program to respond to errors at 
+varying levels of granularity. A general handler (superclass) deals with a wide range of issues, while more specific handlers (subclasses) 
+address particular problems. This hierarchical handling is intentional and practical, ensuring that errors do not go unaddressed while also 
+allowing for specific responses when needed.
+
+Type Matching Over Attribute Access: When an exception is raised, Python's error handling mechanism looks for a match based on the exception's 
+type, not its attributes or methods. This is fundamentally different from how objects typically interact in OOP, where attributes and methods 
+of an object (and by inheritance, of its subclasses) are crucial to how it behaves or is treated. In exception handling, the focus is on the 
+type of error (i.e., its class) rather than on the properties or behaviors of the error object.
+
+Designed for Error Propagation: Exceptions are designed to propagate up the call stack until they find a matching handler. This design ensures
+that errors are not silently ignored but are either handled explicitly or cause the program to terminate with an error message. The ability 
+of a superclass to catch exceptions from its subclasses facilitates this by providing a "catch-all" mechanism for unhandled specific errors.
+
+CONCEPTUAL SHIFT
+Operational, Not Structural: The operation of catching exceptions in a superclass doesn't rely on inheriting attributes or methods from 
+subclasses (which, as you noted, is not how inheritance works). Instead, it's about structurally placing a safety net for any errors that fall
+within a broad category defined by the superclass. This mechanism is purpose-built for error handling and is structured to maximize code 
+robustness and clarity.
+
+Purposeful Design: This design choice is purposeful, reflecting the need for error handling mechanisms to be both comprehensive and manageable. 
+By allowing superclasses to handle exceptions from their subclasses, Python's design ensures that developers have the flexibility to write 
+error handlers that are as generic or as specific as needed without complicating the inheritance hierarchy.
+
+In summary, while the mechanism of exception handling utilizes the class hierarchy in a way that mirrors inheritance, its logic and purpose are 
+tailored specifically to the needs of error management, rather than reflecting the traditional OOP model of attribute and method inheritance.

Diff for: Misc/exceptions.txt

@@ -8,12 +8,12 @@ file.write(string) # Takes a string and appends it at the current file position.
 file.writelines(lines, /)  # Write a list of lines at the current file position. Newline separators ('\n') are not added.
 
 #                                                 READING (r, r+, w+, a+)
-file.read([size=- 1], /)  # Reads entire file or number of characters/bytes from current position, returning empty string at EOF.
+file.read([size= -1], /)  # Reads entire file or number of characters/bytes from current position, returning empty string at EOF.
 
-file.readline([size=- 1], /)  # Returns the next line from the file up to the newline character or size of byteas, whichever is first. 
+file.readline([size = -1], /)  # Returns the next line from the file up to the newline character or size of byteas, whichever is first. 
                               #If EOF, returns an empty string.
 
-file.readlines(hint=- 1, /): # Returns the next list of lines from the file. If 'hint' bytes (approximate) are read, no further lines are read.
+file.readlines(hint = -1, /): # Returns the next list of lines from the file. If 'hint' bytes (approximate) are read, no further lines are read.
                              # An empty list is returned if EOF.
 
 
@@ -26,7 +26,12 @@ file.write(bytearray): # Writes the contents of 'bytearray' to the current file
 file.read([size]): # Reads the entire file or up to 'number' bytes if specified. Returns a bytes object.
 
 file.readinto(bytearray): # Reads bytes from the file into 'bytearray'. Returns the number of bytes read.
-# Example: bytearray_variable = bytearray(100); file.readinto(bytearray_variable)
+
+
+# Example: 
+bytearray_variable = bytearray(100)
+file.readinto(bytearray_variable)
+
 
 """REMEMBER: Use file.close() or a 'with' statement for automatic closing and saving. 
 

Diff for: Misc/file.methods().md

@@ -0,0 +1,2 @@
+import keyword
+print(keyword.kwlist)

Diff for: Misc/keywords.py

@@ -1,5 +1,6 @@
 # type: ignore # pylint: disable=all
 """                                               STRING METHODS                                               """
+# NOTE: ALL string methods return something.
 
 str.capitalize() # Return a copy of the string with ONLY its first character capitalised and THE REST LOWERCASED.
 str.title() # makes the first letter in each word upper-case.
@@ -9,6 +10,7 @@
 
 str.center(width[, fillchar]) # centers the string inside the field of a known length;                                                               
 
+# NOTE: String Methods with Slices: 'start' can be used without 'end' but 'end' cannot be used without 'start'.
 str.count(sub[, start[, end]]) # counts the occurrences of a given character;
 str.find(sub[, start[, end]]) # finds a substring returning its index, or -1 on failure; (start inclusive, end exclusive);    string.find('text', start, end)
 str.rfind(sub[, start[, end]]) # Return the HIGHEST INDEX where the START of the substring is found (from left to right). Returns -1 if failed; (start inclusive, end exclusive);

Diff for: Misc/string_.methods().py

@@ -13,9 +13,12 @@ def print_args(args):
     print(e, e.__str__(), e.args) # Printing 'e' implicitly is the same as invoking e.__str__() explicitly.  And 'args' is just an instance property (a tuple) storing the arguments passed to the exception object's constructor.
     print_args(e.args)
 
+print(e) # <<< ERROR: This last line will raise a NameError because as 'e' is a LOCAL variable (alias) that refers to an instance of the exception class; it only has local variable scope inside the 'except' block it was created.
 
 
 
+# e.__dict__ likely won't show the exception instance's variables such as e.args and e.errno because some exceptions are implemented in C at a deeper level, storing these attributes in C structures rather than the Python object's __dict__.
+
 
 # When creating user defined exceptions, they must be new subclasses derived from predefined ones.  Either closely related, or not.  For a structure not closely related to Python's existing tree, we can choose a top base, like BaseException or Exception.
 
@@ -181,4 +184,7 @@ def update_company_sales(company, sales):
 Exception's constructor.  Since we are overriding the built-in Exception class's constructor with our own class's constructor and 'args' tuple, we 
 are still able to access an e.args tuple. If our custom __init__ method on lines 2/3 were remeoved and replaced only with 'pass', this would have no 
 affect on the program because CustomError would start inheriting the built-in Exception class's constructor.
-"""
+"""
+
+
+# exception instance alias variables (such as 'e.args' or 'e.errno') are local variables that are only accessible within their except block.

Diff for: Python Essentials 2 - Intermediate/Module 3/exceptions.py

@@ -0,0 +1,15 @@
+# TERMINAL/COMMAND PROMPT ARGUMENTS (i.e., flags)
+
+print('hello')
+
+import sys
+print(sys.argv)
+
+"""
+SCRIPT
+Running as a script only outputs a single element list containing this file's path.
+
+COMMAND LINE
+Output when this file is run from a terminal, i.e., `python3 argv.py hi hello test` is:
+['argv.py', 'hi', 'hello', 'test']
+"""