Str: Indexing and Slicing

Loading...

Do curso por University of Toronto

Aprenda os Fundamentos da Programação

2573 classificações

University of Toronto

Aprenda os Fundamentos da Programação

2573 classificações

Behind every mouse click and touch-screen tap, there is a computer program that makes things happen. This course introduces the fundamental building blocks of programming and teaches you how to write fun and useful programs using the Python language.

Na lição

For Loops and Fancy String Manipulation

This module introduces one way to repeat code (using a for loop), how to manipulate strings, and how to use a debugger to watch a program execute step by step.

More str Operators2:16

Str: Indexing and Slicing4:53

Str Methods: Functions Inside of Objects3:41

For Loop Over Str11:36

Conheça os instrutores

Jennifer Campbell
Associate Professor, Teaching Stream
Department of Computer Science
Paul Gries
Associate Professor, Teaching Stream
Department of Computer Science

When working with strings, we often need to extract substrings.

For example, if a string contains a phone number, we may want to extract the area

code. In this lecture, I'll introduce two

techniques, indexing and slicing, and we'll use those to extract substrings of

the strings we're working with. In this lecture, we'll use the string

learn to program as our running example. Each character of a string has an index

which, which is it's position in the string.

So, the string at index zero, indicated using this bracket notation, is the L.

At index one of the string, we have an e. At index two, is the first a.

Notice that zero is the first position, not one.

We start counting from zero. We can also use negative indices to count

from the end, or from the right hand side of the string.

So, the string at -one is the m. At -two is the last a,

At -three is the r, the last r. So, once we've seen using an index, we can

extract parts of the string one character at a time. But, we can extract more than

one character using an approach called slicing.

With slicing, we provide a start index followed by a colon, followed by an end

index and that gives us a substring from the start index up to, but not including

the ending index. For example, we can get this string from

position zero, index zero up to, but not including index five, and that gives us

the string Learn. From index six up to, but not including

eight, is the to. And, from index nine up to sixteen, is the

word Program, string Program. Sixteen is equal to the length of the

string. So, an alternative would be to start at

index nine but go up to len of s. Len is a built in function that returns

the length of the string, so this expression is equivalent to the one above.

Another alternative would be to go from nine, put the pole in, and omit the ending

index. In which case, the default is to go to the

end of the string, so this is also equivalent to the two expressions above.

The starting index can also be omitted. So, for example, we can include colon and

go up to index a, We can also omit both the starting and

ending indices, And that gives the entire string.

We've seen that negative indices can be used for indexing, and they can be used

for slicing as well. Let's get this substring from index one up

to but not including eight. And our equivalent expression is to get it

from one up to but not including -eight, Or to go from -fifteen up to but not

including -eight. So, those three expressions are all

equivalent. The slicing and index operations do not

modify the string that they act on. So, the value that s refers to is

unchanged by the operations above. In fact, we cannot change the value of a

string. Operations like the following result in

errors. If I take the string at index six and try

and set it to d, I get an error. Similarly, if I try to modify the string

from index nine up to sixteen, have it refer to run, an error also occurs.

But, imagine that we'd like to change string s to refer to Learned to Program.

Here's one approach that we can take. We can use the current value of s and get

the word learn, concatenate that with ed to make it learned, and concatenate that

with the rest of the string, which is, to program.

That evaluates to give Learned to Program. And now that we have this new string,

Learned to Program, we can have s refer to that instead of it's old value.

Notice that we didn't modify the string that s originally referred to,

We can't modify it. Instead, we created a new string and had s

refer to that new string.

Explore nosso catálogo

Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.

O Coursera proporciona acesso universal à melhor educação do mundo fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.

© 2019 Coursera Inc. Todos os direitos reservados.

Baixar na App Store

Baixar no Google Play