Python Programming Cheatsheet

Overview of Python

• Python is an interpreted, high-level, and general-purpose programming language. This means it is executed line by line by the Python interpreter, which makes it easy to debug and allows for quick development.
• Dynamically typed, Python does not require explicit variable type declarations. The type of a variable is inferred at runtime, which simplifies coding but may also introduce potential issues if types are not managed carefully.

Programming Paradigms

• Python supports Object-Oriented Programming (OOP), meaning it allows the creation of classes and objects to model real-world phenomena. It is also modular, promoting code reuse and better organization by allowing the creation of modules that can be imported into different programs.
• Python is also commonly used as a scripting language, ideal for automating tasks, processing text, and managing system operations, among other tasks. This flexibility makes it a go-to language for many software developers and system administrators.

Everything is an Object

• One of Python’s core principles is that everything is an object. Whether it’s a number, a string, a list, or even a function, all of these are treated as objects. This unified approach allows for simplicity and consistency across the language, allowing objects to be manipulated in the same way regardless of their type.

Python Files and Extensions

• Python scripts typically have a .py extension. These files contain Python code that can be executed by the Python interpreter.

Code Structure and Indentation

• Python does not use curly braces {} to denote code blocks, as seen in other languages like C or Java. Instead, Python relies on indentation to define the scope of loops, functions, and conditional statements. This feature encourages cleaner, more readable code by eliminating unnecessary punctuation.

Running Python Files

• To execute a Python file, open the command line interface (CLI) and run the following command:

  python <filename.py>
  

  • On Windows, you can use the Command Prompt (CMD).
  • On macOS or Linux, you can use the terminal shell.

  Simply replace <filename.py> with the name of your Python file.

No Need for Imports (By Default)

• Unlike some other programming languages, Python doesn’t require imports to run basic programs. You can execute a Python script directly, and the standard library is available for use without any initial setup. However, when working with advanced features like web development, data science, or machine learning, you will need to import specific libraries or modules.

Creating and Executing a Python Program

1. Open a Terminal/Command Prompt
   • On Windows, press Win + R, type cmd, and hit Enter to open the Command Prompt.
   • On macOS or Linux, open the Terminal from your applications or use the shortcut Ctrl + Alt + T.
2. Create the Python Program
   • Navigate to the directory where you want to save your Python program.
   • To create a new Python file, use a text editor from the command line, such as nano, vim, or cat. For example, to create a file called nameProgram.py, use:

     nano nameProgram.py
     

     or alternatively:

     cat > nameProgram.py
     

   This command will open a text editor within your terminal where you can start typing your program.

3. Write Your Program and Save It

   • Write your Python code inside the editor. For example, a simple program could be:

     print("Hello, SytBay!")
     

• After writing your program:
  • If you are using nano, press Ctrl + X to exit, then Y to confirm saving, and Enter to save the file.
  • If using cat, press Ctrl + D to save and exit the editor.

1. Execute the Program
   • To run your Python program, type the following command:

     python nameProgram.py
     

• This will execute the Python file and output the result to the terminal.

Basic Datatypes

