Computer Memory and Pointers

How Computers Think

• Computers store files with a filename and content in memory.
• A file's name is in the file directory, like a clickable icon.
• Stored with the filename is the memory address of the file's content.
• Computers use addresses, or "pointers," to quickly access specific memory locations.
• Each spot in memory has a unique numerical address.
• Information like file size is stored with the filename, enabling the computer to read the correct amount of data.
• Programs interact with the computer's memory, creating data bits called "variables".
• Variables have names and point to data stored in memory.
• In a simple program (A=2, B=3, C=A+B), the computer assigns memory locations to A and B, fetches their values, adds them, and stores the result in C.
• Understanding memory interaction is crucial, especially when assigning lists where assigning B=A doesn't duplicate A, but links B to the same memory location. Modifying A also modifies B.
• It's important to have a mental model of how computers manipulate data since programs involve putting, fetching, and manipulating data in memory.

The Zen of Python

• Python's consistency and simplicity contribute to its increasing popularity.
• Python is used to build large complex systems.
• Python's design philosophy is reflected in "import this," an Easter egg containing guiding principles.
• Typing "import this" in a Python terminal displays The Zen of Python principles.
• The Zen of Python emphasizes simplicity, explicitness, and readability in code.

Variables and Types

• Variables are basic programming building blocks used to store values.
• Assigning a value to a variable is done using the equal sign (=), known as the assignment operator (x = 5).
• Variable names must not begin with numbers (x1 is valid, 1x is invalid).
• Variables cannot include special characters other than underscores.
• By convention, start variable names with lowercase letters.
• Variables can store text, known to programmers as a "string" (name = Ryan).
• Strings are sequences of characters stored in contiguous memory locations.
• The type() function reveals a variable's type (type(x) returns int).
• Integers (int) are whole numbers (1, 2, 3), while decimals are called floats (1.5).
• Floats are named because the decimal point's position can vary.
• Complex numbers, represented in Python using j (2j), consist of real and imaginary parts.
• Basic math can be performed on complex numbers (1j * 1j equals -1).
• Strings are defined using single or double quotes ("Ryan").
• Strings can be added together, which is known as concatenating the strings ("String1" + "String2").
• Strings containing numbers are not treated as numbers and will simply be concatenated. "1" + "1" = "11"
• Concatenating a string with a number results in a type error.
• Booleans represent true and false values and start with a capital letter.
• A double equal sign (==) is a comparison operator, which compares two values (1 == 1 gives true).

Data Structures

• Data structures store collections of values.
• Lists are created using square brackets [].
• An empty list is defined as my_list = [].
• Lists can contain values separated by commas (e.g., [1, 2, 3, 4]).
• Lists can store any data type, including strings, integers, Booleans, and even other lists.
• The len() function determines the number of elements in a list.
• Sets are like lists, but each element must be unique.
• Sets are defined with curly brackets {}.
• Duplicate elements are ignored when creating a set.
• The order of elements matters in lists, but not in sets.
• Tuples are similar to lists, but are defined using parentheses ().
• The order matters in tuples.
• Tuples are immutable: elements cannot be appended or modified after creation.
• Tuples use memory efficiently, because the computer knows their size won't change.
• Tuples are often used to store pairs like (X, Y) coordinates.
• Dictionaries are key-value pairs, like words and definitions.
• Dictionaries are defined using curly brackets {}.
• Data in dictionaries is accessed via keys (e.g., my_dictionary["apple"]).
• Values in a dictionary are accessed using square brackets with the key name.
• Keys in dictionaries must be unique; adding a duplicate key overwrites the existing value.
• The order of keys in dictionaries doesn't matter.

Operators

• Operators perform actions on variables and values.
• Arithmetic operators perform mathematical operations.
• The addition operator (+) adds numbers.
• The multiplication operator (*) multiplies numbers.
• Exponents are calculated using (**).
• Division is performed using a forward slash (/), and always returns a float.
• The modulus operator (%) returns the remainder of a division.
• Strings can be concatenated (joined) using the + operator. "string" + "string"
• Multiplying a string by a number repeats the string that many times. "string" * 4
• Comparison operators, logical operators, identity operators and membership operators produces a Boolean (true or false).
• Comparison operators include == (equal to), < (less than), > (greater than), <= (less than or equal to).
• Logical operators include and, or, and not, and operate on Boolean values.
• The and operator requires both sides to be true.
• The or operator requires either side to be true.
• The not operator reverses a Boolean value.
• Membership operators include in and not in check for membership in a sequence.
• "x" in "example"
• 10 not in [1,2,3]

Control Flow

• Common types of control flow that we're going to cover are if statements, else statements and loops.
• if statements execute code only if a condition is true.
• Code indented directly beneath an if statement is part of the "if block".
• else statements provide an alternative block of code to execute when the if condition is false.
• Nesting multiple if statements can lead to excessive indentation.
• for loops iterate over "iterables" like lists.
• The in keyword, used in for loops, is different from the membership operator.
• Items can be temporarily assigned to the variable in a loop, such as in the expression for item in my_list.
• while loops repeat as long as a condition remains true.
• It is important that while loops have a line of code that eventually evaluates to false, or the loop will never end.

Functions

• A function is a reusable block of code that performs a specific task.
• Functions are defined using the def keyword, followed by the function name, parentheses for arguments, and a colon.
• The name rules for functions are the same for variables.
• Functions can take inputs, called arguments, inside the parentheses.
• Use return to output a value from a function (like toast from a toaster).
• Functions don't always have to return a value. They can modify something.
• The print function doesn't return a value, printing print(print("Hello")) results in "None".
• "None" represents the absence of a value.

Classes and Objects

