This class provides an introduction to the Python programming language and the iPython notebook. This is the third course in the Genomic Big Data Science Specialization from Johns Hopkins University.
Lecture 3.2: Data Structures Part 2 (10:41)
Loading...
来自 Johns Hopkins University 的课程
Python for Genomic Data Science
512 个评分
从本节课中
Week Two
In this module, we'll be taking a look at Data Structures and Ifs and Loops.
与讲师见面
Mihaela Pertea, PhDAssistant Professor
Center for Computational Biology
Steven Salzberg, PhDProfessor
Biomedical Engineering, Computer Science, and Biostatistics
Next we are going to talk about another data structure called a tuple.
Tuples function just like lists with the exception that
their elements cannot be changed and, therefore, they are immutable data types.
Let's see an example of a tuple.
To define a tuple t ,we
just need to enter the values in the tuple separated by commas.
When we check the value of t, we see that
Python prints actually two rounded parentheses around the values we entered.
We could have done exactly the same thing by entering t surrounded
by the values in t surrounded by rounded parentheses.
And the result would have been exactly the same.
So the tuple t would have stayed unchanged.
You can apply all operations and functions that we learn for
lists to tuples as long as they don't modify the tuple.
Usually tuples are more often used with heterogeneous elements.
Another data structure, is the set.
A set is an unordered collection with no duplicate elements.
In other words, sets are lists with no duplicate entries, and
since they are in order, they don't have an index.
Let's look at some set examples.
Suppose we are interested in all the gene ontology annotations
associated with the gene brca1.
Mutations in this gene are responsible for approximately 40% of inherited
breast cancers, and more than 80% of inherited ovarian cancers.
Suppose that when we create a set of go terms for brca1,
we introduce by mistake, the term DNA repair twice.
If we check the brca1 variable now,
we notice that Python removed the duplicated element.
So, DNA repair element only appears once.
Suppose we are also interested in another gene called brca2.
And this gene is also a gene that
confers increased lifetime risk of developing breast or ovarian cancer.
We can also store the go terms associated with this gene in another set
variable called brca2.
Having created these two sets of terms associated with brca1 and
brca2, we can now answer questions such as,
what are the annotation terms associated with both genes?
To do this we need an union operation in Python
which is represented by the vertical bar.
We can also find out what terms brca1 and brca2 have in common.
To do this, we will need an intersection operation, which in Python,
is specified by the symbol @.
To find out only the terms that are annotated in brca1 and
not in brca2, we can do a difference of the two sets.
The difference operation is accomplished with the minus symbol.
Another important data type is the dictionary.
Steven, would you like to explain why dictionaries are important?
>> Okay, let's talk about dictionaries.
Dictionaries are just what you'd expect them to be.
They're a data structure where you can store things that you want to look
up later.
In particular with dictionaries you don't just store a value,
you store a pair of values.
We call the value that you're using to look up values with the key.
So you've got a key just like in a regular dictionary, and
a value is what you want to associate with that key.
You can think of it like a dictionary of say, the English language where
you look up a word and associated with that would be it's definition.
So in our case when we're dealing with DNA sequences we might have different types of
sequences.
I'm going to use an example of a transcription factor motif, so
we're going to call it TF_motif.
We might have a number of different motifs that we give names to when we might
have DNA sequences we want to associate with those.
The keys can be any immutable type.
They can be strings, as in the examples I'm describing, or they can be numbers.
The values can be any type.
So the way we create a dictionary,
is we just give it a name like TF_motif and we use the equal sign.
And we wrap our dictionary in In the curly brackets, and
every key value pair that is separated by commas.
And the key value pairs, themselves, are shown as key,
and then the special character, colon, and then the value.
So, you have key, colon, value comma, and
another key, and another value, separated by a colon.
And then another comma.
As many as we like.
Now let's talk about how to get values out of our dictionary.
To access a dictionary value, use its key within square brackets.
So here's our dictionary again, TF_motif, with all the keys and value pairs.
If we want to get out the value of, say the ATF Transcription factor,
we can print it out with this print statement.
And as usual for a string,
we replace the position where we want the string to print with %s.
And then we provide TF_motif, and then in square brackets,
the name of our key, which is ATF in quotes.
So you see TF_motif of ATF, that should return for
us the string TGAC GTCA, which is that particular motif.
And sure enough, when we print it out, that's what we get.
If you try to access a key which is not in your dictionary, in other words,
you try to look something up which you've never stored a value for,
Python's going to give you an error.
So here we try to do that same print statement for
a transcription factor called NF-1, which is not in our dictionary.
And Python's going to just give you an error.
So it's important to check to see if your key is present.
Fortunately, you can do that using the special keyword in here.
You can say NF-1 in TF_motif and that test will return false,
so you know that it's not in your dictionary.
You can update your dictionary by adding new values.
So here's our dictionary again.
Suppose you want to add a new key value pair to it.
For that we can use assignment of a value to that key.
So the key doesn't have to be in the dictionary for this.
In fact, it shouldn't be.
You're trying to assign a new one.
So we want to add a new motif called AP-1.
We would just say TF_motif of AP-1.
Again, square brackets.
Equals, and we give it that DNA sequence we want that motif to be corresponding to.
And then we can look at our dictionary again, and
we'll see that, sure enough, it's got an extra value in it, the value of AP-1.
We can modify an entry in pretty much the same way if
we assign to a key that's already in our dictionary.
A new value, then if we look at our, in here we've done it for AP one.
We give it a new DNA sequence.
Now if we look at our dictionary again,
we will see that now the motif AP-1 has a different value.
We can also update a dictionary by deleting a key from it entirely.
So to do that, we use a special function delete, or delete TF_motif of SP1,
is going to delete the SP1 motif entirely from the dictionary.
So if you look at our TF_motif dictionary again,
we'll see that one of the entries is gone.
We could add multiple key value pairs at once.
We could think of that as adding an entire dictionary to the current one.
So to do that, you use the special method update.
TF_motif.update.
And then you provide your new dictionary.
Here I provided a small dictionary with three key value pairs and
added them all to our TF_motif dictionary.
Now it's okay if some of those pairs already exist in the current dictionary.
Python will handle that and make sure there is no duplicates.
If you want to find out how big your dictionary is,
you can use the built in function len for length.
So if I call len on TF_motif, that tells me there are six entries.
Those are six key value pairs.
So six pairs of entries.
We can also find out what the keys are.
That's often something you want to do.
So give me all the words in my dictionary of English, for example.
So we want to get all the words or keys in my dictionary.
I use the keys method, which is attached to it.
And I can do that by typing TF_motif.keys, as we do with methods.
And return that as a list by wrapping that inside of a call to the list command.
So if I say, list of TF_motif.keys,
that returns all the keys in my transcription factor motif dictionary.
And you can see them here, ATF, c-Myc, SP1 and so on.
Returns those as a list.
And similarly, I can get a list of all the values
by using the values method instead of the keys method.
So I would type TF_motif.values, do the same thing, and
I get a list of all the values.
Now, these values come out in an arbitrary order.
You might want to have them sorted, say, alphabetically.
So you can use the sorted function to do that.
So if I simply call sorted on TF_motif.keys,
that'll return all my keys in sorted order.
And I can do the same thing on the values and return my values in sorted order.
Now you might notice in the keys here that c-Myc appears at the end of the list even
though they're in alphabetical order, and that starts with the letter C.
This is because in our sorting conventions,
uppercase letters always occur before lowercase letters.
So that's a good thing to keep in mind in case your names use a mixture of
uppercase and lowercase.
So let's look at a quick summary of what we've been over so
far on sequence data types.
We have three data types we've been talking about.
Strings, lists, and dictionaries.
And there's a variety of things you can do with all three of these data types.
Of course, you can create them and there are different commands to do creation for
each of those data types.
You can access particular elements, of course.
You need to access elements in your In your data type, whether it's a string,
a list or a dictionary.
You can test to see whether something is a member of these data types.
For some of them if they're mutable you can remove an element.
Note the strings are not mutable.
So here we've shown an example of how you'd create a string with an element
removed, but you can't actually modify the string because it's immutable.
You'd have to create a new string which has the element removed.
You can similarly change an element in any of these data sets.
You can add an element.
Again, not if they're immutable.
You can remove a series of consecutive elements.
That's particularly easy with lists, not so easy with the other data types.
You can also, in the same spirit, you can change consecutive elements, and
you can also add more than one element at a time to both lists and dictionaries.
