KNSIT Module 2 Python-Chapter 1
KNSIT Module 2 Python-Chapter 1
CHAPTER 1: LISTS
A list begins with an opening square bracket and ends with a closing square bracket,
[].
Values inside the list are also called items and are separated with commas.
The first value in the list is at index 0, the second value is at index 1, and the third value
is at index 2, and so on.
For example, type the following expressions into the interactive shell.
The expression 'Hello ' + spam[0] evaluates to 'Hello ' + 'cat' because spam[0] evaluates
to the string 'cat'. This expression in turn evaluates to the string value 'Hello cat'.
If we use an index that exceeds the number of values in the list value then, python gives
IndexError.
Indexes can be only integer values, not floats. The following example will cause a
TypeError error:
Lists can also contain other list values. The values in these lists of lists can be
accessed using multiple indexes.
The first index dictates which list value to use, and the second indicates the value
within the list value. Ex, spam[0][1] prints 'bat', the second value in the first list.
Negative Indexes
We can also use negative integers for the index. The integer value -1 refers to the last
index in a list, the value -2 refers to the second-to-last index in a list, and so on.
A slice is typed between square brackets, like an index, but it has two integers
separated by a colon.
As a shortcut, we can leave out one or both of the indexes on either side of the
colon in the slice.
o Leaving out the first index is the same as using 0, or the beginning of the list.
o Leaving out the second index is the same as using the length of the list, which
will slice to the end of the list.
The len() function will return the number of values that are in a list value.
We can also use an index of a list to change the value at that index.
Ex: spam[1] = 'aardvark' means “Assign the value at index 1 in the list spam to the
string 'aardvark'.”
The * operator can also be used with a list and an integer value to replicate the list.
The del statement can also be used to delete a variable After deleting if we try to use
the variable, we will get a NameError error because the variable no longer exists.
In practice, you almost never need to delete simple variables.
The del statement is mostly used to delete values from lists.
Which is bad way to write code because it leads to have a duplicate code in the
program.
Instead of using multiple, repetitive variables, we can use a single variable that
contains a list value.
For Ex: The following program uses a single list and it can store any number of cats
that the user types in.
Program:
Output:
A for loop repeats the code block once for each value in a list or list-like value.
Program
Output:
A common Python technique is to use range (len(someList)) with a for loop to iterate
over the indexes of a list.
The code in the loop will access the index (as the variable i), the value at that index (as
supplies[i]) and range(len(supplies)) will iterate through all the indexes of supplies, no
matter how many items it contains.
We can determine whether a value is or isn’t in a list with the in and not in operators.
in and not in are used in expressions and connect two values: a value to look for in a
list and the list where it may be found and these expressions will evaluate to a Boolean
value.
The following program lets the user type in a pet name and then checks to see whether
the name is in a list of pets.
Program
Output
When assigning a value to a variable, we will frequently use the variable itself
Instead of left-side program we could use right-side program i.e., with the augmented
assignment operator += to do the same thing as a shortcut.
The Augmented Assignment Operators are listed in the below table:
The += operator can also do string and list concatenation, and the *= operator can do
string and list replication.
1.4 Methods
A method is same as a function, except it is “called on” a value.
The method part comes after the value, separated by a period.
Each data type has its own set of methods.
The list data type has several useful methods for finding, adding, removing, and
manipulating values in a list.
Finding a Value in a List with the index() Method
List values have an index() method that can be passed a value, and if that value exists
in the list, the index of the value is returned. If the value isn’t in the list, then Python
produces a ValueError error.
When there are duplicates of the value in the list, the index of its first appearance is
returned.
To add new values to a list, use the append() and insert() methods.
The append() method call adds the argument to the end of the list.
The insert() method can insert a value at any index in the list. The first argument to
insert() is the index for the new value, and the second argument is the new value to be
inserted.
The append() and insert() methods are list methods and can be called only on list values,
not on other values such as strings or integers.
The remove() method is passed the value to be removed from the list it is called on.
Attempting to delete a value that does not exist in the list will result in a ValueError
error.
If the value appears multiple times in the list, only the first instance of the value will
be removed.
The del statement is good to use when you know the index of the value you want to
remove from the list. The remove() method is good when you know the value you
want to remove from the list.
Sorting the Values in a List with the sort() Method
Lists of number values or lists of strings can be sorted with the sort() method.
You can also pass True for the reverse keyword argument to have sort() sort the
values in reverse order.
There are three things you should note about the sort() method.
o First, the sort() method sorts the list in place; don’t try to return value by
writing code like spam = spam.sort().
o Second, we cannot sort lists that have both number values and string values in
them.
o Third, sort() uses “ASCIIbetical order(upper case)” rather than actual alphabetical
order(lower case) for sorting strings.
If we need to sort the values in regular alphabetical order, pass str.lower for the key
keyword argument in the sort() method call.
The expression you use as the index into messages: random .randint (0, len(messages)
- 1). This produces a random number to use for the index, regardless of the size of
messages. That is, you’ll get a random number between 0 and the value of
len(messages) - 1.
We can also split up a single instruction across multiple lines using the \ line
continuation character at the end.
The proper way to “mutate” a string is to use slicing and concatenation to build a new
string by copying from parts of the old string.
We used [0:7] and [8:12] to refer to the characters that we don’t wish to replace. Notice
that the original 'Zophie a cat' string is not modified because strings are immutable.
List
A list value is a mutable data type: It can have values added, removed, or changed.
The list value in eggs isn’t being changed here; rather, an entirely new and different list
value ([4, 5, 6]) is overwriting the old list value ([1, 2, 3]).
Figure: When eggs = [4, 5, 6] is executed, the contents of eggs are replaced with a
new list value.
If we want to modify the original list in eggs to contain [4, 5, 6], you would have to
delete the items in that and then add items to it.
Figure: The del statement and the append() method modify the same list value in place.
Second, benefit of using tuples instead of lists is that, because they are immutable and
their contents don’t change. Tuples cannot have their values modified, appended, or
removed.
If you have only one value in your tuple, you can indicate this by placing a trailing
comma after the value inside the parentheses.
The functions list() and tuple() will return list and tuple versions of the values passed
to them.
References
As , variables store strings and integer values.
We assign 42 to the spam variable, and then we copy the value in spam and assign it to the
variable cheese. When we later change the value in spam to 100, this doesn’t affect the
value in cheese. This is because spam and cheese are different variables that store different
values.
But lists works differently. When we assign a list to a variable, we are actually assigning
a list reference to the variable. A reference is a value that points to some bit of data, and
a list reference is a value that points to a list.
When we create the list ❶, we assign a reference to it in the spam variable. But the
next line copies only the list reference in spam to cheese, not the list value itself. This
means the values stored in spam and cheese now both refer to the same list.
There is only one underlying list because the list itself was never actually copied. So
when we modify the first element of cheese, we are modifying the same list that spam
refers to.
List variables don’t actually contain lists—they contain references to lists.