Python is a popular programming language. It was created by Guido van Rossum, and released in 1991.
Python can connect to database systems. It can also read and modify files.
Python can be used to handle big data and perform complex mathematics.
Python can be used for rapid prototyping, or for production-ready software development.
Python works on different platforms (Windows, Mac, Linux, Raspberry Pi, etc).
Python has syntax that allows developers to write programs with fewer lines than some other programming languages.
Python runs on an interpreter system, meaning that code can be executed as soon as it is written. This means that prototyping can be very quick.
Python can be treated in a procedural way, an object-orientated way or a functional way.
The most recent major version of Python is Python 3, which we shall be using in this tutorial. However, Python 2, although not being updated with anything other than security updates, is still quite popular.
In this tutorial Python will be written in a text editor. It is possible to write Python in an Integrated Development Environment, such as Thonny, Pycharm, Netbeans or Eclipse which are particularly useful when managing larger collections of Python files.
Python was designed for readability, and has some similarities to the English language with influence from mathematics.
Python uses new lines to complete a command, as opposed to other programming languages which often use semicolons or parentheses.
Python relies on indentation, using whitespace, to define scope; such as the scope of loops, functions and classes. Other programming languages often use curly-brackets for this purpose.
Many PCs and Macs will have python already installed.
To check if you have python installed on a Windows PC, search in the start bar for Python or run the following on the Command Line (cmd.exe):
C:\Users\Your Name>python --version
To check if you have python installed on a Linux or Mac, then on linux open the command line or on Mac open the Terminal and type:
If you find that you do not have python installed on your computer, then you can download it for free from the following website: https://www.python.org/
Python is an interpreted programming language, this means that as a developer you write Python (.py) files in a text editor and then put those files into the python interpreter to be executed.
The way to run a python file is like this on the command line:
C:\Users\Your Name>python helloworld.py
Where "helloworld.py" is the name of your python file.
Let's write our first Python file, called helloworld.py, which can be done in any text editor.
Simple as that. Save your file. Open your command line, navigate to the directory where you saved your file, and run:
C:\Users\Your Name>python helloworld.py
Congratulations, you have written and executed your first Python program.
To test a short amount of code in python sometimes it is quickest and easiest not to write the code in a file. This is made possible because Python can be run as a command line itself.
Type the following on the Windows, Mac or Linux command line:
Or, if the "python" command did not work, you can try "py":
From there you can write any python, including our hello world example from earlier in the tutorial:
Python 3.6.4 (v3.6.4:d48eceb, Dec 19 2017, 06:04:45) [MSC v.1900 32 bit
Type "help", "copyright", "credits" or "license" for more information.
Which will write "Hello, World!" in the command line:
Python 3.6.4 (v3.6.4:d48eceb, Dec 19 2017, 06:04:45) [MSC v.1900 32 bit
Type "help", "copyright", "credits" or "license" for more information.
>>> print("Hello, World!") Hello, World!
Whenever you are done in the python command line, you can simply type the following to quit the python command line interface:
Latest Jobs and Internships are regularly uplaoded here : https://telegram.me/PLACEMENTLELO
As we learned in the previous page, Python syntax can be executed by writing directly in the Command Line:
>>> print("Hello, World!") Hello, World!
Or by creating a python file on the server, using the .py file extension, and running it in the Command Line:
C:\Users\Your Name>python myfile.py
Indentation refers to the spaces at the beginning of a code line.
Where in other programming languages the indentation in code is for readability only, the indentation in Python is very important.
Python uses indentation to indicate a block of code.
print("Five is greater than two!")
Python will give you an error if you skip the indentation:
print("Five is greater than two!")
The number of spaces is up to you as a programmer, but it has to be at least one.
print("Five is greater than two!") if 5 > 2:
print("Five is greater than two!")
You have to use the same number of spaces in the same block of code, otherwise Python will give you an error:
print("Five is greater than two!") print("Five is greater than two!")
In Python variables are created the moment you assign a value to it:
Python has no command for declaring a variable.
You will learn more about variables in the Python Variables chapter.
Python has commenting capability for the purpose of in-code documentation. Comments start with a #, and Python will render the rest of the line as a comment:
Comments can be used to explain Python code. Comments can be used to make the code more readable.
Comments can be used to prevent execution when testing code.
Comments starts with a #, and Python will ignore them:
#This is a comment print("Hello, World!")
Comments can be placed at the end of a line, and Python will ignore the rest of the line:
print("Hello, World!") #This is a comment
Comments does not have to be text to explain the code, it can also be used to prevent Python from executing code:
#print("Hello, World!") print("Cheers, Mate!")
Python does not really have a syntax for multi line comments.
To add a multiline comment you could insert a # for each line:
#This is a comment #written in
#more than just one line print("Hello, World!")
Or, not quite as intended, you can use a multiline string.
Since Python will ignore string literals that are not assigned to a variable, you can add a multiline string (triple quotes) in your code, and place your comment inside it:
As long as the string is not assigned to a variable, Python will read the code, but then ignore it, and you have made a multiline comment.
Variables are containers for storing data values.
Unlike other programming languages, Python has no command for declaring a variable.
A variable is created the moment you first assign a value to it.
Variables do not need to be declared with any particular type and can even change type after they have been set.
x = "Sally" # x is now of type str print(x)
String variables can be declared either by using single or double quotes:
A variable can have a short name (like x and y) or a more descriptive name (age, carname, total_volume). Rules for Python variables:
A variable name must start with a letter or the underscore character
A variable name can only contain alpha-numeric characters and underscores (A-z, 0-9, and _ )
Variable names are case-sensitive (age, Age and AGE are three different variables)
Remember that variable names are case-sensitive
Assign Value to Multiple Variables
Python allows you to assign values to multiple variables in one line:
x, y, z = "Orange", "Banana", "Cherry" print(x)
And you can assign the same value to multiple variables in one line:
The Python print statement is often used to output variables.
To combine both text and a variable, Python uses the + character:
x = "awesome" print("Python is " + x)
You can also use the + character to add a variable to another variable:
For numbers, the + character works as a mathematical operator:
If you try to combine a string and a number, Python will give you an error:
Variables that are created outside of a function (as in all of the examples above) are known as global variables.
Global variables can be used by everyone, both inside of functions and outside.
Create a variable outside of a function, and use it inside the function
def myfunc(): print("Python is " + x)
If you create a variable with the same name inside a function, this variable will be local, and can only be used inside the function. The global variable with the same name will remain as it was, global and with the original value.
Create a variable inside a function, with the same name as the global variable
x = "fantastic" print("Python is " + x)
Normally, when you create a variable inside a function, that variable is local, and can only be used inside that function.
To create a global variable inside a function, you can use the global keyword.
If you use the global keyword, the variable belongs to the global scope:
Also, use the global keyword if you want to change a global variable inside a function.
To change the value of a global variable inside a function, refer to the variable by using the global keyword:
In programming, data type is an important concept.
Variables can store data of different types, and different types can do different things. Python has the following data types built-in by default, in these categories:
You can get the data type of any object by using the type() function:
Print the data type of the variable x:
In Python, the data type is set when you assign a value to a variable:
Latest Jobs and Internships are regularly uplaoded here : https://telegram.me/PLACEMENTLELO
Setting the Specific Data Type
If you want to specify the data type, you can use the following constructor functions:
There are three numeric types in Python:
Variables of numeric types are created when you assign a value to them:
To verify the type of any object in Python, use the type() function:
print(type(x)) print(type(y)) print(type(z))
Int, or integer, is a whole number, positive or negative, without decimals, of unlimited length.
print(type(x)) print(type(y)) print(type(z))
Float, or "floating point number" is a number, positive or negative, containing one or more decimals.
print(type(x)) print(type(y)) print(type(z))
Float can also be scientific numbers with an "e" to indicate the power of 10.
print(type(x)) print(type(y)) print(type(z))
Complex numbers are written with a "j" as the imaginary part:
print(type(x)) print(type(y)) print(type(z))
You can convert from one type to another with the int(), float(), and complex() methods:
Convert from one type to another:
print(type(a)) print(type(b)) print(type(c))
Note: You cannot convert complex numbers into another number type.
Python does not have a random() function to make a random number, but Python has a built-in module called random that can be used to make random numbers:
Import the random module, and display a random number between 1 and 9:
In our Random Module Reference you will learn more about the Random module.
Latest Jobs and Internships are regularly uplaoded here : https://telegram.me/PLACEMENTLELO
There may be times when you want to specify a type on to a variable. This can be done with casting. Python is an object-orientated language, and as such it uses classes to define data types, including its primitive types.
Casting in python is therefore done using constructor functions:
int() - constructs an integer number from an integer literal, a float literal (by rounding down to the previous whole number), or a string literal (providing the string represents a whole number)
float() - constructs a float number from an integer literal, a float literal or a string literal (providing the string represents a float or an integer)
str() - constructs a string from a wide variety of data types, including strings, integer literals and float literals
y = float(2.8) # y will be 2.8
z = float("3") # z will be 3.0 w = float("4.2") # w will be 4.2
x = str("s1") # x will be 's1'
z = str(3.0) # z will be '3.0'
String literals in python are surrounded by either single quotation marks, or double quotation marks.
'hello' is the same as "hello".
You can display a string literal with the print() function:
Assigning a string to a variable is done with the variable name followed by an equal sign and the string:
You can assign a multiline string to a variable by using three quotes:
You can use three double quotes:
a = """Lorem ipsum dolor sit amet,
consectetur adipiscing elit, sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua.""" print(a)
a = '''Lorem ipsum dolor sit amet,
consectetur adipiscing elit, sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua.''' print(a)
Note: in the result, the line breaks are inserted at the same position as in the code.
Like many other popular programming languages, strings in Python are arrays of bytes representing unicode characters.
However, Python does not have a character data type, a single character is simply a string with a length of 1.
Square brackets can be used to access elements of the string.
Get the character at position 1 (remember that the first character has the position 0):
You can return a range of characters by using the slice syntax.
Specify the start index and the end index, separated by a colon, to return a part of the string.
Get the characters from position 2 to position 5 (not included):
Use negative indexes to start the slice from the end of the string:
Get the characters from position 5 to position 1, starting the count from the end of the string:
To get the length of a string, use the len() function.
The len() function returns the length of a string:
Python has a set of built-in methods that you can use on strings.
The strip() method removes any whitespace from the beginning or the end:
print(a.strip()) # returns "Hello, World!"
The lower() method returns the string in lower case:
The upper() method returns the string in upper case:
The replace() method replaces a string with another string:
The split() method splits the string into substrings if it finds instances of the separator:
print(a.split(",")) # returns ['Hello', ' World!']
Learn more about String Methods with our String Methods Reference
To check if a certain phrase or character is present in a string, we can use the keywords in or not in.
Check if the phrase "ain" is present in the following text:
txt = "The rain in Spain stays mainly in the plain"
Check if the phrase "ain" is NOT present in the following text:
txt = "The rain in Spain stays mainly in the plain" x = "ain" not in txt
To concatenate, or combine, two strings you can use the + operator.
Merge variable a with variable b into variable c:
To add a space between them, add a " ":
As we learned in the Python Variables chapter, we cannot combine strings and numbers like this:
txt = "My name is John, I am " + age print(txt)
But we can combine strings and numbers by using the format() method!
The format() method takes the passed arguments, formats them, and places them in the string where the placeholders {} are:
Use the format() method to insert numbers into strings:
txt = "My name is John, and I am {}" print(txt.format(age))
The format() method takes unlimited number of arguments, and are placed into the respective placeholders:
myorder = "I want {} pieces of item {} for {} dollars." print(myorder.format(quantity, itemno, price))
You can use index numbers {0} to be sure the arguments are placed in the correct placeholders:
myorder = "I want to pay {2} dollars for {0} pieces of item {1}." print(myorder.format(quantity, itemno, price))
To insert characters that are illegal in a string, use an escape character.
An escape character is a backslash \ followed by the character you want to insert.
An example of an illegal character is a double quote inside a string that is surrounded by double quotes:
You will get an error if you use double quotes inside a string that is surrounded by double quotes:
txt = "We are the so-called "Vikings" from the north."
To fix this problem, use the escape character \":
The escape character allows you to use double quotes when you normally would not be allowed:
txt = "We are the so-called \"Vikings\" from the north."
Other escape characters used in Python:
Python has a set of built-in methods that you can use on strings.
Note: All string methods returns new values. They do not change the original string.
Returns the number of times a specified value occurs in a string | |
Fills the string with a specified number of 0 values at the beginning |
Use the len method to print the length of the string.
Submit Answer » Start the Exercise
Booleans represent one of two values: True or False.
In programming you often need to know if an expression is True or False.
You can evaluate any expression in Python, and get one of two answers, True or False.
When you compare two values, the expression is evaluated and Python returns the Boolean answer:
When you run a condition in an if statement, Python returns True or False:
Print a message based on whether the condition is True or False:
print("b is greater than a") else:
print("b is not greater than a")
The bool() function allows you to evaluate any value, and give you True or False in return,
Evaluate a string and a number:
Almost any value is evaluated to True if it has some sort of content.
Any string is True, except empty strings.
Any list, tuple, set, and dictionary are True, except empty ones.
The following will return True:
bool(["apple", "cherry", "banana"])
In fact, there are not many values that evaluates to False, except empty values, such as (), [], {}, "", the number 0, and the value None. And of course the
value False evaluates to False.
The following will return False:
One more value, or object in this case, evaluates to False, and that is if you have an objects that are made from a class with a len function that returns 0 or False:
myobj = myclass() print(bool(myobj))
Functions can Return a Boolean
Python also has many built-in functions that returns a boolean value, like
the isinstance() function, which can be used to determine if an object is of a certain data type:
Check if an object is an integer or not:
Operators are used to perform operations on variables and values. Python divides the operators in the following groups:
Arithmetic operators are used with numeric values to perform common mathematical operations:
Assignment operators are used to assign values to variables:
Comparison operators are used to compare two values:
Logical operators are used to combine conditional statements:
Identity operators are used to compare the objects, not if they are equal, but if they are actually the same object, with the same memory location:
Membership operators are used to test if a sequence is presented in an object:
Returns True if a sequence with the specified value is present in the object | |||
Returns True if a sequence with the specified value is not present in the object |
Bitwise operators are used to compare (binary) numbers:
Shift left by pushing zeros in from the right and let the leftmost bits fall off | ||
There are four collection data types in the Python programming language:
List is a collection which is ordered and changeable. Allows duplicate members.
Tuple is a collection which is ordered and unchangeable. Allows duplicate members.
Set is a collection which is unordered and unindexed. No duplicate members.
Dictionary is a collection which is unordered, changeable and indexed. No duplicate members.
When choosing a collection type, it is useful to understand the properties of that type. Choosing the right type for a particular data set could mean retention of meaning, and, it could mean an increase in efficiency or security.
A list is a collection which is ordered and changeable. In Python lists are written with square brackets.
thislist = ["apple", "banana", "cherry"]
You access the list items by referring to the index number:
Print the second item of the list:
thislist = ["apple", "banana", "cherry"]
Negative indexing means beginning from the end, -1 refers to the last item, -2 refers to the second last item etc.
Print the last item of the list:
thislist = ["apple", "banana", "cherry"]
You can specify a range of indexes by specifying where to start and where to end the range.
When specifying a range, the return value will be a new list with the specified items.
Return the third, fourth, and fifth item:
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
Note: The search will start at index 2 (included) and end at index 5 (not included). Remember that the first item has index 0.
By leaving out the start value, the range will start at the first item:
This example returns the items from the beginning to "orange":
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
By leaving out the end value, the range will go on to the end of the list:
This example returns the items from "cherry" and to the end:
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
Specify negative indexes if you want to start the search from the end of the list:
This example returns the items from index -4 (included) to index -1 (excluded)
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
To change the value of a specific item, refer to the index number:
thislist = ["apple", "banana", "cherry"]
thislist[1] = "blackcurrant" print(thislist)
You can loop through the list items by using a for loop:
Print all items in the list, one by one:
thislist = ["apple", "banana", "cherry"]
You will learn more about for loops in our Python For Loops Chapter.
To determine if a specified item is present in a list use the in keyword:
Check if "apple" is present in the list:
thislist = ["apple", "banana", "cherry"]
print("Yes, 'apple' is in the fruits list")
To determine how many items a list has, use the len() function:
Print the number of items in the list:
thislist = ["apple", "banana", "cherry"]
To add an item to the end of the list, use the append() method:
Using the append() method to append an item:
thislist = ["apple", "banana", "cherry"]
thislist.append("orange") print(thislist)
To add an item at the specified index, use the insert() method:
Insert an item as the second position:
thislist = ["apple", "banana", "cherry"]
thislist.insert(1, "orange") print(thislist)
There are several methods to remove items from a list:
The remove() method removes the specified item:
thislist = ["apple", "banana", "cherry"] thislist.remove("banana") print(thislist)
The pop() method removes the specified index, (or the last item if index is not specified):
thislist = ["apple", "banana", "cherry"]
thislist.pop() print(thislist)
The del keyword removes the specified index:
thislist = ["apple", "banana", "cherry"]
del thislist[0] print(thislist)
The del keyword can also delete the list completely:
thislist = ["apple", "banana", "cherry"]
The clear() method empties the list:
thislist = ["apple", "banana", "cherry"]
thislist.clear() print(thislist)
You cannot copy a list simply by typing list2 = list1, because: list2 will only be a reference to list1, and changes made in list1 will automatically also be made in list2.
There are ways to make a copy, one way is to use the built-in List method copy().
Make a copy of a list with the copy() method:
thislist = ["apple", "banana", "cherry"] mylist = thislist.copy()
Another way to make a copy is to use the built-in method list().
Make a copy of a list with the list() method:
thislist = ["apple", "banana", "cherry"]
mylist = list(thislist) print(mylist)
There are several ways to join, or concatenate, two or more lists in Python.
One of the easiest ways are by using the + operator.
list3 = list1 + list2 print(list3)
Another way to join two lists are by appending all the items from list2 into list1, one by one:
for x in list2: list1.append(x)
Or you can use the extend() method, which purpose is to add elements from one list to another list:
Use the extend() method to add list2 at the end of list1:
list1.extend(list2) print(list1)
It is also possible to use the list() constructor to make a new list.
Using the list() constructor to make a List:
thislist = list(("apple", "banana", "cherry")) # note the double round-brackets
Python has a set of built-in methods that you can use on lists.
Add the elements of a list (or any iterable), to the end of the current list | |
Returns the index of the first element with the specified value | |
A tuple is a collection which is ordered and unchangeable. In Python tuples are written with round brackets.
thistuple = ("apple", "banana", "cherry")
You can access tuple items by referring to the index number, inside square brackets:
Print the second item in the tuple:
thistuple = ("apple", "banana", "cherry")
Negative indexing means beginning from the end, -1 refers to the last item, -2 refers to the second last item etc.
Print the last item of the tuple:
thistuple = ("apple", "banana", "cherry")
You can specify a range of indexes by specifying where to start and where to end the range.
When specifying a range, the return value will be a new tuple with the specified items.
Return the third, fourth, and fifth item:
thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
Note: The search will start at index 2 (included) and end at index 5 (not included).
Remember that the first item has index 0.
Specify negative indexes if you want to start the search from the end of the tuple:
This example returns the items from index -4 (included) to index -1 (excluded)
thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
Once a tuple is created, you cannot change its values. Tuples are unchangeable, or immutable as it also is called.
But there is a workaround. You can convert the tuple into a list, change the list, and convert the list back into a tuple.
Convert the tuple into a list to be able to change it:
x = ("apple", "banana", "cherry")
You can loop through the tuple items by using a for loop.
Iterate through the items and print the values:
thistuple = ("apple", "banana", "cherry")
You will learn more about for loops in our Python For Loops Chapter.
To determine if a specified item is present in a tuple use the in keyword:
Check if "apple" is present in the tuple:
thistuple = ("apple", "banana", "cherry")
print("Yes, 'apple' is in the fruits tuple")
To determine how many items a tuple has, use the len() method:
Print the number of items in the tuple:
thistuple = ("apple", "banana", "cherry") print(len(thistuple))
Once a tuple is created, you cannot add items to it. Tuples are unchangeable.
You cannot add items to a tuple:
thistuple = ("apple", "banana", "cherry")
thistuple[3] = "orange" # This will raise an error print(thistuple)
To create a tuple with only one item, you have add a comma after the item, unless Python will not recognize the variable as a tuple.
One item tuple, remember the commma:
#NOT a tuple thistuple = ("apple") print(type(thistuple))
Note: You cannot remove items in a tuple.
Tuples are unchangeable, so you cannot remove items from it, but you can delete the tuple completely:
The del keyword can delete the tuple completely:
thistuple = ("apple", "banana", "cherry")
print(thistuple) #this will raise an error because the tuple no longer exists
To join two or more tuples you can use the + operator:
tuple3 = tuple1 + tuple2 print(tuple3)
It is also possible to use the tuple() constructor to make a tuple.
Using the tuple() method to make a tuple:
thistuple = tuple(("apple", "banana", "cherry")) # note the double round-
Python has two built-in methods that you can use on tuples.
Returns the number of times a specified value occurs in a tuple | |
Searches the tuple for a specified value and returns the position of where it was found |
Print the first item in the fruits tuple.
fruits = ("apple", "banana", "cherry")
Submit Answer » Start the Exercise
A set is a collection which is unordered and unindexed. In Python sets are written with curly brackets.
thisset = {"apple", "banana", "cherry"}
Note: Sets are unordered, so you cannot be sure in which order the items will appear.
You cannot access items in a set by referring to an index, since sets are unordered the items has no index.
But you can loop through the set items using a for loop, or ask if a specified value is present in a set, by using the in keyword.
Loop through the set, and print the values:
thisset = {"apple", "banana", "cherry"}
Check if "banana" is present in the set:
thisset = {"apple", "banana", "cherry"}
Once a set is created, you cannot change its items, but you can add new items.
To add one item to a set use the add() method.
To add more than one item to a set use the update() method.
Add an item to a set, using the add() method:
thisset = {"apple", "banana", "cherry"}
Add multiple items to a set, using the update() method:
thisset.add("orange") print(thisset)
thisset = {"apple", "banana", "cherry"} thisset.update(["orange", "mango", "grapes"]) print(thisset)
To determine how many items a set has, use the len() method.
Get the number of items in a set:
thisset = {"apple", "banana", "cherry"}
To remove an item in a set, use the remove(), or the discard() method.
Remove "banana" by using the remove() method:
thisset = {"apple", "banana", "cherry"}
Remove "banana" by using the discard() method:
Note: If the item to remove does not exist, remove() will raise an error.
thisset.remove("banana") print(thisset)
Note: If the item to remove does not exist, discard() will NOT raise an error.
thisset = {"apple", "banana", "cherry"} thisset.discard("banana") print(thisset)
You can also use the pop(), method to remove an item, but this method will remove the last item. Remember that sets are unordered, so you will not know what item that gets removed.
The return value of the pop() method is the removed item.
Remove the last item by using the pop() method:
thisset = {"apple", "banana", "cherry"}
The clear() method empties the set:
Note: Sets are unordered, so when using the pop() method, you will not know which item that gets removed.
x = thisset.pop() print(x) print(thisset)
thisset = {"apple", "banana", "cherry"} thisset.clear()
The del keyword will delete the set completely:
thisset = {"apple", "banana", "cherry"}
There are several ways to join two or more sets in Python.
You can use the union() method that returns a new set containing all items from both sets, or the update() method that inserts all the items from one set into another:
The union() method returns a new set with all items from both sets:
set3 = set1.union(set2) print(set3)
The update() method inserts the items in set2 into set1:
Note: Both union() and update() will exclude any duplicate items.
There are other methods that joins two sets and keeps ONLY the duplicates, or NEVER the duplicates, check the full list of set methods in the bottom of this page.
It is also possible to use the set() constructor to make a set.
Using the set() constructor to make a set:
thisset = set(("apple", "banana", "cherry")) # note the double round-brackets
Python has a set of built-in methods that you can use on sets.
Returns a set containing the difference between two or more sets | |
Removes the items in this set that are also included in another, specified set |
Removes the items in this set that are not present in other, specified set(s) | |
Latest Jobs and Internships are regularly uplaoded here : https://telegram.me/PLACEMENTLELO
Check if "apple" is present in the fruits set.
fruits = {"apple", "banana", "cherry"}
if ("apple" fruits): print("Yes, apple is a fruit!")
Submit Answer » Start the Exercise
A dictionary is a collection which is unordered, changeable and indexed. In Python dictionaries are written with curly brackets, and they have keys and values.
Create and print a dictionary:
"model": "Mustang", "year": 1964
You can access the items of a dictionary by referring to its key name, inside square brackets:
Get the value of the "model" key:
There is also a method called get() that will give you the same result:
Get the value of the "model" key:
You can change the value of a specific item by referring to its key name:
"model": "Mustang", "year": 1964
You can loop through a dictionary by using a for loop.
When looping through a dictionary, the return value are the keys of the dictionary, but there are methods to return the values as well.
Print all key names in the dictionary, one by one:
Print all values in the dictionary, one by one:
You can also use the values() function to return values of a dictionary:
Loop through both keys and values, by using the items() function:
To determine if a specified key is present in a dictionary use the in keyword:
Check if "model" is present in the dictionary:
"model": "Mustang", "year": 1964
print("Yes, 'model' is one of the keys in the thisdict dictionary")
To determine how many items (key-value pairs) a dictionary has, use the len() method.
Print the number of items in the dictionary:
Adding an item to the dictionary is done by using a new index key and assigning a value to it:
"model": "Mustang", "year": 1964
thisdict["color"] = "red" print(thisdict)
There are several methods to remove items from a dictionary:
The pop() method removes the item with the specified key name:
"model": "Mustang", "year": 1964
thisdict.pop("model") print(thisdict)
The popitem() method removes the last inserted item (in versions before 3.7, a random item is removed instead):
"model": "Mustang", "year": 1964
thisdict.popitem() print(thisdict)
The del keyword removes the item with the specified key name:
"model": "Mustang", "year": 1964
del thisdict["model"] print(thisdict)
The del keyword can also delete the dictionary completely:
"model": "Mustang", "year": 1964
print(thisdict) #this will cause an error because "thisdict" no longer exists.
The clear() keyword empties the dictionary:
"model": "Mustang", "year": 1964
thisdict.clear() print(thisdict)
You cannot copy a dictionary simply by typing dict2 = dict1, because: dict2 will only be a reference to dict1, and changes made in dict1 will automatically also be made in dict2.
There are ways to make a copy, one way is to use the built-in Dictionary method copy().
Make a copy of a dictionary with the copy() method:
"model": "Mustang", "year": 1964
mydict = thisdict.copy() print(mydict)
Another way to make a copy is to use the built-in method dict().
Make a copy of a dictionary with the dict() method:
"model": "Mustang", "year": 1964
mydict = dict(thisdict) print(mydict)
A dictionary can also contain many dictionaries, this is called nested dictionaries.
Create a dictionary that contain three dictionaries:
"child1" : { "name" : "Emil", "year" : 2004
"name" : "Tobias", "year" : 2007
"child3" : { "name" : "Linus", "year" : 2011
Or, if you want to nest three dictionaries that already exists as dictionaries:
Create three dictionaries, than create one dictionary that will contain the other three dictionaries:
"name" : "Emil", "year" : 2004
"name" : "Tobias", "year" : 2007
"name" : "Linus", "year" : 2011
myfamily = { "child1" : child1, "child2" : child2, "child3" : child3
It is also possible to use the dict() constructor to make a new dictionary:
thisdict = dict(brand="Ford", model="Mustang", year=1964) # note that keywords are not string literals
# note the use of equals rather than colon for the assignment print(thisdict)
Python has a set of built-in methods that you can use on dictionaries.
Python Conditions and If statements
Python supports the usual logical conditions from mathematics:
These conditions can be used in several ways, most commonly in "if statements" and loops.
An "if statement" is written by using the if keyword.
In this example we use two variables, a and b, which are used as part of the if statement to test whether b is greater than a. As a is 33, and b is 200, we know that 200 is greater than 33, and so we print to screen that "b is greater than a".
Python relies on indentation (whitespace at the beginning of a line) to define scope in the code. Other programming languages often use curly-brackets for this purpose.
If statement, without indentation (will raise an error):
print("b is greater than a") # you will get an error
The elif keyword is pythons way of saying "if the previous conditions were not true, then try this condition".
print("b is greater than a") elif a == b:
In this example a is equal to b, so the first condition is not true, but the elif condition is true, so we print to screen that "a and b are equal".
The else keyword catches anything which isn't caught by the preceding conditions.
print("b is greater than a") elif a == b:
print("a and b are equal") else:
In this example a is greater than b, so the first condition is not true, also
the elif condition is not true, so we go to the else condition and print to screen that "a is greater than b".
You can also have an else without the elif:
print("b is greater than a") else:
print("b is not greater than a")
If you have only one statement to execute, you can put it on the same line as the if statement.
if a > b: print("a is greater than b")
If you have only one statement to execute, one for if, and one for else, you can put it all on the same line:
print("A") if a > b else print("B")
You can also have multiple else statements on the same line:
One line if else statement, with 3 conditions:
print("A") if a > b else print("=") if a == b else print("B")
The and keyword is a logical operator, and is used to combine conditional statements:
Test if a is greater than b, AND if c is greater than a:
print("Both conditions are True")
The or keyword is a logical operator, and is used to combine conditional statements:
Test if a is greater than b, OR if a is greater than c:
print("At least one of the conditions is True")
You can have if statements inside if statements, this is called nested if statements.
if x > 10: print("Above ten,") if x > 20:
print("and also above 20!") else:
if statements cannot be empty, but if you for some reason have an if statement with no content, put in the pass statement to avoid getting an error.
Python has two primitive loop commands:
With the while loop we can execute a set of statements as long as a condition is true.
Print i as long as i is less than 6:
Note: remember to increment i, or else the loop will continue forever.
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:
while i < 6: print(i) if i == 3:
With the continue statement we can stop the current iteration, and continue with the next:
Continue to the next iteration if i is 3:
With the else statement we can run a block of code once when the condition no longer is true:
Print a message once the condition is false:
print("i is no longer less than 6")
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.
Print each fruit in a fruit list:
fruits = ["apple", "banana", "cherry"]
The for loop does not require an indexing variable to set beforehand.
Even strings are iterable objects, they contain a sequence of characters:
Loop through the letters in the word "banana":
With the break statement we can stop the loop before it has looped through all the items:
Exit the loop when x is "banana":
fruits = ["apple", "banana", "cherry"]
Exit the loop when x is "banana", but this time the break comes before the print:
fruits = ["apple", "banana", "cherry"]
for x in fruits: if x == "banana":
With the continue statement we can stop the current iteration of the loop, and continue with the next:
fruits = ["apple", "banana", "cherry"]
for x in fruits: if x == "banana":
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.
Note that range(6) is not the values of 0 to 6, but the values 0 to 5.
The range() function defaults to 0 as a starting value, however it is possible to specify the starting value by adding a parameter: range(2, 6), which means values from 2 to 6 (but not including 6):
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):
Increment the sequence with 3 (default is 1):
The else keyword in a for loop specifies a block of code to be executed when the loop is finished:
Print all numbers from 0 to 5, and print a message when the loop has ended:
A nested loop is a loop inside a loop.
The "inner loop" will be executed one time for each iteration of the "outer loop":
Print each adjective for every fruit:
fruits = ["apple", "banana", "cherry"]
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.
Loop through the items in the fruits list.
fruits = ["apple", "banana", "cherry"]
Submit Answer » Start the Exercise
A function can return data as a result.
In Python a function is defined using the def keyword:
print("Hello from a function")
To call a function, use the function name followed by parenthesis:
print("Hello from a function")
Information can be passed to functions as parameter.
Parameters are specified after the function name, inside the parentheses. You can add as many parameters as you want, just separate them with a comma.
The following example has a function with one parameter (fname). When the function is called, we pass along a first name, which is used inside the function to print the full name:
my_function("Emil") my_function("Tobias") my_function("Linus")
The following example shows how to use a default parameter value. If we call the function without parameter, it uses the default value:
def my_function(country = "Norway"):
my_function("Sweden") my_function("India") my_function() my_function("Brazil")
You can send any data types of parameter to a function (string, number, list, dictionary etc.), and it will be treated as the same data type inside the function.
E.g. if you send a List as a parameter, it will still be a List when it reaches the function:
fruits = ["apple", "banana", "cherry"] my_function(fruits)
To let a function return a value, use the return statement:
print(my_function(3)) print(my_function(5)) print(my_function(9))
You can also send arguments with the key = value syntax. This way the order of the arguments does not matter.
def my_function(child3, child2, child1): print("The youngest child is " + child3)
my_function(child1 = "Emil", child2 = "Tobias", child3 = "Linus")
The phrase Keyword Arguments are often shortened to kwargs in Python documentations.
If you do not know how many arguments that will be passed into your function, add a * before the parameter name in the function definition.
This way the function will receive a tuple of arguments, and can access the items accordingly:
If the number of arguments are unknown, add a * before the parameter name:
print("The youngest child is " + kids[2]) my_function("Emil", "Tobias", "Linus")
definitions cannot be empty, but if you for some reason have
definition with no content, put in the pass statement to avoid getting an
Python also accepts function recursion, which means a defined function can call itself.
Recursion is a common mathematical and programming concept. It means that a function calls itself. This has the benefit of meaning that you can loop through data to reach a result.
The developer should be very careful with recursion as it can be quite easy to slip into writing a function which never terminates, or one that uses excess amounts of memory or processor power. However, when written correctly recursion can be a very efficient and mathematically-elegant approach to programming.
In this example, tri_recursion() is a function that we have defined to call itself ("recurse"). We use the k variable as the data, which decrements (-1) every time we recurse. The recursion ends when the condition is not greater than 0 (i.e. when it is 0).
To a new developer it can take some time to work out how exactly this works, best way to find out is by testing and modifying it.
result = k+tri_recursion(k-1) print(result)
print("\n\nRecursion Example Results") tri_recursion(6)
A lambda function is a small anonymous function.
A lambda function can take any number of arguments, but can only have one expression.
The expression is executed and the result is returned:
A lambda function that adds 10 to the number passed in as an argument, and print the result:
Lambda functions can take any number of arguments:
A lambda function that multiplies argument a with argument b and print the result:
A lambda function that sums argument a, b, and c and print the result:
x = lambda a, b, c : a + b + c
The power of lambda is better shown when you use them as an anonymous function inside another function.
Say you have a function definition that takes one argument, and that argument will be multiplied with an unknown number:
Use that function definition to make a function that always doubles the number you send in:
return lambda a : a * n mydoubler = myfunc(2) print(mydoubler(11))
Or, use the same function definition to make a function that always triples the number you send in:
return lambda a : a * n mytripler = myfunc(3) print(mytripler(11))
Or, use the same function definition to make both functions, in the same program:
mydoubler = myfunc(2) mytripler = myfunc(3)
print(mydoubler(11)) print(mytripler(11))
Use lambda functions when an anonymous function is required for a short period of time.
Create a lambda function that takes one parameter (a) and returns it.
Note: Python does not have built-in support for Arrays, but Python Lists can be used instead.
Arrays are used to store multiple values in one single variable:
Create an array containing car names:
cars = ["Ford", "Volvo", "BMW"]
An array is a special variable, which can hold more than one value at a time.
If you have a list of items (a list of car names, for example), storing the cars in single variables could look like this:
car1 = "Ford" car2 = "Volvo" car3 = "BMW"
However, what if you want to loop through the cars and find a specific one? And what if you had not 3 cars, but 300?
An array can hold many values under a single name, and you can access the values by referring to an index number.
Access the Elements of an Array
You refer to an array element by referring to the index number.
Get the value of the first array item:
Modify the value of the first array item:
Use the len() method to return the length of an array (the number of elements in an array).
Return the number of elements in the cars array:
Note: The length of an array is always one more than the highest array index.
You can use the for in loop to loop through all the elements of an array.
Print each item in the cars array:
You can use the append() method to add an element to an array.
Add one more element to the cars array:
You can use the pop() method to remove an element from the array.
Delete the second element of the cars array:
You can also use the remove() method to remove an element from the array.
Delete the element that has the value "Volvo":
Note: The list's remove() method only removes the first occurrence of the specified value.
Python has a set of built-in methods that you can use on lists/arrays.
Add the elements of a list (or any iterable), to the end of the current list | |
Returns the index of the first element with the specified value | |
Note: Python does not have built-in support for Arrays, but Python Lists can be used instead.
Python is an object oriented programming language.
Almost everything in Python is an object, with its properties and methods. A Class is like an object constructor, or a "blueprint" for creating objects.
To create a class, use the keyword class:
Create a class named MyClass, with a property named x:
Now we can use the class named myClass to create objects:
Create an object named p1, and print the value of x:
The examples above are classes and objects in their simplest form, and are not really useful in real life applications.
To understand the meaning of classes we have to understand the built-in init () function.
All classes have a function called init (), which is always executed when the class is being initiated.
Use the init () function to assign values to object properties, or other operations that are necessary to do when the object is being created:
Create a class named Person, use the init () function to assign values for name and age:
self.name = name self.age = age
function is called automatically every time the class is being used
Objects can also contain methods. Methods in objects are functions that belong to the object.
Let us create a method in the Person class:
Insert a function that prints a greeting, and execute it on the p1 object:
self.name = name self.age = age
print("Hello my name is " + self.name)
p1 = Person("John", 36) p1.myfunc()
parameter is a reference to the current instance of the class, and is
used to access variables that belong to the class.
The self parameter is a reference to the current instance of the class, and is used to access variables that belongs to the class.
It does not have to be named self , you can call it whatever you like, but it has to be the first parameter of any function in the class:
Use the words mysillyobject and abc instead of self:
def init (mysillyobject, name, age):
mysillyobject.name = name mysillyobject.age = age
print("Hello my name is " + abc.name)
p1 = Person("John", 36) p1.myfunc()
You can modify properties on objects like this:
You can delete properties on objects by using the del keyword:
Delete the age property from the p1 object:
You can delete objects by using the del keyword:
class definitions cannot be empty, but if you for some reason have a class definition with no content, put in the pass statement to avoid getting an error.
Inheritance allows us to define a class that inherits all the methods and properties from another class.
Parent class is the class being inherited from, also called base class.
Child class is the class that inherits from another class, also called derived class.
Any class can be a parent class, so the syntax is the same as creating any other class:
Create a class named Person, with firstname and lastname properties, and a printname method:
def init (self, fname, lname):
self.firstname = fname self.lastname = lname
def printname(self): print(self.firstname, self.lastname)
#Use the Person class to create an object, and then execute the printname method:
x = Person("John", "Doe") x.printname()
To create a class that inherits the functionality from another class, send the parent class as a parameter when creating the child class:
Create a class named Student, which will inherit the properties and methods from the Person class:
keyword when you do not want to add any other properties or
Now the Student class has the same properties and methods as the Person class.
Use the Student class to create an object, and then execute the printname method:
So far we have created a child class that inherits the properties and methods from its parent.
We want to add the function to the child class (instead of the pass keyword).
Add the init () function to the Student class:
Note: The init () function is called automatically every time the class is being used to create a new object.
def init (self, fname, lname):
When you add the init () function, the child class will no longer inherit the parent's init () function.
Note: The child's init () function overrides the inheritance of the parent's init () function.
To keep the inheritance of the parent's init () function, add a call to the parent's init () function:
def init (self, fname, lname):
Person. init (self, fname, lname)
Now we have successfully added the init () function, and kept the inheritance of
the parent class, and we are ready to add functionality in the function.
Python also has a super() function that will make the child class inherit all the methods and properties from its parent:
def init (self, fname, lname):
By using the super() function, you do not have to use the name of the parent element, it will automatically inherit the methods and properties from its parent.
Add a property called graduationyear to the Student class:
def init (self, fname, lname):
super(). init (fname, lname) self.graduationyear = 2019
In the example below, the year 2019 should be a variable, and passed into
the Student class when creating student objects. To do so, add another parameter in the init () function:
Add a year parameter, and pass the correct year when creating objects:
def init (self, fname, lname, year):
super(). init (fname, lname) self.graduationyear = year
x = Student("Mike", "Olsen", 2019)
Add a method called welcome to the Student class:
def init (self, fname, lname, year):
super(). init (fname, lname) self.graduationyear = year
print("Welcome", self.firstname, self.lastname, "to the class of", self.graduationyear)
If you add a method in the child class with the same name as a function in the parent class, the inheritance of the parent method will be overridden.
An iterator is an object that contains a countable number of values.
An iterator is an object that can be iterated upon, meaning that you can traverse through all the values.
Technically, in Python, an iterator is an object which implements the iterator protocol,
which consist of the methods and next ().
Lists, tuples, dictionaries, and sets are all iterable objects. They are iterable containers which you can get an iterator from.
All these objects have a iter() method which is used to get an iterator:
Return an iterator from a tuple, and print each value:
mytuple = ("apple", "banana", "cherry")
print(next(myit)) print(next(myit)) print(next(myit))
Even strings are iterable objects, and can return an iterator:
Strings are also iterable objects, containing a sequence of characters:
print(next(myit)) print(next(myit)) print(next(myit)) print(next(myit)) print(next(myit)) print(next(myit))
We can also use a for loop to iterate through an iterable object:
Iterate the values of a tuple:
mytuple = ("apple", "banana", "cherry")
Iterate the characters of a string:
The for loop actually creates an iterator object and executes the next() method for each loop.
To create an object/class as an iterator you have to implement the methods iter () and next () to your object.
As you have learned in the Python Classes/Objects chapter, all classes have a function called init (), which allows you do some initializing when the object is being created.
The iter () method acts similar, you can do operations (initializing etc.), but must always return the iterator object itself.
The next () method also allows you to do operations, and must return the next item in the sequence.
Create an iterator that returns numbers, starting with 1, and each sequence will increase by one (returning 1,2,3,4,5 etc.):
myclass = MyNumbers() myiter = iter(myclass)
print(next(myiter)) print(next(myiter)) print(next(myiter)) print(next(myiter)) print(next(myiter))
The example above would continue forever if you had enough next() statements, or if it was used in a for loop.
To prevent the iteration to go on forever, we can use the StopIteration statement.
In the next () method, we can add a terminating condition to raise an error if the iteration is done a specified number of times:
if self.a <= 20: x = self.a self.a += 1 return x
myclass = MyNumbers() myiter = iter(myclass)
A variable is only available from inside the region it is created. This is called scope.
A variable created inside a function belongs to the local scope of that function, and can only be used inside that function.
A variable created inside a function is available inside that function:
As explained in the example above, the variable x is not available outside the function, but it is available for any function inside the function:
The local variable can be accessed from a function within the function:
A variable created in the main body of the Python code is a global variable and belongs to the global scope.
Global variables are available from within any scope, global and local.
A variable created outside of a function is global and can be used by anyone:
If you operate with the same variable name inside and outside of a function, Python will treat them as two separate variables, one available in the global scope (outside the function) and one available in the local scope (inside the function):
The function will print the local x, and then the code will print the global x:
If you need to create a global variable, but are stuck in the local scope, you can use the global keyword.
The global keyword makes the variable global.
If you use the global keyword, the variable belongs to the global scope:
Also, use the global keyword if you want to make a change to a global variable inside a function.
To change the value of a global variable inside a function, refer to the variable by using the global keyword:
Consider a module to be the same as a code library.
A file containing a set of functions you want to include in your application.
To create a module just save the code you want in a file with the file extension .py:
Save this code in a file named mymodule.py
Now we can use the module we just created, by using the import statement:
Import the module named mymodule, and call the greeting function:
Note: When using a function from a module, use the syntax: module_name.function_name.
The module can contain functions, as already described, but also variables of all types (arrays, dictionaries, objects etc):
Save this code in the file mymodule.py
"name": "John", "age": 36, "country": "Norway"
Import the module named mymodule, and access the person1 dictionary:
a = mymodule.person1["age"] print(a)
You can name the module file whatever you like, but it must have the file extension .py
You can create an alias when you import a module, by using the as keyword:
Create an alias for mymodule called mx:
a = mx.person1["age"] print(a)
There are several built-in modules in Python, which you can import whenever you like.
Import and use the platform module:
x = platform.system() print(x)
There is a built-in function to list all the function names (or variable names) in a module. The dir() function:
List all the defined names belonging to the platform module:
Note: The dir() function can be used on all modules, also the ones you create yourself.
You can choose to import only parts from a module, by using the from keyword.
The module named mymodule has one function and one dictionary:
person1 = { "name": "John", "age": 36,
Import only the person1 dictionary from the module:
A date in Python is not a data type of its own, but we can import a module named datetime to work with dates as date objects.
Import the datetime module and display the current date:
x = datetime.datetime.now() print(x)
When we execute the code from the example above the result will be:
The date contains year, month, day, hour, minute, second, and microsecond.
The datetime module has many methods to return information about the date object. Here are a few examples, you will learn more about them later in this chapter:
Return the year and name of weekday:
print(x.year) print(x.strftime("%A"))
To create a date, we can use the datetime() class (constructor) of the datetime module.
The datetime() class requires three parameters to create a date: year, month, day.
x = datetime.datetime(2020, 5, 17) print(x)
The datetime() class also takes parameters for time and timezone (hour, minute, second, microsecond, tzone), but they are optional, and has a default value of 0, (None for timezone).
The datetime object has a method for formatting date objects into readable strings.
The method is called strftime(), and takes one parameter, format, to specify the format of the returned string:
Display the name of the month:
x = datetime.datetime(2018, 6, 1)
A reference of all the legal format codes:
Python has a built-in package called json, which can be used to work with JSON data.
Parse JSON - Convert from JSON to Python
If you have a JSON string, you can parse it by using the json.loads() method.
The result will be a Python dictionary.
x = '{ "name":"John", "age":30, "city":"New York"}'
# the result is a Python dictionary:
If you have a Python object, you can convert it into a JSON string by using the json.dumps() method.
# a Python object (dict): x = {
# the result is a JSON string: print(y)
You can convert Python objects of the following types, into JSON strings:
Convert Python objects into JSON strings, and print the values:
print(json.dumps({"name": "John", "age": 30}))
print(json.dumps(["apple", "bananas"]))
print(json.dumps(("apple", "bananas"))) print(json.dumps("hello")) print(json.dumps(42)) print(json.dumps(31.76)) print(json.dumps(True)) print(json.dumps(False)) print(json.dumps(None))
When you convert from Python to JSON, Python objects are converted into the JSON (JavaScript) equivalent:
Convert a Python object containing all the legal data types:
"name": "John", "age": 30, "married": True, "divorced": False,
"children": ("Ann","Billy"), "pets": None,
{"model": "BMW 230", "mpg": 27.5},
{"model": "Ford Edge", "mpg": 24.1}
The example above prints a JSON string, but it is not very easy to read, with no indentations and line breaks.
The json.dumps() method has parameters to make it easier to read the result:
Use the indent parameter to define the numbers of indents:
You can also define the separators, default value is (", ", ": "), which means using a comma and a space to separate each object, and a colon and a space to separate keys from values:
Use the separators parameter to change the default separator:
json.dumps(x, indent=4, separators=(". ", " = "))
The json.dumps() method has parameters to order the keys in the result:
Use the sort_keys parameter to specify if the result should be sorted or not:
json.dumps(x, indent=4, sort_keys=True)
A RegEx, or Regular Expression, is a sequence of characters that forms a search pattern.
RegEx can be used to check if a string contains the specified search pattern.
Python has a built-in package called re, which can be used to work with Regular Expressions.
When you have imported the re module, you can start using regular expressions:
Search the string to see if it starts with "The" and ends with "Spain":
x = re.search("^The.*Spain$", txt)
The re module offers a set of functions that allows us to search a string for a match:
Returns a Match object if there is a match anywhere in the string | |
Returns a list where the string has been split at each match | |
Metacharacters are characters with a special meaning:
Signals a special sequence (can also be used to escape special characters) | |||
A special sequence is a \ followed by one of the characters in the list below, and has a special meaning:
A set is a set of characters inside a pair of square brackets [] with a special meaning:
The findall() function returns a list containing all matches.
str = "The rain in Spain" x = re.findall("ai", str) print(x)
The list contains the matches in the order they are found. If no matches are found, an empty list is returned:
Return an empty list if no match was found:
x = re.findall("Portugal", str) print(x)
The search() function searches the string for a match, and returns a Match object if there is a match.
If there is more than one match, only the first occurrence of the match will be returned:
Search for the first white-space character in the string:
print("The first white-space character is located in position:", x.start())
If no matches are found, the value None is returned:
Make a search that returns no match:
x = re.search("Portugal", str) print(x)
The split() function returns a list where the string has been split at each match:
Split at each white-space character:
str = "The rain in Spain" x = re.split("\s", str) print(x)
You can control the number of occurrences by specifying the maxsplit parameter:
Split the string only at the first occurrence:
str = "The rain in Spain" x = re.split("\s", str, 1) print(x)
The sub() function replaces the matches with the text of your choice:
Replace every white-space character with the number 9:
str = "The rain in Spain" x = re.sub("\s", "9", str) print(x)
You can control the number of replacements by specifying the count parameter:
Replace the first 2 occurrences:
x = re.sub("\s", "9", str, 2) print(x)
A Match Object is an object containing information about the search and the result.
Do a search that will return a Match Object:
Note: If there is no match, the value None will be returned, instead of the Match Object.
print(x) #this will print an object
The Match object has properties and methods used to retrieve information about the search, and the result:
returns a tuple containing the start-, and end positions of the match. returns the string passed into the function
returns the part of the string where there was a match
Print the position (start- and end-position) of the first match occurrence.
The regular expression looks for any words that starts with an upper case "S":
x = re.search(r"\bS\w+", str) print(x.span())
Print the string passed into the function:
x = re.search(r"\bS\w+", str) print(x.string)
Print the part of the string where there was a match.
The regular expression looks for any words that starts with an upper case "S":
x = re.search(r"\bS\w+", str) print(x.group())
Note: If there is no match, the value Object.
will be returned, instead of the Match
PIP is a package manager for Python packages, or modules if you like.
Note: If you have Python version 3.4 or later, PIP is included by default.
A package contains all the files you need for a module.
Modules are Python code libraries you can include in your project.
Navigate your command line to the location of Python's script directory, and type the following:
C:\Users\Your Name\AppData\Local\Programs\Python\Python36-32\Scripts>pip --version
If you do not have PIP installed, you can download and install it from this page: https://pypi.org/project/pip/
Downloading a package is very easy.
Open the command line interface and tell PIP to download the package you want.
Navigate your command line to the location of Python's script directory, and type the following:
Download a package named "camelcase":
C:\Users\Your Name\AppData\Local\Programs\Python\Python36-32\Scripts>pip install camelcase
Now you have downloaded and installed your first package!
Once the package is installed, it is ready to use. Import the "camelcase" package into your project.
c = camelcase.CamelCase() txt = "hello world" print(c.hump(txt))
Find more packages at https://pypi.org/.
Use the uninstall command to remove a package:
Uninstall the package named "camelcase":
C:\Users\Your Name\AppData\Local\Programs\Python\Python36-32\Scripts>pip uninstall camelcase
The PIP Package Manager will ask you to confirm that you want to remove the camelcase package:
Uninstalling camelcase-02.1: Would remove:
c:\users\Your Name\appdata\local\programs\python\python36-32\lib\site-packages\camecase-0.2-py3.6.egg-info
c:\users\Your Name\appdata\local\programs\python\python36-32\lib\site-packages\camecase\*
Press y and the package will be removed.
Use the list command to list all the packages installed on your system:
C:\Users\Your Name\AppData\Local\Programs\Python\Python36-32\Scripts>pip list
The try block lets you test a block of code for errors. The except block lets you handle the error.
The finally block lets you execute code, regardless of the result of the try- and except blocks.
When an error occurs, or exception as we call it, Python will normally stop and generate an error message.
These exceptions can be handled using the try statement:
The try block will generate an exception, because x is not defined:
print("An exception occurred")
Since the try block raises an error, the except block will be executed. Without the try block, the program will crash and raise an error:
This statement will raise an error, because x is not defined:
You can define as many exception blocks as you want, e.g. if you want to execute a special block of code for a special kind of error:
Print one message if the try block raises a NameError and another for other errors:
print("Variable x is not defined") except:
print("Something else went wrong")
You can use the else keyword to define a block of code to be executed if no errors were raised:
In this example, the try block does not generate any error:
print("Something went wrong") else:
The finally block, if specified, will be executed regardless if the try block raises an error or not.
print("Something went wrong") finally:
print("The 'try except' is finished")
This can be useful to close objects and clean up resources:
Try to open and write to a file that is not writable:
f = open("demofile.txt") f.write("Lorum Ipsum")
print("Something went wrong when writing to the file") finally:
The program can continue, without leaving the file object open.
As a Python developer you can choose to throw an exception if a condition occurs.
To throw (or raise) an exception, use the raise keyword.
Raise an error and stop the program if x is lower than 0:
raise Exception("Sorry, no numbers below zero")
The raise keyword is used to raise an exception.
You can define what kind of error to raise, and the text to print to the user.
Raise a TypeError if x is not an integer:
raise TypeError("Only integers are allowed")
That means we are able to ask the user for input.
The method is a bit different in Python 3.6 than Python 2.7.
Python 3.6 uses the input() method.
Python 2.7 uses the raw_input() method.
The following example asks for the username, and when you entered the username, it gets printed on the screen:
username = input("Enter username:") print("Username is: " + username)
username = raw_input("Enter username:") print("Username is: " + username)
Python stops executing when it comes to the input() function, and continues when the user has given some input.
To make sure a string will display as expected, we can format the result with the format() method.
The format() method allows you to format selected parts of a string.
Sometimes there are parts of a text that you do not control, maybe they come from a database, or user input?
To control such values, add placeholders (curly brackets {}) in the text, and run the values through the format() method:
Add a placeholder where you want to display the price:
txt = "The price is {} dollars" print(txt.format(price))
You can add parameters inside the curly brackets to specify how to convert the value:
Format the price to be displayed as a number with two decimals:
txt = "The price is {:.2f} dollars"
Check out all formatting types in our String format() Reference.
If you want to use more values, just add more values to the format() method:
print(txt.format(price, itemno, count))
myorder = "I want {} pieces of item number {} for {:.2f} dollars." print(myorder.format(quantity, itemno, price))
You can use index numbers (a number inside the curly brackets {0}) to be sure the values are placed in the correct placeholders:
myorder = "I want {0} pieces of item number {1} for {2:.2f} dollars." print(myorder.format(quantity, itemno, price))
Also, if you want to refer to the same value more than once, use the index number:
txt = "His name is {1}. {1} is {0} years old." print(txt.format(age, name))
You can also use named indexes by entering a name inside the curly
brackets {carname}, but then you must use names when you pass the parameter values txt.format(carname = "Ford"):
myorder = "I have a {carname}, it is a {model}." print(myorder.format(carname = "Ford", model = "Mustang"))
File handling is an important part of any web application.
Python has several functions for creating, reading, updating, and deleting files.
The key function for working with files in Python is the open() function.
The open() function takes two parameters; filename, and mode. There are four different methods (modes) for opening a file:
"r" - Read - Default value. Opens a file for reading, error if the file does not exist
"a" - Append - Opens a file for appending, creates the file if it does not exist
"w" - Write - Opens a file for writing, creates the file if it does not exist
"x" - Create - Creates the specified file, returns an error if the file exists
In addition you can specify if the file should be handled as binary or text mode
"t" - Text - Default value. Text mode
"b" - Binary - Binary mode (e.g. images)
To open a file for reading it is enough to specify the name of the file:
The code above is the same as:
f = open("demofile.txt", "rt")
Because "r" for read, and "t" for text are the default values, you do not need to specify them.
Note: Make sure the file exists, or else you will get an error.
Assume we have the following file, located in the same folder as Python:
Hello! Welcome to demofile.txt
This file is for testing purposes. Good Luck!
To open the file, use the built-in open() function.
The open() function returns a file object, which has a read() method for reading the content of the file:
f = open("demofile.txt", "r") print(f.read())
By default the read() method returns the whole text, but you can also specify how many characters you want to return:
Return the 5 first characters of the file:
You can return one line by using the readline() method:
By calling readline() two times, you can read the two first lines:
print(f.readline()) print(f.readline())
By looping through the lines of the file, you can read the whole file, line by line:
Loop through the file line by line:
It is a good practice to always close the file when you are done with it.
Close the file when you are finish with it:
Note: You should always close your files, in some cases, due to buffering, changes made to a file may not show until you close the file.
To write to an existing file, you must add a parameter to the open() function:
"a" - Append - will append to the end of the file
"w" - Write - will overwrite any existing content
Open the file "demofile2.txt" and append content to the file:
f = open("demofile2.txt", "a")
f.write("Now the file has more content!") f.close()
#open and read the file after the appending: f = open("demofile2.txt", "r") print(f.read())
Open the file "demofile3.txt" and overwrite the content:
f = open("demofile3.txt", "w")
f.write("Woops! I have deleted the content!") f.close()
#open and read the file after the appending: f = open("demofile3.txt", "r") print(f.read())
Note: the "w" method will overwrite the entire file.
To create a new file in Python, use the open() method, with one of the following parameters:
"x" - Create - will create a file, returns an error if the file exist
"a" - Append - will create a file if the specified file does not exist
"w" - Write - will create a file if the specified file does not exist
Create a file called "myfile.txt":
Result: a new empty file is created!
Create a new file if it does not exist:
To delete a file, you must import the OS module, and run its os.remove() function:
Remove the file "demofile.txt":
To avoid getting an error, you might want to check if the file exists before you try to delete it:
Check if file exists, then delete it:
if os.path.exists("demofile.txt"): os.remove("demofile.txt")
print("The file does not exist")
To delete an entire folder, use the os.rmdir() method:
import os os.rmdir("myfolder")
Note: You can only remove empty folders.
Python can be used in database applications. One of the most popular databases is MySQL.
To be able to experiment with the code examples in this tutorial, you should have MySQL installed on your computer.
You can download a free MySQL database at https://www.mysql.com/downloads/.
Python needs a MySQL driver to access the MySQL database. In this tutorial we will use the driver "MySQL Connector".
We recommend that you use PIP to install "MySQL Connector". PIP is most likely already installed in your Python environment.
Navigate your command line to the location of PIP, and type the following:
Download and install "MySQL Connector":
C:\Users\Your Name\AppData\Local\Programs\Python\Python36-32\Scripts>python -m pip install mysql-connector
Now you have downloaded and installed a MySQL driver.
To test if the installation was successful, or if you already have "MySQL Connector" installed, create a Python page with the following content:
If the above code was executed with no errors, "MySQL Connector" is installed and ready to be used.
Start by creating a connection to the database.
Use the username and password from your MySQL database:
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword"
Now you can start querying the database using SQL statements.
To create a database in MySQL, use the "CREATE DATABASE" statement:
create a database named "mydatabase":
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword"
mycursor = mydb.cursor() mycursor.execute("CREATE DATABASE mydatabase")
If the above code was executed with no errors, you have successfully created a database.
You can check if a database exist by listing all databases in your system by using the "SHOW DATABASES" statement:
Return a list of your system's databases:
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword"
mycursor = mydb.cursor() mycursor.execute("SHOW DATABASES")
Or you can try to access the database when making the connection:
Try connecting to the database "mydatabase":
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
If the database does not exist, you will get an error.
To create a table in MySQL, use the "CREATE TABLE" statement.
Make sure you define the name of the database when you create the connection
Create a table named "customers":
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
mycursor.execute("CREATE TABLE customers (name VARCHAR(255), address VARCHAR(255))")
If the above code was executed with no errors, you have now successfully created a table.
You can check if a table exist by listing all tables in your database with the "SHOW TABLES" statement:
Return a list of your system's databases:
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
mycursor = mydb.cursor() mycursor.execute("SHOW TABLES") for x in mycursor:
When creating a table, you should also create a column with a unique key for each record.
This can be done by defining a PRIMARY KEY.
We use the statement "INT AUTO_INCREMENT PRIMARY KEY" which will insert a unique number for each record. Starting at 1, and increased by one for each record.
Create primary key when creating the table:
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
mycursor.execute("CREATE TABLE customers (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255), address VARCHAR(255))")
If the table already exists, use the ALTER TABLE keyword:
Create primary key on an existing table:
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
mycursor.execute("ALTER TABLE customers ADD COLUMN id INT AUTO_INCREMENT PRIMARY KEY")
To fill a table in MySQL, use the "INSERT INTO" statement.
Insert a record in the "customers" table:
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
sql = "INSERT INTO customers (name, address) VALUES (%s, %s)" val = ("John", "Highway 21")
print(mycursor.rowcount, "record inserted.")
Important!: Notice the statement: mydb.commit(). It is required to make the changes, otherwise no changes are made to the table.
To insert multiple rows into a table, use the executemany() method.
The second parameter of the executemany() method is a list of tuples, containing the data you want to insert:
Fill the "customers" table with data:
mydb = mysql.connector.connect(
host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
sql = "INSERT INTO customers (name, address) VALUES (%s, %s)" val = [
('Ben', 'Park Lane 38'), ('William', 'Central st 954'), ('Chuck', 'Main Road 989'),
mycursor.executemany(sql, val) mydb.commit()
print(mycursor.rowcount, "was inserted.")
You can get the id of the row you just inserted by asking the cursor object.
Insert one row, and return the ID:
Note: If you insert more that one row, the id of the last inserted row is returned.
mydb = mysql.connector.connect( host="localhost", user="yourusername",
passwd="yourpassword", database="mydatabase"
sql = "INSERT INTO customers (name, address) VALUES (%s, %s)" val = ("Michelle", "Blue Village")
mycursor.execute(sql, val) mydb.commit()
print("1 record inserted, ID:", mycursor.lastrowid)
To select from a table in MySQL, use the "SELECT" statement:
Select all records from the "customers" table, and display the result:
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
mycursor = mydb.cursor() mycursor.execute("SELECT * FROM customers") myresult = mycursor.fetchall()
method, which fetches all rows from the last executed
To select only some of the columns in a table, use the "SELECT" statement followed by the column name(s):
Select only the name and address columns:
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
mycursor.execute("SELECT name, address FROM customers") myresult = mycursor.fetchall()
If you are only interested in one row, you can use the fetchone() method.
The fetchone() method will return the first row of the result:
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
mycursor = mydb.cursor() mycursor.execute("SELECT * FROM customers") myresult = mycursor.fetchone() print(myresult)
When selecting records from a table, you can filter the selection by using the "WHERE" statement:
Select record(s) where the address is "Park Lane 38": result:
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
sql = "SELECT * FROM customers WHERE address ='Park Lane 38'"
myresult = mycursor.fetchall() for x in myresult:
You can also select the records that starts, includes, or ends with a given letter or phrase.
Use the % to represent wildcard characters:
Select records where the address contains the word "way":
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
sql = "SELECT * FROM customers WHERE address LIKE '%way%'" mycursor.execute(sql)
myresult = mycursor.fetchall()
When query values are provided by the user, you should escape the values.
This is to prevent SQL injections, which is a common web hacking technique to destroy or misuse your database.
The mysql.connector module has methods to escape query values:
Escape query values by using the placholder %s method:
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
sql = "SELECT * FROM customers WHERE address = %s" adr = ("Yellow Garden 2", )
mycursor.execute(sql, adr) myresult = mycursor.fetchall() for x in myresult:
Use the ORDER BY statement to sort the result in ascending or descending order.
The ORDER BY keyword sorts the result ascending by default. To sort the result in descending order, use the DESC keyword.
Sort the result alphabetically by name: result:
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
sql = "SELECT * FROM customers ORDER BY name" mycursor.execute(sql)
myresult = mycursor.fetchall()
Use the DESC keyword to sort the result in a descending order.
Sort the result reverse alphabetically by name:
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
sql = "SELECT * FROM customers ORDER BY name DESC" mycursor.execute(sql)
myresult = mycursor.fetchall()
You can delete records from an existing table by using the "DELETE FROM" statement:
Delete any record where the address is "Mountain 21":
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
sql = "DELETE FROM customers WHERE address = 'Mountain 21'" mycursor.execute(sql)
print(mycursor.rowcount, "record(s) deleted")
Important!: Notice the statement: mydb.commit(). It is required to make the changes, otherwise no changes are made to the table.
Notice the WHERE clause in the DELETE syntax: The WHERE clause specifies which record(s) that should be deleted. If you omit the WHERE clause, all records will be deleted!
It is considered a good practice to escape the values of any query, also in delete statements.
This is to prevent SQL injections, which is a common web hacking technique to destroy or misuse your database.
The mysql.connector module uses the placeholder %s to escape values in the delete statement:
Escape values by using the placeholder %s method:
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
sql = "DELETE FROM customers WHERE address = %s" adr = ("Yellow Garden 2", )
mycursor.execute(sql, adr) mydb.commit()
print(mycursor.rowcount, "record(s) deleted")
You can delete an existing table by using the "DROP TABLE" statement:
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
sql = "DROP TABLE customers" mycursor.execute(sql)
If the the table you want to delete is already deleted, or for any other reason does not exist, you can use the IF EXISTS keyword to avoid getting an error.
Delete the table "customers" if it exists:
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
sql = "DROP TABLE IF EXISTS customers" mycursor.execute(sql)
You can update existing records in a table by using the "UPDATE" statement:
Overwrite the address column from "Valley 345" to "Canyoun 123":
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
sql = "UPDATE customers SET address = 'Canyon 123' WHERE address = 'Valley 345'"
mycursor.execute(sql) mydb.commit()
print(mycursor.rowcount, "record(s) affected")
Important!: Notice the statement: mydb.commit(). It is required to make the changes, otherwise no changes are made to the table.
Notice the WHERE clause in the UPDATE syntax: The WHERE clause specifies which record or records that should be updated. If you omit the WHERE clause, all records will be updated!
It is considered a good practice to escape the values of any query, also in update statements.
This is to prevent SQL injections, which is a common web hacking technique to destroy or misuse your database.
The mysql.connector module uses the placeholder %s to escape values in the delete statement:
Escape values by using the placholder %s method:
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
sql = "UPDATE customers SET address = %s WHERE address = %s" val = ("Valley 345", "Canyon 123")
mycursor.execute(sql, val) mydb.commit()
print(mycursor.rowcount, "record(s) affected")
You can limit the number of records returned from the query, by using the "LIMIT" statement:
Select the 5 first records in the "customers" table:
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
mycursor.execute("SELECT * FROM customers LIMIT 5") myresult = mycursor.fetchall()
If you want to return five records, starting from the third record, you can use the "OFFSET" keyword:
Start from position 3, and return 5 records:
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
mycursor.execute("SELECT * FROM customers LIMIT 5 OFFSET 2") myresult = mycursor.fetchall()
You can combine rows from two or more tables, based on a related column between them, by using a JOIN statement.
Consider you have a "users" table and a "products" table:
{ id: 1, name: 'John', fav: 154},
{ id: 2, name: 'Peter', fav: 154},
{ id: 3, name: 'Amy', fav: 155},
{ id: 4, name: 'Hannah', fav:},
{ id: 5, name: 'Michael', fav:}
{ id: 154, name: 'Chocolate Heaven' },
{ id: 155, name: 'Tasty Lemons' },
{ id: 156, name: 'Vanilla Dreams' }
These two tables can be combined by using users' fav field and products' id field.
Join users and products to see the name of the users favorite product:
mydb = mysql.connector.connect( host="localhost", user="yourusername", passwd="yourpassword", database="mydatabase"
mycursor = mydb.cursor() sql = "SELECT \
products.name AS favorite \ FROM users \
INNER JOIN products ON users.fav = products.id" mycursor.execute(sql)
myresult = mycursor.fetchall()
Note: You can use JOIN instead of INNER JOIN. They will both give you the same result.
In the example above, Hannah, and Michael were excluded from the result, that is because INNER JOIN only shows the records where there is a match.
If you want to show all users, even if they do not have a favorite product, use the LEFT JOIN statement:
Select all users and their favorite product:
users.name AS user, \ products.name AS favorite \ FROM users \
LEFT JOIN products ON users.fav = products.id"
If you want to return all products, and the users who have them as their favorite, even if no user have them as their favorite, use the RIGHT JOIN statement:
Select all products, and the user(s) who have them as their favorite:
users.name AS user, \ products.name AS favorite \
RIGHT JOIN products ON users.fav = products.id"
Note: Hannah and Michael, who have no favorite product, are not included in the result.
Python can be used in database applications.
One of the most popular NoSQL database is MongoDB.
MongoDB stores data in JSON-like documents, which makes the database very flexible and scalable.
To be able to experiment with the code examples in this tutorial, you will need access to a MongoDB database.
You can download a free MongoDB database at https://www.mongodb.com.
Python needs a MongoDB driver to access the MongoDB database. In this tutorial we will use the MongoDB driver "PyMongo".
We recommend that you use PIP to install "PyMongo".
PIP is most likely already installed in your Python environment.
Navigate your command line to the location of PIP, and type the following:
Download and install "PyMongo":
C:\Users\Your Name\AppData\Local\Programs\Python\Python36-32\Scripts>python -m pip install pymongo
Now you have downloaded and installed a mongoDB driver.
To test if the installation was successful, or if you already have "pymongo" installed, create a Python page with the following content:
If the above code was executed with no errors, "pymongo" is installed and ready to be used.
To create a database in MongoDB, start by creating a MongoClient object, then specify a connection URL with the correct ip address and the name of the database you want to create.
MongoDB will create the database if it does not exist, and make a connection to it.
Create a database called "mydatabase":
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
Important: In MongoDB, a database is not created until it gets content!
MongoDB waits until you have created a collection (table), with at least one document (record) before it actually creates the database (and collection).
Remember: In MongoDB, a database is not created until it gets content, so if this is your first time creating a database, you should complete the next two chapters (create collection and create document) before you check if the database exists!
You can check if a database exist by listing all databases in you system:
Return a list of your system's databases:
print(myclient.list_database_names())
Or you can check a specific database by name:
dblist = myclient.list_database_names()
if "mydatabase" in dblist: print("The database exists.")
A collection in MongoDB is the same as a table in SQL databases.
To create a collection in MongoDB, use database object and specify the name of the collection you want to create.
MongoDB will create the collection if it does not exist.
Create a collection called "customers":
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
Important: In MongoDB, a collection is not created until it gets content!
MongoDB waits until you have inserted a document before it actually creates the collection.
Remember: In MongoDB, a collection is not created until it gets content, so if this is your first time creating a collection, you should complete the next chapter (create document) before you check if the collection exists!
You can check if a collection exist in a database by listing all collections:
Return a list of all collections in your database:
print(mydb.list_collection_names())
Or you can check a specific collection by name:
Check if the "customers" collection exists:
collist = mydb.list_collection_names()
print("The collection exists.")
A document in MongoDB is the same as a record in SQL databases.
To insert a record, or document as it is called in MongoDB, into a collection, we use the insert_one() method.
The first parameter of the insert_one() method is a dictionary containing the name(s) and value(s) of each field in the document you want to insert.
Insert a record in the "customers" collection:
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
mydict = { "name": "John", "address": "Highway 37" } x = mycol.insert_one(mydict)
The insert_one() method returns a InsertOneResult object, which has a property, inserted_id, that holds the id of the inserted document.
Insert another record in the "customers" collection, and return the value of the _id field:
mydict = { "name": "Peter", "address": "Lowstreet 27" }
x = mycol.insert_one(mydict) print(x.inserted_id)
If you do not specify an _id field, then MongoDB will add one for you and assign a unique id for each document.
In the example above no _id field was specified, so MongoDB assigned a unique _id for the record (document).
To insert multiple documents into a collection in MongoDB, we use the insert_many() method.
The first parameter of the insert_many() method is a list containing dictionaries with the data you want to insert:
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
{ "name": "Amy", "address": "Apple st 652"},
{ "name": "Hannah", "address": "Mountain 21"},
{ "name": "Michael", "address": "Valley 345"},
{ "name": "Sandy", "address": "Ocean blvd 2"},
{ "name": "Betty", "address": "Green Grass 1"},
{ "name": "Richard", "address": "Sky st 331"},
{ "name": "Susan", "address": "One way 98"},
{ "name": "Vicky", "address": "Yellow Garden 2"},
{ "name": "Ben", "address": "Park Lane 38"},
{ "name": "William", "address": "Central st 954"},
{ "name": "Chuck", "address": "Main Road 989"},
{ "name": "Viola", "address": "Sideway 1633"}
#print list of the _id values of the inserted documents: print(x.inserted_ids)
method returns a InsertManyResult object, which has a
, that holds the ids of the inserted documents.
Insert Multiple Documents, with Specified IDs
If you do not want MongoDB to assign unique ids for you document, you can specify the _id field when you insert the document(s).
Remember that the values has to be unique. Two documents cannot have the same
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
mycol = mydb["customers"] mylist = [
#print list of the _id values of the inserted documents: print(x.inserted_ids)
In MongoDB we use the find and findOne methods to find data in a collection.
Just like the SELECT statement is used to find data in a table in a MySQL database.
To select data from a collection in MongoDB, we can use the find_one() method.
The find_one() method returns the first occurrence in the selection.
Find the first document in the customers collection:
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
mycol = mydb["customers"] x = mycol.find_one() print(x)
To select data from a table in MongoDB, we can also use the find() method.
The find() method returns all occurrences in the selection.
The first parameter of the find() method is a query object. In this example we use an empty query object, which selects all documents in the collection.
Return all documents in the "customers" collection, and print each document:
No parameters in the find() method gives you the same result as SELECT * in MySQL.
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
for x in mycol.find(): print(x)
The second parameter of the find() method is an object describing which fields to include in the result.
This parameter is optional, and if omitted, all fields will be included in the result.
Return only the names and addresses, not the _ids:
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
for x in mycol.find({},{ "_id": 0, "name": 1, "address": 1 }): print(x)
This example will exclude "address" from the result:
You are not allowed to specify both 0 and 1 values in the same object (except if one of the fields is the _id field). If you specify a field with the value 0, all other fields get the value 1, and vice versa:
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
for x in mycol.find({},{ "address": 0 }): print(x)
You get an error if you specify both 0 and 1 values in the same object (except if one of the fields is the _id field):
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
for x in mycol.find({},{ "name": 1, "address": 0 }): print(x)
When finding documents in a collection, you can filter the result by using a query object.
The first argument of the find() method is a query object, and is used to limit the search.
Find document(s) with the address "Park Lane 38":
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
myquery = { "address": "Park Lane 38" } mydoc = mycol.find(myquery)
To make advanced queries you can use modifiers as values in the query object.
E.g. to find the documents where the "address" field starts with the letter "S" or higher (alphabetically), use the greater than modifier: {"$gt": "S"}:
Find documents where the address starts with the letter "S" or higher:
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
myquery = { "address": { "$gt": "S" } } mydoc = mycol.find(myquery)
Filter With Regular Expressions
You can also use regular expressions as a modifier.
Regular expressions can only be used to query strings.
To find only the documents where the "address" field starts with the letter "S", use the regular expression {"$regex": "^S"}:
Find documents where the address starts with the letter "S":
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
myquery = { "address": { "$regex": "^S" } } mydoc = mycol.find(myquery)
Use the sort() method to sort the result in ascending or descending order.
The sort() method takes one parameter for "fieldname" and one parameter for "direction" (ascending is the default direction).
Sort the result alphabetically by name:
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
mydoc = mycol.find().sort("name") for x in mydoc:
Use the value -1 as the second parameter to sort descending.
Sort the result reverse alphabetically by name:
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
mydoc = mycol.find().sort("name", -1) for x in mydoc:
To delete one document, we use the delete_one() method.
The first parameter of the delete_one() method is a query object defining which document to delete.
Delete the document with the address "Mountain 21":
Note: If the query finds more than one document, only the first occurrence is deleted.
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
myquery = { "address": "Mountain 21" } mycol.delete_one(myquery)
To delete more than one document, use the delete_many() method.
The first parameter of the delete_many() method is a query object defining which documents to delete.
Delete all documents were the address starts with the letter S:
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
myquery = { "address": {"$regex": "^S"} } x = mycol.delete_many(myquery)
print(x.deleted_count, " documents deleted.")
Delete All Documents in a Collection
To delete all documents in a collection, pass an empty query object to the delete_many() method:
Delete all documents in the "customers" collection:
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
mycol = mydb["customers"] x = mycol.delete_many({})
print(x.deleted_count, " documents deleted.")
You can delete a table, or collection as it is called in MongoDB, by using the drop() method.
Delete the "customers" collection:
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
mycol = mydb["customers"] mycol.drop()
The drop() method returns true if the collection was dropped successfully, and false if the collection does not exist.
You can update a record, or document as it is called in MongoDB, by using the update_one() method.
The first parameter of the update_one() method is a query object defining which document to update.
Note: If the query finds more than one record, only the first occurrence is updated.
The second parameter is an object defining the new values of the document.
Change the address from "Valley 345" to "Canyon 123":
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
myquery = { "address": "Valley 345" }
newvalues = { "$set": { "address": "Canyon 123" } } mycol.update_one(myquery, newvalues)
#print "customers" after the update:
for x in mycol.find(): print(x)
To update all documents that meets the criteria of the query, use the update_many() method.
Update all documents where the address starts with the letter "S":
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
myquery = { "address": { "$regex": "^S" } }
newvalues = { "$set": { "name": "Minnie" } } x = mycol.update_many(myquery, newvalues) print(x.modified_count, "documents updated.")
To limit the result in MongoDB, we use the limit() method.
The limit() method takes one parameter, a number defining how many documents to return.
Limit the result to only return 5 documents:
Consider you have a "customers" collection:
myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"]
myresult = mycol.find().limit(5) #print the result:
Python has a set of built-in functions.
Returns a readable version of an object. Replaces none-ascii characters with escape character | |
Returns True if the specified object is callable, otherwise False |
Convert an integer representing the Unicode of the specified character | |
Returns a sequence of numbers, starting from 0 and increments by 1 (by default) | |
Python has a set of built-in methods that you can use on strings.
Note: All string methods returns new values. They do not change the original string.
Returns the number of times a specified value occurs in a string | |
Searches the string for a specified value and returns the position of where it was found |
Splits the string at the specified separator, and returns a list | |
Splits the string at the specified separator, and returns a list | |
Fills the string with a specified number of 0 values at the beginning |
Note: All string methods returns new values. They do not change the original string.
Python has a set of built-in methods that you can use on lists/arrays.
Add the elements of a list (or any iterable), to the end of the current list | |
Returns the index of the first element with the specified value | |
Note: Python does not have built-in support for Arrays, but Python Lists can be used instead.
Python has a set of built-in methods that you can use on dictionaries.
Python has two built-in methods that you can use on tuples.
Returns the number of times a specified value occurs in a tuple | |
Searches the tuple for a specified value and returns the position of where it was found |
Python has a set of built-in methods that you can use on sets.
Returns a set containing the difference between two or more sets |
Removes the items in this set that are also included in another, specified set | |
Removes the items in this set that are not present in other, specified set(s) | |
Python has a set of methods available for the file object.
Returns a number that represents the stream, from the operating system's perspective | |
Returns whether the file allows us to change the file position | |
Python has a set of keywords that are reserved words that cannot be used as variable names, function names, or any other identifiers:
Python has a built-in module that you can use to make random numbers.
The random module has a set of methods:
Returns the current internal state of the random number generator | |
Returns a random float number between 0 and 1 based on the Weibull distribution (used in statistics) |
Make a request to a web page, and print the response text:
x = requests.get('https://xyz.com/python/demopage.htm') print(x.text)
The requests module allows you to send HTTP requests using Python.
The HTTP request returns a Response Object with all the response data (content, encoding, status, etc).
Download and Install the Requests Module
Navigate your command line to the location of PIP, and type the following:
C:\Users\Your Name\AppData\Local\Programs\Python\Python36-32\Scripts>pip install requests
Sends a request of the specified method to the specified url |
Learn how to remove duplicates from a List in Python.
Remove any duplicates from a List:
mylist = ["a", "b", "a", "c", "c"]
mylist = list(dict.fromkeys(mylist)) print(mylist)
First we have a List that contains duplicates:
mylist = ["a", "b", "a", "c", "c"] mylist = list(dict.fromkeys(mylist)) print(mylist)
Create a dictionary, using the List items as keys. This will automatically remove any duplicates because dictionaries cannot have duplicate keys.
mylist = ["a", "b", "a", "c", "c"] mylist = list( dict.fromkeys(mylist) ) print(mylist)
Then, convert the dictionary back into a list:
mylist = ["a", "b", "a", "c", "c"] mylist = list( dict.fromkeys(mylist) ) print(mylist)
Now we have a List without any duplicates, and it has the same order as the original List.
Print the List to demonstrate the result
mylist = ["a", "b", "a", "c", "c"] mylist = list(dict.fromkeys(mylist)) print(mylist)
If you like to have a function where you can send your lists, and get them back without duplicates, you can create a function and insert the code from the example above.
mylist = my_function(["a", "b", "a", "c", "c"]) print(mylist)
Create a function that takes a List as an argument.
mylist = my_function(["a", "b", "a", "c", "c"]) print(mylist)
Create a dictionary, using this List items as keys.
return list( dict.fromkeys(x) )
mylist = my_function(["a", "b", "a", "c", "c"]) print(mylist)
Convert the dictionary into a list.
return list( dict.fromkeys(x) )
mylist = my_function(["a", "b", "a", "c", "c"]) print(mylist)
mylist = my_function(["a", "b", "a", "c", "c"]) print(mylist)
Call the function, with a list as a parameter:
mylist = my_function(["a", "b", "a", "c", "c"])
mylist = my_function(["a", "b", "a", "c", "c"])
Learn how to reverse a String in Python.
There is no built-in function to reverse a String in Python.
The fastest (and easiest?) way is to use a slice that steps backwards, -1.
Reverse the string "Hello World":
We have a string, "Hello World", which we want to reverse:
txt = "Hello World" [::-1] print(txt)
Create a slice that starts at the end of the string, and moves backwards.
In this particular example, the slice statement [::-1] means start at the end of the string and end at position 0, move with the step -1, negative one, which means one step backwards.
Now we have a string txt that reads "Hello World" backwards. Print the String to demonstrate the result
If you like to have a function where you can send your strings, and return them backwards, you can create a function and insert the code from the example above.
def my_function(x): return x[::-1]
mytxt = my_function("I wonder how this text looks like backwards")
Create a function that takes a String as an argument.
mytxt = my_function("I wonder how this text looks like backwards") print(mytxt)
Slice the string starting at the end of the string and move backwards.
def my_function(x): return x [::-1]
mytxt = my_function("I wonder how this text looks like backwards") print(mytxt)
mytxt = my_function("I wonder how this text looks like backwards") print(mytxt )
Call the function, with a string as a parameter:
def my_function(x): return x[::-1]
mytxt = my_function("I wonder how this text looks like backwards")
def my_function(x): return x[::-1]
mytxt = my_function("I wonder how this text looks like backwards")