1 .. Objectives |
|
2 .. ---------- |
|
3 |
|
4 .. By the end of this tutorial, you will be able to |
|
5 |
|
6 .. 1. Slice strings and get sub-strings out of them |
|
7 .. #. Reverse strings |
|
8 .. #. Replace characters in strings. |
|
9 .. #. Convert strings to upper or lower case |
|
10 .. #. joining a list of strings |
|
11 |
|
12 .. Prerequisites |
|
13 .. ------------- |
|
14 |
|
15 .. 1. getting started with strings |
|
16 .. #. getting started with lists |
|
17 .. #. basic datatypes |
|
18 |
|
19 .. Author : Puneeth |
|
20 Internal Reviewer : Amit |
|
21 External Reviewer : |
|
22 Language Reviewer : Bhanukiran |
|
23 Checklist OK? : <08-11-2010, Anand, OK> [2010-10-05] |
|
24 |
|
25 Script |
|
26 ------ |
|
27 |
|
28 {{{ Show the slide containing title }}} |
|
29 |
|
30 Hello Friends. Welcome to this tutorial on manipulating strings. |
|
31 |
|
32 {{{ show the slide with outline }}} |
|
33 |
|
34 In this tutorial we shall learn to manipulate strings, specifically |
|
35 slicing and reversing them, or replacing characters, converting from |
|
36 upper to lower case and vice-versa and joining a list of strings. |
|
37 |
|
38 We have an ``ipython`` shell open, in which we are going to work, |
|
39 through out this session. |
|
40 |
|
41 Let us consider a simple problem, and learn how to slice strings and |
|
42 get sub-strings. |
|
43 |
|
44 Let's say the variable ``week`` has the list of the names of the days |
|
45 of the week. |
|
46 |
|
47 :: |
|
48 |
|
49 week = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"] |
|
50 |
|
51 |
|
52 Now given a string ``s``, we should be able to check if the string is a |
|
53 valid name of a day of the week or not. |
|
54 |
|
55 :: |
|
56 |
|
57 s = saturday |
|
58 |
|
59 |
|
60 ``s`` could be in any of the forms --- sat, saturday, Sat, Saturday, |
|
61 SAT, SATURDAY. For now, shall now be solving the problem only for the forms, |
|
62 sat and saturday. We shall solve it for the other forms, at the end of |
|
63 the tutorial. |
|
64 |
|
65 {{{ show these forms in a slide }}} |
|
66 |
|
67 So, we need to check if the first three characters of the given string |
|
68 exists in the variable ``week``. |
|
69 |
|
70 As, with any of the sequence data-types, strings can be sliced into |
|
71 sub-strings. To get the first three characters of s, we say, |
|
72 |
|
73 :: |
|
74 |
|
75 s[0:3] |
|
76 |
|
77 Note that, we are slicing the string from the index 0 to index 3, 3 |
|
78 not included. |
|
79 |
|
80 As we already know, the last element of the string can be accessed |
|
81 using ``s[-1]``. |
|
82 |
|
83 Following is an exercise that you must do. |
|
84 |
|
85 %%1%% Obtain the sub-string excluding the first and last characters |
|
86 from the string s. |
|
87 |
|
88 Please, pause the video here. Do the exercise(s) and then continue. |
|
89 |
|
90 :: |
|
91 |
|
92 s[1:-1] |
|
93 |
|
94 gives the substring of s, without the first and the last |
|
95 characters of s. |
|
96 |
|
97 :: |
|
98 |
|
99 s = saturday |
|
100 s[:3] |
|
101 |
|
102 Now, we just check if that substring is present in the variable |
|
103 ``week``. |
|
104 |
|
105 :: |
|
106 |
|
107 s[:3] in week |
|
108 |
|
109 Let us now consider the problem of finding out if a given string is |
|
110 palindromic or not. First of all, a palindromic string is a string |
|
111 that remains same even when it has been reversed. |
|
112 |
|
113 Let the string given be ``malayalam``. |
|
114 |
|
115 :: |
|
116 |
|
117 s = "malayalam" |
|
118 |
|
119 Now, we need to compare this string with it's reverse. |
|
120 |
|
121 Again, we will use a technique common to all sequence data-types, |
|
122 [::-1] |
|
123 |
|
124 So, we obtain the reverse of s, by simply saying, |
|
125 |
|
126 :: |
|
127 |
|
128 s[::-1] |
|
129 |
|
130 Now, to check if the string is ``s`` is palindromic, we say |
|
131 :: |
|
132 |
|
133 s == s[::-1] |
|
134 |
|
135 As, expected, we get ``True``. |
|
136 |
|
137 Now, if the string we are given is ``Malayalam`` instead of |
|
138 ``malayalam``, the above comparison would return a False. So, we will |
|
139 have to convert the string to all lower case or all upper case, before |
|
140 comparing. Python provides methods, ``s.lower`` and ``s.upper`` to |
|
141 achieve this. |
|
142 |
|
143 Let's try it out. |
|
144 :: |
|
145 |
|
146 s = "Malayalam" |
|
147 |
|
148 s.upper() |
|
149 |
|
150 s |
|
151 |
|
152 As you can see, s has not changed. It is because, ``upper`` returns a |
|
153 new string. It doesn't change the original string. |
|
154 |
|
155 :: |
|
156 |
|
157 s.lower() |
|
158 |
|
159 s.lower() == s.lower()[::-1] |
|
160 |
|
161 Following is an exercise that you must do. |
|
162 |
|
163 %%2%% Check if ``s`` is a valid name of a day of the week. Change the |
|
164 solution to this problem, to include forms like, SAT, SATURDAY, |
|
165 Saturday and Sat. |
|
166 |
|
167 Please, pause the video here. Do the exercise and then continue. |
|
168 |
|
169 :: |
|
170 |
|
171 s in week |
|
172 |
|
173 s.lower()[:3] in week |
|
174 |
|
175 |
|
176 So, as you can see, now we can check for presence of ``s`` in |
|
177 ``week``, in whichever format it is present -- capitalized, or all |
|
178 caps, full name or short form. |
|
179 |
|
180 We just convert any input string to lower case and then check if it is |
|
181 present in the list ``week``. |
|
182 |
|
183 Now, let us consider another problem. We often encounter e-mail id's |
|
184 which have @ and periods replaced with text, something like |
|
185 info[at]fossee[dot]in. We now wish to get back proper e-mail |
|
186 addresses. |
|
187 |
|
188 Let's say the variable email has the email address. |
|
189 :: |
|
190 |
|
191 email = "info[at]fossee[dot]in" |
|
192 |
|
193 Now, we first replace the ``[at]`` with the ``@``, using the replace |
|
194 method of strings. |
|
195 :: |
|
196 |
|
197 email = email.replace("[at]", "@") |
|
198 print email |
|
199 |
|
200 Following is an exercise that you must do. |
|
201 |
|
202 %%3%% Replace the ``[dot]`` with ``.`` in ``email`` |
|
203 |
|
204 Please, pause the video here. Do the exercise and then continue. |
|
205 |
|
206 :: |
|
207 |
|
208 email = email.replace("[dot]", ".") |
|
209 print email |
|
210 |
|
211 Now, let's look at another interesting problem where we have a list of |
|
212 e-mail addresses and we wish to obtain one long string of e-mail |
|
213 addresses separated by commas or semi-colons. |
|
214 |
|
215 :: |
|
216 |
|
217 email_list = ["info@fossee.in", "enquiries@fossee.in", "help@fossee.in"] |
|
218 |
|
219 |
|
220 Now, if we wish to obtain one long string, separating each of the |
|
221 email id by a comma, we use the join operator on ``,``. |
|
222 |
|
223 :: |
|
224 |
|
225 email_str = ", ".join(email_list) |
|
226 print email_str |
|
227 |
|
228 Notice that the email ids are joined by a comma followed by a space. |
|
229 |
|
230 Following is an exercise that you must do. |
|
231 |
|
232 %%3%% From the email_str that we generated, change the separator to be |
|
233 a semicolon instead of a comma. |
|
234 |
|
235 Please, pause the video here. Do the exercise and then continue. |
|
236 |
|
237 :: |
|
238 |
|
239 email_str = email_str.replace(",", ";") |
|
240 |
|
241 That brings us to the end of the tutorial. |
|
242 |
|
243 {{{ show summary slide }}} |
|
244 |
|
245 In this tutorial, we have learnt how to get substrings, reverse |
|
246 strings and a few useful methods, namely upper, lower, replace and |
|
247 join. |
|
248 |
|
249 {{{ Show the "sponsored by FOSSEE" slide }}} |
|
250 |
|
251 This tutorial was created as a part of FOSSEE project, NME ICT, MHRD India |
|
252 |
|
253 Hope you have enjoyed and found it useful. |
|
254 Thank you! |
|
255 |
|