Python Data Types and Calculations

Calculations

• Calculations are a central part of computer programming.
• Formulas involve variables, operators (multiply, divide, add), and the assignment operator.
• The assignment operator assigns the right-hand side (RHS) of the formula to the left-hand side ( LHS ).
• In Python, formulas are coded using variables, arithmetic operators, and the assignment operator.

Conversion of Celsius to Fahrenheit

• In Python, variables like celsius and fahrenheit are stored in RAM to perform calculations.
• Variables are categorized based on their memory needs: Integers ( int ), Real Numbers ( float ), Strings ( str ).

Data Types

• Data Types categorize variables based on the nature of the data they hold.
• int : integers ( 0, 1, 2, 3, ... and negative counterparts ).
• float : real numbers ( -23.5, -9, 0, 0.5, 1, 2.34, 6, ...).
• str : alphanumeric character strings ( "ITM200", "123ER" ).
• Data Types allow for the enforcement of constraints on operations that can be applied to data.
• For example, it makes sense to add variables that hold int values, but it's incorrect to add variables holding strings of characters.

Data Variables

• Variable names can be any alphanumeric string where the first character is not a numeral.
• Variable names are case-sensitive.
• Variable names cannot be any of Python's reserved keywords (and, as, assert, break, class, continue, def, del, elif, else, except, exec, finally, for, from, global, if, import, in, is, lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield, False, True, None).

Arithmetic Operators

• * : multiplication.
• / : division.
• - : subtraction.
• ** : exponentiation.
• % : modulus (remainder of a division between integers).
• // : floor division (integer part of a division result).
• + : addition.
• Arithmetic operators in Python work in the usual way.
• The order of operations (precedence) for arithmetic expressions evaluation is:
  1. Brackets ( ).
  2. Exponentiation **.
  3. Multiplication, Division, Modulus, Floor Division *, /, %, //.
  4. Addition, Subtraction +, -.

Arithmetic Operations (Shorthand)

• x += y: equivalent to x = x + y.
• x -= y: equivalent to x = x - y.
• x *= y: equivalent to x = x * y.
• x /= y: equivalent to x = x / y.
• x //= y: equivalent to x = x // y.
• x %= y: equivalent to x = x % y.
• x **= y: equivalent to x = x ** y.

Dynamically Typed

• Variables can be assigned different data types at runtime.

Strongly Typed

• Operations incompatible with the data type are not allowed, and will result in run-time errors.

Characters in Python

• There is no dedicated character data type in Python; a character is considered a string of a single character.
• ord() : gets the ASCII/Unicode value of a character.
• chr() : gets the character corresponding to an ASCII/Unicode value.

Formatting Outputs

• str(n) : converts n to a string type for string concatenation using '+'.
• round(x, n) : rounds x to n digits after the decimal point.

Strings

• A sequence of characters.
• Each character has a position (index) within the string.
• String length is the number of characters in the string.
• Empty string: s = "".
• None string: s = None.

User Input

• The input() function allows the user to enter data.

Processing User Input

• The input() function returns data as a str, even if the input is a number.
• To perform calculations on user input, the input needs to be converted to the appropriate data type (e.g., int, float).

Calculation using Input

• The Python built-in function int() converts a string of numerals into an integer.

Data Type Conversion

• Data types can be converted using built-in functions:
  • int() : to convert to integer.
  • float() : to convert to real number.
  • str() : to convert to string.
  • bool() : to convert to Boolean (True or False).
• The conversion is only possible if the string can be interpreted as the target data type.
• Attempts to convert strings that can't be interpreted as the target data type will result in a run-time error.

Calculations in programming

• Performing calculations is a fundamental function of computer programming.
• The basic elements of a calculation are variables, arithmetic operators, and the assignment operator.
• The assignment operator assigns the value calculated on the right-hand side (RHS) to the left-hand side (LHS).
• Arithmetic operators include multiplication (*), division (/), subtraction (-), exponentiation (**), modulus (%), floor division (//), and addition (+).
• Python follows an order of precedence for evaluating arithmetic expressions:
  • Operations within parentheses are evaluated first.
  • Then **
  • Followed by *, /, %, //.
  • Finally, +, -.

Data types

• Data types categorize variables based on the type of data they hold.
• Common data types:
  • int: for whole numbers (e.g., 0, 1, 2, -1, -2, ...).
  • float: for real numbers (e.g., -23.5, -9, 0.5, 1, 2.34).
  • str: for strings of characters (e.g., "ITM200", "123ER").
  • bool: for Boolean values, which can be either True or False.
• Using data types enforces constraints on operations to prevent errors. For example, adding two int variables is valid, but adding a str variable to an int variable is not allowed.

Variables

• Variable names can be any alphanumeric string, but the first character must not be a numeral.
• Variable names are case-sensitive.
• Reserved keywords cannot be used as variable names.

String manipulation

• Strings are sequences of characters.
• Each character in a string has a unique position (index), starting from 0.
• ord() function returns the ASCII/Unicode value of a character.
• chr() function converts an ASCII/Unicode value to a character.
• String concatenation is performed using the + operator.
• str(n) converts a non-string n to a string.
• round(x,n) rounds x to n digits after the decimal point.

User input

• Python's input() function allows programs to get user input from the console.
• The user input is usually stored as a string.
• To perform calculations with user input, it often needs to be converted to a numerical data type using int() or float() functions.

Dynamically and strongly typed languages

• Python is dynamically typed, meaning that the type of a variable can change at runtime.
• Python is also strongly typed; operations incompatible with data types are not allowed and result in run-time errors.