- Missing comma after dictionary entry
- Confusing assignment operator (=) and comparison operator (==)
- Using Python keyword where unintended*
- Missing parentheses, brackets, or quotes**
- Adding extra parentheses or brackets
- Missing a colon at the end of a for, while, or if statement
- Improper indentation

*Note: The keyword library can be used to check if something is a Python keyword. To demonstrate,
```python
import keyword as kw
kw.iskeyword('class') # returns True
```

**Note: To initialize a string containing the quote character (e.g. English contractions), you can escape the quote symbol using a backslash:
```python
message = 'can\'t'
print(message) # prints "can't"
```

Common Syntax Errors in Python

- Look for the line number in the error message to find where the interpreter believes the error is coming from. Trace backwards if error doesn't stem from that line
- Understand the different types of errors (Syntax, Runtime, Semantic) 
- Use print statements to check the values of variables and if a block of code is being run, especially when your code has if-statements or loops
- Debug code in blocks as you go. This will make it easier to find more subtle semantic issues instead of having to look through your entire program when debugging at the end
-Usage of Break Points can be very useful if your IDE allows for it. This way you can run the program up to the break point and step through the code step by step checking the value of variables and comparing it to what you expect it to be. If there is a miss-match then you can trace it back to the line where the program deviated from your intended functionality. 

-When dealing with large amounts of data, use mocking to test your code as you build bigger projects. Mocking is the action of running smaller, more palpable data sets through code to more easily see errors in code designed for larger amounts of data. 

General Tips for Debugging

- Syntax Errors
- Semantic Errors
- Runtime Errors

Error Types

```pdb``` is a built-in python debugging tool. It is a very simple and effective tool. To start debugging session, we write the following line of code:
```python
import pdb; pdb.set_trace()
``` 
When this line is reached, python will stop the execution and start an interactive debugging session in the console.

Python 3.7 brings the ability to use breakpoint() rather than 
import pdb;pdb.set_trace()

Python built-in debugger "pdb"

Python provides a construct called the try-except construct that allows a programmer to capture a runtime error and give the programmer the option to handle that error.

```python
try:
     #code
except (insert_error_name):
     #code to run when faced this error
```

Try and except blocks allows for multiple different except blocks to handle a variety of errors. Exceptions can also be raised intentionally to test try and except functionality. 

try-except

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

University of Michigan - Ann Arbor

Rutgers University

- 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

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

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 

- 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

Expressions in Python 

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