Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Strings and Character Data in Python
In the tutorial on Basic Data Types in Python, you learned how to define strings: objects that contain sequences of character data. Processing character data is integral to programming. It is a rare application that doesn’t need to manipulate strings at least to some extent.
Here’s what you’ll learn in this tutorial: Python provides a rich set of operators, functions, and methods for working with strings. When you are finished with this tutorial, you will know how to access and extract portions of strings, and also be familiar with the methods that are available to manipulate and modify string data.
You will also be introduced to two other Python objects used to represent raw byte data, the bytes and bytearray types.
Take the Quiz: Test your knowledge with our interactive “Python Strings and Character Data” quiz. You’ll receive a score upon completion to help you track your learning progress:
The sections below highlight the operators, methods, and functions that are available for working with strings.
You have already seen the operators + and * applied to numeric operands in the tutorial on Operators and Expressions in Python. These two operators can be applied to strings as well.
+ OperatorThe + operator concatenates strings. It returns a string consisting of the operands joined together, as shown here:
Python
* OperatorThe * operator creates multiple copies of a string. If s is a string and n is an integer, either of the following expressions returns a string consisting of n concatenated copies of s:
s * n
n * s
Here are examples of both forms:
Python
The multiplier operand n must be an integer. You’d think it would be required to be a positive integer, but amusingly, it can be zero or negative, in which case the result is an empty string:
Python
If you were to create a string variable and initialize it to the empty string by assigning it the value 'foo' * -8, anyone would rightly think you were a bit daft. But it would work.
in OperatorPython also provides a membership operator that can be used with strings. The in operator returns True if the first operand is contained within the second, and False otherwise:
Python
There is also a not in operator, which does the opposite:
Python
As you saw in the tutorial on Basic Data Types in Python, Python provides many functions that are built-in to the interpreter and always available. Here are a few that work with strings:
| Function | Description |
|---|---|
chr() |
Converts an integer to a character |
ord() |
Converts a character to an integer |
len() |
Returns the length of a string |
str() |
Returns a string representation of an object |
These are explored more fully below.
ord(c)Returns an integer value for the given character.
At the most basic level, computers store all information as numbers. To represent character data, a translation scheme is used which maps each character to its representative number.
The simplest scheme in common use is called ASCII. It covers the common Latin characters you are probably most accustomed to working with. For these characters, ord(c) returns the ASCII value for character c:
Python
ASCII is fine as far as it goes. But there are many different languages in use in the world and countless symbols and glyphs that appear in digital media. The full set of characters that potentially may need to be represented in computer code far surpasses the ordinary Latin letters, numbers, and symbols you usually see.
Unicode is an ambitious standard that attempts to provide a numeric code for every possible character, in every possible language, on every possible platform. Python 3 supports Unicode extensively, including allowing Unicode characters within strings.
As long as you stay in the domain of the common characters, there is little practical difference between ASCII and Unicode. But the ord() function will return numeric values for Unicode characters as well:
Python
chr(n)Returns a character value for the given integer.
chr() does the reverse of ord(). Given a numeric value n, chr(n) returns a string representing the character that corresponds to n:
Python
chr() handles Unicode characters as well:
Python
len(s)
Returns the length of a string.
With len(), you can check Python string length. len(s) returns the number of characters in s:
Python
str(obj)
Returns a string representation of an object.
Virtually any object in Python can be rendered as a string. str(obj) returns the string representation of object obj:
Python
Often in programming languages, individual items in an ordered set of data can be accessed directly using a numeric index or key value. This process is referred to as indexing.
In Python, strings are ordered sequences of character data, and thus can be indexed in this way. Individual characters in a string can be accessed by specifying the string name followed by a number in square brackets ([]).
String indexing in Python is zero-based: the first character in the string has index 0, the next has index 1, and so on. The index of the last character will be the length of the string minus one.
For example, a schematic diagram of the indices of the string 'foobar' would look like this:
The individual characters can be accessed by index as follows:
Python
Attempting to index beyond the end of the string results in an error:
Python
String indices can also be specified with negative numbers, in which case indexing occurs from the end of the string backward: -1 refers to the last character, -2 the second-to-last character, and so on. Here is the same diagram showing both the positive and negative indices into the string 'foobar':
Here are some examples of negative indexing:
Python
Attempting to index with negative numbers beyond the start of the string results in an error:
Python
For any non-empty string s, s[len(s)-1] and s[-1] both return the last character. There isn’t any index that makes sense for an empty string.
Python also allows a form of indexing syntax that extracts substrings from a string, known as string slicing. If s is a string, an expression of the form s[m:n] returns the portion of s starting with position m, and up to but not including position n:
Python
Again, the second index specifies the first character that is not included in the result—the character 'r' (s[5]) in the example above. That may seem slightly unintuitive, but it produces this result which makes sense: the expression s[m:n] will return a substring that is n - m characters in length, in this case, 5 - 2 = 3.
If you omit the first index, the slice starts at the beginning of the string. Thus, s[:m] and s[0:m] are equivalent:
Python
Similarly, if you omit the second index as in s[n:], the slice extends from the first index through the end of the string. This is a nice, concise alternative to the more cumbersome s[n:len(s)]:
Python
For any string s and any integer n (0 ≤ n ≤ len(s)), s[:n] + s[n:] will be equal to s:
Python
Omitting both indices returns the original string, in its entirety. Literally. It’s not a copy, it’s a reference to the original string:
Python
If the first index in a slice is greater than or equal to the second index, Python returns an empty string. This is yet another obfuscated way to generate an empty string, in case you were looking for one:
Python
Negative indices can be used with slicing as well. -1 refers to the last character, -2 the second-to-last, and so on, just as with simple indexing. The diagram below shows how to slice the substring 'oob' from the string 'foobar' using both positive and negative indices:
Here is the corresponding Python code:
Python
There is one more variant of the slicing syntax to discuss. Adding an additional : and a third index designates a stride (also called a step), which indicates how many characters to jump after retrieving each character in the slice.
For example, for the string 'foobar', the slice 0:6:2 starts with the first character and ends with the last character (the whole string), and every second character is skipped. This is shown in the following diagram:
Similarly, 1:6:2 specifies a slice starting with the second character (index 1) and ending with the last character, and again the stride value 2 causes every other character to be skipped:
The illustrative REPL code is shown here:
Python
As with any slicing, the first and second indices can be omitted, and default to the first and last characters respectively:
Python
You can specify a negative stride value as well, in which case Python steps backward through the string. In that case, the starting/first index should be greater than the ending/second index:
Python
In the above example, 5:0:-2 means “start at the last character and step backward by 2, up to but not including the first character.”
When you are stepping backward, if the first and second indices are omitted, the defaults are reversed in an intuitive way: the first index defaults to the end of the string, and the second index defaults to the beginning. Here is an example:
Python
This is a common paradigm for reversing a string:
Python
In Python version 3.6, a new string formatting mechanism was introduced. This feature is formally named the Formatted String Literal, but is more usually referred to by its nickname f-string.
The formatting capability provided by f-strings is extensive and won’t be covered in full detail here. If you want to learn more, you can check out the Real Python article Python’s F-String for String Interpolation and Formatting. There is also a tutorial on Formatted Output coming up later in this series that digs deeper into f-strings.
One simple feature of f-strings you can start using right away is variable interpolation. You can specify a variable name directly within an f-string literal, and Python will replace the name with the corresponding value.
For example, suppose you want to display the result of an arithmetic calculation. You can do this with a straightforward print() statement, separating numeric values and string literals by commas:
Python
But this is cumbersome. To accomplish the same thing using an f-string:
f or uppercase F directly before the opening quote of the string literal. This tells Python it is an f-string instead of a standard string.{}).Recast using an f-string, the above example looks much cleaner:
Python
Any of Python’s three quoting mechanisms can be used to define an f-string:
Python
In a nutshell, you can’t. Strings are one of the data types Python considers immutable, meaning not able to be changed. In fact, all the data types you have seen so far are immutable. (Python does provide data types that are mutable, as you will soon see.)
A statement like this will cause an error:
Python
In truth, there really isn’t much need to modify strings. You can usually easily accomplish what you want by generating a copy of the original string that has the desired change in place. There are very many ways to do this in Python. Here is one possibility:
Python
There is also a built-in string method to accomplish this:
Python
Read on for more information about built-in string methods!
You learned in the tutorial on Variables in Python that Python is a highly object-oriented language. Every item of data in a Python program is an object.
You are also familiar with functions: callable procedures that you can invoke to perform specific tasks.
Methods are similar to functions. A method is a specialized type of callable procedure that is tightly associated with an object. Like a function, a method is called to perform a distinct task, but it is invoked on a specific object and has knowledge of its target object during execution.
The syntax for invoking a method on an object is as follows:
Python
This invokes method .foo() on object obj. <args> specifies the arguments passed to the method (if any).
You will explore much more about defining and calling methods later in the discussion of object-oriented programming. For now, the goal is to present some of the more commonly used built-in methods Python supports for operating on string objects.
In the following method definitions, arguments specified in square brackets ([]) are optional.
Methods in this group perform case conversion on the target string.
s.capitalize()
Capitalizes the target string.
s.capitalize() returns a copy of s with the first character converted to uppercase and all other characters converted to lowercase:
Python
Non-alphabetic characters are unchanged:
Python
s.lower()
Converts alphabetic characters to lowercase.
s.lower() returns a copy of s with all alphabetic characters converted to lowercase:
Python
s.swapcase()
Swaps case of alphabetic characters.
s.swapcase() returns a copy of s with uppercase alphabetic characters converted to lowercase and vice versa:
Python
s.title()
Converts the target string to “title case.”
s.title() returns a copy of s in which the first letter of each word is converted to uppercase and remaining letters are lowercase:
Python
This method uses a fairly simple algorithm. It does not attempt to distinguish between important and unimportant words, and it does not handle apostrophes, possessives, or acronyms gracefully:
Python
s.upper()
Converts alphabetic characters to uppercase.
s.upper() returns a copy of s with all alphabetic characters converted to uppercase:
Python
These methods provide various means of searching the target string for a specified substring.
Each method in this group supports optional <start> and <end> arguments. These are interpreted as for string slicing: the action of the method is restricted to the portion of the target string starting at character position <start> and proceeding up to but not including character position <end>. If <start> is specified but <end> is not, the method applies to the portion of the target string from <start> through the end of the string.
s.count(<sub>[, <start>[, <end>]])
Counts occurrences of a substring in the target string.
s.count(<sub>) returns the number of non-overlapping occurrences of substring <sub> in s:
Python
The count is restricted to the number of occurrences within the substring indicated by <start> and <end>, if they are specified:
Python
s.endswith(<suffix>[, <start>[, <end>]])
Determines whether the target string ends with a given substring.
s.endswith(<suffix>) returns True if s ends with the specified <suffix> and False otherwise:
Python
The comparison is restricted to the substring indicated by <start> and <end>, if they are specified:
Python
s.find(<sub>[, <start>[, <end>]])
Searches the target string for a given substring.
You can use .find() to see if a Python string contains a particular substring. s.find(<sub>) returns the lowest index in s where substring <sub> is found:
Python
This method returns -1 if the specified substring is not found:
Python
The search is restricted to the substring indicated by <start> and <end>, if they are specified:
Python
s.index(<sub>[, <start>[, <end>]])
Searches the target string for a given substring.
This method is identical to .find(), except that it raises an exception if <sub> is not found rather than returning -1:
Python
s.rfind(<sub>[, <start>[, <end>]])
Searches the target string for a given substring starting at the end.
s.rfind(<sub>) returns the highest index in s where substring <sub> is found:
Python
As with .find(), if the substring is not found, -1 is returned:
Python
The search is restricted to the substring indicated by <start> and <end>, if they are specified:
Python
s.rindex(<sub>[, <start>[, <end>]])
Searches the target string for a given substring starting at the end.
This method is identical to .rfind(), except that it raises an exception if <sub> is not found rather than returning -1:
Python
s.startswith(<prefix>[, <start>[, <end>]])
Determines whether the target string starts with a given substring.
When you use the Python .startswith() method, s.startswith(<suffix>) returns True if s starts with the specified <suffix> and False otherwise:
Python
The comparison is restricted to the substring indicated by <start> and <end>, if they are specified:
Python
Methods in this group classify a string based on the characters it contains.
s.isalnum()
Determines whether the target string consists of alphanumeric characters.
s.isalnum() returns True if s is nonempty and all its characters are alphanumeric (either a letter or a number), and False otherwise:
Python
s.isalpha()
Determines whether the target string consists of alphabetic characters.
s.isalpha() returns True if s is nonempty and all its characters are alphabetic, and False otherwise:
Python
s.isdigit()
Determines whether the target string consists of digit characters.
You can use the .isdigit() Python method to check if your string is made of only digits. s.isdigit() returns True if s is nonempty and all its characters are numeric digits, and False otherwise:
Python
s.isidentifier()
Determines whether the target string is a valid Python identifier.
s.isidentifier() returns True if s is a valid Python identifier according to the language definition, and False otherwise:
Python
s.islower()
Determines whether the target string’s alphabetic characters are lowercase.
s.islower() returns True if s is nonempty and all the alphabetic characters it contains are lowercase, and False otherwise. Non-alphabetic characters are ignored:
Python
s.isprintable()
Determines whether the target string consists entirely of printable characters.
s.isprintable() returns True if s is empty or all the alphabetic characters it contains are printable. It returns False if s contains at least one non-printable character. Non-alphabetic characters are ignored:
Python
s.isspace()
Determines whether the target string consists of whitespace characters.
s.isspace() returns True if s is nonempty and all characters are whitespace characters, and False otherwise.
The most commonly encountered whitespace characters are space ' ', tab '\t', and newline '\n':
Python
However, there are a few other ASCII characters that qualify as whitespace, and if you account for Unicode characters, there are quite a few beyond that:
Python
('\f' and '\r' are the escape sequences for the ASCII Form Feed and Carriage Return characters; '\u2005' is the escape sequence for the Unicode Four-Per-Em Space.)
s.istitle()
Determines whether the target string is title cased.
s.istitle() returns True if s is nonempty, the first alphabetic character of each word is uppercase, and all other alphabetic characters in each word are lowercase. It returns False otherwise:
Python
s.isupper()
Determines whether the target string’s alphabetic characters are uppercase.
s.isupper() returns True if s is nonempty and all the alphabetic characters it contains are uppercase, and False otherwise. Non-alphabetic characters are ignored:
Python
Methods in this group modify or enhance the format of a string.
s.center(<width>[, <fill>])
Centers a string in a field.
s.center(<width>) returns a string consisting of s centered in a field of width <width>. By default, padding consists of the ASCII space character:
Python
If the optional <fill> argument is specified, it is used as the padding character:
Python
If s is already at least as long as <width>, it is returned unchanged:
Python
s.expandtabs(tabsize=8)
Expands tabs in a string.
s.expandtabs() replaces each tab character ('\t') with spaces. By default, spaces are filled in assuming a tab stop at every eighth column:
Python
tabsize is an optional keyword parameter specifying alternate tab stop columns:
Python
s.ljust(<width>[, <fill>])
Left-justifies a string in field.
s.ljust(<width>) returns a string consisting of s left-justified in a field of width <width>. By default, padding consists of the ASCII space character:
Python
If the optional <fill> argument is specified, it is used as the padding character:
Python
If s is already at least as long as <width>, it is returned unchanged:
Python
s.lstrip([<chars>])
Trims leading characters from a string.
s.lstrip() returns a copy of s with any whitespace characters removed from the left end:
Python
If the optional <chars> argument is specified, it is a string that specifies the set of characters to be removed:
Python
s.replace(<old>, <new>[, <count>])
Replaces occurrences of a substring within a string.
In Python, to remove a character from a string, you can use the Python string .replace() method. s.replace(<old>, <new>) returns a copy of s with all occurrences of substring <old> replaced by <new>:
Python
If the optional <count> argument is specified, a maximum of <count> replacements are performed, starting at the left end of s:
Python
s.rjust(<width>[, <fill>])
Right-justifies a string in a field.
s.rjust(<width>) returns a string consisting of s right-justified in a field of width <width>. By default, padding consists of the ASCII space character:
Python
If the optional <fill> argument is specified, it is used as the padding character:
Python
If s is already at least as long as <width>, it is returned unchanged:
Python
s.rstrip([<chars>])
Trims trailing characters from a string.
s.rstrip() returns a copy of s with any whitespace characters removed from the right end:
Python
If the optional <chars> argument is specified, it is a string that specifies the set of characters to be removed:
Python
s.strip([<chars>])
Strips characters from the left and right ends of a string.
s.strip() is essentially equivalent to invoking s.lstrip() and s.rstrip() in succession. Without the <chars> argument, it removes leading and trailing whitespace:
Python
As with .lstrip() and .rstrip(), the optional <chars> argument specifies the set of characters to be removed:
Python
s.zfill(<width>)
Pads a string on the left with zeros.
s.zfill(<width>) returns a copy of s left-padded with '0' characters to the specified <width>:
Python
If s contains a leading sign, it remains at the left edge of the result string after zeros are inserted:
Python
If s is already at least as long as <width>, it is returned unchanged:
Python
.zfill() is most useful for string representations of numbers, but Python will still happily zero-pad a string that isn’t:
Python
Methods in this group convert between a string and some composite data type by either pasting objects together to make a string, or by breaking a string up into pieces.
These methods operate on or return iterables, the general Python term for a sequential collection of objects. You will explore the inner workings of iterables in much more detail in the upcoming tutorial on definite iteration.
Many of these methods return either a list or a tuple. These are two similar composite data types that are prototypical examples of iterables in Python. They are covered in the next tutorial, so you’re about to learn about them soon! Until then, simply think of them as sequences of values. A list is enclosed in square brackets ([]), and a tuple is enclosed in parentheses (()).
With that introduction, let’s take a look at this last group of string methods.
s.join(<iterable>)
Concatenates strings from an iterable.
s.join(<iterable>) returns the string that results from concatenating the objects in <iterable> separated by s.
Note that .join() is invoked on s, the separator string. <iterable> must be a sequence of string objects as well.
Some sample code should help clarify. In the following example, the separator s is the string ', ', and <iterable> is a list of string values:
Python
The result is a single string consisting of the list objects separated by commas.
In the next example, <iterable> is specified as a single string value. When a string value is used as an iterable, it is interpreted as a list of the string’s individual characters:
Python
Thus, the result of ':'.join('corge') is a string consisting of each character in 'corge' separated by ':'.
This example fails because one of the objects in <iterable> is not a string:
Python
That can be remedied, though:
Python
As you will soon see, many composite objects in Python can be construed as iterables, and .join() is especially useful for creating strings from them.
s.partition(<sep>)
Divides a string based on a separator.
s.partition(<sep>) splits s at the first occurrence of string <sep>. The return value is a three-part tuple consisting of:
s preceding <sep><sep> itselfs following <sep>Here are a couple examples of .partition() in action:
Python
If <sep> is not found in s, the returned tuple contains s followed by two empty strings:
Python
s.rpartition(<sep>)
Divides a string based on a separator.
s.rpartition(<sep>) functions exactly like s.partition(<sep>), except that s is split at the last occurrence of <sep> instead of the first occurrence:
Python
s.rsplit(sep=None, maxsplit=-1)
Splits a string into a list of substrings.
Without arguments, s.rsplit() splits s into substrings delimited by any sequence of whitespace and returns the substrings as a list:
Python
If <sep> is specified, it is used as the delimiter for splitting:
Python
(If <sep> is specified with a value of None, the string is split delimited by whitespace, just as though <sep> had not been specified at all.)
When <sep> is explicitly given as a delimiter, consecutive delimiters in s are assumed to delimit empty strings, which will be returned:
Python
This is not the case when <sep> is omitted, however. In that case, consecutive whitespace characters are combined into a single delimiter, and the resulting list will never contain empty strings:
Python
If the optional keyword parameter <maxsplit> is specified, a maximum of that many splits are performed, starting from the right end of s:
Python
The default value for <maxsplit> is -1, which means all possible splits should be performed—the same as if <maxsplit> is omitted entirely:
Python
s.split(sep=None, maxsplit=-1)
Splits a string into a list of substrings.
s.split() behaves exactly like s.rsplit(), except that if <maxsplit> is specified, splits are counted from the left end of s rather than the right end:
Python
If <maxsplit> is not specified, .split() and .rsplit() are indistinguishable.
s.splitlines([<keepends>])
Breaks a string at line boundaries.
s.splitlines() splits s up into lines and returns them in a list. Any of the following characters or character sequences is considered to constitute a line boundary:
| Escape Sequence | Character |
|---|---|
\n |
Newline |
\r |
Carriage Return |
\r\n |
Carriage Return + Line Feed |
\v or \x0b |
Line Tabulation |
\f or \x0c |
Form Feed |
\x1c |
File Separator |
\x1d |
Group Separator |
\x1e |
Record Separator |
\x85 |
Next Line (C1 Control Code) |
\u2028 |
Unicode Line Separator |
\u2029 |
Unicode Paragraph Separator |
Here is an example using several different line separators:
Python
If consecutive line boundary characters are present in the string, they are assumed to delimit blank lines, which will appear in the result list:
Python
If the optional <keepends> argument is specified and is truthy, then the lines boundaries are retained in the result strings:
Python
bytes ObjectsThe bytes object is one of the core built-in types for manipulating binary data. A bytes object is an immutable sequence of single byte values. Each element in a bytes object is a small integer in the range 0 to 255.
bytes ObjectA bytes literal is defined in the same way as a string literal with the addition of a 'b' prefix:
Python
As with strings, you can use any of the single, double, or triple quoting mechanisms:
Python
Only ASCII characters are allowed in a bytes literal. Any character value greater than 127 must be specified using an appropriate escape sequence:
Python
The 'r' prefix may be used on a bytes literal to disable processing of escape sequences, as with strings:
Python
bytes Object With the Built-in bytes() FunctionThe bytes() function also creates a bytes object. What sort of bytes object gets returned depends on the argument(s) passed to the function. The possible forms are shown below.
bytes(<s>, <encoding>)
Creates a
bytesobject from a string.
bytes(<s>, <encoding>) converts string <s> to a bytes object, using str.encode() according to the specified <encoding>:
Python
bytes(<size>)
Creates a
bytesobject consisting of null (0x00) bytes.
bytes(<size>) defines a bytes object of the specified <size>, which must be a positive integer. The resulting bytes object is initialized to null (0x00) bytes:
Python
bytes(<iterable>)
Creates a
bytesobject from an iterable.
bytes(<iterable>) defines a bytes object from the sequence of integers generated by <iterable>. <iterable> must be an iterable that generates a sequence of integers n in the range 0 ≤ n ≤ 255:
Python
bytes ObjectsLike strings, bytes objects support the common sequence operations:
The in and not in operators:
Python
The concatenation (+) and replication (*) operators:
Python
Indexing and slicing:
Python
Built-in functions:
Python
Many of the methods defined for string objects are valid for bytes objects as well:
Python
Notice, however, that when these operators and methods are invoked on a bytes object, the operand and arguments must be bytes objects as well:
Python
Although a bytes object definition and representation is based on ASCII text, it actually behaves like an immutable sequence of small integers in the range 0 to 255, inclusive. That is why a single element from a bytes object is displayed as an integer:
Python
A slice is displayed as a bytes object though, even if it is only one byte long:
Python
You can convert a bytes object into a list of integers with the built-in list() function:
Python
Hexadecimal numbers are often used to specify binary data because two hexadecimal digits correspond directly to a single byte. The bytes class supports two additional methods that facilitate conversion to and from a string of hexadecimal digits.
bytes.fromhex(<s>)
Returns a
bytesobject constructed from a string of hexadecimal values.
bytes.fromhex(<s>) returns the bytes object that results from converting each pair of hexadecimal digits in <s> to the corresponding byte value. The hexadecimal digit pairs in <s> may optionally be separated by whitespace, which is ignored:
Python
b.hex()
Returns a string of hexadecimal value from a
bytesobject.
b.hex() returns the result of converting bytes object b into a string of hexadecimal digit pairs. That is, it does the reverse of .fromhex():
Python
bytearray ObjectsPython supports another binary sequence type called the bytearray. bytearray objects are very like bytes objects, despite some differences:
There is no dedicated syntax built into Python for defining a bytearray literal, like the 'b' prefix that may be used to define a bytes object. A bytearray object is always created using the bytearray() built-in function:
Python
bytearray objects are mutable. You can modify the contents of a bytearray object using indexing and slicing:
Python
A bytearray object may be constructed directly from a bytes object as well:
Python
This tutorial provided an in-depth look at the many different mechanisms Python provides for string handling, including string operators, built-in functions, indexing, slicing, and built-in methods. You also were introduced to the bytes and bytearray types.
These types are the first types you have examined that are composite—built from a collection of smaller parts. Python provides several composite built-in types. In the next tutorial, you will explore two of the most frequently used: lists and tuples.
Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Strings and Character Data in Python