CS 61A Discussion 7 Iterators/Generators & Linked Lists Albert - - PowerPoint PPT Presentation

CS 61A Discussion 7

Iterators/Generators & Linked Lists

Attendance: links.cs61a.org/albert-disc Slides: albertxu.xyz/teaching/cs61a/

Albert Xu

Announcements

Linked Lists

a new type of list

1 4 2 3

regular lists look something like this

Linked Lists

a new type of list

1 1 4 2 3

regular lists look something like this

4 2 3

the same list as a linked list

Linked Lists

a new type of list

1 1 4 2 3

regular lists look something like this

4 2 3

the same list as a linked list

Each element of the linked list is like a link in a chain, and contains a single element of the linked list. It also tells us where to find the next element in the linked list!

Linked Lists

a new type of list

1 1 4 2 3

regular lists look something like this

4 2 3

the same list as a linked list by the way, why do linked lists exist?

Each element of the linked list is like a link in a chain, and contains a single element of the linked list. It also tells us where to find the next element in the linked list!

Linked Lists

a new type of list

1 1 4 2 3

regular lists look something like this

4 2 3

the same list as a linked list by the way, why do linked lists exist? it’s fast to add/delete elements!

Each element of the linked list is like a link in a chain, and contains a single element of the linked list. It also tells us where to find the next element in the linked list!

Link Class

under the hood

1 4 2 3

first rest

Link Class

under the hood

1 4 2 3

an instance of the Link class

first rest

Link Class

under the hood

1 4 2 3

an instance of the Link class

• Each instance of the Link class has a first, which stores the

element,

first rest

Link Class

under the hood

1 4 2 3

an instance of the Link class

• Each instance of the Link class has a first, which stores the

element,

• …and rest attribute, which stores a pointer to the next Link.

first rest

Link Class

under the hood

1 4 2 3

an instance of the Link class

• Each instance of the Link class has a first, which stores the

element,

• …and rest attribute, which stores a pointer to the next Link.
• Finally, the last link in the list has a rest attribute which points

to an object called Link.empty!

first rest

Iterators, Iterables

iterable iterator

• h my

Iterators, Iterables

• h my

iterator iterable

Iterators, Iterables

• h my

iterator iterable

iter as in iteration!

Iterators, Iterables

iterator

• h my

both iterators and iterables implement the __iter__ method, meaning that given an instance x of an iterator or iterable, calling iter(x) will give you a new iterator over x!

iterable

iter as in iteration!

Iterators, Iterables

iterator

• h my

iterable

implying that it is ABLE to be iterated over!

Iterators, Iterables

iterator

• h my

an iterable is any object, sequence or not, that can be iterated over! Examples include lists, tuples, sets, strings, and dictionaries!

iterable

implying that it is ABLE to be iterated over!

Iterators, Iterables

iterable iterator

• h my

implying that it is ABLE to be iterated over!

an iterable is any object, sequence or not, that can be iterated over! Examples include lists, tuples, sets, strings, and dictionaries!

this is the thing DOING the iteration!

Iterators, Iterables

iterable iterator

• h my

implying that it is ABLE to be iterated over!

an iterable is any object, sequence or not, that can be iterated over! Examples include lists, tuples, sets, strings, and dictionaries!

this is the thing DOING the iteration!

an iterator is an object that lets you get the next element of a sequence repeatedly until no more elements exist.

A Good Comparison

*borrowed from Kevin T. Li

WWPD, Iter*

>>> a = [1, 2, 3] >>> fun_iter = iter(a)

WWPD, Iter*

>>> a = [1, 2, 3] >>> fun_iter = iter(a) >>> next(fun_iter)

WWPD, Iter*

>>> a = [1, 2, 3] >>> fun_iter = iter(a) >>> next(fun_iter) 1

WWPD, Iter*

>>> a = [1, 2, 3] >>> fun_iter = iter(a) >>> next(fun_iter) 1 >>> next(fun_iter)

WWPD, Iter*

