Python lower() – How to Lowercase a Python String with the tolower Function Equivalent
Tantoluwa Heritage Alabi
A string is a datatype that consists of characters wrapped in quotation marks. These characters can be letters, symbols, or numbers.
In Python, there are different ways of working with strings. These methods are built-in functions that change the results of the string.
For instance, if I want to print out my name with its first letter capitalized, I use the .title() method to capitalize the first letter.
In this article, we will learn how to convert uppercase letters to lowercase letters without using the built-in method.
How to Convert a String to Lowercase using .lower()
Strings can consist of different characters – one of those characters being letters of the alphabet. You can write the English alphabet as uppercase or lowercase letters. When changing a string to lowercase, it only applies to the letters.
In Python, there is a built-in method that can change a string that is in uppercase to lowercase. It also applies to strings that have letters both in uppercase and lowercase. The “.lower() “ method changes the strings to lowercase.
We can see in the above code block that the variables that store each string have uppercase letters. Then with the .lower() method, it converts those letters to lowercase.
Other Ways to Convert a Python String to Lowercase
Apart from the inbuilt method “.lower()”, there are different ways of converting uppercase letters to lowercase letters in Python. In this article, we will look at two different ways.
There are two ways of accessing letters:
- copying them manually into a list or
- making use of Unicode standard
How to Access Letters from a List
The idea is to loop through a list of letters and replace the uppercase letters in a string with lowercase letters.
First, create a variable that stores an input that accepts a string with uppercase letters.
Then, create another variable that stores a list of uppercase letters and lowercase letters.
Last, create the final variable that stores an empty string, which is where the lowercase letters will be stored.
In the list above, we see that it has lowercase letters and uppercase letters. There are 26 letters in the English alphabet, but the index in a list starts from 0, so the count of the alphabet is 51 (for both upper and lowercase letters).
We can also see that the lowercase letters are written first (left side), and the uppercase letters are written second (right side). The indexes of the lowercase letters range from 0 — 25, while the indexes of the upper case letters ranges from 26 — 51.
Next, we loop through each character in the string.
<char> is the new variable name that stores all the characters from the <word> variable.
There are two cases of strings we are going to convert. The first case is the strings with only uppercase letters and the second has strings with special symbols, numerals, some lowercase, and some uppercase letters.
CASE I: strings with uppercase only
To convert the uppercase letters to lowercase, we have to find the index of each letter stored by the variable <char> from the list. To find an index we use the «.index()» method:
In the above code, the indexes of the letters in the <word> «GIRL» are printed.
In the list, the lowercase letters have indexes from 0-25 and uppercase letters have indexes from 26 — 51. When setting the condition («if» statement) we start checking if the index of the letter is greater than ’25’ because the first uppercase index starts from ’26’ .
To get the corresponding lowercase letters, we substract 26 from each uppercase index. When we get the indexes of the lowercase numbers, we use indexing (variable_name[index_number]) to find the corresponding letters. The lowercase letters are now added to the variable name <lower_case_letters> that stores an empty string.
We return the variable <lowercase_letters> by printing it outside the loop.
This is what the code looks like when we bring it all together:
CASE II: strings with special symbols, numerals, lowercase letters alongside uppercase letters.
Before converting the uppercase letters to lowercase, there are some conditions we need to check. The conditions will check if each character <char> from the word:
- is not a letter
- has both uppercase and lowercase letters in the word. If some letters in the word are lowercase, they will be left unchanged.
After these checks, it assumes the remaining characters are uppercase letters.
To check if a character is not a letter, we use the “not in” keyword. To check if a character is lowercase, we find the index and compare it to the last count of the lowercase letters in the list.
Again, lowercase letters have indexes from 0-25, and the index of the last lowercase letter <z> is 25. These characters are added to the variable name <lower_case_letters> that stores an empty string.
In the above code block, we used the .index() method to find the position of letters in the alphabet.
For the remaining characters that we assume are uppercase letters, in the list of letters, the indexes of those letters are from 26 — 51. To find their corresponding lowercase letter indexes, we subtract by 26, and use the .index() method to find the letter.
Indexing = variable_name[index_number]. We add the final result to the variable storing the empty string.
Then we print lowercase_letters outside the loop:
This is what the code looks like when we bring it all together:
How to Access Letters using the Unicode Standard
Unicode means universal character encoding standard. According to unicode.org,
In simple terms, all letters from different languages have a unique number representing every character present in Unicode.
We use two methods when working with Unicode in Python: ord() and chr() .
- ord(): this function accepts characters (letters in any language) and returns the unique number under the Unicode standard.
- chr(): this function accepts integers and returns the character equivalent under the Unicode standard.
Before diving into the code explanation, here is a chart containing all the unique numbers for the English alphabet, both lowercase and uppercase letters.
Now that we are familiar with what Unicode is and how to access the values in Python, let’s dive in.
First, create a variable that stores an input that accepts a string with uppercase letters.
Then, create the final variable that stores an empty string, which is where the lowercase letters will be stored.
Then we loop through each character in the string.
<char> is the new variable name that stores all the characters from the <word> variable.
CASE I: strings containing uppercase letters only.
Before converting the uppercase letters to lowercase, we need to check if each character <char> from the word is in uppercase.
According to the Unicode chart, the capital letter A has the number “65”, and the capital letter Z has the number “90”. We check if each character <char> in <word> has numbers between 65 and 90. If they do, they are uppercase letters.
The ord() function returns the unique number of each letter in uppercase.
To convert uppercase letters to lowercase letters, we add the difference between both cases, “32”, to each number from the uppercase to get the lower case letters.
In the above code, ‘a” is 97 on the unicode chart and ‘A’ is 65. The difference between them is 32. If we want to get the value of “a” on the chart, we add 32 to the value of A “65” and get “97”.
So to convert to lowercase, we have to add 32 to each of the numbers of the uppercase letters to get their corresponding lowercase letters.
In the above code, we loop through the variable <word> to get access to each character.
Then we check if each character in the variable <word> has a unique number between 65 and 90. If it does, it consists of uppercase letters.
To get the corresponding lowercase letters, we add 32. The result above prints the unique numbers of lowercase letters.
We can match the numbers with their letters by using the chr() function.
Now we see that the letters returned are in lowercase. To get the letters in one line, we add it to the variable that stores the empty string and return the variable.
Here’s what it looks like when we bring it all together:
CASE II: strings with special symbols, numerals, lowercase alongside uppercase letters.
For strings that have non-letters and some lowercase letters, we add an ‘else’ statement to return the values as they appear in the string. The uppercase letters are then converted to lowercase:
Here’s what it looks like when we bring it all together:
I know the second method is a lot take in but it also gets you the result, just as the first method does.
Summary
In this article, you’ve learnt about how to convert characters and strings from one case to another. We also took a look at the ASCII table.
The second method is more efficient and straightforward once you know how to use the two important functions. The indexes of the letters are built-in in Python, so there’s no need to memorize them.
# String Methods
Python’s string type provides many functions that act on the capitalization of a string. These include :
- str.casefold
- str.upper
- str.lower
- str.capitalize
- str.title
- str.swapcase
With unicode strings (the default in Python 3), these operations are not 1:1 mappings or reversible. Most of these operations are intended for display purposes, rather than normalization.
# str.casefold()
str.casefold creates a lowercase string that is suitable for case insensitive comparisons. This is more aggressive than str.lower and may modify strings that are already in lowercase or cause strings to grow in length, and is not intended for display purposes.
The transformations that take place under casefolding are defined by the Unicode Consortium in the CaseFolding.txt file on their website.
# str.upper()
str.upper takes every character in a string and converts it to its uppercase equivalent, for example:
# str.lower()
str.lower does the opposite; it takes every character in a string and converts it to its lowercase equivalent:
# str.capitalize()
str.capitalize returns a capitalized version of the string, that is, it makes the first character have upper case and the rest lower:
# str.title()
str.title returns the title cased version of the string, that is, every letter in the beginning of a word is made upper case and all others are made lower case:
# str.swapcase()
str.swapcase returns a new string object in which all lower case characters are swapped to upper case and all upper case characters to lower:
# Usage as str class methods
It is worth noting that these methods may be called either on string objects (as shown above) or as a class method of the str class (with an explicit call to str.upper , etc.)
This is most useful when applying one of these methods to many strings at once in say, a map
# str.translate: Translating characters in a string
Python supports a translate method on the str type which allows you to specify the translation table (used for replacements) as well as any characters which should be deleted in the process.
The translate method returns a string which is a translated copy of the original string.
You can set the table argument to None if you only need to delete characters.
# str.format and f-strings: Format values into a string
Python provides string interpolation and formatting functionality through the str.format function, introduced in version 2.6 and f-strings introduced in version 3.6.
Given the following variables:
The following statements are all equivalent
For reference, Python also supports C-style qualifiers for string formatting. The examples below are equivalent to those above, but the str.format versions are preferred due to benefits in flexibility, consistency of notation, and extensibility:
The braces uses for interpolation in str.format can also be numbered to reduce duplication when formatting strings. For example, the following are equivalent:
While the official python documentation is, as usual, thorough enough, pyformat.info
(opens new window) has a great set of examples with detailed explanations.
Additionally, the < and >characters can be escaped by using double brackets:
(opens new window) for additional information. str.format() was proposed in PEP 3101
# String module’s useful constants
Python’s string module provides constants for string related operations. To use them, import the string module:
# string.ascii_letters :
Concatenation of ascii_lowercase and ascii_uppercase :
# string.ascii_lowercase :
Contains all lower case ASCII characters:
# string.ascii_uppercase :
Contains all upper case ASCII characters:
# string.digits :
Contains all decimal digit characters:
# string.hexdigits :
Contains all hex digit characters:
# string.octaldigits :
Contains all octal digit characters:
# string.punctuation :
Contains all characters which are considered punctuation in the C locale:
# string.whitespace :
Contains all ASCII characters considered whitespace:
In script mode, print(string.whitespace) will print the actual characters, use str to get the string returned above.
# string.printable :
Contains all characters which are considered printable; a combination of string.digits , string.ascii_letters , string.punctuation , and string.whitespace .
# Split a string based on a delimiter into a list of strings
# str.split(sep=None, maxsplit=-1)
str.split takes a string and returns a list of substrings of the original string. The behavior differs depending on whether the sep argument is provided or omitted.
If sep isn’t provided, or is None , then the splitting takes place wherever there is whitespace. However, leading and trailing whitespace is ignored, and multiple consecutive whitespace characters are treated the same as a single whitespace character:
The sep parameter can be used to define a delimiter string. The original string is split where the delimiter string occurs, and the delimiter itself is discarded. Multiple consecutive delimiters are not treated the same as a single occurrence, but rather cause empty strings to be created.
The default is to split on every occurrence of the delimiter, however the maxsplit parameter limits the number of splittings that occur. The default value of -1 means no limit:
# str.rsplit(sep=None, maxsplit=-1)
str.rsplit ("right split") differs from str.split ("left split") when maxsplit is specified. The splitting starts at the end of the string rather than at the beginning:
Note: Python specifies the maximum number of splits performed, while most other programming languages specify the maximum number of substrings created. This may create confusion when porting or comparing code.
# Replace all occurrences of one substring with another substring
Python’s str type also has a method for replacing occurences of one sub-string with another sub-string in a given string. For more demanding cases, one can use re.sub
# str.replace(old, new[, count]) :
str.replace takes two arguments old and new containing the old sub-string which is to be replaced by the new sub-string. The optional argument count specifies the number of replacements to be made:
For example, in order to replace ‘foo’ with ‘spam’ in the following string, we can call str.replace with old = ‘foo’ and new = ‘spam’ :
If the given string contains multiple examples that match the old argument, all occurrences are replaced with the value supplied in new :
unless, of course, we supply a value for count . In this case count occurrences are going to get replaced:
# Testing what a string is composed of
Python’s str type also features a number of methods that can be used to evaluate the contents of a string. These are str.isalpha , str.isdigit , str.isalnum , str.isspace . Capitalization can be tested with str.isupper , str.islower and str.istitle .
# str.isalpha
str.isalpha takes no arguments and returns True if the all characters in a given string are alphabetic, for example:
As an edge case, the empty string evaluates to False when used with "".isalpha() .
# str.isupper , str.islower , str.istitle
These methods test the capitalization in a given string.
str.isupper is a method that returns True if all characters in a given string are uppercase and False otherwise.
Conversely, str.islower is a method that returns True if all characters in a given string are lowercase and False otherwise.
str.istitle returns True if the given string is title cased; that is, every word begins with an uppercase character followed by lowercase characters.
# str.isdecimal , str.isdigit , str.isnumeric
str.isdecimal returns whether the string is a sequence of decimal digits, suitable for representing a decimal number.
str.isdigit includes digits not in a form suitable for representing a decimal number, such as superscript digits.
str.isnumeric includes any number values, even if not digits, such as values outside the range 0-9.
Bytestrings ( bytes in Python 3, str in Python 2), only support isdigit , which only checks for basic ASCII digits.
As with str.isalpha , the empty string evaluates to False .
# str.isalnum
This is a combination of str.isalpha and str.isnumeric , specifically it evaluates to True if all characters in the given string are alphanumeric, that is, they consist of alphabetic or numeric characters:
# str.isspace
Evaluates to True if the string contains only whitespace characters.
Sometimes a string looks “empty” but we don’t know whether it’s because it contains just whitespace or no character at all
To cover this case we need an additional test
But the shortest way to test if a string is empty or just contains whitespace characters is to use strip
(opens new window) (with no arguments it removes all leading and trailing whitespace characters)
# Stripping unwanted leading/trailing characters from a string
Three methods are provided that offer the ability to strip leading and trailing characters from a string: str.strip , str.rstrip and str.lstrip . All three methods have the same signature and all three return a new string object with unwanted characters removed.
# str.strip([chars])
str.strip acts on a given string and removes (strips) any leading or trailing characters contained in the argument chars ; if chars is not supplied or is None , all white space characters are removed by default. For example:
If chars is supplied, all characters contained in it are removed from the string, which is returned. For example:
# str.rstrip([chars]) and str.lstrip([chars])
These methods have similar semantics and arguments with str.strip() , their difference lies in the direction from which they start. str.rstrip() starts from the end of the string while str.lstrip() splits from the start of the string.
For example, using str.rstrip :
While, using str.lstrip :
# Reversing a string
A string can reversed using the built-in reversed() function, which takes a string and returns an iterator in reverse order.
reversed() can be wrapped in a call to ».join() to make a string
While using reversed() might be more readable to uninitiated Python users, using extended slicing
(opens new window) with a step of -1 is faster and more concise. Here , try to implement it as function:
# Join a list of strings into one string
A string can be used as a separator to join a list of strings together into a single string using the join() method. For example you can create a string where each element in a list is separated by a space.
The following example separates the string elements with three hyphens.
# String Contains
Python makes it extremely intuitive to check if a string contains a given substring. Just use the in operator:
Note: testing an empty string will always result in True :
# Counting number of times a substring appears in a string
One method is available for counting the number of occurrences of a sub-string in another string, str.count .
# str.count(sub[, start[, end]])
str.count returns an int indicating the number of non-overlapping occurrences of the sub-string sub in another string. The optional arguments start and end indicate the beginning and the end in which the search will take place. By default start = 0 and end = len(str) meaning the whole string will be searched:
By specifying a different value for start , end we can get a more localized search and count, for example, if start is equal to 13 the call to:
is equivalent to:
# Case insensitive string comparisons
Comparing string in a case insensitive way seems like something that’s trivial, but it’s not. This section only considers unicode strings (the default in Python 3). Note that Python 2 may have subtle weaknesses relative to Python 3 — the later’s unicode handling is much more complete.
The first thing to note it that case-removing conversions in unicode aren’t trivial. There is text for which text.lower() != text.upper().lower() , such as "ß" :
But let’s say you wanted to caselessly compare "BUSSE" and "Buße" . Heck, you probably also want to compare "BUSSE" and "BUẞE" equal — that’s the newer capital form. The recommended way is to use casefold :
Do not just use lower . If casefold is not available, doing .upper().lower() helps (but only somewhat).
Then you should consider accents. If your font renderer is good, you probably think "ê" == "ê" — but it doesn’t:
This is because they are actually
The simplest way to deal with this is unicodedata.normalize . You probably want to use NFKD normalization, but feel free to check the documentation. Then one does
To finish up, here this is expressed in functions:
# Test the starting and ending characters of a string
In order to test the beginning and ending of a given string in Python, one can use the methods str.startswith() and str.endswith() .
# str.startswith(prefix[, start[, end]])
As it’s name implies, str.startswith is used to test whether a given string starts with the given characters in prefix .
The optional arguments start and end specify the start and end points from which the testing will start and finish. In the following example, by specifying a start value of 2 our string will be searched from position 2 and afterwards:
This yields True since s[2] == ‘i’ and s[3] == ‘s’ .
You can also use a tuple to check if it starts with any of a set of strings
# str.endswith(prefix[, start[, end]])
str.endswith is exactly similar to str.startswith with the only difference being that it searches for ending characters and not starting characters. For example, to test if a string ends in a full stop, one could write:
as with startswith more than one characters can used as the ending sequence:
You can also use a tuple to check if it ends with any of a set of strings
# Justify strings
Python provides functions for justifying strings, enabling text padding to make aligning various strings much easier.
Below is an example of str.ljust and str.rjust :
ljust and rjust are very similar. Both have a width parameter and an optional fillchar parameter. Any string created by these functions is at least as long as the width parameter that was passed into the function. If the string is longer than width alread, it is not truncated. The fillchar argument, which defaults to the space character ‘ ‘ must be a single character, not a multicharacter string.
The ljust function pads the end of the string it is called on with the fillchar until it is width characters long. The rjust function pads the beginning of the string in a similar fashion. Therefore, the l and r in the names of these functions refer to the side that the original string, not the fillchar , is positioned in the output string.
# Conversion between str or bytes data and unicode characters
The contents of files and network messages may represent encoded characters. They often need to be converted to unicode for proper display.
In Python 2, you may need to convert str data to Unicode characters. The default ( » , "" , etc.) is an ASCII string, with any values outside of ASCII range displayed as escaped values. Unicode strings are u» (or u"" , etc.).
In Python 3 you may need to convert arrays of bytes (referred to as a ‘byte literal’) to strings of Unicode characters. The default is now a Unicode string, and bytestring literals must now be entered as b» , b"" , etc. A byte literal will return True to isinstance(some_val, byte) , assuming some_val to be a string that might be encoded as bytes.
# Syntax
- str.capitalize() -> str
- str.casefold() -> str [only for Python > 3.3]
- str.center(width[, fillchar]) -> str
- str.count(sub[, start[, end]]) -> int
- str.decode(encoding="utf-8"[, errors]) -> unicode [only in Python 2.x]
- str.encode(encoding="utf-8", errors="strict") -> bytes
- str.endswith(suffix[, start[, end]]) -> bool
- str.expandtabs(tabsize=8) -> str
- str.find(sub[, start[, end]]) -> int
- str.format(*args, **kwargs) -> str
- str.format_map(mapping) -> str
- str.index(sub[, start[, end]]) -> int
- str.isalnum() -> bool
- str.isalpha() -> bool
- str.isdecimal() -> bool
- str.isdigit() -> bool
- str.isidentifier() -> bool
- str.islower() -> bool
- str.isnumeric() -> bool
- str.isprintable() -> bool
- str.isspace() -> bool
- str.istitle() -> bool
- str.isupper() -> bool
- str.join(iterable) -> str
- str.ljust(width[, fillchar]) -> str
- str.lower() -> str
- str.lstrip([chars]) -> str
- static str.maketrans(x[, y[, z]])
- str.partition(sep) -> (head, sep, tail)
- str.replace(old, new[, count]) -> str
- str.rfind(sub[, start[, end]]) -> int
- str.rindex(sub[, start[, end]]) -> int
- str.rjust(width[, fillchar]) -> str
- str.rpartition(sep) -> (head, sep, tail)
- str.rsplit(sep=None, maxsplit=-1) -> list of strings
- str.rstrip([chars]) -> str
- str.split(sep=None, maxsplit=-1) -> list of strings
- str.splitlines([keepends]) -> list of strings
- str.startswith(prefix[, start[, end]]) -> book
- str.strip([chars]) -> str
- str.swapcase() -> str
- str.title() -> str
- str.translate(table) -> str
- str.upper() -> str
- str.zfill(width) -> str
# Remarks
String objects are immutable, meaning that they can’t be modified in place the way a list can. Because of this, methods on the built-in type str always return a new str object, which contains the result of the method call.
Что такое lower в python
Python String lower() method converts all uppercase characters in a string into lowercase characters and returns it. In this article, we will cover how lower() is used in a program to convert uppercase to lowercase in Python. Here we will also cover casefold and swapcase function to lower our string.
Syntax of String lower()
Parameters: The lower() method doesn’t take any parameters.
Returns: Returns a lowercase string of the given string