{"id":2578,"date":"2020-08-17T16:39:15","date_gmt":"2020-08-17T16:39:15","guid":{"rendered":"https:\/\/idiagress.com\/vinaaypatil\/?p=2578"},"modified":"2023-10-28T07:19:38","modified_gmt":"2023-10-28T07:19:38","slug":"1-4-strings-lists-and-directories","status":"publish","type":"post","link":"https:\/\/idiagress.com\/vinaaypatil\/2020\/08\/17\/1-4-strings-lists-and-directories\/","title":{"rendered":"1.4 Strings, Lists and Directories"},"content":{"rendered":"\n

In Python, the default data type for the ‘input’ command is a string<\/strong>. <\/p>\n\n\n\n

A string is essentially a collection of characters, which can include letters, symbols, numbers, and more. It’s important to note that when you input numbers using the ‘input’ command, they are stored as characters within a string. This means that you cannot perform mathematical operations on them directly.<\/p>\n\n\n\n

Let’s understand strings with a straightforward Python program, ‘strings.py<\/strong>‘:<\/p>\n\n\n\n

_name=input(\"Enter Name :\") \nprint(_name)\u00a0<\/span><\/code><\/pre>\n\n\n\n
When you run this program, you will get the same string that you entered as the output. This showcases the string data type’s role in capturing and displaying text-based information in Python programs<\/p>\n\n\n\n
<\/div>\n\n\n
\n
\"\"<\/a><\/figure>\n<\/div>\n\n\n
<\/div>\n\n\n\n
In Python, when we input data using the ‘input’ function, the input is stored as a collection of characters within a string. Each character in the string is assigned a unique position number, starting with zero at the leftmost character and increasing by 1 as we move rightward through the string. This concept is technically known as “string indexing<\/strong><\/mark>.”<\/p>\n\n\n\n
<\/div>\n\n\n\n
Index number<\/b><\/td>0<\/b><\/td>1<\/b><\/td>2<\/b><\/td>3<\/b><\/td>4<\/b><\/td>5<\/b><\/td>6<\/b><\/td>7<\/b><\/td>8<\/b><\/td>9<\/b><\/td>10<\/b><\/td><\/tr>
String <\/span><\/td>p<\/td>u <\/span><\/td>r<\/td>u<\/td>s<\/td>h<\/td>o<\/td>t<\/td>t<\/td>a<\/td>m<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
<\/div>\n\n\n\n
String indexing allows us to access and manipulate individual characters within a string by referring to their specific positions, making it a fundamental concept in string processing and manipulation<\/p>\n\n\n\n
This indexing gives us ability to interact with individual members of the string, for example<\/p>\n\n\n\n
_name[0]\n\nthis will give us \u00a0 \u00a0 \u00a0 _name[0] = p<\/code><\/pre>\n\n\n\n
We can also extract part of the string, for example, if we want to assign the nickname as the first four letters of the name,<\/p>\n\n\n\n
_name[0:4]\n\nthis will give us \u00a0 \u00a0 \u00a0_name[0:4] = puru<\/code><\/pre>\n\n\n\n
If you observe, the ‘4th’ index member of the string is ‘s’. <\/p>\n\n\n\n
However, when we extract [0:4], ‘s’ was not included in the result. <\/p>\n\n\n\n
This is because the selection process excludes the upper-bound value. When we extract [0:4], it retrieves characters at indices [0, 1, 2, and 3]. In this case, ‘p,’ ‘u,’ ‘r,’ and ‘u’ are extracted, excluding the character at the upper bound (index 4). <\/p>\n\n\n\n
This behavior is a fundamental aspect of Python’s string indexing and slicing<\/p>\n\n\n\n
<\/div>\n\n\n\n
We can also     <\/span>\u2018add\u2019 <\/span><\/b>   <\/span>two strings with a straightforward     <\/span>\u2018+\u2019<\/b>     <\/span>operator. For example<\/p>\n\n\n\n
_name=input(\"Enter Name\u00a0 <\/span>\")\n_middle=input(\"Enter middle name \")\n_fullname=_name+_middle\nprint<\/b>(_fullname)<\/code><\/pre>\n\n\n\n
the output we will get for this \u2018simple_string.py\u2019 is<\/p>\n\n\n\n
<\/div>\n\n\n
\n
\"\"<\/a><\/figure>\n<\/div>\n\n\n
<\/div>\n\n\n\n
An observation, empty spaces need to be defined explicitly, because addition is a simple combination of the strings. So a better command is \u2014<\/p>\n\n\n\n
_fullname = _name+\" \"+_middle<\/code><\/pre>\n\n\n\n
Now, the string    <\/span>\u2018_fullname\u2019    <\/span>has become long. (11 characters + space + 6 characters ), 18 characters long. Suppose, we are required to extract the last four letters     <\/span>\u2018xman\u2019     <\/span>, going by usual indexing (left to right), it will be a long count. To make things easy, python uses negative indexing from right to left, as shown below —<\/p>\n\n\n\n
<\/div>\n\n\n\n
Index<\/b><\/td>0<\/b><\/td>1<\/b><\/td>2<\/b><\/td>3<\/b><\/td>4<\/b><\/td>5<\/b><\/td>6<\/b><\/td>7<\/b><\/td>8<\/b><\/td>9<\/b><\/td>10<\/b><\/td>11<\/b><\/td>12<\/b><\/td>13<\/b><\/td>14<\/b><\/td>15<\/b><\/td>16<\/b><\/td>17<\/b><\/td><\/tr>
String<\/td>p<\/td>u<\/td>r<\/td>u<\/td>s<\/td>h<\/td>o<\/td>t<\/td>t<\/td>a<\/td>m<\/td> <\/span><\/td>l<\/td>a<\/td>x<\/td>m<\/td>a<\/td>n<\/td><\/tr>
Reverse<\/b><\/td>-18<\/b><\/td>-17<\/b><\/td>-16<\/b><\/td>-15<\/b><\/td>-14<\/b><\/td>-13<\/b><\/td>-12<\/b><\/td>-11<\/b><\/td>-10<\/b><\/td>-9<\/b><\/td>-8<\/b><\/td>-7<\/b><\/td>-6<\/b><\/td>-5<\/b><\/td>-4<\/b><\/td>-3<\/b><\/td>-2<\/b><\/td>-1<\/b><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
<\/div>\n\n\n\n
Thus, to extract     <\/span>\u2018xman<\/b>\u2019     <\/span>from the full string, we can use      <\/span> _fullname[-4,-1]<\/b><\/p>\n\n\n\n
However, remember the \u00a0 \u00a0 <\/span>\u2018upper-bound\u2019<\/b>\u00a0 \u00a0 <\/span>exclusion,\u00a0 <\/span>thus\u00a0 \u00a0 <\/span>\u2018-1\u2019<\/b> \u00a0 \u00a0 <\/span>will get excluded and our output will be<\/p>\n\n\n\n
_fullname[-4, -1] = xma<\/b><\/code><\/pre>\n\n\n\n
to get around this, we will not give the upper-bound<\/p>\n\n\n\n
_fullname[-4 : ] = xman<\/b><\/code><\/pre>\n\n\n\n
\n\n\n\n
Let\u2019s combine and illustrate our string operations in a \u00a0 <\/span>\u2018string_indexing.py<\/b>\u2019\u00a0<\/span><\/p>\n\n\n\n
<\/div>\n\n\n
\n
\"\"<\/a><\/figure>\n<\/div>\n\n\n
<\/div>\n\n\n\n
Moving further, it’s important to consider that the output of our program should adhere to English language rules, which typically require the first letter of a proper noun (such as a name) to be in uppercase (capitalized). While a typical user might provide input in lowercase, our program should be able to correct such basic mistakes. To achieve this, Python provides string functions.<\/p>\n\n\n\n
For instance, to convert the first letter of a string to uppercase, we can use the ‘capitalize()’ function. The typical syntax for using functions is as follows:<\/p>\n\n\n\n
string_name.function_name(arguments_if_any)<\/code><\/pre>\n\n\n\n
In the case of the ‘capitalize()’ function, it can be implemented for the input string as follows:<\/p>\n\n\n\n
_name.capitalize()\n<\/code><\/pre>\n\n\n\n
Let\u2019s combine what we have learnt so far into a new program  <\/span>\u2018strings_functions.py<\/strong>\u2019<\/p>\n\n\n\n
<\/div>\n\n\n
\n
\"\"<\/a><\/figure>\n<\/div>\n\n\n
<\/div>\n\n\n\n
In the program, you’ll notice an interesting operation. After using the ‘capitalize()’ function, we could have created a new variable to store the capitalized name<\/p>\n\n\n\n
_name = input(\"Enter First Name: \")\n_capitalized_name = _name.capitalize()\n<\/code><\/pre>\n\n\n\n
However, creating too many intermediate variables can lead to confusion and is unnecessary if we have no further use for the original variable. Therefore, we use the technique of reassigning the variable to rewrite itself:<\/p>\n\n\n\n
_name = _name.capitalize()\n<\/code><\/pre>\n\n\n\n
This ability to rewrite the same variable with its modified value is extremely useful. It not only reduces the number of variables but also has broader applications, including creating loops and more, which we will explore in later chapters<\/p>\n\n\n\n
<\/div>\n\n\n
Exercise<\/span><\/h4>
<\/p>\n