Gimme a L
'L'
Gimme a o
'o'
Gimme a s
's'
Gimme a e
'e'
The middle character is: d
The middle character is: r
The middle character is: a

What these programs demonstrate is that strings are similar to lists in several ways. The shout() function shows that for loops can be used with strings just as they can be used with lists. The middle procedure shows that that strings can also use the len() function and array indexes and slices. Most list features work on strings as well.

The next feature demonstrates some string specific features:

defto_upper(string):## Converts a string to upper caseupper_case=""forcharacterinstring:if'a'<=character<='z':location=ord(character)-ord('a')new_ascii=location+ord('A')character=chr(new_ascii)upper_case=upper_case+characterreturnupper_caseprint(to_upper("This is Text"))

with the output being:

THIS IS TEXT

This works because the computer represents the characters of a string as numbers from 0 to 1,114,111. For example 'A' is 65, 'B' is 66 and א is 1488. The values are the unicode value. Python has a function called ord() (short for ordinal) that returns a character as a number. There is also a corresponding function called chr() that converts a number into a character. With this in mind the program should start to be clear. The first detail is the line: if 'a' <= character <= 'z': which checks to see if a letter is lower case. If it is then the next lines are used. First it is converted into a location so that a = 0, b = 1, c = 2 and so on with the line: location = ord(character) - ord('a'). Next the new value is found with new_ascii = location + ord('A'). This value is converted back to a character that is now upper case. Note that if you really need the upper case of a letter, you should use u=var.upper() which will work with other languages as well.

If you haven't guessed already the function repr() can convert an integer to a string and the function int() can convert a string to an integer. The function float() can convert a string to a float. The repr() function returns a printable representation of something. Here are some examples of this:

The int() function tries to convert a string (or a float) into an integer. There is also a similar function called float() that will convert a integer or a string into a float. Another function that Python has is the eval() function. The eval() function takes a string and returns data of the type that python thinks it found. For example:

Notice how split() converts a string into a list of strings. The string is split by whitespace by default or by the optional argument (in this case a comma).
You can also add another argument that tells split() how many times the separator will be used to split the text. For example:

Strings can be cut into pieces — in the same way as it was shown for lists in the previous chapter — by using the slicing "operator" []. The slicing operator works in the same way as before: text[first_index:last_index] (in very rare cases there can be another colon and a third argument, as in the example shown below).

In order not to get confused by the index numbers, it is easiest to see them as clipping places, possibilities to cut a string into parts. Here is an example, which shows the clipping places (in yellow) and their index numbers (red and blue) for a simple text string:

0

1

2

...

-2

-1

↓

↓

↓

↓

↓

↓

↓

text =

"

S

T

R

I

N

G

"

↑

↑

[:

:]

Note that the red indexes are counted from the beginning of the string and the blue ones from the end of the string backwards. (Note that there is no blue -0, which could seem to be logical at the end of the string. Because -0 == 0, -0 means "beginning of the string" as well.) Now we are ready to use the indexes for slicing operations:

text[1:4]

→

"TRI"

text[:5]

→

"STRIN"

text[:-1]

→

"STRIN"

text[-4:]

→

"RING"

text[2]

→

"R"

text[:]

→

"STRING"

text[::-1]

→

"GNIRTS"

text[1:4] gives us all of the text string between clipping places 1 and 4, "TRI". If you omit one of the [first_index:last_index] arguments, you get the beginning or end of the string as default: text[:5] gives "STRIN". For both first_index and last_index we can use both the red and the blue numbering schema: text[:-1] gives the same as text[:5], because the index -1 is at the same place as 5 in this case. If we do not use an argument containing a colon, the number is treated in a different way: text[2] gives us one character following the second clipping point, "R". The special slicing operation text[:] means "from the beginning to the end" and produces a copy of the entire string (or list, as shown in the previous chapter).

Last but not least, the slicing operation can have a second colon and a third argument, which is interpreted as the "step size": text[::-1] is text from beginning to the end, with a step size of -1. -1 means "every character, but in the other direction". "STRING" backwards is "GNIRTS" (test a step length of 2, if you have not got the point here).

All these slicing operations work with lists as well. In that sense strings are just a special case of lists, where the list elements are single characters. Just remember the concept of clipping places, and the indexes for slicing things will get a lot less confusing.

# This program requires an excellent understanding of decimal numbers.defto_string(in_int):"""Converts an integer to a string"""out_str=""prefix=""ifin_int<0:prefix="-"in_int=-in_intwhilein_int//10!=0:out_str=str(in_int%10)+out_strin_int=in_int//10out_str=str(in_int%10)+out_strreturnprefix+out_strdefto_int(in_str):"""Converts a string to an integer"""out_num=0ifin_str[0]=="-":multiplier=-1in_str=in_str[1:]else:multiplier=1forcinin_str:out_num=out_num*10+int(c)returnout_num*multiplierprint(to_string(2))print(to_string(23445))print(to_string(-23445))print(to_int("14234"))print(to_int("12345"))print(to_int("-3512"))