Python Sequences and Subscription

Loading...

Del curso dictado por University of Alberta

Problem Solving, Programming, and Video Games

calificaciones

University of Alberta

Problem Solving, Programming, and Video Games

calificaciones

This course is an introduction to computer science and programming in Python. Upon successful completion of this course, you will be able to: 1. Take a new computational problem and develop a plan to solve it through problem understanding and decomposition. 2. Follow a design creation process that includes specifications, algorithms, and testing. 3. Code, test, and debug a program in Python, based on your design. Important computer science concepts such as problem solving (computational thinking), problem decomposition, algorithms, abstraction, and software quality are emphasized throughout. The Python programming language and video games are used to demonstrate computer science concepts in a concrete and fun manner. However, a learner can take the knowledge and skills from this course and apply them to non-game problems, other programming languages, and other computer science courses. You do not need any previous programming, Python, or video game experience. However, some computer skills (e.g., mouse, keyboard, document editing), knowledge of algebra, attention to detail (as with many technical subjects), and a “just give it a try” spirit will be keys to your success. Despite the use of video games for all the programming examples, PVG is not about computer games. PVG will still provide valuable knowledge and skills for non-game computational problems. The interactive learning objects (ILO) of the course provide automatic, context-specific guidance and feedback, like a virtual teaching assistant, as you develop problem descriptions, algorithms, and functional test plans. The course forums will be supported by the creators of the course, to help you succeed. All videos, assessments, and ILOs are available free of charge. There is an optional certificate available for a fee.

De la lección

Module 5: Hacking Version 4 & 5

In Module 5, you will modify your game design using two new abstraction techniques, called control abstraction and data abstraction. You will explore two different control abstractions, called definite and indefinite repetition. You will learn two new Python statements (for, while), four new Python expressions (subscription expression, expression list, parenthesized expression, list display), and three new Python types (tuple, list, range). You will employ these Python constructs to write, test, and debug Hacking Version 4 and Hacking Version 5.

Python Sequences and Subscription8:20

Conoce a los instructores

Duane Szafron
Professor
Computing Science
Paul Lu
Professor
Computing Science

In this video, I introduce a category of types called sequence types.

This category includes the string type

and other types which will be introduced in future lessons.

I also introduced the subscription expression,

which is a mechanism for referring to elements of a sequence.

A sequence is a finite ordered group of elements,

where each object has a numerical index between

zero and one less than the number of elements in the sequence.

There is no sequence type in Python.

Instead, sequences are category that includes several different Python types.

The Python STR type is one kind of sequence.

Each string is a finite ordered group of indexed characters.

For example, the string object "hello" is

a sequence of characters where H is element zero,

E is element one,

L is both element two and element three,

and O is element four.

Remember, that Python always starts its index is at zero instead of one.

I can use a new kind of Python expression called

a subscription expression to reference an element of a sequence.

Subscription uses two delimetres,

left bracket and right bracket.

Python subscription is analogous to using subscripts in mathematics.

For example, I can reference the string element of

"hello" at index one using this expression,

which is pronounced "hello of one".

In many programming languages,

the elements of a string are objects whose type is char,

which is short for character.

However, there is no char type in Python.

Let's find out what type of elements Python uses in a string.

The type STR was displayed.

It appears that the elements in a Python string are one element string objects.

However, Python string elements are characters that have

an internal representation that do not have a Python type.

When you use subscription to reference one of these characters,

the interpreter returns a one element string object.

This is a simplified syntax diagram for the subscription expression.

Here is a generalized syntax diagram for expression that includes subscription.

The simplified semantic rule for subscription

is: evaluate the left expression to get the primary object,

evaluate the bracketed expression to get the index object.

If the primary object is not a sequence,

report a subscription error.

If the index object is not a non-negative integer less than the sequence length,

report an indexing error.

Reference the primary objects element at the index.

The expression "hello of one" is lexically and syntactically correct.

I will apply the semantic rule for subscription.

In step one, the left expression is evaluated to obtain the primary object "hello".

In step two, the bracketed expression evaluates to the object one.

In step three, the primary object has type STR which is a sequence.

So no subscription error is reported.

In step four, the int object one is

a non-negative integer that is less than the string length five.

So no indexing error is reported.

In step five, the primary object is "hello",

so the interpreter returns the element at index one.

This is the single element string E,

not H which is at index zero.

This expression is also lexically and syntactically correct.

I will apply the semantic rule for subscription.

In step one, the left expression is evaluated to obtain the primary object 27.

In step two, the bracketed expression is evaluated to obtain the index object one.

In step three, the primary object has type int,

which is not a sequence.

So a semantic type error reports that the integer

is not sub-scriptable and evaluation stops.

Here's another lexically and syntactically correct subscription expression.

I will apply the semantic rule for subscription.

In step one, the left expression is evaluated to obtain the primary object hello.

In step two, the bracketed expression is evaluated to obtain the index object one.

In step three, the primary object has type STR which is a sequence.

So, no subscription error is reported.

In step four, the string object one is not a non-negative integer.

So a semantic type error reports that the index must be an integer and evaluation stops.

Here is yet another lexically and syntactically correct subscription expression.

I will apply the semantic rule for subscription.

In step one, the left expression is evaluated to obtain the primary object "hello".

In step two, the bracketed expression is evaluated to obtain the index object five.

In step three, the primary object has type STR which is a sequence.

So no new subscription error is reported.

In step four, the int object five is a non-negative integer,

but it is not less than the string length which is also five.

So a semantic indexing error reports that the index is out of range and evaluation stops.

The reason the largest index must be strictly less than

the length instead of less than or equal to the length,

is that sequences are indexed from zero to one less than the sequence length.

I know I have discussed indexing from zero instead of one

several times but you will probably make indexing errors anyway.

I still make indexing errors.

In the subscription semantic,

step four indicates that the interpreter reports

an indexing error for all negative integers.

However, the built-in sequence types can handle some negative indexes.

In this expression, the last element O is returned.

This is done by adding the index negative one to

the string length five to obtain the index four,

and returning the element O at this index.

Using an index of negative n,

yields the nth last element.

This can sometimes be useful.

However, if you use a negative index whose magnitude is too large,

you will still get an indexing error.

For example, hello of negative six is an error because there is

no sixth last element of hello which has only five characters.

In this video, I introduced a category of types called sequence types.

This category includes the string type

and other types that will be introduced in future lessons.

I also introduced the subscription expression,

which you can use to refer to elements of a sequence.

Explora nuestro catálogo

Inscríbete de manera gratuita y obtén recomendaciones personalizadas, actualizaciones y ofertas.

Coursera brinda acceso universal a la mejor educación del mundo, al asociarse con las mejores universidades y organizaciones, para ofrecer cursos en línea.

© 2018 Coursera Inc. Todos los derechos reservados.

Descargar en la App Store

Consíguelo en Google Play