Как сделать регистр нижним а питоне

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.

Как сделать регистр нижним а питоне

Python String lower() method converts all uppercase characters in a string into lowercase characters and returns it. In this article, we will cover how to convert uppercase to lowercase in Python.

Here we will also cover casefold and swapcase function to lower our string.

Syntax of .lower() function

Syntax: string.lower()

Parameters: The lower() method doesn’t take any parameters.

Returns: Returns a lowercase string of the given string

How do I lowercase a string in Python?

However, if the purpose is to do case insensitive matching, you should use case-folding:

This is a str method in Python 3, but in Python 2, you’ll want to look at the PyICU or py2casefold — several answers address this here.

Unicode Python 3

Python 3 handles plain string literals as unicode:

Python 2, plain string literals are bytes

In Python 2, the below, pasted into a shell, encodes the literal as a string of bytes, using utf-8 .

And lower doesn’t map any changes that bytes would be aware of, so we get the same string.

In scripts, Python will object to non-ascii (as of Python 2.5, and warning in Python 2.4) bytes being in a string with no encoding given, since the intended coding would be ambiguous. For more on that, see the Unicode how-to in the docs and PEP 263

Use Unicode literals, not str literals

So we need a unicode string to handle this conversion, accomplished easily with a unicode string literal, which disambiguates with a u prefix (and note the u prefix also works in Python 3):

Note that the bytes are completely different from the str bytes — the escape character is ‘\u’ followed by the 2-byte width, or 16 bit representation of these unicode letters:

Now if we only have it in the form of a str , we need to convert it to unicode . Python’s Unicode type is a universal encoding format that has many advantages relative to most other encodings. We can either use the unicode constructor or str.decode method with the codec to convert the str to unicode :

Both methods convert to the unicode type — and same as the unicode_literal.

Best Practice, use Unicode

It is recommended that you always work with text in Unicode.

Software should only work with Unicode strings internally, converting to a particular encoding on output.

Can encode back when necessary

However, to get the lowercase back in type str , encode the python string to utf-8 again:

So in Python 2, Unicode can encode into Python strings, and Python strings can decode into the Unicode type.

string — Common string operations¶

The concatenation of the ascii_lowercase and ascii_uppercase constants described below. This value is not locale-dependent.

The lowercase letters ‘abcdefghijklmnopqrstuvwxyz’ . This value is not locale-dependent and will not change.

The uppercase letters ‘ABCDEFGHIJKLMNOPQRSTUVWXYZ’ . This value is not locale-dependent and will not change.

The string ‘0123456789’ .

The string ‘0123456789abcdefABCDEF’ .

The string ‘01234567’ .

String of ASCII characters which are considered punctuation characters in the C locale: !"#$%&'()*+,-./:;<=>?@[\]^_`

String of ASCII characters which are considered printable. This is a combination of digits , ascii_letters , punctuation , and whitespace .

A string containing all ASCII characters that are considered whitespace. This includes the characters space, tab, linefeed, return, formfeed, and vertical tab.

Custom String Formatting¶

The built-in string class provides the ability to do complex variable substitutions and value formatting via the format() method described in PEP 3101. The Formatter class in the string module allows you to create and customize your own string formatting behaviors using the same implementation as the built-in format() method.

class string. Formatter ¶

The Formatter class has the following public methods:

The primary API method. It takes a format string and an arbitrary set of positional and keyword arguments. It is just a wrapper that calls vformat() .

Changed in version 3.7: A format string argument is now positional-only .

This function does the actual work of formatting. It is exposed as a separate function for cases where you want to pass in a predefined dictionary of arguments, rather than unpacking and repacking the dictionary as individual arguments using the *args and **kwargs syntax. vformat() does the work of breaking up the format string into character data and replacement fields. It calls the various methods described below.

In addition, the Formatter defines a number of methods that are intended to be replaced by subclasses:

Loop over the format_string and return an iterable of tuples (literal_text, field_name, format_spec, conversion). This is used by vformat() to break the string into either literal text, or replacement fields.

The values in the tuple conceptually represent a span of literal text followed by a single replacement field. If there is no literal text (which can happen if two replacement fields occur consecutively), then literal_text will be a zero-length string. If there is no replacement field, then the values of field_name, format_spec and conversion will be None .

