{"id":112668,"date":"2022-05-17T11:57:07","date_gmt":"2022-05-17T11:57:07","guid":{"rendered":"https:\/\/codeinstitute.net\/global\/?p=112668"},"modified":"2022-05-17T11:57:07","modified_gmt":"2022-05-17T11:57:07","slug":"python-cheat-sheet","status":"publish","type":"post","link":"https:\/\/codeinstitute.net\/global\/blog\/python-cheat-sheet\/","title":{"rendered":"Python Cheat Sheet"},"content":{"rendered":"\n

Python is one of the most popular programming languages. It currently takes first place both in the Tiobe index and the PYPL index and has been named Language of the Year in 2007, 2010, 2018, 2020, and 2021. This popularity stems both from Python\u2019s versatility and ease of use. Python can be used for<\/a> Web and Internet Development, Data Analysis and Machine Learning, Scripting, Software Testing, and Desktop GUIs (graphical user interfaces). Python uses a simple syntax and is very beginner-friendly. It is therefore a great choice for entry-level coders. The Python cheat sheet will introduce you to some important Python concepts.<\/p>\n\n\n\n

Python Syntax<\/h2>\n\n\n\n

Python uses an elegant syntax and uncluttered layout. Combined with frequently used English keywords like \u2018continue\u2019, \u2018return\u2019, and \u2018import\u2019, this makes Python a highly readable language.<\/p>\n\n\n\n

Indentation<\/h3>\n\n\n\n

One of the main characteristics of Python is indentation. While other programming languages, like Java<\/a> and JavaScript<\/a>, use braces to separate blocks of code, Python code blocks are identified by different levels of line indentation. Here is a code example using multiple levels of indentation:<\/p>\n\n\n\n

def printer_errors(s):\n    errors = 0 # first level of indentation\n    for letter in s:\n        if letter > 'm': # second level of indentation\n            errors += 1 # third level of indentation\n    return f'{errors}\/{len(s)}' # first level of indentation<\/code><\/pre><\/div>\n\n\n\n
Writing the code without or with wrong indentation will lead to an error, and the code won\u2019t be executed. It is best practice to use 4 spaces per level of indentation. It is possible to use either spaces or the Tabulator key for indentation, but you should stick to using either spaces or tabs. <\/p>\n\n\n\n
Comments<\/h3>\n\n\n\n
The hash sign from the above example is used for comments. Everything after the hash sign will be ignored by the Python interpreter and is used to add comments either for yourself or other people reading the code. Comments can be added above a line of code or next to a line of code, like in the above example. For long comments that span multiple lines, the hash sign can be added to the start of each new line, or the comment can be placed inside triple-quotes, like in the instruction below:<\/p>\n\n\n\n
# The function returns the number of errors in a given control string.\n# Letters from a to m are used to differentiate between colours.\n# All other letters indicate an error.\n# Write a function that returns the number of errors and the length of the control string.\n\n'''\nExamples:\ns = 'adgbfbchaifjm'\nprinter_errors(s) # Output: '0\/14'\n'''<\/code><\/pre><\/div>\n\n\n\n
Quotation<\/h3>\n\n\n\n
It is possible to use single (‘), double (“), and triple (”’ or “””) quotes in Python. It is, however, important and necessary to use the same kind of quote at the start and end of a string. If the string itself contains quotes, they must not match the outer quotes. Like with comments, triple quotes are used for strings that span multiple lines. See the examples below:<\/p>\n\n\n\n
name = 'Thomas'\ncolour = "blue"\nsentence = "It's a pleasure to meet you!" # note the single quote \nparagraph = '''One Ring to rule them all, One Ring to find them, One Ring to bring them all, and in the darkness bind them.'''<\/code><\/pre><\/div>\n\n\n\n
Keywords<\/h3>\n\n\n\n
A Python identifier is a name used to identify a variable, function, class or module. It is best practice to use descriptive names, like ‘first_name’ or ‘calculate_stardate(year)’, to make the code easier to understand. Some identifiers are reserved by the Python language and cannot be used as ordinary identifiers. They are listed in the table below.<\/p>\n\n\n\n
False<\/td>await<\/td>else<\/td>import<\/td>pass<\/td><\/tr>
None<\/td>break<\/td>except<\/td>in<\/td>raise<\/td><\/tr>
True<\/td>class<\/td>finally<\/td>is<\/td>return<\/td><\/tr>
and<\/td>continue<\/td>for<\/td>lambda<\/td>try<\/td><\/tr>
as<\/td>def<\/td>from<\/td>nonlocal<\/td>while<\/td><\/tr>
assert<\/td>del<\/td>global<\/td>not<\/td>with<\/td><\/tr>
async<\/td>elif<\/td>if<\/td>or<\/td>yield<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Python primitive data structures<\/h2>\n\n\n\n
There are four types of primitive data structures in Python. They contain pure values of data and are essential for data manipulation. <\/p>\n\n\n\n
String<\/h3>\n\n\n\n
To display sequences of character data in Python, the string type (abbreviated as str) is used. In most cases, strings will be words, but it is possible to put licence plates, passwords, symbols, or even numbers into an str variable.\u00a0 A string can be empty. The only limitation regarding length is the available computer memory. Strings<\/a> can be used with single, double, and triple quotes like mentioned above in the Quotation section.<\/p>\n\n\n\n
String methods<\/h4>\n\n\n\n
Strings in Python are immutable, which means they cannot be changed. However, it is possible to return a modified copy of a string by using string methods. To keep the modified string, it must be assigned to a new variable! Below, the most common string methods are listed with a short explanation.<\/p>\n\n\n\n
text = 'Hello, World!' # assign 'Hello, World!' to the variable text\nvulcan_greeting = ' Live long and prosper! ' # note the spaces at the start and end of the string\nlist_of_strings = ['Nice', 'to', 'meet', 'you']\n\n' '.join(list_of_strings) # join all the strings by the delimiter (in this case an empty space). Output: 'Nice to meet you'\ntext.capitalize() # convert the first character to upper case. Output: 'Hello, world!'\ntext.count('o') # return the number of occurrences of the specified substring. Output: 2\ntext.endswith('o') # return True if the string ends with the specified substring. Output: False\ntext.find('o') # return the lowest index of the specified substring. Output: 4 (the index starts with 0)\ntext.islower() # return True if all cased characters are lowercase and the string contains at least one character. Output: False\ntext.istitle() # return True if the string is titlecased and contains at least one character. Output: True\ntext.isupper() # return True if the string is in uppercase and contains at least one character. Output: False\nvulcan_greeting.lstrip() # remove the left whitespace. Output: 'Live long and prosper!'\ntext.lower() # convert the string into lower case. Output: 'hello, world!'\ntext.replace('World', 'Universe') # return the string with all occurrences of the first substring replaced by the second substring. Output: 'Hello, Universe'\nvulcan_greeting.rsplit() # remove the right whitespace. Output ' Live long and prosper!'\ntext.split() # split the string into separate words and return a list. Output: ['Hello,', 'World']\nvulcan_greeting.strip() # remove whitespace from both ends of the string. Output: 'Live long and prosper!'\ntext.startswith('o') # return True if the string starts with the specified substring. Output: False\ntext.swapcase() # swaps lower case to upper case and vice versa. Output: 'hELLO, wORLD'\nvulcan_greeting.title() # convert the first letter of each word to upper case. Output: 'Live Long And Prosper!'\ntext.upper() # convert the string into upper case. Output: 'HELLO, WORLD!'<\/code><\/pre><\/div>\n\n\n\n
String concatenation<\/h4>\n\n\n\n
It is possible to combine (or concatenate) multiple strings by using the + operator. When alpha-numeric strings are concatenated, the result might at first be surprising. Instead of adding them up, they are just written next to each other:<\/p>\n\n\n\n
greeting = 'Hello!'\nquestion = 'Do you want some coffee?'\ngreeting + question # Output:'Hello! Do you want some coffee?'\nx = '7'\ny = '5'\nx + y # Output: 75<\/code><\/pre><\/div>\n\n\n\n
It is also possible to repeat strings by using the * operator:<\/p>\n\n\n\n
greeting * 3 # Output: Hello!Hello!Hello!<\/code><\/pre><\/div>\n\n\n\n
Numeric: Integer and Float<\/h3>\n\n\n\n
Integers are whole numbers from negative infinity to infinity. There are no limits to the length of an integer value, except the amount of available memory. All decimal digits without a prefix will be treated as decimal numbers. To use another base, a prefix must be added to the integer value. The prefix for binary numbers using the base 2 is 0b or 0B, to use octal numbers with the base 8 add 0o or 0O, and for hexadecimal numbers with the base 16 add 0x or 0X. <\/p>\n\n\n\n
Float (for floating point number) values end with a decimal figure, e.g. 2.75. The difference between integers and floats is very important for division. Using the division operator \/ always results in a float:<\/p>\n\n\n\n
6 \/ 3 # Output: 2.0\n6 \/ 3.0 # Output: 2.0\n6.0 \/ 3 # Output: 2.0\n6.0 \/ 3.0 # Output: 2.0<\/code><\/pre><\/div>\n\n\n\n
Using integer division with \/\/ results in an integer, if both dividend and divisor are integers, and in a float in all other cases. For the numbers from the above example, not much will change. However, if the result of an integer division is not a whole number, it will always be rounded towards the lesser integer value. Integer division is therefore also called floor division.<\/p>\n\n\n\n
6 \/\/ 4 # Output: 1\n6.0 \/\/ 4 # Output: 1.0<\/code><\/pre><\/div>\n\n\n\n
Boolean<\/h3>\n\n\n\n
Objects of Boolean type can have one of two values: True or False. Booleans can be used both in conditional and comparison expressions.<\/p>\n\n\n\n
# Comparison expressions\nx = 5\ny = 10\n\nx < y # Output: True\nx > y # Output: False\nx + 7 > y # Output: True\nX <= y # Output: True\nX >= y # Output: False\nx == y # Output: False\nx != y # Output: True\n\n# Conditional expressions\ntemperature_in_degrees_celsius = 20\nsunny = temperature_in_degrees_celsius >= 20 # evaluates to True\ncold = temperature_in_degrees_celsius <= 10 # evaluates to False\n\nif sunny: \n    print('Wear a t-shirt')\nelif cold:\n    print('Wear a pullover and a jacket')\nelse:\n    print('More information needed to make a suggestion!')\n\n# Output: 'Wear a t-shirt'<\/code><\/pre><\/div>\n\n\n\n
Python Built-in non-primitive data structures<\/h2>\n\n\n\n
Python provides several built-in non-primitive data structures to store and organize a collection of values.<\/p>\n\n\n\n
Dictionaries<\/h3>\n\n\n\n
In a dictionary, keys are mapped with values. Each combination of a key and a value is called a key-value pair or an item. While the values in a dictionary can be of any type and different values can be of different types, the keys must be hashable<\/a>. Most often, strings and numbers are used as dictionary keys. The keys are immutable and unique. The dictionaries themselves are mutable. It is possible to add, delete, or change key-value elements. <\/p>\n\n\n\n
Create a dictionary:<\/strong><\/p>\n\n\n\n
# Create an empty dictionary eng_ger \neng_ger = {}\n\n# Typecast an empty dictionary ger_eng\nger_eng = dict()\n\n# Create a dictionary from two iterables\nweekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']\nweekday_numbers = [1, 2, 3, 4, 5, 6, 7]\n\n# zip both lists\nweekdays_with_numbers = dict(zip(weekdays, weekday_numbers))\nprint(weekdays_with_numbers) # Output: {'Monday': 1, 'Tuesday': 2, 'Wednesday': 3, 'Thursday': 4, 'Friday': 5, 'Saturday': 6, 'Sunday': 7}<\/code><\/pre><\/div>\n\n\n\n
Adding, replacing, and deleting items:<\/strong><\/p>\n\n\n\n
# Add multiple key-value pairs to an empty dictionary\neng_ger = {'car': 'Automobil', 'house': 'Haus', 'cat': 'Katze'}\nprint(eng_ger) # Output: {'car': 'Automobil', 'house': 'Haus', 'cat': 'Katze'}\n\n# Add a key-value-pair to an existing, non-empty dictionary\neng_ger['dog'] = 'Hund'\nprint(eng_ger) # output: {'car': 'Automobil', 'house': 'Haus', 'cat': 'Katze', 'dog': 'Hund'}\n# Modify the value of an existing key\neng_ger['car'] = 'Auto'\nprint(eng_ger['car'] # Output: Auto\n\n# Remove key-value pairs from a dictionary\ndel eng_ger['car']\nprint(eng_ger) # output: {'house': 'Haus', 'cat': 'Katze', 'dog': 'Hund'}  \n\n# Remove all items from a dictionary\neng_ger.clear()\nprint(eng_ger) # Output: {}<\/code><\/pre><\/div>\n\n\n\n
Check whether a key or a value is contained in a dictionary:<\/strong><\/p>\n\n\n\n
# Check if a key is contained in a dictionary with the in keyword\nprint('mouse' in eng_ger) # Output: False\n\n# Check if something appears as a value in a dictionary\nvalues_in_dict = list(eng_ger.values()) # convert into list\nprint('Katze' in values_in_dict) # Output: True<\/code><\/pre><\/div>\n\n\n\n
Iterate over keys, values, and key-value pairs in dictionaries:<\/strong><\/p>\n\n\n\n
villains = {'Star Trek': 'The Borg', 'Star Wars': 'The Emperor', 'Harry Potter': 'Lord Voldemort', 'Lord of the Rings': 'Sauron'}\n\n# iterate over the keys short version\nfor franchise in villains:\n    print(franchise)\n\n# Output:\nStar Trek\nStar Wars\nHarry Potter\nThe Lord of the Rings\n# iterate over the keys long version\nFor franchise in villains.keys():\n    print(franchise) # Output: same as above\n\n# iterate over the values\nfor villain in villains.values(): # the values() function must be called\n    print(villain)\n\n# Output:\nThe Borg\nThe Emperor\nLord Voldemort\nSauron\n\n# iterate over the key-value pairs\nfor key, value in villains.items():\n    print(f'Key: {key}, Value: {value}')\n\n# Output:\nKey: Star Trek, Value: The Borg\nKey: Star Wars, Value: the Emperor\nKey: Harry Potter, Value: Lord Voldemort\nKey: Lord of the Rings, Value: Sauron<\/code><\/pre><\/div>\n\n\n\n
Get the number of key-value pairs in a dictionary:<\/strong><\/p>\n\n\n\n
# Get the number of key-value pairs in a dictionary\nprint(len(en_ger) # Output: 3<\/code><\/pre><\/div>\n\n\n\n
Merge multiple dictionaries into one dictionary:<\/strong><\/p>\n\n\n\n
villains = {'Star Trek': 'The Borg', 'Star Wars': 'The Emperor', 'Harry Potter': 'Lord Voldemort', 'Lord of the Rings': 'Sauron'}\nmore_villains = {'Star Trek TOS': 'Khan', 'Fantastic Beasts': 'Grindelwald', 'Star Wars': 'Darth Sidious'}\n\n# In case of overlapping keys between the dictionaries, the newest value will be assigned to the key\n\n# merge dictionaries with the update() function\nvillains.update(more_villains) # the villains dictionary is updated\nprint(villains)\n# Output:\n{'Star Trek': 'The Borg', 'Star Wars': 'Darth Sidious', 'Harry Potter': 'Lord Voldemort', 'Lord of the Rings': 'Sauron', 'Star Trek TOS': 'Khan', 'Fantastic Beasts': 'Grindelwald'}\n\n# merge dictionaries with unpacking\ncombined_villains = {**villains, **more_villains} # a new dictionary is created and contains all values from the villains + more_villains dictionaries\nprint(combined_villains) # Output: same as above\n\n# merge dictionaries with the dict() constructor\nvillains_combined = dict(villains, **more_villains) # the new dictionary takes the villains dictionary and combines it with the unpacked items of the more_villains dictionary\nprint(villains_combined) # Output: same as in the first example<\/code><\/pre><\/div>\n\n\n\n
Lists<\/h2>\n\n\n\n
Lists can contain zero or more items of different types. Like dictionaries, lists are mutable. Unlike dictionaries, the items in a list are indexed by their position, starting at 0. Lists can be sorted, reversed, sliced, and concatenated.<\/p>\n\n\n\n
# create an empty list\nfriends = []\npets = list()\n\n# create a list with some items\nfavourite_colours = ['blue', 'black', 'orange']<\/code><\/pre><\/div>\n\n\n\n
Add and remove items:<\/strong><\/p>\n\n\n\n
# add an item at the end of a list\nfavourite_colours.append('green')\nprint(favourite_colours)\n# Output: ['blue', 'black', 'orange', 'green']\n\n# insert an item at a given position\nfavourite_colours.insert(1, 'yellow')\nprint(favourite_colours)\n# Output: ['blue', 'yellow', 'black', 'orange', 'green']\n\n# extend a list by appending another list\nmore_colours = ['red', 'grey', 'silver', 'purple']\nfavourite_colours.extend(more_colours)\nprint(favourite_colours)\n# Output: ['blue', 'yellow', 'black', 'orange', 'green', 'red', 'grey', 'silver', 'purple']\n\n# remove an item value from a list\nfavourite_colours.remove('yellow')\nprint(favourite_colours)\n# Output: ['blue', 'black', 'orange', 'green', red', 'grey', 'silver', 'purple']\n\n# remove the last item from a list\nfavourite_colours.pop()\nprint(favourite_colours)\n# Output: ['blue', 'black', 'orange', 'green', red', 'grey', 'silver']\n\n# remove an item at a given position from a list\nfavourite_colours.pop(3)\nprint(favourite_colours)\n# Output: ['blue', 'black', 'orange', 'red', 'grey', 'silver']\n\n# remove all items from a list\nmore_colours.clear()\nprint(more_colours)\n# Output: []<\/code><\/pre><\/div>\n\n\n\n
Sort and reverse:<\/strong><\/p>\n\n\n\n
# sort a list alphabetically\nfavourite_colours.sort()\nprint(favourite_colours)\n# Output: ['black', 'blue', 'grey', 'orange', 'red', 'silver']\n\n# reverse a list\nfavourite_colours.reverse()\nprint(favourite_colours()\n# Output: ['silver', 'red', 'orange', 'grey', 'blue', 'black']<\/code><\/pre><\/div>\n\n\n\n
Count:<\/strong><\/p>\n\n\n\n
# return the number of items in a list\nprint(len(favourite_colours)\n# Output: 6\n\n# return the number of occurrences of a specified value\nprint(favourite_colours.count('grey'))\n# Output: 1<\/code><\/pre><\/div>\n\n\n\n
Tuples<\/h3>\n\n\n\n
Like lists, the values in a tuple are indexed by integers, and tuples can contain elements of different types. The most important difference is that tuples are immutable. This means there are fewer functions available for tuples than for lists, because tuples can\u2019t be modified. Why should tuples be used if they seem to be a light version of a list? <\/p>\n\n\n\n