• Classes organize related functions and attributes into labeled collections.
• A class is used to keep related collections of functions and attributes labelled and organized.
• The classic way to demonstrate classes in programming is by using animals.
• Class names start with an uppercase letter, which is a Python convention.
• The init function initializes a class instance and is called whenever a new object of the class is created.
• The self variable refers to the specific instance of the class.
• Variables inside classes are called attributes.
• Functions inside classes are called methods.
• Object-oriented programming (OOP) refers to using class instances, also called objects.

Solution: Factorials

• The factorial of a non-negative integer n can be written as n! is the product of all positive integers less than or equal to n
• Error case include when the input is not an integer, or negative.
• The factorial of 0 is 1.
• Solution: Iteratively, use a while loop to perform all iterations and in each iteration multiply the existing factorial value, keeping track with a counter.
• Solution: Recursively, calling the factorial function within itself.

Ints and Floats

• Integers are whole numbers, and floats are decimal numbers.
• Division always results in receiving a float.
• Adding a float and an int results in a float.
• The integer class, int(), can be used to cast to an int. Casting from one type to another.
• Casting a float to an int lops off the numbers behind the decimal.
• The round() function can be used to round floats.
• Floats are approximations, they are stored as binary ones and zeros and use tricks and approximations due to finite memory. These can occasionally result in weird rounding errors. Must be aware of potential pitfalls.

Other Types of Numbers

• The int class can convert strings to integers (int("100")).
• It can also convert from different bases by providing a second argument (int("100", 2) converts binary 100 to decimal 4).
• For situations that involve money, and other applications with complex math, Python has the decimal module.
• Modules are handy pieces of code available by default with your python installation.
• When importing from modules from decimal import decimal. In this example importing the decimal class from the decimal module.

Booleans

• Booleans can be cast with integers in Python where 1 is true and 0 is false.
• Empty strings are false but anything else is true.
• Empty data structures (lists, dictionaries) are false, otherwise, they are true.
• There is often more than one way to evaluate a Boolean, be careful when creating boolean logic.
• Remember that Python evaluates Booleans left to right.
• It's important to be careful and think about how Python is evaluating each piece of the statement, and double check Boolean logic.

Strings

• Strings are worked with a lot to extract data or construct information.
• Strings and lists are very similar types, and slicing can be used on strings.
• With slicing, a part of a string can be extracted and returned.
• name[0] can be used to grab the first letter of a string.
• Slicing can be performed with two colons that specify a start and end point. name[0:7]
• Slicing can be used with a step size myList[0:6:2]
• Strings can be combined using concatenation string 1 + string 2. "number"
• Formatted strings can be constructed with an f before the string and variables in curly braces: f “My number is {variable}""
• Strings can have math and expressions performed inside curly braces for formatted strings
• Python can perform rounding in formatted strings via f “My number is {variable:.2f}""
• Multi-line strings can be constructed with three quotation marks in a row that allows new lines: “““This is a multi-line string”””

Bytes

• Commonly used for streaming files or transmitting data, but rarely manipulated. Is often data being passed around behind the scenes.
• bytes() creates an empty byte object.
• b differentiates bytes from a regular string.
• encode() creates a byte object with data in it.
• decode() takes a bytes object and represents it as a string again.
• Byte objects are immutable, like tuples.
• bytearray() create a bytes object that can be modified.

Solution: Converting hex to decimal

• Solution: Iteratively, converting each place value to its corresponding power of 16 using the character's index.
• Solution: First making sure that everything passed is a string and exists in a pre-defined hex character dictionary for a known good input, this can be skipped by checking the input length and creating an assumption.

Lists

• Lists are similar to strings in Python.
• Slicing syntax is applicable to lists.
• A third value can be added to the slicing syntax that determines step size, which can also be a negative value to step through the list backwards.
• Dynamically generating much longer lists can be done than manually typing.
• The range function helps generate a new sequence which is a lot like a tuple, and converting it to a list.
• The most common ways read data from list are using slicing and extracting.
• List can also be modified.
• append adds an item to the end of a list.
• insert adds an item at a specific place.
• remove removes a specific value. Will throw an error if a value is not in the list.
• Pop removes and returns an item from the end of the list.
• Python contains a copy function that can be used rather than setting one variable equal to another variable. Otherwise they will modify the same memory.

Tuples and Sets

• Sets are declared with curly brackets {} or the set operator.
• Sets are only able to contain unique values.
• Order of items in a list does not matter.
• The syntax cannot be used to get specific elements in a set. (Sets are not subscriptable.)
• Elements can be added to a set with add vs append. The add function does not add to the end, but is more like tossing the element on a pile.
• Sets have a membership function that will return a Boolean if a value is in a set.
• Sets can have a length function used.
• Sets also have a pop function. However, like with lists you're not going to get an element from the end of the set per se, but it'll grab an element for you and return it while removing the element from the set.
• Tuples are declared with parenthesis.
• Tuples are ordered and subscriptable but you cannot modify them.
• The elements of tuples can never be assigned or modified.
• The Python function can return multiple values separated by commas.
• As it turns out, Python doesn't require parenthesis around tuples at all. Is for readability and to reduce confusion.
• This is called unpacking values and can be used set many variables in a row.

Dictionaries

• Dictionaries work so well, almost any problem can be solved with lists and dictionaries combined.
• It is good practice and convention to add a comma to the end of the last key value pair in the dictionary, this is called a trailing comma.
• Specific values can be grabbed out of the diction with bracket notation.
• New values can be added with the key-value assignment with bracket notation.
• Update values can be changed in a key with using assignment.
• keys() and value() print out the keys and values of a dictionary in dict keys and dict value forms, and has similar properties of lists.
• To take the values and keys objects and turn them into a list, they can be passed in as an argument for casting.
• There is a function get() that will obtain a value by key that will return an error on failure, and if instead passed a default, that will be returned instead.