Study with the several resources on Docsity
Earn points by helping other students or get them with a premium plan
Prepare for your exams
Study with the several resources on Docsity
Earn points to download
Earn points by helping other students or get them with a premium plan
A complete pocket book for python programming. Everything you need to know about dictionaries is listed on page 17.
Typology: Cheat Sheet
1 / 24
This page cannot be seen from the preview
Don't miss anything!
Python Basics: Getting Started Main Python Data Types How to Create a String in Python Math Operators How to Store Strings in Variables Built-in Functions in Python How to Define a Function List List Comprehensions Tuples Dictionaries If Statements (Conditional Statements) in Python Python Loops Class Dealing with Python Exceptions (Errors) How to Troubleshoot the Errors
Most Windows and Mac computers come with Python pre-installed. You can check that via a Command Line search. The particular appeal of Python is that you can write a program in any text editor, save it in .py format and then run via a Command Line. But as you learn to write more complex code or venture into data science, you might want to switch to an IDE or IDLE.
IDLE (Integrated Development and Learning Environment) comes with every Python installation. Its advantage over other text editors is that it highlights important keywords (e.g. string functions), making it easier for you to interpret code. Shell is the default mode of operation for Python IDLE. In essence, it’s a simple loop that performs that following four steps:
Python shell is a great place to test various small code snippets.
You can create a string in three ways using single , double or triple quotes. Here’s an example of every option:
IMP! Whichever option you choose, you should stick to it and use it consistently within your program. As the next step, you can use the print() function to output your string in the console window. This lets you review your code and ensure that all functions well. Here’s a snippet for that:
my_string = “Let’s Learn Python!” another_string = ‘It may seem difficult first, but you can do it!’ a_long_string = ‘’’Yes, you can even master multi-line strings that cover more than one line with some practice’’’
The next thing you can master is concatenation — a way to add two strings together using the “+” operator. Here’s how it’s done:
Note: You can’t apply + operator to two different data types e.g. string + integer. If you try to do that, you’ll get the following Python error:
string_one = “I’m reading “ string_two = “a new great book!” string_three = string_one + string_two
TypeError: Can’t convert ‘int’ object to str implicitly
print(“Let’s print out a string!”)
As the name implies, this command lets you repeat the same string several times. This is done using ***** operator. Mind that this operator acts as a replicator only with string data types. When applied to numbers, it acts as a multiplier. String replication example:
For reference, here’s a list of other math operations you can apply towards numbers:
And with print ()
And your output will be Alice written five times in a row.
‘Alice’ * 5 ‘AliceAliceAliceAliceAlice’
print(“Alice” * 5 )
**Operators Operation Example ** Exponent 2 ** 3 = 8 % Modulus/Remainder 22 % 8 = 6 // Integer division 22 // 8 = 2 / Division 22 / 8 = 2.
- (^) **Subtraction 5 - 2 = 3
You already know the most popular function in Python — print(). Now let’s take a look at its equally popular cousins that are in-built in the platform.
When you run this short program, the results will look like this:
Output:
input() function is a simple way to prompt the user for some input (e.g. provide their name). All user input is stored as a string. Here’s a quick snippet to illustrate this:
len() function helps you find the length of any string, list, tuple, dictionary, or another data type. It’s a handy command to determine excessive values and trim them to optimize the performance of your program. Here’s an input function example for a string:
Hi! What’s your name? “Jim” Nice to meet you, Jim! How old are you? 25 So, you are already 25 years old, Jim!
The length of the string is: 35
name = input(“Hi! What’s your name? “) print(“Nice to meet you “ + name + “!”) age = input(“How old are you “) print(“So, you are already “ + str(age) + “ years old, “
# testing len() str1 = “Hope you are enjoying our tutorial!” print(“The length of the string is :”, len(str1))
Use the Filter() function to exclude items in an iterable object (lists, tuples, dictionaries, etc)
(Optional: The PDF version of the checklist can also include a full table of all the in-built functions).
ages = [ 5 , 12 , 17 , 18 , 24 , 32 ] def myFunc(x): if x < 18 : return False else: return True adults = filter(myFunc, ages) for x in adults: print(x)
In this case, you pass the number 1 in for the x parameter, 2 in for the y parameter, and 3 in for the z parameter. The program will that do the simple math of adding up the numbers: Output:
A function can also accept keyword arguments. In this case, you can use parameters in random order as the Python interpreter will use the provided keywords to match the values to the parameters. Here’s a simple example of how you pass a keyword argument to a function.
Output:
# Define function with parameters def product_info(product name, price): print(“productname: “ + product name) print(“Price “ + str(dollars)) # Call function with parameters assigned as above product_info(“White T-shirt”, 15 dollars) # Call function with keyword arguments product_info(productname=”jeans”, price= 45 )
Productname: White T-shirt Price: 15 Productname: Jeans Price: 45
a = 1 + 2 b = 1 + 3 c = 2 + 3
Lists are another cornerstone data type in Python used to specify an ordered sequence of elements. In short, they help you keep related data together and perform the same operations on several values at once. Unlike strings, lists are mutable (=changeable). Each value inside a list is called an item and these are placed between square brackets.
Alternatively, you can use list() function to do the same:
You have two ways to add new items to existing lists.
The first one is using append() function:
The second option is to insert() function to add an item at the specified index:
my_list = [ 1 , 2 , 3 ] my_list2 = [“a”, “b”, “c”] my_list3 = [“4”, d, “book”, 5 ]
beta_list = [“apple”, “banana”, “orange”] beta_list.append(“grape”) print(beta_list)
beta_list = [“apple”, “banana”, “orange”] beta_list.insert(“2 grape”) print(beta_list)
alpha_list = list((“1”, “2”, “3”)) print(alpha_list)
Use the sort() function to organize all items in your list.
Now, if you want to call just a few elements from your list (e.g. the first 4 items), you need to specify a range of index numbers separated by a colon [x:y]. Here’s an example:
You can easily overwrite a value of one list items:
Using for loop you can multiply the usage of certain items, similarly to what * operator does. Here’s an example:
Output:
alpha_list = [ 34 , 23 , 67 , 100 , 88 , 2 ] alpha_list.sort() alpha_list [ 2 , 23 , 34 , 67 , 88 , 100 ]
alpha_list[ 0 : 4 ] [ 2 , 23 , 34 , 67 ]
beta_list = [“apple”, “banana”, “orange”] beta_list[ 1 ] = “pear” print(beta_list)
for x in range( 1 , 4 ): beta_list += [‘fruit’] print(beta_list)
[‘apple’, ‘pear’, ‘cherry’]
Use the built-in copy() function to replicate your data:
Alternatively, you can copy a list with the list() method:
beta_list = [“apple”, “banana”, “orange”] beta_list = beta_list.copy() print(beta_list)
beta_list = [“apple”, “banana”, “orange”] beta_list = list (beta_list) print(beta_list)
Since Tuples are immutable, you can’t change them. What you can do though is convert a tuple into a list, make an edit and then convert it back to a tuple. Here’s how to accomplish this:
A dictionary holds indexes with keys that are mapped to certain values. These key-value pairs offer a great way of organizing and storing data in Python. They are mutable, meaning you can change the stored information. A key value can be either a string , Boolean , or integer. Here’s an example dictionary illustrating this:
Here’s a quick example showcasing how to make an empty dictionary. Option 1: new_dict = {} Option 2: other_dict= dict()
And you can use the same two approaches to add values to your dictionary:
x = (“apple”, “orange”, “pear”) y = list(x) y[ 1 ] = “grape” x = tuple(y) print(x)
Customer 1 = {‘username’: ‘john-sea’, ‘online’: false, ‘friends’: 100 }
new_dict = { “brand”: “Honda” , “model”: “Civic” , “year”: 1995 } print(new_dict)
You can access any of the values in your dictionary the following way:
You can also use the following methods to accomplish the same.
To change one of the items, you need to refer to it by its key name:
Again to implement looping, use for loop command.
Note: In this case, the return values are the keys of the dictionary. But, you can also return values using another method.
x = new_dict[“brand”]
#Change the “year” to 2020: new_dict= { “brand”: “Honda” , “model”: “Civic” , “year”: 1995 } new_dict[“year”] = 2020
#print all key names in the dictionary for x in new_dict: print(x) #print all values in the dictionary for x in new_dict: print(new_dict[x]) #loop through both keys and values for x, y in my_dict.items(): print(x, y)
elif keyword prompts your program to try another condition if the previous one(s) was not true. Here’s an example:
else keyword helps you add some additional filters to your condition clause. Here’s how an if-elif-else combo looks:
If statements can’t be empty. But if that’s your case, add the pass statement to avoid having an error:
Not keyword let’s you check for the opposite meaning to verify whether the value is NOT True:
a = 45 b = 45 if b > a: print(“b is greater than a”) elif a == b: print(“a and b are equal”)
if age < 4 : ticket_price = 0 elif age < 18 : ticket_price = 10 else: ticket_price = 15
a = 33 b = 200 if b > a: pass
new_list = [ 1 , 2 , 3 , 4 ] x = 10 if x not in new_list: print(“’x’ isn’t on the list, so this is True!”)
Python has two simple loop commands that are good to know:
Let’s take a look at each of these.
As already illustrated in the other sections of this Python checklist, for loop is a handy way for iterating over a sequence such as a list, tuple, dictionary, string, etc. Here’s an example showing how to loop through a string:
While loop enables you to execute a set of statements as long as the condition for them is true.
You can also stop the loop from running even if the condition is met. For that, use the break statement both in while and for loops:
Plus, you’ve already seen other examples for lists and dictionaries.
for x in “apple”: print(x)
#print as long as x is less than 8 i = 1 while i< 8 : print(x) i += 1
i = 1 while i < 8 : print(i) if i == 4 : break i += 1