get_field ( field_name , args , kwargs ) ¶

Given field_name as returned by parse() (see above), convert it to an object to be formatted. Returns a tuple (obj, used_key). The default version takes strings of the form defined in PEP 3101, such as “0[name]” or “label.title”. args and kwargs are as passed in to vformat() . The return value used_key has the same meaning as the key parameter to get_value() .

Retrieve a given field value. The key argument will be either an integer or a string. If it is an integer, it represents the index of the positional argument in args; if it is a string, then it represents a named argument in kwargs.

The args parameter is set to the list of positional arguments to vformat() , and the kwargs parameter is set to the dictionary of keyword arguments.

For compound field names, these functions are only called for the first component of the field name; subsequent components are handled through normal attribute and indexing operations.

So for example, the field expression ‘0.name’ would cause get_value() to be called with a key argument of 0. The name attribute will be looked up after get_value() returns by calling the built-in getattr() function.

If the index or keyword refers to an item that does not exist, then an IndexError or KeyError should be raised.

check_unused_args ( used_args , args , kwargs ) ¶

Implement checking for unused arguments if desired. The arguments to this function is the set of all argument keys that were actually referred to in the format string (integers for positional arguments, and strings for named arguments), and a reference to the args and kwargs that was passed to vformat. The set of unused args can be calculated from these parameters. check_unused_args() is assumed to raise an exception if the check fails.

format_field ( value , format_spec ) ¶

format_field() simply calls the global format() built-in. The method is provided so that subclasses can override it.

convert_field ( value , conversion ) ¶

Converts the value (returned by get_field() ) given a conversion type (as in the tuple returned by the parse() method). The default version understands ‘s’ (str), ‘r’ (repr) and ‘a’ (ascii) conversion types.

Format String Syntax¶

The str.format() method and the Formatter class share the same syntax for format strings (although in the case of Formatter , subclasses can define their own format string syntax). The syntax is related to that of formatted string literals , but it is less sophisticated and, in particular, does not support arbitrary expressions.

Format strings contain “replacement fields” surrounded by curly braces <> . Anything that is not contained in braces is considered literal text, which is copied unchanged to the output. If you need to include a brace character in the literal text, it can be escaped by doubling: << and >> .

The grammar for a replacement field is as follows:

In less formal terms, the replacement field can start with a field_name that specifies the object whose value is to be formatted and inserted into the output instead of the replacement field. The field_name is optionally followed by a conversion field, which is preceded by an exclamation point ‘!’ , and a format_spec, which is preceded by a colon ‘:’ . These specify a non-default format for the replacement value.

The field_name itself begins with an arg_name that is either a number or a keyword. If it’s a number, it refers to a positional argument, and if it’s a keyword, it refers to a named keyword argument. If the numerical arg_names in a format string are 0, 1, 2, … in sequence, they can all be omitted (not just some) and the numbers 0, 1, 2, … will be automatically inserted in that order. Because arg_name is not quote-delimited, it is not possible to specify arbitrary dictionary keys (e.g., the strings ’10’ or ‘:-]’ ) within a format string. The arg_name can be followed by any number of index or attribute expressions. An expression of the form ‘.name’ selects the named attribute using getattr() , while an expression of the form ‘[index]’ does an index lookup using __getitem__() .

Changed in version 3.1: The positional argument specifiers can be omitted for str.format() , so ‘<> <>‘.format(a, b) is equivalent to ‘ <0><1>‘.format(a, b) .

Changed in version 3.4: The positional argument specifiers can be omitted for Formatter .

Some simple format string examples:

The conversion field causes a type coercion before formatting. Normally, the job of formatting a value is done by the __format__() method of the value itself. However, in some cases it is desirable to force a type to be formatted as a string, overriding its own definition of formatting. By converting the value to a string before calling __format__() , the normal formatting logic is bypassed.

Three conversion flags are currently supported: ‘!s’ which calls str() on the value, ‘!r’ which calls repr() and ‘!a’ which calls ascii() .

The format_spec field contains a specification of how the value should be presented, including such details as field width, alignment, padding, decimal precision and so on. Each value type can define its own “formatting mini-language” or interpretation of the format_spec.

