We see that the result is correct given the following hard code:
```
x = 4
y = 10
avg = 7
print(avg) #Prints 7
```
But If we change the values assigned to x and y assuming avg is still set to 7:
```
x = 5
y = 120
print(avg) #Still Prints 7
```
The result would not apply to all situations since the logic is flawed; avg is simply set to 7, not averaged to 7. Therefore, the appropriate solution would be:
```
x = 4
y = 10
avg = (x + y) / 2
print(avg) #Prints 7
``` 
If we changed the values of x and y, our result would still be correct with non-hard code:
```
x = 12
y = 20
avg = (x + y) / 2
print(avg) #Prints 16
```

Examples of Hard Coding

Hard Coding is the practice of writing code that can only satisfy one solution. While the hard-coded variable may be correct in a given circumstance, the overall logic of the code is not validated. 

The logic, flow, and computations should be depended on when writing code.

University of Michigan - Ann Arbor

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

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

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

Runestone: Foundations of Python Programming

- 4 + 4 = 8
- 9 - 7 = 2
- 6 * 6 = 36
- 6 ** 2 = 36
- 4 / 2 = 2
- 19 // 5 = 3 
- 5 % 3 = 2

Examples of Operator-Operand Expressions

The order of operations in Python is as follows: 
- Parenthesis: ()
- Exponentiation: **
- Multiplication and Division: *, /, //, %
- Addition and Subtraction: +, -

If operators have the same priority, they are evaluated left to right, except for exponentiation which is evaluated right to left.

Order of Operations

Logical operators can be thought as any expressions which act on boolean (True or False) expressions. These include: 
- and
- or
- not 

Logical Operators in Python 

In Python, **bitwise operators** allow the direct manipulation of individual bits (1s and 0s) within a bit string. The primary bitwise operators in Python include:

* **Bitwise AND (`&`)**: Compares two bit strings and returns a new bit string with `1`s only where both corresponding bits are `1`.
* **Bitwise OR (`|`)**: Compares two bit strings and returns a new bit string with `1`s where at least one corresponding bit is `1`.
* **Bitwise Left Shift (`<<`)**: Shifts the bits of the first operand to the left by the number of positions specified by the second operand.
* **Bitwise Right Shift (`>>`)**: Shifts the bits of the first operand to the right by the number of positions specified by the second operand.

Bitwise Operators in Python

Comparison operators are often used in true/false statements and loops to compare two objects. There are six comparison operators:
- equal to: denoted by == 
- not equal to: denoted by != or <>
- greater than: denoted by >
- greater than or equal to: denoted by >=
- less than: denoted by <
- less than or equal to: denoted by <=

Comparison Operators in Python

Variables, which store values, can have names of any length, but variables named with the following will be considered invalid:
- Have spaces 
- Start with numbers
- Possess illegal characters (i.e. $)
- Is a Python Keyword

As long as the variable name does not possess any of the above characteristics, it will be valid. 


Rules for Naming Variables 

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 

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. 

Learn Before

Related

Learn After