Here we talk about some basic operations on python sequences. Let's create some sequences.
strFruits='Apples, Oranges, Bananas, Coconuts, Lychee, Watermelon, Mangoes'
tplFruits=('Apples','Oranges','Bananas','Coconuts','Lychee','Watermelon','Mangoes')
lstFruits=['Apples', 'Oranges', 'Bananas', 'Coconuts', 'Lychee', 'Watermelon', 'Mangoes']
A sequence has a length. We can find out the length of a sequence using len()
print 'Lengths are -- string:',len(strFruits), 'tuple:', len(tplFruits), 'list:', len(lstFruits)
First, we will talk about some string operations.
The string module defines a number of constant strings which can come in handy.
import string
print 'Digits',string.digits
print 'ASCII Letters',string.ascii_letters
print 'ASCII Lowecase',string.ascii_lowercase
print 'ASCII Uppercase',string.ascii_uppercase
print 'Punctuation',string.punctuation
print 'Whitespace',[string.whitespace]
You can call string functions as string.function(...). For example, in order to count how many times a substring appears in a string the following function can be used:
string.count(strFruits,',')
Another way of calling the same function is:
strFruits.count(',')
The 'find' function can be used to search for a character or substring within a string. If the substring occurs within the string, the starting index is returned. If not found, then -1 is returned.
strFruits.find('Man')
print strFruits[strFruits.find('Ban'):]
strFruits.find('G')
The 'index' function is similar to the 'find' function except that it throws a 'ValueError' exception if the substring is not found.
strFruits.index('M')
strFruits.index('G')
The simplest way to check if a substring occurs in a string is to use 'in':
'A' in strFruits
'G' in strFruits
A number of functions are available to check if the string is of a certain type.
Check if a string is alphanumeric:
'123AB'.isalnum()
'123AB-'.isalnum()
Check if a string is digit:
'123'.isdigit()
Check if a string is lowercase:
'hello'.islower()
'lower' and 'upper' functions can be used to convert a string to lower and upper case, respectively.
'HELLO'.lower().islower()
'lstrip' and 'rstrip' remove leading and trailing whitespaces from a string. 'strip' does both.
' hello '.strip()
'+' can be used to concatenate strings.
'hello'+' world'
'a.join(b)' inserts 'a' after every element of 'b'.
' '.join(strFruits)
The 'split' function breaks up a string into a list based on a specific substring.
strFruits.split(',')
'str' converts other sequences into string.
str(lstFruits)
Why is the length of len(str(lstFruits)) different?
len(str(lstFruits))
'join' can also concatenate list elements. See the examples below.
''.join(lstFruits)
', '.join(lstFruits)
'==' can be used to check if two strings are same.
', '.join(lstFruits)==strFruits
'replace' replaces all occurrences of a substring with another.
strFruits.replace('a','A')
Remove all punctuation and numbers from the following string and convert the whole string to lower case:
strCaesar="In cryptography, a Caesar cipher, also known as Caesar\'s cipher, the shift cipher, Caesar's code or Caesar shift, is one of the simplest and most widely known encryption techniques. It is a type of substitution cipher in which each letter in the plaintext is replaced by a letter some fixed number of positions down the alphabet. For example, with a left shift of three, D would be replaced by A, E would become B, and so on. The method is named after Julius Caesar, who used it in his private correspondence.In cryptography, a Caesar cipher, also known as Caesar's cipher, the shift cipher, Caesar's code or Caesar shift, is one of the simplest and most widely known encryption techniques. It is a type of substitution cipher in which each letter in the plaintext is replaced by a letter some fixed number of positions down the alphabet. For example, with a left shift of three, D would be replaced by A, E would become B, and so on. The method is named after Julius Caesar (100BC-44BC), who used it in his private correspondence."
print strCaesar
The solution is below:
strClean=strCaesar
for c in string.punctuation+string.whitespace+string.digits:
strClean=strClean.replace(c,'')
strClean=strClean.lower()
print strClean
print strClean.isalpha()and strClean.islower()
'+' concatenates tuples.
print tplFruits+('Guava',)
'*' and pow will have the same effect as they do on strings.
print 2*tplFruits
Tuples can be used in swapping as shown below.
a=1
b=2
c=3
d=4
a,b,c,d=d,c,a,b
print a,b,c,d
Multiple returns from a function are, in reality, implemented as tuples.
def func(x,y):
return x+y,y*x
v = func(4,2)
print type(v)
a,b=v
print a,b
'+' concates lists too. Below, we concate one list with another list that contains a tuple.
tmp=lstFruits+[tplFruits]
print 'Length of the list tmp is',len(tmp),'and the contents are',tmp
print "The last element of tmp is:",tmp[-1]
Multiple indexing is also supported:
print tmp[-1][2]
We can also delete elements from a list as follows:
del tmp[-1]
print 'After deletion',tmp
Since we have removed the last element of tmp it should now be equal to lstFruits:
print tmp==lstFruits
'all' and 'any' can be used to check if all or any elements in a sequence are logically true.
print all([1,0])
print all((1,)),all('1')
print any([1,0])
'append' can be used to append elements to a list.
lstFruits.append('Apples')
print lstFruits
'count' can be used to count the number of occurrences of an element in a list.
print lstFruits.count('Apples')
'append' simply appends to the list. Here we append a list to lstFruits.
lstFruits.append(['Grapes','Strawberry'])
print lstFruits
Deletion of the list's last element results in the removal of the list we added above. The point: a list can be an element of another list and so on.
del lstFruits[-1]
print lstFruits
We can also removed the first occurrence of an element.
lstFruits.remove('Apples')
print lstFruits
'extend' adds elements of a list to the list.
lstFruits.extend(['Grapes','Strawberry'])
print lstFruits
'index' finds the index at which a certain element occurs in the list. 'in' can be used to test presence of an element within a list.
lstFruits.index('Grapes')
lstFruits.index('Tomato')
'Tomato' in lstFruits
'pop' can be used to remove elements from a list.
v=lstFruits.pop()
print 'The popped element is:',v
print 'The list is:',lstFruits
v=lstFruits.pop(2) # pop the 3rd element
print 'After removal of 3rd element \''+v+'\', the list is:',lstFruits
'reverse' reverses the list.
lstFruits.reverse()
print lstFruits
Solution:
lstFruits=lstFruits[:2]+['Oranges']+lstFruits[2:]
print lstFruits
'min','max' and 'sum' do what they are named for.
lstRange=range(10)
print lstRange
print 'min:',min(lstRange),'max:', max(lstRange),'sum:',sum(lstRange)
'sorted' and 'sort' both sort.
lstRange=range(10)+range(-3,5)
print lstRange
print sorted(lstRange)
print lstRange
lstRange.sort()
print lstRange
'==' can be used to test for element-wise equality of two lists.
a=1
b=2
[1,2]==[a,b]
There are different ways of constructing a list:
lstNew=[]
for i in range(10):
lstNew.append(i**2)
print lstNew
lstNew=[i**2 for i in range(10)]
print lstNew
print [i**2 for i in range(10) if 2*i>=i**2]
print [ i**2 if 2*i>=i**2 else i for i in range(10) ]
What does the following code do?
[i*j for i in range(10) for j in range(10) if i%2 and not j%2]
Let's make a list of lists and change one element in this list of lists.
a=[1,2,3]
b=[4]
print 'a =',a
lol=[a,a]+b #equivalently lol=a*2+b
print 'lol =',lol
lol[1][1]=100
print 'lol =',lol
print 'a =',a
Nore that chaing an element in 'lol' changes the corresponding element in 'a'. This is because of Python's philosophy of making no unecessary copies and using references rather than deep copying.
Let' see another example to illustrate the same issue.
def foo(a):
a[-1]='last'
b=['this','is','added']
return a+b
a=[1,2,3]
print foo(a)
print a
Another example of shallow copying:
list1 = [1, 'element']
list2 = list1
print 'Are the ids the same: ', id(list1)==id(list2)
list2[0] = 2 # Modifies the original list
print 'list1[0]=',list1[0] # Displays 1
print 'list2[0]=',list2[0] # Displays 1
[:] can be used to make a 'deep' copy.
list1= [1, 'element']
list2 = list1[:] # Copy using "[:]"
print 'Are the ids the same: ', id(list1)==id(list2)
list2[0] = 2 #Making a change
print 'list1[0]=',list1[0] # Displays 1
print 'list2[0]=',list2[0] # Displays 1
Another way of making a deep copy is to use the 'copy' module.
import copy
list1 = [1, [2, 3]] # Notice the second item being a nested list
list2 = copy.deepcopy(list1) # A deep copy
print 'Are the ids the same: ', id(list1)==id(list2)
list2[1][0] = 4 # Leaves the 2nd item of list1 unmodified
print 'list1[1][0]=',list1[1][0] # Displays 2
print 'list2[1][0]=',list2[1][0] # Displays 4
Instead of focusing just on the mechanics, let's dig a little deeper this time. The concept manifesting itself as the behavior you have seen earlier is:
In Python, variables are references to objects.
This generalizes to all variables in Python and not just sequences. Python variables merely refer to python objects and they are not, themselves, the objects they refer to (because they are just references!).
A python object exists in memory and a number of variables can refer to it. Python objects are typed but variables are untyped. A shallow copy, through assignment (x=y), makes a copy of the reference (y) in (x). As a consequence, both the variables now refer to the same object. A deep copy, on the other hand, makes a copy of the object and makes a variable to refer to this new copy.
Now see the above code in the light of this new concept: variables list1 and list2 after the assignment list2=list1 in our example of shallow copying refer to the same object. The identity of that object can be obtained by using id(obj) on the variables. The id's are the same in case of shallow copying but not in the case of deep copying which indicates that the result of deep copying is a new object.
Apart from allowing the behavior above, the concept of variables being references has a number of implications:
x change outside the function in the code below?¶def fcn(x):
y=[4,5,6]
print 'y before change:',y
x=y
x[0]=10
print 'y before change through x:',y
x=[1,2,3]
print 'x before function call:',x
fcn(x)
print 'x after function call:',x
The function call fcn(x) makes a copy of the reference x being specified as input (assignment). What is changed is a copy of the reference which now points to a new object whereas the original reference (x outside the function) remains the same. The use of assignment in Python function calls is underlined in the alternative way of calling a function in Python: fcn(x=x).
Let's get back to focus on sequences. For loops operate on sequences.
A=range(2,10,2)
for a in A:
print a
'enumerate' is an interesting function that enumerates the elements in a sequence. This can be very handy in a large number of sitations.
for a in enumerate(A):
print a
For example in selecting certain elements from a list to make a new list.
print [val for idx,val in enumerate(A) if idx in [0,1,3]]
'zip' zips multiple sequences to generate a list of tuples by selecting one element from each of the sequences.
zip('hello',['p','a','k','i','s','t','a','n'])
Another example:
lots=zip([1,2,3],[4,5,6]) #zip list of lists into a list of tuples
print lots
We can 'unzip' by using '*':
zip(*lots)