- 7 * 6
- 5 / 3
- 1429
- print("Hello World!") 
- print(add(square(x), square(y)))
- len("What's up, man?") 

Examples of Expressions in Python 

After setting variables, their assigned values can be updated through the use of operators. If the print() function is applied to the reset variable, the newly updated value will appear. 

Updating Variables in Python 

A common programming exercise involves writing a program to calculate the sum of the squares of numbers in a given list. For instance, given the list of numbers [2, 10, -9, 78], the task is to compute the value of $2^2 + 10^2 + (-9)^2 + 78^2$.

Calculate the Sum of Squares of a List of Numbers

- Expressions are any combination of data types to be evaluated. Evaluating an expression results in values/objects. Expressions can also be evaluated into or set to values. 
- Asking Python to print an expression will result in the interpreter attempting to evaluate the expression and display the result

University of Michigan - Ann Arbor

Google

Values can be classified into different classes, known as data types:
- Integer (int) - 1, 4, 7, 24, 578, etc.
- Float (float) - 2.2, 2.59, 3.14159, etc.
- String (str) - *Any combination of characters in quotes
- List (list) - An ordered, mutable collection of items
- Tuple (tuple) - An ordered, immutable collection of items
- Dictionary (dict) - An unordered collection of data with keys and values
- Boolean (bool) - True or False
 
The terms "data type" and "class" are often used interchangeably.

Data Types in Python

A value is any thing in the form of a number, string, character, etc. that can be manipulated. Values can also be referred to as objects. 

Values in Python

- Values 
- Operators & Operands
- Functions
- Statements
- Expressions
- Debugging
- Classes and Objects
- Data Structures

Python Programming Language Foundational Concepts 

https://runestone.academy/runestone/books/published/fopp/index.html

Runestone: Foundations of Python Programming

Reference of Foundations of Large Language Models Course

Use the ```type()``` function to get the type of an object in Python. 
For example, 
```print(type(4))``` 
outputs ```<class 'int'>```.

Getting the type of an object

Expressions in Python 

In Python, a sequence refers to any ordered set. This includes strings, lists and tuples. All sequences can be sliced, indexed into, and are iterable.

Sequences

An object is mutable if its data can be changed after initialization. Inversely, an object is immutable if its data cannot be changed after creation. Lists are mutable, and tuples are immutable. This makes lists better suited for data which we anticipate will be modified. However, tuples (but not lists) can serve as dictionary keys. In addition to lists, dictionary objects are also mutable.

In Python, most data types are immutable, such as integers, floats, strings, tuples and booleans. Immutable data types are faster to use in code, but their values can only be changed by creating a copy of the object to be altered. 

Mutability

In Python, the type() function is used to return the class (data type) of an object. For example:
```python
print(type(66))
print(type("hello there"))
print(type(["General", "Kenobi"]))
```
will print:
<class 'int'>
<class 'str'>
<class 'list'>

type() Function

Every key in all the key value pairs witin a dictionary must be unique. Each key is an identifier for that key value pair so it can not be repeated. On the other hand, the values can be duplicated within a dictionary.

Dictionaries can not Have Duplicate Keys

Lists in Python are indexed, which means they can have items with the same value.
For example, the picture below shows that the list called thislist has the value "cherry" twice. This is not an issue will lists.

Duplicate Values in a List

If you want to specify the data type of an object, you can use constructor functions like str(), float(), list(), and tuple().

Example:
x = list(("apple", "banana", "cherry"))

The example above will turn the sequence into a list

Assigning a Python Object to Have a Certain Type

Python has 4 collection data types:
- lists - Ordered, mutable collection of items allowing duplicate members
- tuples - Ordered, immutable collection of items allowing duplicate members
- sets - Unordered, unindexed collection of items not allowing duplicate members
- dictionaries - Ordered, mutable collection of items not allowing duplicate members


Python Collections

Data types in a program are likely to be allocated into memory when encountered in a program. Python's interpreter includes the Python memory manager, which handles how data types are stored and tracked in memory. The user has no control over this process. Memory allocation for each new variable is performed on demand by the Python memory manager automatically.

Memory Allocation

A variable is where data values can be stored. Another way to say this is that a value can be referred to by its respective variable. Variables do not need to be declared with any particular type, and can even change type after they have been set.

Variables in Python

Use the equal sign ("=") with the variable name on the left and the value on the right. 

Examples:
- car_model = "Ford Taurus"
- Total_Cost = 400
- n = 18

Note that the equal sign does not mean "equal to" in this case. It should be read as "(Variable) refers to (Value)." For example, "n refers to 18." 

Setting Variables in Python 

Scope determines where a variable can be accessed. The two common Scopes are Local scope and Global scope.

Variables in Local scope are called local variables and these variables are defined inside a function. Local variables can only be accessed inside that function. Similarly, variables defined inside a loop of a function can only be accessed inside that loop. To use those variables outside of the loop in the rest of the function, they must be defined before the loop starts. 

Variables in Global scope are called global variables and these are defined outside functions. Global variables are accessible anywhere in the Python module.

Scope in Python

Operators are things that represent computational processes in Python. These include +, -, *, **, //, %, and /. 
- "+" = Addition
- "-" = Subtraction
- "*" = Multiplication

- "**" = Exponent
- "//" = Divide, but only include whole number in result
- "%" = Modulo, which only displays remainder of operands 

Operands are the values being acted on by the operator. 

Operators & Operands in Python

Function can be thought of as devices that take in material, perform a specified operation on the taken-in material, then output a resulting object. 

Inputs are referred to as arguments 
End result is referred to as output or return value. 

Functions in Python

A statement is any line of instruction that the Python interpreter can potentially execute. 

Types of statements include but are not limited to:
- Variable assignment statements 
- while statements
- for statements
- if statements
- import statements 

Statements in Python 

- General Tips & Tricks
- Common Syntax Errors
- Error types
- Error Messages

Debugging in Python

A Class allows us to group together data and functions. It provides a template which can be instantiated to create objects. Classes and Objects help improve readability and allow code reuse. 

Classes are most often used in Object Oriented Programming, as they allow programmers to bundle sets of functions and data together. 

Python Classes and Objects

Data structures facilitate the organization of data in computer memory in an efficient manner which further support faster and more flexible data manipulations.


The python interpreter offers the following built-in data structures:


- List
- Set
- Tuple
- Dictionary


Data Structures in Python

https://www.geeksforgeeks.org/vectorization-in-python/

Vectorization in python

Vectorization is a computational technique used to replace explicit, element-by-element loops (such as Python for-loops) with optimized operations on entire data structures simultaneously. In machine learning, vectorization leverages highly optimized linear algebra libraries to perform mathematical operations—like calculating the elementwise sum of vectors or processing whole minibatches of examples—at once. This approach dramatically reduces execution time by yielding order-of-magnitude speedups, simplifies code, reduces the potential for bugs, and increases portability by offloading mathematics to underlying libraries.

Learn Before

Related

Learn After