Business Benefits
Store text in string variables to build reusable code or functions in Python.
Define string variables using assignment statements in the format variable name = 'String'.
Assign strings to variables and use them to print output at certain stages of the program. For example:
>>>
>>> s1 = 'String in single quotes'
>>> s1
'String in single quotes'
>>>
>>> s2 = "String in double quotes"
>>> s2
'String in double quotes'
>>>
```Python will show an error if a single quote or apostrophe is used. For example:
s1 = 'Hello, this is Tom's laptop'
>>> Output:
>>> s1 = 'Hello, this is Tom's laptop'
File "", line 1
s1 = 'Hello, this is Tom's laptop'
```The above code would give a SyntaxError: invalid syntax.
If you encapsulate the string in double quotes, Python will assign it to the variable s1. For example:
s1 = “Hello, this is Tom’s laptop”
print(s1)
Hello, this is Tom’s laptop
Use the len() built-in function to count the number of characters in the string.
For example, len () in the snippet below is used to count the numbers of characters in a string, as well as the number of characters in the string variable s.
>>> len("a string")
8
>>>
>>> s = "a long string"
>>>
>>> len(s)
13
>>>
>>> len("")
0
>>>
Use empty strings to create null value variables or to clear string variable values.
For example:
>>>
>>> s3 = '' # empty string using single quotes
>>> s3
''
>>>
>>> s4 = "" # empty string using double quotes
>>> s4
''
>>>
```Variables `s3` and `s4` are still valid strings, despite not containing any characters. This can be verified using the `type()` function.
type(s3)
type(s4)
## Use double quotes when you have single quotation marks inside a string to avoid quote exceptions.
Similarly, wrap the string in single quotes instead of double quotes if you want to print double quotes in a string:
print(‘John says “Hello there!”’)
John says “Hello there!”
## Use escape sequences to print special characters, tabs, or line breaks
Escape sequences start with a backslash ( `` ). Some common escape sequences are:
- `n` Newline - Prints a newline character
- `t ` Tab - Prints a tab character
- `\ ` Backslash - Prints a backslash ( \ )
- `' ` Single quote - Prints a single quote
- `"` Double quote - Prints a double quote
Python treats escape sequences in strings as special commands. For example, the `t` character inside a string prints a tab character (equivalent to four spaces):
s = “NametAgetMarks”
s
‘NametAget\Marks’
print(s)
Name Age Marks
```Similarly, an n character inside the string prints a newline character. The newline character isn’t displayed on the screen - instead, it causes the cursor to start printing subsequent characters from the beginning of the next line. For example:
>>>
>>> s2 = 'OnenTwonThree'
>>> s2
'OnenTwonThree'
>>> print(s2)
One
Two
Three
>>>
```You can use `'` and `"` escape sequences to print single or double quotation marks in a string. If you use escape sequences to print single or double quotes, it doesn't matter whether the string is wrapped in single or double quotes. For example:
print(‘I’m learning python’)
I’m learning pythonprint(“John says “Hello there !””)
John says “Hello there !”
```To print a single backslash character ``, use the \ escape sequence.
>>>
>>> s3 = 'C:\Users\Q'
>>> s3
'C:\Users\Q'
>>> print(s3)
C:UsersQ
>>>
Use the + operator to perform string concatenation and join one or more strings together.
For example:
>>> s1 = "This is " + "one complete string"
>>> print(s1)
This is one complete string
>>>
>>> s2 = "One " + "really really " + "long string"
>>> print(s2)
One really really long string
>>>
```Note that the `+` operator will perform additions when used with numbers, but concatenates strings.
98+57 # + operators add numbers together
155
```Python does not allow concatenations of numerical strings or strings with different data types. So, you need to use the str() function to convert them to strings:
>>>
>>> s = str(100)
>>> s
'100'
>>> type(s)
>>>
Use the * operator to repeat strings n number of times.
The general format is:
string * n
```Where `n` is a number of type `int`. Using the `*` operator repeats the string `n` number of times. For example:
s = "www " * 5 # repeat "www " 5 times
s
'www www www www www ’print(“We have got some”, “spam” * 5)
We have got some spamspamspamspamspam
```Note that 5 * "www " and "www " * 5 yields the same result.
Python can’t multiply strings by non-int data types and will show an error if you use a different data type for n. For example:
Traceback (most recent call last):
File "", line 1, in
TypeError: can't multiply sequence by non-int of type 'str'
>>>
>>>
>>> "www" * 1.5 # n is a float
Traceback (most recent call last):
File "", line 1, in
TypeError: can't multiply sequence by non-int of type 'float'
>>>
Type the name of a variable followed by the index of the character inside square brackets [] to access individual characters in a string.
Python stores string characters in sequence, and indexes can be used to refer to the position of a particular character in a string. The first character in a string is at the index 0, the second character is at index 1 and so on. For example:
String: H e l l o
Index: 0 1 2 3 4
s1 = “Hello”
s1[0] # first character
‘H’
s1[1] # second character
‘e’
s1[2] # third character
‘l’
s1[3] # fourth character
‘l’
s1[4] # fifth character
‘o’
```Alternatively, use the len() function to calculate the length of the string and subtract 1 from it to get the index position of the last character.
>>>
>>> quote = "The best is the enemy of the good"
>>>
>>> quote[len(quote)-1]
'd'
>>>
```You can also use negative indexes to access characters from the end of the string. Negative indexes start from -1, so the index position of the last character is -1, the second to last character is -2, and so on. For example:
String H e l l o
Index 0 1 2 3 4
Negative Index -5 -4 -3 -2 -1
>>>
>>> s = "Hello"
>>>
>>> s[-1] # last character
'o'
>>>
>>> s[-2] # second last character
'l'
>>>
>>> s[-3] # first character
'l'
>>>
>>> s[-len(s)] # first character using a combination of the len() function and negative indexes.
'H'
>>>
```
## Use slicing operators `[start_index:end_index]` to get a slice of a string.
```
str_name[start_index:end_index]
````str_name[start_index:end_index]` would return a slice of string starting from index `start_index` to `end_index`. The character at the `end_index` location is not included in the slice. For example:
```
>>>
>>> s = "markdown"
>>>
>>>
>>> s[0:3] # returns a string slice starting from index 0 to 3, not including the character at index 3
'mar'
>>>
>>>
>>> s[2:5] # returns a string slice starting from index 2 to 5, not including the character at index 5
'rkd'
>>>
```If `end_index` is greater than the length of the string, then the slice operator would return a string slice starting from `start_index` to the end of the string.
```
>>>
>>> s[2:len(s)+200]
'rkdown'
>>>
````start_index` and `end_index` are optional. If `start_index` is not specified, then slicing will begin at the beginning of the string. If `end_index` is not specified, then it goes on to the end of the string. For example:
```
>>>
>>> s[:4] # start slicing from the beginning
'mark'
>>>
```In the above expression, the slicing begins at the beginning of the string, so the above expression is the same as `s[0:4]`.
```
>>>
>>> s[5:]
'own'
>>>
```