>>> a = [1, 2, 3] >>> fun_iter = iter(a) >>> next(fun_iter) 1 >>> next(fun_iter) 2

WWPD, Iter*

>>> a = [1, 2, 3] >>> fun_iter = iter(a) >>> next(fun_iter) 1 >>> next(fun_iter) 2 >>> unfun_iter = iter(fun_iter)

WWPD, Iter*

>>> a = [1, 2, 3] >>> fun_iter = iter(a) >>> next(fun_iter) 1 >>> next(fun_iter) 2 >>> unfun_iter = iter(fun_iter) >>> funner_iter = iter(a)

WWPD, Iter*

>>> a = [1, 2, 3] >>> fun_iter = iter(a) >>> next(fun_iter) 1 >>> next(fun_iter) 2 >>> unfun_iter = iter(fun_iter) >>> funner_iter = iter(a) >>> next(unfun_iter)

WWPD, Iter*

>>> a = [1, 2, 3] >>> fun_iter = iter(a) >>> next(fun_iter) 1 >>> next(fun_iter) 2 >>> unfun_iter = iter(fun_iter) >>> funner_iter = iter(a) >>> next(unfun_iter) 3

WWPD, Iter*

>>> a = [1, 2, 3] >>> fun_iter = iter(a) >>> next(fun_iter) 1 >>> next(fun_iter) 2 >>> unfun_iter = iter(fun_iter) >>> funner_iter = iter(a) >>> next(unfun_iter) 3 >>> next(fun_iter)

WWPD, Iter*

>>> a = [1, 2, 3] >>> fun_iter = iter(a) >>> next(fun_iter) 1 >>> next(fun_iter) 2 >>> unfun_iter = iter(fun_iter) >>> funner_iter = iter(a) >>> next(unfun_iter) 3 >>> next(fun_iter) StopIteration

WWPD, Iter*

>>> a = [1, 2, 3] >>> fun_iter = iter(a) >>> next(fun_iter) 1 >>> next(fun_iter) 2 >>> unfun_iter = iter(fun_iter) >>> funner_iter = iter(a) >>> next(unfun_iter) 3 >>> next(fun_iter) StopIteration >>> next(unfun_iter)

WWPD, Iter*

>>> a = [1, 2, 3] >>> fun_iter = iter(a) >>> next(fun_iter) 1 >>> next(fun_iter) 2 >>> unfun_iter = iter(fun_iter) >>> funner_iter = iter(a) >>> next(unfun_iter) 3 >>> next(fun_iter) StopIteration >>> next(unfun_iter) StopIteration

WWPD, Iter*

>>> a = [1, 2, 3] >>> fun_iter = iter(a) >>> next(fun_iter) 1 >>> next(fun_iter) 2 >>> unfun_iter = iter(fun_iter) >>> funner_iter = iter(a) >>> next(unfun_iter) 3 >>> next(fun_iter) StopIteration >>> next(unfun_iter) StopIteration >>> next(funner_iter)

WWPD, Iter*

>>> a = [1, 2, 3] >>> fun_iter = iter(a) >>> next(fun_iter) 1 >>> next(fun_iter) 2 >>> unfun_iter = iter(fun_iter) >>> funner_iter = iter(a) >>> next(unfun_iter) 3 >>> next(fun_iter) StopIteration >>> next(unfun_iter) StopIteration >>> next(funner_iter) 1

WWPD, Iter*

>>> a = [1, 2, 3] >>> fun_iter = iter(a) >>> next(fun_iter) 1 >>> next(fun_iter) 2 >>> unfun_iter = iter(fun_iter) >>> funner_iter = iter(a) >>> next(unfun_iter) 3 >>> next(fun_iter) StopIteration >>> next(unfun_iter) StopIteration >>> next(funner_iter) 1 >>> a

WWPD, Iter*

>>> a = [1, 2, 3] >>> fun_iter = iter(a) >>> next(fun_iter) 1 >>> next(fun_iter) 2 >>> unfun_iter = iter(fun_iter) >>> funner_iter = iter(a) >>> next(unfun_iter) 3 >>> next(fun_iter) StopIteration >>> next(unfun_iter) StopIteration >>> next(funner_iter) 1 >>> a [1, 2, 3]

