This chapter is full of new things. Hang in there! If anything doesn't make sense now, don't worry: What we explain now will teach you important things we will use in another lesson.
Try each example in this lesson; what Python prints is an important part of the lesson.
Today we will show you how to work with lists. We will use square brackets a lot because that's how lists are created:
numbers = [1, 1, 2, 3, 5, 8, 13]
print(numbers)
A list is a value that can contain many other values.
Just like a string contains a sequence of characters,
a list contains a sequence of anything. Numbers, for example.
And just as we can use the for loop
to print strings character by character,
we can loop over list elements:
for number in numbers:
print(number)
Lists in programs are very common:
A file can be retrieved as a list of strings
line by line.
A list of strings like 7 ♥
and K ♣ can be used as a deck of cards.
Math is full of numerical lists and
each online service has a list of users.
The values in a list can be of any type, we can even mix different types in one list (even though we won't meet such mixed lists very often - they are more used in tuples, which we will tell you about later):
list = [1, 'abc', True, None, range(10), len]
print(list)
Yo already know the most basic operation with lists,
the for loop.
The second most important operation is picking
individual elements.
This works the same way as in strings: square brackets and
the element number. List elements are numbered from zero,
just as characters in strings; negative numbers indicate elements from the end.
print(numbers[2])
We use square brackets to access subsets. [Strings Chart] (naucse:page?lesson=beginners-en/str # slicing-diagram) shows you how to write the numbers when you want parts of the list:
print(numbers[2:-3])
An important feature of lists, that neither numbers nor strings
(nor True/False/None) have, is
that lists can be changed.
Numbers can't be changed - if you have a = 3 and
you write a = a + 1, the number 3 will not change.
A new number 4 will be calculated, and the variable a
will be set to this new number.
By contrast, lists can be changed without setting a variable to a new value.
The most basic way to change a list is to add elements
to its end, using the append method.
Doing this doesn't return anything (actually it returns None)
but it changes the list we are working on in place (append means
add to the end of the list). Try it:
prime_numbers = [2, 3, 5, 7, 11, 13, 17]
print(prime_numbers)
prime_numbers.append(19)
print(prime_numbers)
Such a value change can sometimes be surprising, because multiple variables can have the same value. Because the value itself changes, it may seem that the variable "changes without us touching it":
a = [1, 2, 3] # creates a list 'a'
b = a # no new list is created, 'b' just points to 'a'
# the list created in the first row now has two variable names: "a" and "b",
# but we are still working with just one and the same list:
print(b)
a.append(4)
print(b)
Apart from the append method that adds
only one element, there is also the extend method,
which can add more elements.
The elements to be added here are in the form of a list:
more_prime_nr = [23, 29, 31]
prime_numbers.extend(more_prime_nr)
print(primary)
The extend method can work with other
types of variables - it can work with anything on which
we can use a for loop: For example,
individual strings, rows of files, or numbers from range().
listA = []
listA.extend('abcdef')
listA.extend(range(10))
print(listA)
But enough adding. You can change individual elements of lists, simply by assigning a value to the element, as if it were a variable:
numbers = [1, 0, 3, 4]
numbers[1] = 2
print(numbers)
You can also assign new values to a sublist - in this case
the subset is replaced by the individual values we write.
Like with extend, you can replace the elements with anything
that works with for loops - list, string, range(), etc.
numbers = [1, 2, 3, 4]
numbers[1:-1] = [6, 5]
print(numbers)
We can also change the length of the list by replacing a sublist with fewer elements, or by removing some of the elements completely:
numbers = [1, 2, 3, 4]
numbers[1:-1] = [0, 0, 0, 0, 0]
print(numbers)
numbers[1:-1] = []
print(numbers)
This form of deleting elements is quite obscure,
therefore we have a special command named del.
It deletes everything that we tell it to - individual
elements, sublists and even variables!
numbers = [1, 2, 3, 4, 5, 6]
del numbers[-1]
print(numbers)
del numbers[3:5]
print(numbers)
del numbers
print(numbers)
Other deleting methods are:
pop, which removes and returns the last element in the list - for example, if
I have a list of cards in a deck, pop is like "drawing a card".remove, which finds the element in the list and removes it,clear, which clears the entire list.numbers = [1, 2, 3, 'abc', 4, 5, 6, 12]
last = numbers.pop()
print(last)
print(numbers)
numbers.remove('abc')
print(numbers)
numbers.clear()
print(numbers)
And we also have a sort method that sorts list elements.
listA = [4, 7, 8, 3, 5, 2, 4, 8, 5]
listA.sort()
print(listA)
In order to be sorted, the elements of the list must be
comparable - we have to be able to use the < operator with them.
A mixed list of numbers and strings cannot be sorted.
The operator < defines how exactly the elements will
be sorted (e.g., numbers by size; strings according to the special "alphabet"
where upper case is smaller than lower case, etc.).
The sort method has a reverse argument.
If you set it to True, it will sort the elements in backwards order.
The default value is False, so if you want the elements to be
sorted from smaller to larger, you don't have to specify this argument.
listA = [4, 7, 8, 3, 5, 2, 4, 8, 5]
listA.sort(reverse=True)
print(listA)
Lots of what we can do with strings, we can also do with lists. For example adding and multiplying:
melody = ['C', 'E', 'G'] * 2 + ['E', 'E', 'D', 'E', 'F', 'D'] * 2 + ['E', 'D', 'C']
print(melody)
As with strings, the list can be added only to other lists
Other known methods are len, count, andindex,
and the in operator.
print(len(melody)) # Length of the list
print(melody.count('E')) # How many 'E's are in the list?
print(melodie.index('E')) # Position of the first 'E'
print('E' in melody) # Is 'E' in the list?
The last three methods work a little bit differently:
for strings they are work on substrings,
for lists they work on individual elements.
So although our melody contains the elements
D and E next to each other, DE is not in the list:
print('DE' in melody)
print(melody.count('DE'))
print(melody.index('DE'))
A list can be used in an if (orwhile) statement
which is true while there is something in that list.
In other words, list is an 'abbreviation' for len(list) > 0.
if list:
print ('There is something in the list!')
else:
print ('The list is empty!')
Strings can be used similarly. And even numbers - the condition is True if they are not zero.
Just like the int function converts values to
integers and str converts values to strings,
the list function converts values to a list.
As an argument, we can give it any value,
which can be processed by a for loop.
A string will turn into a list of characters, a file
will turn into a list of rows, a range will turn
into a list of numbers.
alphabet = list('abcdefghijklmnopqrstuvwxyz')
numbers = list(range(100))
print(alphabet)
print(numbers)
The list function can also create a list from a list.
It may sound useless, but it isn't - it creates a new list that
is not dependent on the old list.
It will contain the same elements in the same order,
but it will not be the same list:
You can change it independently of the old one.
a = [1, 2, 3]
b = list(a)
print(b)
a.append(4)
print(b)
Another way to create lists
(especially more complex lists) is to first make an empty
list, and then fill it up using the append function.
For example, if you want a list with numbers that are
powers of two, pass the numbers into a for loop, and
for each number, add the appropriate power to the list:
power_of_two = []
for number in range (10):
power_of_two.append (2 ** number)
print(power_of_two)
If you want a list that represents a deck of cards,
call append for all combinations of color and value.
deck = []
for color in '♠', '♥', '♦', '♣': # (Use text names on Windows)
for value in list(range(2, 11)) + ['J', 'Q', 'K', 'A']:
deck.append(str(value) + color)
print(deck)
Lists and strings are types of "sequences",
so it is not surprising that they can be converted
from one type to another.
The list function creates a list of characters from a string.
If we want to get a list of words, we use the split method on a sentence:
words = 'This sentence is complex, split it into words!'.split()
print(words)
The split method can also take an argument.
If we pass it a separator character, the string is "cut"
at this given separator, instead of at spaces (and new lines).
So, when we have some data separated by commas,
there is nothing easier than using split with a comma argument:
records = '3A, 8B, 2E, 9D'.split(',')
print(records)
If we want to join a list of strings into
a single string, we use the method join.
Note that this method is called on the delimiter character that we want to use
between the elements of a list, and as an argument, it takes the list.
sentence = ' '.join(words)
print(sentence)
Imagine that users enter their names and surnames, and you store them in a list for future use, for instance, student records. Not all users are careful when entering their names, so the names can appear with incorrectly capitalized letters. For example:
records = ['john doe', 'John Smith', 'Stuart little', 'petr File']
Your task is:
The result should look like this:
records = ['john doe', 'John Smith', 'Stuart little', 'petr File']
error_entries = select_errors(records)
print(error_entries) # → ['john doe', 'Stuart little', 'petr File']
ok_entries = select_correct(records)
print(ok_entries) # → ['John Smith']
corected_entries = correct_entries(records)
print(corected_entries) # → ['John Doe', 'John Smith', 'Stuart Little', 'Petr File']
An easy way to find out if the string is written in lower case,
is the islower() method, which returns True if the string contains only lower
case letters, otherwise it returns False. For example, 'abc'.islower() == True but
'aBc'.islower() == False.
The easiest way to convert first letters to upper case is capitalize():
'abc'.capitalize() == 'Abc'
The random module contains two functions that can be used with lists.
First, the shuffle function shuffles elements - all elements are left in a random order.
Just like sort, shuffle does not return anything.
import random
deck = []
for color in '♠', '♥', '♦', '♣':
for value in list(range(2, 11)) + ['J', 'Q', 'K', 'A']:
deck.append(str(value) + color)
print(deck)
random.shuffle(deck)
print(deck)
The second one is the choice function that selects a random element from the list.
Using a list, it's much easier to implement rock/paper/scissors:
import random
possibilities = ['rock', 'scissors', 'paper']
pc_choice = random.choice(possibilities)
In the beginning of this lesson we said that a list can contain any type of value. A list can even contain other lists:
list_of_lists = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Such a list behaves as expected - we can choose elements (which are, of course, lists):
first_list = list_of_lista[0]
print(first_list)
And since elements are themselves lists, we can talk about elements like "the first element of the second list":
second_list = list_of_lists[1]
first_element_of_second_list = second_list[0]
print(first_element_of_second_list)
And because list_of_lists[1]
indicates the list, we can take the elements directly from it:
first_element_of_second_list = (list_of_list[1])[0]
Or:
first_element_of_second_list = list_of_list[1][0]
This approach is quite useful.
Same as nested for loops
allowed us to list a table, nested lists
allow us to store a table.
def create_tab(size=11):
row_list = []
for a in range(size):
row = []
for b in range(size):
row.append(a * b)
row_list.append(row)
return row_list
multiplication_tab = create_tab()
print(multiplication_tab[2][3]) # two times three
print(multiplication_tab[5][2]) # five times two
print(multiplication_tab[8][7]) # eight times seven
# List the entire table
for row in multiplication_tab:
for number in row:
print(number, end = '')
print()
What can we do with such a stored table? For example, you can save the positions of figures on a chessboard, or of the crosses and circles in a 2D tictactoe.
{
"data": {
"sessionMaterial": {
"id": "session-material:2018/pyladies-en-prague:list:0",
"title": "Lists",
"html": "\n \n \n\n <p>This chapter is full of new things. Hang in there! \nIf anything doesn't make sense now, don't worry:\nWhat we explain now will teach you important\nthings we will use in another lesson.</p>\n<p>Try each example in this lesson;\nwhat Python prints is an important part of the lesson.</p>\n<h1>Lists</h1>\n<p>Today we will show you how to work with <em>lists</em>.\nWe will use square brackets a lot because that's how lists are created:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">numbers</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">,</span> <span class=\"mi\">8</span><span class=\"p\">,</span> <span class=\"mi\">13</span><span class=\"p\">]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">numbers</span><span class=\"p\">)</span>\n</pre></div><p>A list is a value that can contain many other values.\nJust like a string contains a sequence of characters,\na list contains a sequence of anything. Numbers, for example.\nAnd just as we can use the <code>for</code> loop\nto print strings character by character,\nwe can loop over list elements:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">for</span> <span class=\"n\">number</span> <span class=\"ow\">in</span> <span class=\"n\">numbers</span><span class=\"p\">:</span>\n <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">number</span><span class=\"p\">)</span>\n</pre></div><p>Lists in programs are very common:\nA file can be retrieved as a list of strings\nline by line.\nA list of strings like <code>7 ♥</code>\nand <code>K ♣</code> can be used as a deck of cards.\nMath is full of numerical lists and\neach online service has a list of users.</p>\n<p>The values ​​in a list can be of any type,\nwe can even mix different types in one list\n(even though we won't meet such mixed lists\nvery often - they are more used in tuples,\nwhich we will tell you about later):</p>\n<div class=\"highlight\"><pre><span></span><span class=\"nb\">list</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"s1\">'abc'</span><span class=\"p\">,</span> <span class=\"bp\">True</span><span class=\"p\">,</span> <span class=\"bp\">None</span><span class=\"p\">,</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"mi\">10</span><span class=\"p\">),</span> <span class=\"nb\">len</span><span class=\"p\">]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"nb\">list</span><span class=\"p\">)</span>\n</pre></div><h2>Selection from lists</h2>\n<p>Yo already know the most basic operation with lists, \nthe <code>for</code> loop.\nThe second most important operation is picking\nindividual elements.\nThis works the same way as in strings: square brackets and\nthe element number. List elements are numbered from zero, \njust as characters in strings; negative numbers indicate elements from the end.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">numbers</span><span class=\"p\">[</span><span class=\"mi\">2</span><span class=\"p\">])</span>\n</pre></div><p>We use square brackets to access subsets.\n[Strings Chart] (naucse:page?lesson=beginners-en/str # slicing-diagram)\nshows you how to write the numbers when you want parts of the list:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">numbers</span><span class=\"p\">[</span><span class=\"mi\">2</span><span class=\"p\">:</span><span class=\"o\">-</span><span class=\"mi\">3</span><span class=\"p\">])</span>\n</pre></div><h2>Changing lists</h2>\n<p>An important feature of lists, that neither numbers nor strings\n(nor <code>True</code>/<code>False</code>/<code>None</code>) have, is\nthat lists can be changed.</p>\n<p>Numbers can't be changed - if you have <code>a = 3</code> and\nyou write <code>a = a + 1</code>, the number <code>3</code> will not change.\nA new number <code>4</code> will be calculated, and the variable <code>a</code>\nwill be set to this new number.</p>\n<p>By contrast, lists can be changed without setting a variable to a new value.\nThe most basic way to change a list is to add elements\nto its end, using the <code>append</code> method.\nDoing this doesn't return <em>anything</em> (actually it returns <code>None</code>)\nbut it changes the list we are working on <em>in place</em> (<code>append</code> means \nadd to <em>the end</em> of the list). Try it:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">prime_numbers</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">,</span> <span class=\"mi\">7</span><span class=\"p\">,</span> <span class=\"mi\">11</span><span class=\"p\">,</span> <span class=\"mi\">13</span><span class=\"p\">,</span> <span class=\"mi\">17</span><span class=\"p\">]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">prime_numbers</span><span class=\"p\">)</span>\n<span class=\"n\">prime_numbers</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"mi\">19</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">prime_numbers</span><span class=\"p\">)</span>\n</pre></div><p>Such a value change can sometimes be surprising,\nbecause multiple variables can have the same value.\nBecause the value itself changes, it may seem\nthat the variable "changes without us touching it":</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">a</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">]</span> <span class=\"c1\"># creates a list 'a'</span>\n<span class=\"n\">b</span> <span class=\"o\">=</span> <span class=\"n\">a</span> <span class=\"c1\"># no new list is created, 'b' just points to 'a'</span>\n\n<span class=\"c1\"># the list created in the first row now has two variable names: "a" and "b",</span>\n<span class=\"c1\"># but we are still working with just one and the same list:</span>\n\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">b</span><span class=\"p\">)</span>\n<span class=\"n\">a</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"mi\">4</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">b</span><span class=\"p\">)</span>\n</pre></div><h2>More ways to edit lists</h2>\n<p>Apart from the <code>append</code> method that adds\nonly one element, there is also the <code>extend</code> method,\nwhich can add more elements.\nThe elements to be added here are in the form of a list:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">more_prime_nr</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">23</span><span class=\"p\">,</span> <span class=\"mi\">29</span><span class=\"p\">,</span> <span class=\"mi\">31</span><span class=\"p\">]</span>\n<span class=\"n\">prime_numbers</span><span class=\"o\">.</span><span class=\"n\">extend</span><span class=\"p\">(</span><span class=\"n\">more_prime_nr</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">primary</span><span class=\"p\">)</span>\n</pre></div><p>The <code>extend</code> method can work with other\ntypes of variables - it can work with anything on which\nwe can use a <code>for</code> loop: For example,\nindividual strings, rows of files, or numbers from <code>range()</code>.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">listA</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n<span class=\"n\">listA</span><span class=\"o\">.</span><span class=\"n\">extend</span><span class=\"p\">(</span><span class=\"s1\">'abcdef'</span><span class=\"p\">)</span>\n<span class=\"n\">listA</span><span class=\"o\">.</span><span class=\"n\">extend</span><span class=\"p\">(</span><span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"mi\">10</span><span class=\"p\">))</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">listA</span><span class=\"p\">)</span>\n</pre></div><h2>Changing elements</h2>\n<p>But enough adding.\nYou can change individual elements of lists,\nsimply by assigning a value to the element,\nas if it were a variable:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">numbers</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">]</span>\n<span class=\"n\">numbers</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"mi\">2</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">numbers</span><span class=\"p\">)</span>\n</pre></div><p>You can also assign new values to a sublist - in this case\nthe subset is replaced by the individual values we write.\nLike with <code>extend</code>, you can replace the elements with anything \nthat works with <code>for</code> loops - list, string, <code>range()</code>, etc.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">numbers</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">]</span>\n<span class=\"n\">numbers</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">:</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">6</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">numbers</span><span class=\"p\">)</span>\n</pre></div><h2>Deleting elements</h2>\n<p>We can also change the length of the\nlist by replacing a sublist with fewer elements,\nor by removing some of the elements completely:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">numbers</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">]</span>\n<span class=\"n\">numbers</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">:</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">0</span><span class=\"p\">]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">numbers</span><span class=\"p\">)</span>\n<span class=\"n\">numbers</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">:</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">numbers</span><span class=\"p\">)</span>\n</pre></div><p>This form of deleting elements is quite obscure,\ntherefore we have a special command named <code>del</code>.\nIt deletes everything that we tell it to - individual\nelements, sublists and even variables!</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">numbers</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">,</span> <span class=\"mi\">6</span><span class=\"p\">]</span>\n<span class=\"k\">del</span> <span class=\"n\">numbers</span><span class=\"p\">[</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">numbers</span><span class=\"p\">)</span>\n<span class=\"k\">del</span> <span class=\"n\">numbers</span><span class=\"p\">[</span><span class=\"mi\">3</span><span class=\"p\">:</span><span class=\"mi\">5</span><span class=\"p\">]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">numbers</span><span class=\"p\">)</span>\n<span class=\"k\">del</span> <span class=\"n\">numbers</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">numbers</span><span class=\"p\">)</span>\n</pre></div><p>Other deleting methods are:</p>\n<ul>\n<li><code>pop</code>, which removes <em>and returns</em> the last element in the list - for example, if\n  I have a list of cards in a deck, <code>pop</code> is like "drawing a card".</li>\n<li><code>remove</code>, which finds the element in the list and removes it,</li>\n<li><code>clear</code>, which clears the entire list.</li>\n</ul>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">numbers</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"s1\">'abc'</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">,</span> <span class=\"mi\">6</span><span class=\"p\">,</span> <span class=\"mi\">12</span><span class=\"p\">]</span>\n<span class=\"n\">last</span> <span class=\"o\">=</span> <span class=\"n\">numbers</span><span class=\"o\">.</span><span class=\"n\">pop</span><span class=\"p\">()</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">last</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">numbers</span><span class=\"p\">)</span>\n\n<span class=\"n\">numbers</span><span class=\"o\">.</span><span class=\"n\">remove</span><span class=\"p\">(</span><span class=\"s1\">'abc'</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">numbers</span><span class=\"p\">)</span>\n\n<span class=\"n\">numbers</span><span class=\"o\">.</span><span class=\"n\">clear</span><span class=\"p\">()</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">numbers</span><span class=\"p\">)</span>\n</pre></div><h2>Sorting</h2>\n<p>And we also have a <code>sort</code> method that sorts list elements.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">listA</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">4</span><span class=\"p\">,</span> <span class=\"mi\">7</span><span class=\"p\">,</span> <span class=\"mi\">8</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">,</span> <span class=\"mi\">8</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">]</span>\n<span class=\"n\">listA</span><span class=\"o\">.</span><span class=\"n\">sort</span><span class=\"p\">()</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">listA</span><span class=\"p\">)</span>\n</pre></div><p>In order to be sorted, the elements of the list must be\n<em>comparable</em> - we have to be able to use the <code><</code> operator with them.\nA mixed list of numbers and strings cannot be sorted.\nThe operator <code><</code> defines how exactly the elements will\nbe sorted (e.g., numbers by size; strings according to the special "alphabet"\nwhere upper case is smaller than lower case, etc.).</p>\n<p>The <code>sort</code> method has a <code>reverse</code> argument. \nIf you set it to <em>True</em>, it will sort the elements in backwards order.\nThe default value is <em>False</em>, so if you want the elements to be\nsorted from smaller to larger, you don't have to specify this argument.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">listA</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">4</span><span class=\"p\">,</span> <span class=\"mi\">7</span><span class=\"p\">,</span> <span class=\"mi\">8</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">4</span><span class=\"p\">,</span> <span class=\"mi\">8</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">]</span>\n<span class=\"n\">listA</span><span class=\"o\">.</span><span class=\"n\">sort</span><span class=\"p\">(</span><span class=\"n\">reverse</span><span class=\"o\">=</span><span class=\"bp\">True</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">listA</span><span class=\"p\">)</span>\n</pre></div><h2>Other methods</h2>\n<p>Lots of what we can do with strings, we can also do with lists.\nFor example adding and multiplying:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">melody</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"s1\">'C'</span><span class=\"p\">,</span> <span class=\"s1\">'E'</span><span class=\"p\">,</span> <span class=\"s1\">'G'</span><span class=\"p\">]</span> <span class=\"o\">*</span> <span class=\"mi\">2</span> <span class=\"o\">+</span> <span class=\"p\">[</span><span class=\"s1\">'E'</span><span class=\"p\">,</span> <span class=\"s1\">'E'</span><span class=\"p\">,</span> <span class=\"s1\">'D'</span><span class=\"p\">,</span> <span class=\"s1\">'E'</span><span class=\"p\">,</span> <span class=\"s1\">'F'</span><span class=\"p\">,</span> <span class=\"s1\">'D'</span><span class=\"p\">]</span> <span class=\"o\">*</span> <span class=\"mi\">2</span> <span class=\"o\">+</span> <span class=\"p\">[</span><span class=\"s1\">'E'</span><span class=\"p\">,</span> <span class=\"s1\">'D'</span><span class=\"p\">,</span> <span class=\"s1\">'C'</span><span class=\"p\">]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">melody</span><span class=\"p\">)</span>\n</pre></div><p>As with strings, the list can be added only to other lists</p>\n<ul>\n<li>not to a string or to a number.</li>\n</ul>\n<p>Other known methods are <code>len</code>, <code>count</code>, and<code>index</code>,\nand the <code>in</code> operator.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">melody</span><span class=\"p\">))</span> <span class=\"c1\"># Length of the list</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">melody</span><span class=\"o\">.</span><span class=\"n\">count</span><span class=\"p\">(</span><span class=\"s1\">'E'</span><span class=\"p\">))</span> <span class=\"c1\"># How many 'E's are in the list?</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">melodie</span><span class=\"o\">.</span><span class=\"n\">index</span><span class=\"p\">(</span><span class=\"s1\">'E'</span><span class=\"p\">))</span> <span class=\"c1\"># Position of the first 'E'</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'E'</span> <span class=\"ow\">in</span> <span class=\"n\">melody</span><span class=\"p\">)</span> <span class=\"c1\"># Is 'E' in the list?</span>\n</pre></div><p>The last three methods work a little bit differently:\nfor strings they are work on <em>substrings</em>,\nfor lists they work on <em>individual</em> elements.\nSo although our melody contains the elements\n<code>D</code> and <code>E</code> next to each other, <code>DE</code> is not in the list:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">'DE'</span> <span class=\"ow\">in</span> <span class=\"n\">melody</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">melody</span><span class=\"o\">.</span><span class=\"n\">count</span><span class=\"p\">(</span><span class=\"s1\">'DE'</span><span class=\"p\">))</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">melody</span><span class=\"o\">.</span><span class=\"n\">index</span><span class=\"p\">(</span><span class=\"s1\">'DE'</span><span class=\"p\">))</span>\n</pre></div><h2>A list as a condition</h2>\n<p>A list can be used in an <code>if</code> (or<code>while</code>) statement\nwhich is true while there is something in that list.\nIn other words, <code>list</code> is an 'abbreviation' for <code>len(list) > 0</code>.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">if</span> <span class=\"nb\">list</span><span class=\"p\">:</span>\n <span class=\"k\">print</span> <span class=\"p\">(</span><span class=\"s1\">'There is something in the list!'</span><span class=\"p\">)</span>\n<span class=\"k\">else</span><span class=\"p\">:</span>\n <span class=\"k\">print</span> <span class=\"p\">(</span><span class=\"s1\">'The list is empty!'</span><span class=\"p\">)</span>\n</pre></div><p>Strings can be used similarly.\nAnd even numbers - the condition is <em>True</em> if they are not zero.</p>\n<h2>Creating lists</h2>\n<p>Just like the <code>int</code> function converts values to\nintegers and <code>str</code> converts values to strings,\nthe <code>list</code> function converts values to a list.\nAs an argument, we can give it any value,\nwhich can be processed by a <code>for</code> loop.\nA string will turn into a list of characters, a file\nwill turn into a list of rows, a <code>range</code> will turn \ninto a list of numbers.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">alphabet</span> <span class=\"o\">=</span> <span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"s1\">'abcdefghijklmnopqrstuvwxyz'</span><span class=\"p\">)</span>\n<span class=\"n\">numbers</span> <span class=\"o\">=</span> <span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"mi\">100</span><span class=\"p\">))</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">alphabet</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">numbers</span><span class=\"p\">)</span>\n</pre></div><p>The <code>list</code> function can also create a list from a list.\nIt may sound useless, but it isn't - it creates a <em>new</em> list that\nis not dependent on the old list.\nIt will contain the same elements in the same order,\nbut it will not be the same list:\nYou can change it independently of the old one.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">a</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">]</span>\n<span class=\"n\">b</span> <span class=\"o\">=</span> <span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"n\">a</span><span class=\"p\">)</span>\n\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">b</span><span class=\"p\">)</span>\n<span class=\"n\">a</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"mi\">4</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">b</span><span class=\"p\">)</span>\n</pre></div><p>Another way to create lists\n(especially more complex lists) is to first make an empty\nlist, and then fill it up using the <code>append</code> function.\nFor example, if you want a list with numbers that are\npowers of two, pass the numbers into a <code>for</code> loop, and \nfor each number, add the appropriate power to the list:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">power_of_two</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n<span class=\"k\">for</span> <span class=\"n\">number</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span> <span class=\"p\">(</span><span class=\"mi\">10</span><span class=\"p\">):</span>\n <span class=\"n\">power_of_two</span><span class=\"o\">.</span><span class=\"n\">append</span> <span class=\"p\">(</span><span class=\"mi\">2</span> <span class=\"o\">**</span> <span class=\"n\">number</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">power_of_two</span><span class=\"p\">)</span>\n</pre></div><p>If you want a list that represents a deck of cards,\ncall <code>append</code> for all combinations of color and value.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">deck</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n<span class=\"k\">for</span> <span class=\"n\">color</span> <span class=\"ow\">in</span> <span class=\"s1\">'♠'</span><span class=\"p\">,</span> <span class=\"s1\">'♥'</span><span class=\"p\">,</span> <span class=\"s1\">'♦'</span><span class=\"p\">,</span> <span class=\"s1\">'♣'</span><span class=\"p\">:</span> <span class=\"c1\"># (Use text names on Windows)</span>\n <span class=\"k\">for</span> <span class=\"n\">value</span> <span class=\"ow\">in</span> <span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">11</span><span class=\"p\">))</span> <span class=\"o\">+</span> <span class=\"p\">[</span><span class=\"s1\">'J'</span><span class=\"p\">,</span> <span class=\"s1\">'Q'</span><span class=\"p\">,</span> <span class=\"s1\">'K'</span><span class=\"p\">,</span> <span class=\"s1\">'A'</span><span class=\"p\">]:</span>\n <span class=\"n\">deck</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"nb\">str</span><span class=\"p\">(</span><span class=\"n\">value</span><span class=\"p\">)</span> <span class=\"o\">+</span> <span class=\"n\">color</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">deck</span><span class=\"p\">)</span>\n</pre></div><h2>Lists and Strings</h2>\n<p>Lists and strings are types of "sequences",\nso it is not surprising that they can be converted\nfrom one type to another.\nThe <code>list</code> function creates a list of characters from a string.\nIf we want to get a list of words, we use the <code>split</code> method on a sentence:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">words</span> <span class=\"o\">=</span> <span class=\"s1\">'This sentence is complex, split it into words!'</span><span class=\"o\">.</span><span class=\"n\">split</span><span class=\"p\">()</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">words</span><span class=\"p\">)</span>\n</pre></div><p>The <code>split</code> method can also take an argument.\nIf we pass it a separator character, the string is "cut" \nat this given separator, instead of at spaces (and new lines).\nSo, when we have some data separated by commas,\nthere is nothing easier than using <code>split</code> with a comma argument:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">records</span> <span class=\"o\">=</span> <span class=\"s1\">'3A, 8B, 2E, 9D'</span><span class=\"o\">.</span><span class=\"n\">split</span><span class=\"p\">(</span><span class=\"s1\">','</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">records</span><span class=\"p\">)</span>\n</pre></div><p>If we want to join a list of strings into\na single string, we use the method <code>join</code>.\nNote that this method is called on the <em>delimiter</em> character that we want to use\nbetween the elements of a list, and as an argument, it takes the list.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">sentence</span> <span class=\"o\">=</span> <span class=\"s1\">' '</span><span class=\"o\">.</span><span class=\"n\">join</span><span class=\"p\">(</span><span class=\"n\">words</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">sentence</span><span class=\"p\">)</span>\n</pre></div><h2>Task</h2>\n<p>Imagine that users enter their names and surnames, and you store them in\na list for future use, for instance, student records. \nNot all users are careful when entering their names,\nso the names can appear with incorrectly capitalized letters.\nFor example:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">records</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"s1\">'john doe'</span><span class=\"p\">,</span> <span class=\"s1\">'John Smith'</span><span class=\"p\">,</span> <span class=\"s1\">'Stuart little'</span><span class=\"p\">,</span> <span class=\"s1\">'petr File'</span><span class=\"p\">]</span>\n</pre></div><p>Your task is:</p>\n<ul>\n<li>Write a function that selects only those correctly entered entries where\nthe first letters of the first name and last name are capitalized.</li>\n<li>Write a function that selects only the incorrectly entered records.</li>\n<li><em>(Optional)</em> - Write a function that returns a list with corrected records.</li>\n</ul>\n<p>The result should look like this:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">records</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"s1\">'john doe'</span><span class=\"p\">,</span> <span class=\"s1\">'John Smith'</span><span class=\"p\">,</span> <span class=\"s1\">'Stuart little'</span><span class=\"p\">,</span> <span class=\"s1\">'petr File'</span><span class=\"p\">]</span>\n\n<span class=\"n\">error_entries</span> <span class=\"o\">=</span> <span class=\"n\">select_errors</span><span class=\"p\">(</span><span class=\"n\">records</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">error_entries</span><span class=\"p\">)</span> <span class=\"c1\"># → ['john doe', 'Stuart little', 'petr File']</span>\n\n<span class=\"n\">ok_entries</span> <span class=\"o\">=</span> <span class=\"n\">select_correct</span><span class=\"p\">(</span><span class=\"n\">records</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">ok_entries</span><span class=\"p\">)</span> <span class=\"c1\"># → ['John Smith']</span>\n\n<span class=\"n\">corected_entries</span> <span class=\"o\">=</span> <span class=\"n\">correct_entries</span><span class=\"p\">(</span><span class=\"n\">records</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">corected_entries</span><span class=\"p\">)</span> <span class=\"c1\"># → ['John Doe', 'John Smith', 'Stuart Little', 'Petr File']</span>\n</pre></div><div class=\"admonition note\"><p>An easy way to find out if the string is written in lower case,\nis the <code>islower()</code> method, which returns True if the string contains only lower\ncase letters, otherwise it returns False. For example, <code>'abc'.islower() == True</code> but\n<code>'aBc'.islower() == False</code>.</p>\n<p>The easiest way to convert first letters to upper case is <code>capitalize()</code>:\n<code>'abc'.capitalize() == 'Abc'</code></p>\n</div><div class=\"solution\" id=\"solution-0\">\n <h3>Řešení</h3>\n <div class=\"solution-cover\">\n <a href=\"/2018/pyladies-en-prague/beginners-en/list/index/solutions/0/\"><span class=\"link-text\">Ukázat řešení</span></a>\n </div>\n <div class=\"solution-body\" aria-hidden=\"true\">\n <div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">select_errors</span><span class=\"p\">(</span><span class=\"n\">listA</span><span class=\"p\">):</span>\n <span class=\"n\">result</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n <span class=\"k\">for</span> <span class=\"n\">record</span> <span class=\"ow\">in</span> <span class=\"n\">listA</span><span class=\"p\">:</span>\n <span class=\"n\">name_surname</span> <span class=\"o\">=</span> <span class=\"n\">record</span><span class=\"o\">.</span><span class=\"n\">split</span><span class=\"p\">(</span><span class=\"s1\">' '</span><span class=\"p\">)</span>\n <span class=\"n\">name</span> <span class=\"o\">=</span> <span class=\"n\">name_surname</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n <span class=\"n\">surname</span> <span class=\"o\">=</span> <span class=\"n\">name_surname</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">]</span>\n <span class=\"k\">if</span> <span class=\"n\">name</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span><span class=\"o\">.</span><span class=\"n\">islower</span><span class=\"p\">()</span> <span class=\"ow\">or</span> <span class=\"n\">surname</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span><span class=\"o\">.</span><span class=\"n\">islower</span><span class=\"p\">():</span>\n <span class=\"n\">result</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">record</span><span class=\"p\">)</span>\n <span class=\"k\">return</span> <span class=\"n\">result</span>\n\n<span class=\"k\">def</span> <span class=\"nf\">select_correct</span><span class=\"p\">(</span><span class=\"n\">listA</span><span class=\"p\">):</span>\n <span class=\"n\">result</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n <span class=\"k\">for</span> <span class=\"n\">record</span> <span class=\"ow\">in</span> <span class=\"n\">listA</span><span class=\"p\">:</span>\n <span class=\"n\">name_surname</span> <span class=\"o\">=</span> <span class=\"n\">record</span><span class=\"o\">.</span><span class=\"n\">split</span><span class=\"p\">(</span><span class=\"s1\">' '</span><span class=\"p\">)</span>\n <span class=\"n\">name</span> <span class=\"o\">=</span> <span class=\"n\">name_surname</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n <span class=\"n\">surname</span> <span class=\"o\">=</span> <span class=\"n\">name_surname</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">]</span>\n <span class=\"k\">if</span> <span class=\"ow\">not</span> <span class=\"n\">name</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span><span class=\"o\">.</span><span class=\"n\">islower</span><span class=\"p\">()</span> <span class=\"ow\">and</span> <span class=\"ow\">not</span> <span class=\"n\">surname</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span><span class=\"o\">.</span><span class=\"n\">islower</span><span class=\"p\">():</span>\n <span class=\"n\">result</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">record</span><span class=\"p\">)</span>\n <span class=\"k\">return</span> <span class=\"n\">result</span>\n\n<span class=\"k\">def</span> <span class=\"nf\">correct_entries</span><span class=\"p\">(</span><span class=\"n\">listA</span><span class=\"p\">):</span>\n <span class=\"n\">result</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n <span class=\"k\">for</span> <span class=\"n\">record</span> <span class=\"ow\">in</span> <span class=\"n\">listA</span><span class=\"p\">:</span>\n <span class=\"n\">name_surname</span> <span class=\"o\">=</span> <span class=\"n\">record</span><span class=\"o\">.</span><span class=\"n\">split</span><span class=\"p\">(</span><span class=\"s1\">' '</span><span class=\"p\">)</span>\n <span class=\"n\">name</span> <span class=\"o\">=</span> <span class=\"n\">name_surname</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n <span class=\"n\">surname</span> <span class=\"o\">=</span> <span class=\"n\">name_surname</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">]</span>\n <span class=\"n\">result</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">name</span><span class=\"o\">.</span><span class=\"n\">capitalize</span><span class=\"p\">()</span> <span class=\"o\">+</span> <span class=\"s1\">' '</span> <span class=\"o\">+</span> <span class=\"n\">surname</span><span class=\"o\">.</span><span class=\"n\">capitalize</span><span class=\"p\">())</span>\n <span class=\"k\">return</span> <span class=\"n\">result</span>\n</pre></div>\n </div>\n</div><h2>Lists and random</h2>\n<p>The <code>random</code> module contains two functions that can be used with lists.</p>\n<p>First, the <code>shuffle</code> function shuffles elements - all elements are left in a random order.\nJust like <code>sort</code>, <code>shuffle</code> does not return anything.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"kn\">import</span> <span class=\"nn\">random</span>\n\n<span class=\"n\">deck</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n<span class=\"k\">for</span> <span class=\"n\">color</span> <span class=\"ow\">in</span> <span class=\"s1\">'♠'</span><span class=\"p\">,</span> <span class=\"s1\">'♥'</span><span class=\"p\">,</span> <span class=\"s1\">'♦'</span><span class=\"p\">,</span> <span class=\"s1\">'♣'</span><span class=\"p\">:</span>\n <span class=\"k\">for</span> <span class=\"n\">value</span> <span class=\"ow\">in</span> <span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">11</span><span class=\"p\">))</span> <span class=\"o\">+</span> <span class=\"p\">[</span><span class=\"s1\">'J'</span><span class=\"p\">,</span> <span class=\"s1\">'Q'</span><span class=\"p\">,</span> <span class=\"s1\">'K'</span><span class=\"p\">,</span> <span class=\"s1\">'A'</span><span class=\"p\">]:</span>\n <span class=\"n\">deck</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"nb\">str</span><span class=\"p\">(</span><span class=\"n\">value</span><span class=\"p\">)</span> <span class=\"o\">+</span> <span class=\"n\">color</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">deck</span><span class=\"p\">)</span>\n\n<span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">shuffle</span><span class=\"p\">(</span><span class=\"n\">deck</span><span class=\"p\">)</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">deck</span><span class=\"p\">)</span>\n</pre></div><p>The second one is the <code>choice</code> function that selects a random element from the list.\nUsing a list, it's much easier to implement rock/paper/scissors:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"kn\">import</span> <span class=\"nn\">random</span>\n<span class=\"n\">possibilities</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"s1\">'rock'</span><span class=\"p\">,</span> <span class=\"s1\">'scissors'</span><span class=\"p\">,</span> <span class=\"s1\">'paper'</span><span class=\"p\">]</span>\n<span class=\"n\">pc_choice</span> <span class=\"o\">=</span> <span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">choice</span><span class=\"p\">(</span><span class=\"n\">possibilities</span><span class=\"p\">)</span>\n</pre></div><h2>Nested lists</h2>\n<p>In the beginning of this lesson we said that a list\ncan contain any type of value.\nA list can even contain other lists:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">list_of_lists</span> <span class=\"o\">=</span> <span class=\"p\">[[</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"mi\">3</span><span class=\"p\">],</span> <span class=\"p\">[</span><span class=\"mi\">4</span><span class=\"p\">,</span> <span class=\"mi\">5</span><span class=\"p\">,</span> <span class=\"mi\">6</span><span class=\"p\">],</span> <span class=\"p\">[</span><span class=\"mi\">7</span><span class=\"p\">,</span> <span class=\"mi\">8</span><span class=\"p\">,</span> <span class=\"mi\">9</span><span class=\"p\">]]</span>\n</pre></div><p>Such a list behaves as expected - we can choose\nelements (which are, of course, lists):</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">first_list</span> <span class=\"o\">=</span> <span class=\"n\">list_of_lista</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">first_list</span><span class=\"p\">)</span>\n</pre></div><p>And since elements are themselves lists,\nwe can talk about elements like "the first element of the second list":</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">second_list</span> <span class=\"o\">=</span> <span class=\"n\">list_of_lists</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">]</span>\n<span class=\"n\">first_element_of_second_list</span> <span class=\"o\">=</span> <span class=\"n\">second_list</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">first_element_of_second_list</span><span class=\"p\">)</span>\n</pre></div><p>And because <code>list_of_lists[1]</code>\nindicates the list, we can take the elements directly from it:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">first_element_of_second_list</span> <span class=\"o\">=</span> <span class=\"p\">(</span><span class=\"n\">list_of_list</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">])[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n</pre></div><p>Or:</p>\n<div class=\"highlight\"><pre><span></span><span class=\"n\">first_element_of_second_list</span> <span class=\"o\">=</span> <span class=\"n\">list_of_list</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">][</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n</pre></div><p>This approach is quite useful.\nSame as nested <code>for</code> loops\nallowed us to list a table, nested lists\nallow us to store a table.</p>\n<div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">create_tab</span><span class=\"p\">(</span><span class=\"n\">size</span><span class=\"o\">=</span><span class=\"mi\">11</span><span class=\"p\">):</span>\n <span class=\"n\">row_list</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n <span class=\"k\">for</span> <span class=\"n\">a</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">size</span><span class=\"p\">):</span>\n <span class=\"n\">row</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n <span class=\"k\">for</span> <span class=\"n\">b</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">size</span><span class=\"p\">):</span>\n <span class=\"n\">row</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">a</span> <span class=\"o\">*</span> <span class=\"n\">b</span><span class=\"p\">)</span>\n <span class=\"n\">row_list</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">row</span><span class=\"p\">)</span>\n <span class=\"k\">return</span> <span class=\"n\">row_list</span>\n\n<span class=\"n\">multiplication_tab</span> <span class=\"o\">=</span> <span class=\"n\">create_tab</span><span class=\"p\">()</span>\n\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">multiplication_tab</span><span class=\"p\">[</span><span class=\"mi\">2</span><span class=\"p\">][</span><span class=\"mi\">3</span><span class=\"p\">])</span> <span class=\"c1\"># two times three</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">multiplication_tab</span><span class=\"p\">[</span><span class=\"mi\">5</span><span class=\"p\">][</span><span class=\"mi\">2</span><span class=\"p\">])</span> <span class=\"c1\"># five times two</span>\n<span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">multiplication_tab</span><span class=\"p\">[</span><span class=\"mi\">8</span><span class=\"p\">][</span><span class=\"mi\">7</span><span class=\"p\">])</span> <span class=\"c1\"># eight times seven</span>\n\n<span class=\"c1\"># List the entire table</span>\n<span class=\"k\">for</span> <span class=\"n\">row</span> <span class=\"ow\">in</span> <span class=\"n\">multiplication_tab</span><span class=\"p\">:</span>\n <span class=\"k\">for</span> <span class=\"n\">number</span> <span class=\"ow\">in</span> <span class=\"n\">row</span><span class=\"p\">:</span>\n <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">number</span><span class=\"p\">,</span> <span class=\"n\">end</span> <span class=\"o\">=</span> <span class=\"s1\">''</span><span class=\"p\">)</span>\n <span class=\"k\">print</span><span class=\"p\">()</span>\n</pre></div><p>What can we do with such a stored table? For example,\nyou can save the positions of figures on a chessboard, \nor of the crosses and circles in a <em>2D</em> tictactoe.</p>\n\n\n "
}
}
}