Up Your Coding Skills with Python: Strings
Part 2: Showcasing some of the most widely used methods applied to string objects in Python
As the natural follow-up to this article, where I’ve only just scratched the surface of what Python string objects are, I’ll now be doing a general overview of some of the most widely used methods associated with the usage and manipulation of string objects in Python. Going through each of them, one by one, this article aims to familiarize and maybe even point out some hints about Python strings.
Capitalize a string
Useful for situations where you need to ensure that some string is always capitalized (starts with an uppercase letter):
# construct the string
my_string = "abc def"
print(f"{id(my_string)}: {my_string}")# capitalize and save into a new string
my_second_string = my_string.capitalize()
print(f"{id(my_second_string)}: {my_second_string}")Output:
139753899857840: abc def
139753900121200: Abc defNotice how only the first letter of the string was converted to uppercase.
Casefolding a string
Casefolding in Python is an operation that, like the string.lower(), ensures all characters are converted to lowercase. The difference between string.lower() and this string.casefold() is that while lower() handles only characters in the ASCII range, casefold() goes beyond this range, ensuring many other unicode characters get — shall we call it — normalized in view of string comparisons. Since there are languages that feature characters outside of the regular 26-letter alphabet, this string.casefold() is sure to help when trying to compare those strings. For languages featuring all characters within the ASCII range, there should be no difference between casefold() and lower():
# construct the string
my_string = "ABc"
print(f"{id(my_string)}: {my_string}")# casefold and save into a second string
my_second_string = my_string.casefold()
print(f"{id(my_second_string)}: {my_second_string}")Output:
140000165189552: ABc
140000165452912: abcCenter aligning a string
Not as often used as there’s also the string.format() that would be capable of achieving the same effect and more, for that matter, but still worth mentioning, this string.center() method is a quick and intuitive way of centering a string within a given character length:
# construct the string
my_string = "Abc"
print(f"{id(my_string)}: |{my_string}|")# center it, then save it into another string
my_second_string = my_string.center(10)
print(f"{id(my_second_string)}: |{my_second_string}|")Output:
139866075272816: |Abc|
139866075536176: | Abc |As you can see, the string has been successfully centered. I used pipe characters in the print() statements to further emphasize the centering effect.
Counting substring occurrences
Say we have a string on our hands. One that contains a substring in repetition. How do we get the number of its occurrences? By using string.count():
# construct the string
my_string = "ABaca"
print(f"{id(my_string)}: {my_string}")# substring to count
substring = "a"# count the substring occurrences
no_of_chars = my_string.count(substring)
print(f"{my_string} has {no_of_chars} occurrences of '{substring}'")Output:
140705430460336: ABaca
ABaca has 2 occurrences of 'a'Encoding a string
The string.encode() method ensures we get an encoded version of the string we have. We can give it two parameters: the type of encoding we want done and the response type in case of encoding failure. You can read more about it here.
# construct the string
my_string = "Abc"
print(f"{id(my_string)}: {my_string}")# encode the string in utf-8
my_byte_string = my_string.encode(encoding="UTF-8")
print(f"{id(my_byte_string)}: {my_byte_string}")Output:
139704333342640: Abc
139704334105600: b'Abc'Notice the b in front of the encoded strings? That’s the telltale sign of a bytes string. Regular string gets encoded and this result is of type bytes.
Check if a string ends with a substring
This is a very straightforward operation. Just apply string.endswith() and enjoy the boolean result coming out of it:
# construct the string
my_string = "Abc"
print(f"{id(my_string)}: {my_string}")# does the string end with 'bc'?
result = my_string.endswith("bc")
print(f"{result}")Output:
140090950047664: Abc
TrueExpand tabs to spaces
Sometimes, a string can contain tabs. And sometimes, a requirement at work or otherwise is to have those tabs converted into spaces. This is where this method comes in handy. The string.expandtabs() method is successfully transforming the string, converting every tab character it finds into a number of space characters, according to the tab size argument you’re supplying the method with.
Also, it is very important to note that it does actually keep track of the current cursor position. If the string is, say, Abc\tdef the cursor position is at, say, 3 — because this is where the tab character sits at — and we have the tab size argument as 8, then this will result in an extra set of 5 spaces being added to the string instead of the tab character.
# construct the string
my_string = "Abc\tdef"
print(f"{id(my_string)}: {my_string}")# expand the tabs into spaces
my_second_string = my_string.expandtabs(3)
print(f"{id(my_second_string)}: {my_second_string}")
my_third_string = my_string.expandtabs()
print(f"{id(my_third_string)}: {my_third_string}")Output:
139624277039024: Abc def
139624277302384: Abc def
140087303330992: Abc defFind substring within a string
Again, very straightforward. We just need to use string.find() and it will return the index of the first occurrence of the substring within our searched string, or -1, should it fail to find it:
# construct the string
my_string = "Abc"
print(f"{id(my_string)}: {my_string}")# look for the substring
substring = "b"
index = my_string.find("b")
print(f"{index}")# look for a nonexistent substring
index = my_string.find("d")
print(f"{index}")Output:
140410169481136: Abc
1
-1String formatting
One of the most (if probably not the most) widely used string methods in Python is string.format(), as it allows for a multitude of features, such as left/right/center alignment, the number of decimals, and the total number of digits, hex or octal representations in the case of numbers, positional formatting, variable substitution formatting, and so on.
Quite frankly, string formatting would be deserving of a dedicated article, it’s that versatile. For now, I’m only considering covering the essentials, even if that means barely scratching the surface. More stuff about string formatting than I could possibly share in a small article like this can be found here.
# basic string formatting
my_string = "Today is {}"
print(f"{id(my_string)}: {my_string}")
my_second_string = my_string.format("Monday")
print(f"{id(my_second_string)}: {my_second_string}")# right alignment formatting
my_string = "Right aligned: {0:>20}.".format("Hello, world!")
print(f"{id(my_string)}: {my_string}")# left alignment formatting
my_string = "Left aligned: {0:<20}.".format("Hello, world!")
print(f"{id(my_string)}: {my_string}")# center alignment formatting
my_string = "Center aligned: {0:^20}.".format("Hello, world!")
print(f"{id(my_string)}: {my_string}")# hex formatting
my_string = "{0} is {0:x} in hex".format(65)
print(f"{id(my_string)}: {my_string}")# octal formatting
my_string = "{0} is {0:o} in oct".format(65)
print(f"{id(my_string)}: {my_string}")# pi as 5 decimals
my_string = "{0}: {1:7.5f}".format("Pi", 3.1415926535)
print(f"{id(my_string)}: {my_string}")# pi as 4 decimals and variable substitution
my_string = "{name}: {val:6.4f}".format(val=3.1415926535, name="Pi")
print(f"{id(my_string)}: {my_string}")# pi as 4 decimals and dictionary unpacking
values = {"value": 3.1415926535, "name": "Pi"}
my_string = "{name}: {value:6.4f}".format(**values)
print(f"{id(my_string)}: {my_string}")# pi as 4 decimals and format_map()
values = {"value": 3.1415926535, "name": "Pi"}
my_string = "{name}: {value:6.4f}".format_map(values)
print(f"{id(my_string)}: {my_string}")Output:
140259719878576: Today is {}
140259720144432: Today is Monday
140259720001552: Right aligned: Hello, world!.
140259720001744: Left aligned: Hello, world! .
140259720001552: Center aligned: Hello, world! .
140259720145520: 65 is 41 in hex
140259720082208: 65 is 101 in oct
140259720145520: Pi: 3.14159
140259720145584: Pi: 3.1416
140259720145520: Pi: 3.1416
140259720145584: Pi: 3.1416Substring index
Sometimes we’re interested to see where has a substring firstly occurred in a string. We could simply use string.find() for that, right? Well, it depends. If we want it to return -1 in case of failure, then yes. But if we’re counting on an exception being thrown in case the substring isn’t found, then we’re better off using string.index():
# construct the string
my_string = "Abcb"# find index of 'b'
index = my_string.index("b")
print(f"{index}")# try to find index of 'd'
index = my_string.index("d")1
Traceback (most recent call last):
...
index = my_string.index("d")
ValueError: substring not foundWe tried to find d in Abcb. Since it obviously didn’t find d anywhere in that string, it raised a ValueError exception for us to catch and do something with it.
Alpha-numeric string
Sometimes we need to check if all characters in a given string are alpha-numeric (they’re only letters and numbers):
# alpha-numeric string
my_string = "Abc123"
result = my_string.isalnum()
print(result)# non-alpha-numeric string
my_second_string = "Abc.123"
result = my_second_string.isalnum()
print(result)# empty string
my_empty_string = ""
result = my_empty_string.isalnum()
print(result)Output:
True
False
FalseAlpha string
Other times, we’re aiming to test if the string is only consisting of alphabet characters (only letters):
# alphabet string
my_string = "Abc"
result = my_string.isalpha()
print(result)# non-alphabet string
my_second_string = "Ab."
result = my_second_string.isalpha()
print(result)# empty string
my_empty_string = ""
result = my_empty_string.isalpha()
print(result)Output:
True
False
FalseASCII string
In other words, we check if the string only contains characters in the current standard ASCII range or not:
# construct an ascii string
my_string = "Abc"
result = my_string.isascii()
print(result)# empty string
my_empty_string = ""
result = my_empty_string.isascii()
print(result)# non-ascii string
my_non_ascii_string = 'This is not an ascii string \u0080'
result = my_non_ascii_string.isascii()
print(result)Output:
True
True
FalseDecimal string
It may be that sometimes a requirement is that a string is composed of only decimal characters. To that end, string.isdecimal() is available for us. Let’s see how that works:
# construct a non-decimal string
my_string = "Abc"
result = my_string.isdecimal()
print(result)# construct a decimal string
my_decimal_string = "123"
result = my_decimal_string.isdecimal()
print(result)# construct a decimal string with a decimal point
my_other_string = "123.5"
result = my_other_string.isdecimal()
print(result)# empty string
my_empty_string = ""
result = my_empty_string.isdecimal()
print(result)# still a non-decimal string
my_non_decimal_string = "²3455"
result = my_non_decimal_string.isdecimal()
print(result)Output:
False
True
False
False
FalseIt’s only decimal if every character is a decimal character. As we could see, superscript (exponent) characters or decimal points cause the check to fail, returning False.
Digit string
Similarly to string.isdecimal(), the string.isdigit() method checks if all characters are string representations of digits. Unlike string.isdecimal(), though, superscript (exponent) characters are considered digits:
# construct a non-digit string
my_string = "Abc"
result = my_string.isdigit()
print(result)# empty string
my_empty_string = ""
result = my_empty_string.isdigit()
print(result)# digit string
my_digit_string = "²3455"
result = my_digit_string.isdigit()
print(result)# a roman numeral string
my_roman_string = "ↁ"
result = my_roman_string.isdigit()
print(result)Output:
False
False
True
FalseTest if string is a valid identifier
The string.isidentifier() method will check if it can be considered a valid identifier in Python. An identifier is considered valid in Python if it only contains alphabet characters (letters), numbers, and underscores. Furthermore, it cannot contain spaces and cannot start with a digit.
# valid identifier
my_string = "Abc"
result = my_string.isidentifier()
print(result)# invalid identifier
my_other_string = "Abc def"
result = my_other_string.isidentifier()
print(result)# also invalid identifier
another_string = "123def"
result = another_string.isidentifier()
print(result)# empty string
my_empty_string = ""
result = my_empty_string.isidentifier()
print(result)Output:
True
False
False
FalseLowercase string
To test if all characters in one given string are lowercase, just use string.islower():
# not lowercase
my_string = "Abc"
result = my_string.islower()
print(result)# lowercase
my_second_string = "def"
result = my_second_string.islower()
print(result)# empty string
my_empty_string = ""
result = my_empty_string.islower()
print(result)Output:
False
True
FalseCheck if string is numeric
The string.isnumeric() method checks if all characters within the string are numeric. Very similar to the string.isdigit() method, except for the case of Roman numeral strings. This is the main difference between isnumeric() and isdigit(), as the former will return True in the case of a Roman numeral string, while the latter will return False:
# a non-numeric string
my_string = "Abc"
result = my_string.isnumeric()
print(result)# yet another non-numeric string
my_second_string = "12a"
result = my_second_string.isnumeric()
print(result)# a numeric string
my_numeric_string = "²3455"
result = my_numeric_string.isnumeric()
print(result)# an empty string
my_empty_string = ""
result = my_empty_string.isnumeric()
print(result)# a roman numeral string
my_roman_string = "ↁ"
result = my_roman_string.isnumeric()
print(result)Output:
False
False
True
False
TruePrintable strings
There is a way to check if all characters in a string are printable. Let’s demonstrate the string.isprintable() method:
# printable string
my_string = "Abc"
result = my_string.isprintable()
print(result)# empty string
my_empty_string = ""
result = my_empty_string.isprintable()
print(result)# non-printable string
my_non_printable_string = "\nDef"
result = my_non_printable_string.isprintable()
print(result)Output:
True
True
FalseTurns out, empty strings are printable :)
Space strings
If a string is only containing spaces or tabs, the string.isspace() method will come in handy:
# regular string
my_string = "Abc"
result = my_string.isspace()
print(result)# empty string
my_empty_string = ""
result = my_empty_string.isspace()
print(result)# contains spaces, but not only spaces
my_non_space_string = "De f"
result = my_non_space_string.isspace()
print(result)# whitespace string
my_space_string = "\t"
result = my_space_string.isspace()
print(result)# another whitespace string
my_other_space_string = "\t "
result = my_other_space_string.isspace()
print(result)Output:
False
False
False
True
TrueTitlecase string
A string is considered to be titlecase if the words that make it up are having their first letters capitalized:
# titlecase string
my_string = "Abc D Efg"
result = my_string.istitle()
print(result)# not a titlecase string
my_other_string = "Abc def"
result = my_other_string.istitle()
print(result)# an empty string
my_empty_string = ""
result = my_empty_string.istitle()
print(result)Output:
True
False
FalseString is all uppercase
The string class even has a method to check if the string object is exclusively composed of uppercase characters:
# not an uppercase string
my_string = "Abc"
result = my_string.isupper()
print(result)# an uppercase string
my_other_string = "DEF234-78U"
result = my_other_string.isupper()
print(result)# an empty string
my_empty_string = ""
result = my_empty_string.isupper()
print(result)Output:
False
True
FalseNote that the uppercase string we tested, DEF234-78U, has been judged as an actual uppercase string, even though it contains digits and other characters, like the dash symbol.
Join iterable elements into a string
In Python, we can have a list of elements joined into a string, using a separator string:
# define the separator string
my_string = ","# construct the iterator
my_list = ["a", "b", "c"]# join the iterator elements into a string
result = my_string.join(my_list)# print the resulting string
print(result)Output:
a,b,cLeft justify a string
Very straightforward, string.ljust() will do just what its name suggests. All it needs is the width of the space in relation to which the justifying takes place and an optional fill character to fill in the rest of the width space we just mentioned:
# a regular string
my_string = "Abc"
result = my_string.ljust(10, ".")
print(result)# an empty string
my_empty_string = ""
result = my_empty_string.ljust(10, ".")
print(result)Output:
Abc.......
..........Turn all characters lowercase
Another simple, straightforward, and very useful method, string.lower() will make sure your string stays lowercase:
# a regular string
my_string = "Abc"
result = my_string.lower()
print(f"|{result}|")# an empty string
my_empty_string = ""
result = my_empty_string.lower()
print(f"|{result}|")Output:
|abc|
||Had to use pipe symbols to emphasize the empty string result in the second test.
Strip leading whitespace
Eventually, you’ll stumble upon strings containing leading whitespace, like spaces or tabs. Python allows for a simple way of getting rid of the leading whitespace:
# construct the string
my_string = " \t Abc Def "
print(f"|{my_string}|")# left-strip the whitespace
result = my_string.lstrip()
print(f"|{result}|")# try the same with an empty string
my_empty_string = ""
result = my_empty_string.lstrip()
print(f"|{result}|")Output:
| Abc Def |
|Abc Def |
||Note that the method did nothing to alter the trailing whitespace, nor the whitespace from between the two substrings. It only affected the leading whitespace characters, effectively removing them and saving the result in another string.
Maketrans
This method creates a mapping of Unicode ASCII codes of characters, in the shape of a dictionary. Remember dictionaries?
We can give the method 1, 2, or even 3 arguments. If we’re supplying it with an argument, that argument needs to be a dictionary representing an actual mapping. If we’re giving it 2 arguments, as we’ll do in just a minute, they need to have the same length, to have the mapping work. Here’s more on this string.maketrans() method
# construct the two strings
my_first_string = "abc"
my_second_string = "def"# make the translation dictionary
result = str.maketrans(my_first_string, my_second_string)
print(result)Output:
{97: 100, 98: 101, 99: 102}The mapping process has the ASCII codes of the characters from the first string as keys (a is 97, b is 98, c is 99) and the ASCII codes of the characters belonging to the second string (d is 100, e is 101, f is 102) as their corresponding values.
Partition a string
Almost like str.split(), but not quite. Here’s why:
# a simple string
my_string = "abcbde"
result = my_string.partition("b")
print(result)# a second string
my_other_string = "abc"
result = my_other_string.partition("d")
print(result)# an empty string
my_empty_string = ""
result = my_empty_string.partition(",")
print(result)Output:
('a', 'b', 'cbde')
('abc', '', '')
('', '', '')The method needs a separator character to partition the string by. The method only takes the first occurrence (if any) of the separator.
The method is returning a tuple (see here for more on tuples) of exactly 3 elements:
- if the separator has been found within the string, the tuple contains the leading substring, the separator, and the trailing substring;
- if the separator doesn’t exist within the string, the tuple will contain the original string and two empty strings.
Remove prefix
Sometimes we just need a leading part of a string — the prefix — removed:
# regular string
my_string = "abc"
result = my_string.removeprefix("a")
print(f"|{result}|")# a second example - no prefix to remove
my_other_string = "abc"
result = my_other_string.removeprefix("d")
print(f"|{result}|")# a third example
my_third_string = "aabc"
result = my_third_string.removeprefix("a")
print(f"|{result}|")# an empty string
my_empty_string = ""
result = my_empty_string.removeprefix("a")
print(f"|{result}|")Output:
|bc|
|abc|
|abc|
||As can be clearly seen, this doesn’t affect subsequent occurrences of the same prefix. In other words, it does not behave recursively. For example, given aabc and the prefix to remove being a, the method only removes the first occurrence of the prefix.
Again, the pipe symbols are just there to help visualize the result on the fourth, empty string test.
Remove suffix
Same deal as str.removeprefix(), except that this time around it’s the suffix that gets eliminated. And, as we’ll see in just a sec, it doesn’t act in a recursive manner:
# first string
my_string = "abc"
result = my_string.removesuffix("c")
print(f"|{result}|")# another string - no suffix to remove
my_other_string = "abc"
result = my_other_string.removesuffix("d")
print(f"|{result}|")# a third example
my_third_string = "abcc"
result = my_third_string.removesuffix("c")
print(f"|{result}|")my_empty_string = ""
result = my_empty_string.removesuffix("c")
print(f"|{result}|")Output:
|ab|
|abc|
|abc|
||Replace substring
Easily one of the most widely used string methods (and not just in Python), string replacing is very straightforward: it seeks out any occurrences of one substring and replaces all of those with another, secondary substring that we specify. It can work as a substring eliminator too if the second substring we feed into the method is an empty string:
my_string = "abc"
result = my_string.replace("b", "d")
print(result)my_other_string = "abc"
result = my_other_string.replace("d", "e")
print(result)my_third_string = "abc"
result = my_third_string.replace("b", "")
print(result)Output:
adc
abc
acReturn rightmost occurrence of substring (rfind)
Very straightforward, this returns the rightmost (you could say the last) occurrence of a substring within a string, or -1 if it fails to find it. We can also give it the optional start and end arguments, so we don’t always need to search the entire string.
# find rightmost occurrence of "b" in "abcba"
my_string = "abcba"
result = my_string.rfind("b")
print(result)# "d" doesn't exist in "abcba"
my_other_string = "abcba"
result = my_other_string.rfind("d")
print(result)Output:
3
-1Return rightmost occurrence of substring (rindex)
Same deal as with str.rfind(), we can even supply it with start and end optional arguments, but we’ll get an exception thrown if the search failed, as opposed to -1 getting returned in such a case:
# find rightmost occurrence of "b" in "abcba"
my_string = "abcba"
result = my_string.rindex("b")
print(result)my_other_string = "abcba"
result = my_other_string.rindex("d")Output:
3
Traceback (most recent call last):
...
result = my_other_string.rindex("d")
ValueError: substring not foundRight justify a string
Like str.ljust(), except the justifying process is being done on the right side of the width:
# a regular string
my_string = "Abc"
result = my_string.rjust(10, ".")
print(result)# an empty string
my_empty_string = ""
result = my_empty_string.rjust(10, ".")
print(result)Output:
.......Abc
..........Right partitioning a string
Like str.partition(), except on the right side, meaning the search process is starting at the end:
# a simple string
my_string = "abcbde"
result = my_string.rpartition("b")
print(result)# a second string
my_other_string = "abc"
result = my_other_string.rpartition("d")
print(result)# an empty string
my_empty_string = ""
result = my_empty_string.rpartition(",")
print(result)Output:
('abc', 'b', 'de')
('', '', 'abc')
('', '', '')Right splitting a string
This method effectively splits a string into a tuple of substrings by a specified delimiter-string. The search is being done starting from the right and working its way up to the left:
# first example
my_string = "Abc"
result = my_string.rsplit("b")
print(result)# non-existent delimiter
my_other_string = "Abc"
result = my_string.rsplit("d")
print(result)# empty string
my_empty_string = ""
result = my_empty_string.rsplit("b")
print(result)Output:
['A', 'c']
['Abc']
['']Strip trailing whitespace
This is purely similar to str.lstrip(), that was effectively stripping out any leading whitespace characters (spaces, tabs, etc.), the sole difference being that this str.rstrip() is taking care of the trailing (rightmost) part:
# regular string, leading and trailing whitespace
my_string = " Abc Def \t"
print(f"|{my_string}|")# strip away the trailing whitespace
result = my_string.rstrip()
print(f"|{result}|")# empty string
my_empty_string = ""
result = my_empty_string.rstrip()
print(f"|{result}|")Output:
| Abc Def |
| Abc Def|
||Splitting a string
Entirely similar to str.rsplit() we showcased earlier, except for the fact that the search process begins at the left (starting) side, all the way to the right (ending) side of the string:
my_string = "Abc"
result = my_string.split("b")
print(result)my_other_string = "Abc"
result = my_string.split("d")
print(result)my_empty_string = ""
result = my_empty_string.split("b")
print(result)Output:
['A', 'c']
['Abc']
['']Splitting multiline strings
We can even turn a multiline string into a list of strings, using str.splitlines():
my_string = "Abc\nDef"
result = my_string.splitlines()
print(result)Output:
['Abc', 'Def']String starts with
Just as we have covered the str.endswith() method, so shall we demo the similar str.startswith() method:
my_string = "Abc"
print(f"{id(my_string)}: {my_string}")result = my_string.startswith("Ab")
print(f"{result}")Output:
139690571077232: Abc
TrueStrip leading and trailing whitespace
Combining the effects of both str.rstrip() and str.lstrip() methods, str.strip() effectively removes all leading and trailing whitespace characters (tabs, spaces, etc.):
my_string = " \t Abc Def \t"
print(f"|{my_string}|")result = my_string.strip()
print(f"|{result}|")my_empty_string = ""
result = my_empty_string.strip()
print(f"|{result}|")Output:
| Abc Def |
|Abc Def|
||Swapping uppercase with lowercase and vice-versa
Sometimes we may be required to swap the case for all of the characters in a string:
my_string = "Abc Def"
result = my_string.swapcase()
print(result)Output:
aBC dEFConvert a string to titlecase
As its name suggests, str.title() is effectively going to ensure that only the first letter of every word in the string gets capitalized:
my_string = "abc def"
result = my_string.title()
print(result)Output:
Abc DefTranslate string
Using a table of translations (using str.maketrans() we discussed earlier), we can easily translate a string into another:
# create translation table
keys = "abc"
values = "def"
table = str.maketrans(keys, values)# translate a string
my_string = "cba"
result = my_string.translate(table)
print(result)Output:
fedConvert a string to uppercase
All characters of a string will get turned to uppercase:
my_string = "abc"
result = my_string.upper()
print(result)Output:
ABCAdd leading zeroes to a string
Very straightforward, this will add as many leading zeroes as needed to fulfill the length argument:
my_string = "123"
result = my_string.zfill(2)
print(result)my_other_string = "123"\
result = my_other_string.zfill(8)
print(result)Output:
123
00000123Quite the long article on strings. In Python and pretty much anywhere else, strings really are a big deal. We so very rarely need to memorize anything, but we must absolutely learn one thing: where to look for the correct information. This article only served as a very quick demo of string methods we can use on Python string objects, but the learning process should by no means end here. The Internet is full of actual knowledge goldmines and what better place to start looking than the official docs pages?
Keep learning, keep getting better at what you do, and most importantly: stay safe and happy coding! I’ll see you at the next one!
More content at PlainEnglish.io. Sign up for our free weekly newsletter. Follow us on Twitter and LinkedIn. Check out our Community Discord and join our Talent Collective.