Generators

how do you write your own iterators?

Generators

how do you write your own iterators?

Using a list

Generators

how do you write your own iterators?

Using a list

>>> fibs = [1, 1, 2, 3, 5, 8] >>> fib_iter = iter(fibs)

Generators

how do you write your own iterators?

Using a list

>>> fibs = [1, 1, 2, 3, 5, 8] >>> fib_iter = iter(fibs)

Two issues: 1) I have to calculate out values of fib myself 2) I can only make a finite iterator

Generators

how do you write your own iterators?

Using a list

>>> fibs = [1, 1, 2, 3, 5, 8] >>> fib_iter = iter(fibs)

Two issues: 1) I have to calculate out values of fib myself 2) I can only make a finite iterator

Using a generator

Generators

how do you write your own iterators?

Using a list

>>> fibs = [1, 1, 2, 3, 5, 8] >>> fib_iter = iter(fibs)

Two issues: 1) I have to calculate out values of fib myself 2) I can only make a finite iterator

Using a generator

>>> def fibs(): prev = 0 current = 1 while True： yield current current = current + prev prev = current

Generators

how do you write your own iterators?

Using a list

>>> fibs = [1, 1, 2, 3, 5, 8] >>> fib_iter = iter(fibs)

Two issues: 1) I have to calculate out values of fib myself 2) I can only make a finite iterator

Using a generator

>>> def fibs(): prev = 0 current = 1 while True： yield current current = current + prev prev = current >>> fib_iter = fibs()

Generators

how do you write your own iterators?

Using a list

>>> fibs = [1, 1, 2, 3, 5, 8] >>> fib_iter = iter(fibs)

Two issues: 1) I have to calculate out values of fib myself 2) I can only make a finite iterator

Using a generator

>>> def fibs(): prev = 0 current = 1 while True： yield current current = current + prev prev = current >>> fib_iter = fibs()

generator function

Generators

how do you write your own iterators?

Using a list

>>> fibs = [1, 1, 2, 3, 5, 8] >>> fib_iter = iter(fibs)

Two issues: 1) I have to calculate out values of fib myself 2) I can only make a finite iterator

Using a generator

>>> def fibs(): prev = 0 current = 1 while True： yield current current = current + prev prev = current >>> fib_iter = fibs()

generator function generator object (generator)

Everything Takes Time

Everything Takes Time

given the choice, we always want our programs to run faster

Everything Takes Time

but some things are inherently slower than others… given the choice, we always want our programs to run faster

Describing Runtime

Each operation(arithmetic, printing, changing variables) in a function takes

• time. To figure out how long a program

takes, we could count all these

• perations up.

Each operation(arithmetic, printing, changing variables) in a function takes

• time. To figure out how long a program

takes, we could count all these

• perations up.

how many operations?

Describing Runtime

Each operation(arithmetic, printing, changing variables) in a function takes

• time. To figure out how long a program

takes, we could count all these

• perations up.

But given larger and larger input sizes, functions will take longer. The question we are curious about is: How long does a function take, asymptotically, as input size gets really large? how many operations?

Describing Runtime

Describing Runtime

But given larger and larger input sizes, functions will take longer. The question we are curious about is: How long does a function take, asymptotically, as input size gets really large?

But given larger and larger input sizes, functions will take longer. The question we are curious about is: How long does a function take, asymptotically, as input size gets really large?

Describing Runtime

But given larger and larger input sizes, functions will take longer. The question we are curious about is: How long does a function take, asymptotically, as input size gets really large?

Describing Runtime

But given larger and larger input sizes, functions will take longer. The question we are curious about is: How long does a function take, asymptotically, as input size gets really large?

O(1) - constant!

Describing Runtime

But given larger and larger input sizes, functions will take longer. The question we are curious about is: How long does a function take, asymptotically, as input size gets really large?

O(1) - constant!

Describing Runtime

