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 2.2 - First Steps Toward Programming Part 2
Loading...
來自 Johns Hopkins University 的課程
Python for Genomic Data Science
530 個評分
從本節課中
Week One
This week we will have an overview of Python and take the first steps towards programming.
與講師見面
Mihaela Pertea, PhDAssistant Professor
Center for Computational Biology
Steven Salzberg, PhDProfessor
Biomedical Engineering, Computer Science, and Biostatistics
Now let's talk about variables.
Without variables, you can not do anything in Python.
This is an important concept, and it means that instead of manipulating
numbers or strings directly, so any type of values,
we have to store them in some type of containers that have names.
These are variables.
The equals sign is usually used to assign a value to a variable.
So, in this case, let's take a variable that's called codon and
essentially the value ATG which is a string.
So now I'm not using ATG as a string but
I am using a variable coding called codon that refreshed this string ATG.
We can have bigger variable names, bigger strings
enclosed in other variable names, like dna_sequence here.
Which is a longer string of G T A and C's and
note that here after I assign the value of a string ATG to a codon,
Python doesn't print anything back so no result is displayed.
If a variable is not defined,
so I didn't assign a value to it yet, trying to use it will give you an error.
Let's try to see what happens if we type a random name at the prompt like DNA.
Python gave us an error.
DNA is a variable that's not defined.
The name associated with a value is called variable because its value can change and
let's see an example how this might happen.
Let's for instance assign the value of four to a variable called a.
Now let's try to see its value.
a is 4.
We can assign the same value to another variable called b, and
instead of doing it like the first time, b = 4,
let's say we're just going to copy the value of variable a into the variable b,
so b equals a means assign the value of a to b.
So now, test what b is, and we get b = 4.
We can actually increase the value of b by saying, b = b + 3.
And yes, this is legal.
If you are used to math, this might look strange to you,
but equal here doesn't mean the same thing as in a math operation.
It means an assignment So the new value of b gets assigned the old value of b + 3.
So let's test what's the value of b.
It's seven. But let's check a.
a stayed the same.
It's still four.
So value of a didn't change even though we changed the value of b.
Steven can you give us a few tips about how to use variables?
>> Sure I can sayl a little bit more about variables.
First I don't really like these names a and b.
They're very simple and easy to type, but they don't really mean anything.
So in general when you're writing a program your variables will refer to
something that you have in mind.
So whenever you can, give your variable a meaningful name.
For example, dnaSequence might be the name of a variable and
that's much better than say s or a or b.
Now, you can't use just any old set of characters.
You like the variables.
There's specific rules for what letters you can use in your variable names.
First of all they're case sensitive so upper case is important and
often we use upper case to help us remember where the word boundaries are.
So for example, you could say myvariable equals 1,
and that would create a variable called myvariable, all lower case.
Or you could put the letters m and v in upper case and you could say MyVariable =
2, or you could put them all in upper case and say MYVARIABLE = 3.
And those are actually three different values and three different variables.
So, Python pays attention to upper and lower case.
And that's useful for making variable names that are easy for
you to read later on when you go back onto your program again.
Variables also can only have certain characters in them.
So in general, you can use any letter you like, upper case or lower case.
The variable names have to start with a letter.
They can't start with a number.
Except for the first position,
you can put numbers in the middle of your variable names.
And you can also use the underscore character, which again, helps readability.
So here's some examples of variable names.
You can have a variable called name.
You have a variable called _str, a variable called DNA in all uppercase, or
a variable called sequence1.
But you couldn't use a name like 1string here because the first
character of that string is a number and that's not allowed in a variable name.
And you can't use name# pound sign or hashtag, and you can't use year@20.
So, those are illegal characters.
You're not allowed to use those.
Let's talk about a couple of other things you might do with strings besides just
concatenate them together and check for membership or substring's existence.
So, one thing we often do with strings, is we look along those stings and
try to find other strings that are at particular positions in the string.
This especially important when we're dealing with very longs strings such as
genomes which are million or even billion of bases long.
We don't want to be printing out the whole thing to a screen or to a file.
We frequently want to go specifically to a particular location like say
position one million and see what's there.
So if you use the special square bracket characters and
put a number between, like I've shown here,
x in brackets will give you the character that's at position x in a string.
Or you can have x:y and
that'll give you a range of characters between positions x and y.
So let's look at a couple of examples to see how we do this.
So suppose our string is a DNA sequence and
we're going to call it dna and we close it in quotes.
So here's our sequence, a's, c's, d's and t's.
Now we might want to get just the first character of that string.
So then we use this square bracket operator.
We put it next to our variable name.
So DNA zero, that's going to give us the first position in the string.
So that position there, that zero, is called the index.
And there's a funny thing we do in Python programming, and in most programming
languages, and that is, we start indexing things with zero rather than one.
So, we're used to talking about positions in lines or queues or
whatever as being one, two, three.
So you might think that the letter g is the first letter in this string.
And it is the first letter in our normal way of talking about.
But in Python, it's the 0 with letter.
So the first position of the string is actually position 0.
So if I get position 0, I'll get the letter G out of that.
You can also do another neat little trick with indexing,
you can use negative numbers.
And if you use a negative number rather than a positive number,
that says start at the end of the string and count backward.
So let's say dna of -1, what do I get?
I'm going to start the right end of the string which is the string here,
ends in ttgc, so I get c and that c is what came off the very end of the string.
So I can get a little fancier and I can look at something that goes back a little
further, so dna of -2 which is going to go back two letters and give us the g, so
it's second from the end.
Or I could pick out a range so 0 to 3, now there's another little special rule here.
When I give two numbers, it always starts at the position, I'm saying start at
the position of the first number and end just before the second number.
So 0:3 refers to positions 0, 1, and 2 on the string, but not position 3.
So that'll give me the string starting at zero and ending just before three.
So that's gives us gat, which are the first three characters of our string.
You can also omit the first index, if I leave that off that just says,
well, start at the beginning.
So I get the same thing back, so the default is zero there.
The default for this first index.
So dna:3 is the same thing as dna from 0 to 3.
And finally I can leave off the second index, I can say dna 2: blank and
if I leave off the second index that defaults to the very end of the string.
So this says give me the whole string starting at the index corresponding to two
which remember is the third position.
So I would get the whole string,
starting at the t which is the third letter in the string.
Now I'm going to give it back to Ella to tell us about some other useful string
functions.
>> We have already seen a very useful string function that was called print,
which printed the string very nicely on the screen.
Another useful string function is the function len,
which returns the length of a string.
So let's have a variable called dna which is a string of a's, c's, g's, and t's.
And let's compute it's length.
What we are gong to do is we are going to call the building function len,
len of dna, and this will give us the length of the string that we
assigned to the variable DNA in this case it's 49.
Python has many other built in functions and types that are always available.
Some other examples are type that we saw.
Print we saw that one too.
And in general we can find more information about any built-in function by
using the pydoc command in a shell or the help function in the Python interpreter.
For instance, if you try writing help(len),
it will tell you everything that len can do.
But strings are more than variables.
They can be viewed as objects.
We already mentioned that Python uses object-oriented programming.
Object-oriented programming is programming language model
organized around objects rather than actions.
For instance, human in programming can be seen as object and this is okay to do so.
We can see a human object as an object with many attributes like name, address,
that can do many actions like talking, thinking.
The same as with string.
We can see them as objects.
This means that we can do more to them than just assign a value.
So, let's see here in example, the variable DNA is a string variable and
it has assigned a value, which is just a string of a's, c's, g's and t's.
But, if we want to do more then we can also perform some specific actions or
functions that are called methods that only the string objects can perform.
For instance, the DNA variable can count all the character sees
in the string that's been assigned to it.
So dna.count of c will tell me how many c's are in the DNA string.
Notice the dot operator.
Here, it can be interpreted as ask object DNA to do
something such as count how many c's characters it finds.
So dna.count('c') will give me the answer 9.
The method count can also count substrings.
We don't necessarily have to restrict ourselves to single characters.
So if we want to count how many gcs are in DNA, we do dna.count of
the string gc, and item immediately answers five.
There are other useful string functions that we can use.
For instance, we can write a string all in uppercase by calling the matter upper.
Let's see an example for the DNA variable.
dna.upper will turn the string DNA into all upper cases.
There is also a lower function, but I will not show it here.
You can try it yourself on your computer.
Let's see the value of dna now.
It's still in lower cases, so the value of the string dna did not change.
But we could copy for instance the upper case version
of the string stored by DNA into another variable.
Another method that's very useful for
the string objects is finding a sub string in a bigger string.
For instance dna.find ag will find
the first occurrence of the string ag in the bigger DNA string.
So dna.find('ag') is 16.
This means that the first ag appears at position 16, or
rather the index 16 as you now position 16 in this case or
the end of 16, this count is starting from 0 in DNA.
But only the first occurrence of ag is reported,
what if we want to find the next occurrence of ag?
Then we have to tell the method find where to start looking for, and
we can tell it to start looking after the position it found the first occurrence of
ag supposition 17.
So dna.find of ag does, to start looking at position seventeen and
you can find ag at position forty seven.
We can also tell the dna to start looking from the end of the string so
the function of our find will do exactly that.
So, DNA.rfind of ag will start looking by the end of DNA string.
And will give me, again, the position 47.
We can find all the methods associated with
the object strings by typing help(str).
When I type help(str) we can see there are many other useful string functions.
And not all of them do modify the string or
actually do an operation on the string that started the variable string.
For instance, dna.islower will tell me
if all the characters in the dna variable are lowercase.
In this case, it is true.
Same thing, dna.isupper,
will tell me if all the characters in the dna variable are in uppercase.
In this case, this is false.
We also can find another useful string method for
bioinformatics programming, which is called replace.
And what it does, it will replace any character in the first argument
of the method to the next character in the second argument of the method.
For instance, dna.replace, small case a to big
case A will replace all occurrences of lowercase a to uppercase A.
In another lecture, we'll use all these string methods we learned so
far to build our first program in Python.