Most built-in types support a common formatting mini-language, which is described in the next section.

A format_spec field can also include nested replacement fields within it. These nested replacement fields may contain a field name, conversion flag and format specification, but deeper nesting is not allowed. The replacement fields within the format_spec are substituted before the format_spec string is interpreted. This allows the formatting of a value to be dynamically specified.

See the Format examples section for some examples.

Format Specification Mini-Language¶

“Format specifications” are used within replacement fields contained within a format string to define how individual values are presented (see Format String Syntax and Formatted string literals ). They can also be passed directly to the built-in format() function. Each formattable type may define how the format specification is to be interpreted.

Most built-in types implement the following options for format specifications, although some of the formatting options are only supported by the numeric types.

A general convention is that an empty format specification produces the same result as if you had called str() on the value. A non-empty format specification typically modifies the result.

The general form of a standard format specifier is:

If a valid align value is specified, it can be preceded by a fill character that can be any character and defaults to a space if omitted. It is not possible to use a literal curly brace (” < ” or “ >”) as the fill character in a formatted string literal or when using the str.format() method. However, it is possible to insert a curly brace with a nested replacement field. This limitation doesn’t affect the format() function.

The meaning of the various alignment options is as follows:

Note that unless a minimum field width is defined, the field width will always be the same size as the data to fill it, so that the alignment option has no meaning in this case.

The sign option is only valid for number types, and can be one of the following:

The ‘z’ option coerces negative zero floating-point values to positive zero after rounding to the format precision. This option is only valid for floating-point presentation types.

Changed in version 3.11: Added the ‘z’ option (see also PEP 682).

The ‘#’ option causes the “alternate form” to be used for the conversion. The alternate form is defined differently for different types. This option is only valid for integer, float and complex types. For integers, when binary, octal, or hexadecimal output is used, this option adds the respective prefix ‘0b’ , ‘0o’ , ‘0x’ , or ‘0X’ to the output value. For float and complex the alternate form causes the result of the conversion to always contain a decimal-point character, even if no digits follow it. Normally, a decimal-point character appears in the result of these conversions only if a digit follows it. In addition, for ‘g’ and ‘G’ conversions, trailing zeros are not removed from the result.

The ‘,’ option signals the use of a comma for a thousands separator. For a locale aware separator, use the ‘n’ integer presentation type instead.

Changed in version 3.1: Added the ‘,’ option (see also PEP 378).

The ‘_’ option signals the use of an underscore for a thousands separator for floating point presentation types and for integer presentation type ‘d’ . For integer presentation types ‘b’ , ‘o’ , ‘x’ , and ‘X’ , underscores will be inserted every 4 digits. For other presentation types, specifying this option is an error.

Changed in version 3.6: Added the ‘_’ option (see also PEP 515).

width is a decimal integer defining the minimum total field width, including any prefixes, separators, and other formatting characters. If not specified, then the field width will be determined by the content.

When no explicit alignment is given, preceding the width field by a zero ( ‘0’ ) character enables sign-aware zero-padding for numeric types. This is equivalent to a fill character of ‘0’ with an alignment type of ‘=’ .

Changed in version 3.10: Preceding the width field by ‘0’ no longer affects the default alignment for strings.

The precision is a decimal integer indicating how many digits should be displayed after the decimal point for presentation types ‘f’ and ‘F’ , or before and after the decimal point for presentation types ‘g’ or ‘G’ . For string presentation types the field indicates the maximum field size — in other words, how many characters will be used from the field content. The precision is not allowed for integer presentation types.

Finally, the type determines how the data should be presented.

The available string presentation types are:

The available integer presentation types are:

In addition to the above presentation types, integers can be formatted with the floating point presentation types listed below (except ‘n’ and None ). When doing so, float() is used to convert the integer to a floating point number before formatting.

The available presentation types for float and Decimal values are:

Format examples¶

This section contains examples of the str.format() syntax and comparison with the old % -formatting.

In most of the cases the syntax is similar to the old % -formatting, with the addition of the <> and with : used instead of % . For example, ‘%03.2f’ can be translated to ‘<:03.2f>‘ .

The new format syntax also supports new and different options, shown in the following examples.