But given larger and larger input sizes, functions will take longer. The question we are curious about is: How long does a function take, asymptotically, as input size gets really large?

O(1) - constant! O ( n )

• l

i n e a r !

Describing Runtime

More OoG Examples!

Figure out the orders of growth of the following

• functions. Talk to the person next to you!

Drawing the graph out may help!

More OoG Examples!

Figure out the orders of growth of the following

• functions. Talk to the person next to you!

Drawing the graph out may help!

More OoG Examples!

Figure out the orders of growth of the following

• functions. Talk to the person next to you!

Drawing the graph out may help!

O(n

2

) - quadratic!

More OoG Examples!

Figure out the orders of growth of the following

• functions. Talk to the person next to you!

Drawing the graph out may help!

O(n

2

) - quadratic!

More OoG Examples!

Figure out the orders of growth of the following

• functions. Talk to the person next to you!

Drawing the graph out may help!

O(n

2

) - quadratic!

O(1) - constant time!? wow!!!

Now, the Rules

• 1. Eliminate Lower Order Terms

Keep this in mind: How long does a function take, asymptotically, as input size gets really large?

• 1. Eliminate Lower Order Terms

O(n2+n) = O(n2)

Keep this in mind: How long does a function take, asymptotically, as input size gets really large?

Now, the Rules

• 1. Eliminate Lower Order Terms

O(2n+n2+n) = O(2n)

Keep this in mind: How long does a function take, asymptotically, as input size gets really large?

O(n2+n) = O(n2)

Now, the Rules

• 1. Eliminate Lower Order Terms

O(2n+n2+n) = O(2n)

Keep this in mind: How long does a function take, asymptotically, as input size gets really large? Why?

O(n2+n) = O(n2)

Now, the Rules

• 1. Eliminate Lower Order Terms

O(2n+n2+n) = O(2n)

Keep this in mind: How long does a function take, asymptotically, as input size gets really large? Why?

What matters is the run time as n gets really large! What happens when n = 1000? n2 = 1,000,000 n = 1,000 Note than n2 is much bigger, and therefore

• utweighs in importance!

O(n2+n) = O(n2)

Now, the Rules

• 1. Eliminate Lower Order Terms
• 2. Ignore Constants

O(2n+n2+n) = O(2n)

Keep this in mind: How long does a function take, asymptotically, as input size gets really large? Why?

What matters is the run time as n gets really large! What happens when n = 1000? n2 = 1,000,000 n = 1,000 Note than n2 is much bigger, and therefore

• utweighs in importance!

O(500n) = O(n) O(n2+n) = O(n2)

Now, the Rules

• 1. Eliminate Lower Order Terms
• 2. Ignore Constants

O(2n+n2+n) = O(2n)

Keep this in mind: How long does a function take, asymptotically, as input size gets really large? Why?

What matters is the run time as n gets really large! What happens when n = 1000? n2 = 1,000,000 n = 1,000 Note than n2 is much bigger, and therefore

• utweighs in importance!

O(500n) = O(n)

Why?

O(n2+n) = O(n2)

Now, the Rules

• 1. Eliminate Lower Order Terms
• 2. Ignore Constants

O(2n+n2+n) = O(2n)

Keep this in mind: How long does a function take, asymptotically, as input size gets really large? Why?

What matters is the run time as n gets really large! What happens when n = 1000? n2 = 1,000,000 n = 1,000 Note than n2 is much bigger, and therefore

• utweighs in importance!

O(500n) = O(n)

Why?

Some computers are faster, some slower. In fact, it’s likely that Cori supercomputer at LBL is 1000x faster than your laptop. So if you wrote a function that ran in 1000n time, Cori would run it in 1 second and your computer would take 15 minutes for n = 1. But we really only care about the algorithm’s inherent growth, so eliminate constants!

O(n2+n) = O(n2)

Now, the Rules

Thanks for coming.

Have a great rest of your week! :)

Attendance: links.cs61a.org/albert-disc Slides: albertxu.xyz/teaching/cs61a/