Data Type	Description
int	Integer values [0, 1, -2, 3]
float	Floating point values [0.1, 4.532, -5.092]
char	Characters [a, b, @, !, `]
str	Strings [abc, AbC, A@B, sd!, `asa]
bool	Boolean Values [True, False]
char	Characters [a, b, @, !, `]
complex	Complex numbers [2+3j, 4-1j]

Keywords

Keyword	Description
break	Exits the current loop (for, while) and resumes execution after the loop.
char	Used to declare a character type variable (Note: Python does not have a char type, but this is used in languages like C).
const	Declares a constant variable that cannot be changed (Note: Python does not use const for constants; final is used in other languages).
continue	Skips the current iteration of a loop and proceeds to the next iteration.
class	Used to define a new class.
def	Defines a function.
elif	A shorthand for “else if” used in conditional statements.
else	Defines the block of code executed when the if condition is False.
float	Declares a floating-point number.
for	Defines a for loop, used to iterate over a sequence (like a list, tuple, or string).
from	Used in import statements to import specific objects or functions from a module.
if	Defines a conditional statement.
import	Imports a module or specific functions or objects from a module.
pass	Used to indicate a placeholder; does nothing when executed. Common in class definitions and functions.
return	Exits a function and optionally returns a value.
while	Defines a while loop, which runs as long as the condition is True.

Operators

Operator	Description
( )	grouping parenthesis, function call, tuple declaration
[ ]	array indexing, also declaring lists etc.
!	relational not, complement, ! a yields true or false
~	bitwise not, ones complement, ~a
-	unary minus, – a
+	unary plus, + a
*	multiply, a * b
/	divide, a / b
%	modulo, a % b
+	add, a + b
-	subtract, a – b
<<	shift left, left operand is shifted left by right operand bits
>>	shift right, left operand is shifted right by right operand bits
<	less than, result is true or false, a %lt; b
<=	less than or equal, result is true or false, a <= b
>	greater than, result is true or false, a > b
>=	greater than or equal, result is true or false, a >= b
==	equal, result is true or false, a == b
!=	not equal, result is true or false, a != b
&	bitwise and, a & b
^	bitwise exclusive or XOR, a ^ b
|	bitwise or, a | b
&&, and	relational and, result is true or false, a < b && c >= d
||, or	relational or, result is true or false, a < b || c >= d
=	store or assignment
+=	add and store
-=	subtract and store
*=	multiply and store
/=	divide and store
%=	modulo and store
<<=	shift left and store
>>=	shift right and store
&=	bitwise and and store
^=	bitwise exclusive or and store
|=	bitwise or and store
,	separator as in ( y=x,z=++x )

Basic Data Structures

List

• List is a collection which is ordered and changeable. Allows duplicate members.

• Lists are created using square brackets:

thislist = ["apple", "banana", "cherry"] 

• List items are ordered, changeable, and allow duplicate values.

• List items are indexed, the first item has index [0], the second item has index [1] etc.

• The list is changeable, meaning that we can change, add, and remove items in a list after it has been created.

• To determine how many items a list has, use the len() function.

• A list can contain different data types:

list1 = ["abc", 34, True, 40, "male"]

• It is also possible to use the list() constructor when creating a new list

thislist = list(("apple", "banana", "cherry"))  # note the double round-brackets

Tuple

• Tuple is a collection which is ordered and unchangeable. Allows duplicate members.
• A tuple is a collection which is ordered and unchangeable.
• Tuples are written with round brackets.

thistuple = ("apple", "banana", "cherry")

• Tuple items are ordered, unchangeable, and allow duplicate values.
• Tuple items are indexed, the first item has index [0], the second item has index [1] etc.

• When we say that tuples are ordered, it means that the items have a defined order, and that order will not change.

• Tuples are unchangeable, meaning that we cannot change, add or remove items after the tuple has been created.

• Since tuple are indexed, tuples can have items with the same value:
• Tuples allow duplicate values:

thistuple = ("apple", "banana", "cherry", "apple", "cherry")

• To determine how many items a tuple has, use the len()function:

thistuple = ("apple", "banana", "cherry")
print(len(thistuple))

• To create a tuple with only one item, you have to add a comma after the item, otherwise Python will not recognize it as a tuple.

thistuple = ("apple",)
print(type(thistuple))

#NOT a tuple
thistuple = ("apple")
print(type(thistuple))

• It is also possible to use the tuple() constructor to make a tuple.

<br />thistuple = tuple(("apple", "banana", "cherry")) # note the double round-brackets
print(thistuple)

Set

• Set is a collection which is unordered and unindexed. No duplicate members.
• A set is a collection which is both unordered and unindexed.

thisset = {"apple", "banana", "cherry"}

• Set items are unordered, unchangeable, and do not allow duplicate values.

• Unordered means that the items in a set do not have a defined order.

• Set items can appear in a different order every time you use them, and cannot be referred to by index or key.

• Sets are unchangeable, meaning that we cannot change the items after the set has been created.

• Duplicate values will be ignored.
• To determine how many items a set has, use the len() method.

thisset = {"apple", "banana", "cherry"}

print(len(thisset))

• Set items can be of any data type:

set1 = {"apple", "banana", "cherry"}
set2 = {1, 5, 7, 9, 3}
set3 = {True, False, False}
set4 = {"abc", 34, True, 40, "male"}

• It is also possible to use the set() constructor to make a set.

thisset = set(("apple", "banana", "cherry")) # note the double round-brackets

Dictionary

• Dictionary is a collection which is unordered and changeable. No duplicate members.
• Dictionaries are used to store data values in key:value pairs.
• Dictionaries are written with curly brackets, and have keys and values:

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}

• Dictionary items are presented in key:value pairs, and can be referred to by using the key name.

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
print(thisdict["brand"])

• Dictionaries are changeable, meaning that we can change, add or remove items after the dictionary has been created.
• Dictionaries cannot have two items with the same key.
• Duplicate values will overwrite existing values.
• To determine how many items a dictionary has, use the len() function.

print(len(thisdict))

• The values in dictionary items can be of any data type

thisdict = {
  "brand": "Ford",
  "electric": False,
  "year": 1964,
  "colors": ["red", "white", "blue"]
}

Conditional branching

    if condition:
        pass
    elif condition2:
        pass
    else:
        pass

Loops

Python has two primitive loop commands:
1. while loops
2. for loops

While loop

• With the while loop we can execute a set of statements as long as a condition is true.
• Example: Print i as long as i is less than 6

i = 1
while i < 6:
  print(i)
  i += 1

• The while loop requires relevant variables to be ready, in this example we need to define an indexing variable, i, which we set to 1.
• With the break statement we can stop the loop even if the while condition is true

• With the continue statement we can stop the current iteration, and continue with the next.

• With the else statement we can run a block of code once when the condition no longer is true.

For loop

• A for loop is used for iterating over a sequence (that is either a list, a tuple, a dictionary, a set, or a string).

• This is less like the for keyword in other programming languages, and works more like an iterator method as found in other object-orientated programming languages.

• With the for loop we can execute a set of statements, once for each item in a list, tuple, set etc.

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x)

• The for loop does not require an indexing variable to set beforehand.
• To loop through a set of code a specified number of times, we can use the range() function.
• The range() function returns a sequence of numbers, starting from 0 by default, and increments by 1 (by default), and ends at a specified number.
• The range() function defaults to increment the sequence by 1, however it is possible to specify the increment value by adding a third parameter: range(2, 30, 3).

• The else keyword in a for loop specifies a block of code to be executed when the loop is finished.
  A nested loop is a loop inside a loop.

• The “inner loop” will be executed one time for each iteration of the “outer loop”:

adj = ["red", "big", "tasty"]
fruits = ["apple", "banana", "cherry"]

for x in adj:
  for y in fruits:
    print(x, y)

• for loops cannot be empty, but if you for some reason have a for loop with no content, put in the pass statement to avoid getting an error.

for x in [0, 1, 2]:
  pass

Function definition

def function_name():
    return

Function call

function_name()

• We need not to specify the return type of the function.
• Functions by default return None
• We can return any datatype.