Python has many data types, three of which you've learned already (float, int, str). But, to keep going in your Python studies, you'll need to learn five more: bool, list, tuple, set, and dict. Along the way, see how to use methods and a few new tricks for strings.
Methods are a common way of getting or setting information about something. A method is like a function, but it has a slightly different format:
item.methodName(params)Unlike functions, most methods can only be used on one or two types of things. For example, the len() function, which returns something's length, can work on almost any data type.
However, the .append() method, which appends an item to a list, only works on lists. You'll learn more methods on this page.
So far, you know the float, int, and str data types. Here's another to add to your list: boolean values, which Python calls bool types.
A boolean value is just True or False. These are used to control if blocks and while loops, which you'll learn about later. To convert something to a boolean value, use the bool() function.
Some other ways that you can turn something into a boolean value are with comparison tests. Here are some basic tests.
Equivalence Tests
a == b # Returns True if a is equal to b, otherwise returns False.a is b # Returns True if a is equal to b, otherwise returns False.a != b # Returns True if a is NOT equal to b, otherwise returns False.a is not b # Returns True if a is NOT equal to b, otherwise returns False.Less/Greater Than Tests
a < b # Returns True if a is less than b, otherwise returns False.a > b # Returns True if a is greater than b, otherwise returns False.a <= b # Returns True if a is less than or equal to b, otherwise returns False.a >= b # Returns True if a is greater than or equal to b, otherwise returns False.Type Tests
You can use the type(item) function to get an item's type.
type(a) is b # Returns True if the type of a is b, otherwise returns False.Some ways that you can combine comparisons are with and, or, or not. Ex:
statement 1 and statement 2 # Returns True if both statements are True.statement 1 or statement 2 # Returns True if at least one statement is True.not statement # Returns True if the statement is False.not(statement) # Returns True if the statement is False.Remember that not can be used in three ways:
not statement # Returns True if statement is False, otherwise returns False.not(statement) # Returns True if statement is False otherwise returns False.a is not b # Returns True if a is NOT equal to b, otherwise returns False.Let's make a grocery list with Python with carrots, pumpkins, and pasta. We could use a string. However, Python has something called a list, which is better for our job. You'll see why below.
A list is surrounded by brackets ( [ and ] ) and can have multiple comma-separated items which can be anything. Let's turn our grocery list into an actual list:
groceryStr = "carrots, pumpkins, pasta"groceries = ["carrots","pumpkins","pasta"]The list requires more typing. However, it has many advantages. Let's try to get the second item of each "list". To get the second item of groceries, we use groceries[1]. To get the second item from groceryStr, we have to look at it, which is a big no-no in programming, because the computer can't run it on it's own.
Wait! Aren't we trying to get the second item of the list? Yes, but Python uses something called zero-indexing, meaning that the first item is 0, the second is 1, etc. Here's Python's idea of a list:
["carrots", "pumpkins", "pasta"] | | | | 0 1 2 3As you can see from the above diagram, Python is numbering the spaces between the items, not the items themselves. The reason for this is because Python wants to make it easy for us to select parts of a list.
Let's try to select the first two items in our list:
groceries[0:2]This selects everything from the 0th index to the 2nd index.
Python also places negative indexes:
["carrots", "pumpkins", "pasta"] | | |-3 -2 -1If we select groceries[-2] Python would give us "pumpkins". However, if we select groceries[-3:-2] it would give ["carrots"]
What if we realized we needed eggs as well? To add an item to a list, we use the .append(item) method. This will append the item to the end of a list. Example:
groceries.append("eggs")print(groceries) # ["carrots","pumpkins","pasta","eggs"]What if we need to change pumpkins to 2 pumpkins? We can do that by setting groceries[1] as if it were a variable:
groceries[1] = "2 pumpkins"print(groceries) # ["carrots","2 pumpkins","pasta","eggs"]To remove the last item from a list, we use the .pop() method. You can also give the .pop() method an index of an item to delete. We can also remove any item from a list with the del keyword as well.
del groceries[1]print(groceries) # ["carrots","pasta","eggs"]groceries.pop()print(groceries) # ["carrots","pasta"]We can use the in keyword to check if something is in a list. Example:
print("a" in [1,2,3]) # Falseprint(1 in [1,2,3]) # TrueTo convert something to a list, we use the list() function.
Didn't we already learn about strings? Yes, but here we're going to learn how to select parts of a string. Remember the selection trick for lists? That same trick works for strings as well! For example, let's create a string:
newStr = "Hi. My name is Bob!"Let's select the first 6 characters of that with [0:6]:
print(newStr[:6]) # Hi! My Now let's select the last six:
print(newStr[-6:]) # s Bob!Strings have some methods that we can use when we need to convert them to uppercase or lowercase:
print(newStr.upper()) # HI. MY NAME IS BOB!print(newStr.lower()) # hi. my name is bob!As you can see, we used the .upper() method to change to uppercase and the .lower() method to change to lowercase.
Sometimes we need to turn a string into a list. We can do that with the .split(splitOn) method:
print(newStr.split(" ")) # ["Hi.", "My", "name", "is", "Bob!"]We can use the in keyword to check if something is in a string. Example:
print("a" in "bcd") # Falseprint("bc" in "bcd") # TrueA tuple in Python is almost the same thing as a list except for a few minor differences:
Let's create our first tuple:
tup = (1,"This is a string.",True)Tuples cannot be changed once they are created. They can be deleted with del, but you cannot add items, change items, or remove individual items in a tuple. There is a way around this, which is turning the tuple into a list with list(), adding/changing/removing the item, then turning it back into a tuple. Ex:
tup = (1,"This is a string.",True)lst = list(tup)lst.append("abc")tup = tuple(lst)print(tup) # (1, "This is a string", True, "abc")As you can see by testing this code, Python produces no errors.
We can use the in keyword to check if something is in a tuple. Example:
print(1.2 in (1,2,3)) # Falseprint(2 in (1,2,3)) # TrueTo convert something to a list, we use the tuple() function.
Sets, like tuples, are also very similar to lists. They, however, have their own special rules:
set() instead of making a {}. Writing {} causes Python to create an empty dictionary, which you'll learn about later.Let's make our first set!
ourSet = {1,"String in a set!",1,1,("Tuple in a set.")}print(ourSet) # {1, "String in a set!", "Tuple in a set."}Remember how I said that sets cannot have duplicates? That is why Python deleted two of our 1s. Also, did you notice that the tuple is gone and that the string in the tuple is not in a tuple? Items in a tuple are automatically removed from the tuple.
Sets have many useful methods. Here are some:
The .add(item) method adds an item to a set.
The .remove(item) and .discard(item) methods remove an item from a set. If the item is not in the set, .remove() will raise an error, but .discard() will not.
The .union(other_set) method adds the other set's items to the set that the method is called on.
The .intersection(other_set) method sets the set that this method is called on to only have items common to both sets.
The .difference(other_set) sets the set that this method is called on to have items that belong to the original set but NOT the other set.
We can use the in keyword to check if something is in a set. Example:
print("a" in {1,2,3}) # Falseprint(1 in {1,2,3}) # TrueTo convert something to a list, we use the set() function.
If I told you to make a list containing your relatives' favorite sports, you could make one easily:
sports = [ "Me: Tennis", "Mom: Basketball", "Dad: Soccer", "Sister: Football"]You could also find the favorite sport of someone easily, just by looking through the list. But what if the list had hundreds of names? It would be hard to find one name. That's what a dictionary is for.
We use dictionaries every day, without thinking about it. For example, think about person's name: person's address, or room: color.
A dictionary is basically a set comprised of key: value pairs. They have a few rules:
Let's make a sports dictionary!
sports = { "Me": "Tennis", "Mom": "Basketball", "Dad": "Soccer", "Sister": "Football"}To get an item from a dictionary, we write dictionary[key]. For example, to get Dad's favorite sport from our dictionary, we just write sports["Dad"]. Much easier that scanning through a list!
To change the value of a key, we just write dictionary[key] = value, as if it were a variable. We can also delete a key: value pair with del dictionary[key].
To add a new key: value pair, we act as if we were changing the value of an already created key: value pair.
Let's try our skills at dictionaries:
sports["Sister"] = "Soccer"print(sports) # {"Me": "Tennis", "Mom": "Basketball", "Dad": "Soccer", "Sister": "Soccer"}print(sports["Dad"]) # Soccersports["Grandpa"] = "Shuffleboard"del sports["Me"]print(sports) # {"Mom": "Basketball", "Dad": "Soccer", "Sister": "Soccer", "Grandpa": "Shuffleboard"}If we want to get a list of a dictionary's keys, we use dictionary.keys(). To get the values, we use dictionary.values(). Example:
print(sports.keys()) # ["Mom", "Dad", "Sister", "Grandpa"]print(sports.values()) # ["Basketball", "Soccer", "Soccer", "Shuffleboard"]We can use the in keyword to check if a KEY is in a dictionary. Example:
sports = {"Me": "Tennis", "Mom": "Basketball", "Dad": "Soccer", "Sister": "Soccer"}print("Me" in sports) # Trueprint("Basketball" in sports) # FalseWhen a dictionary is converted into a list, tuple, or set, the new list/tuple/set contains the keys of the dictionary, not the values.
The dict() function does convert things to dictionaries, but since nothing else has key: value pairs, the results may not be what you expect.
There is one additional thing in Python called None, which represents undefined, blank, etc. You might use this if you want to calculate a value for a variable if it hasn't been already calculated.