Hướng dẫn dùng members syn python
The Show 7.1.1. String constants¶The constants defined in this module are: string. ascii_letters ¶The concatenation of the string. ascii_lowercase ¶The lowercase letters string. ascii_uppercase ¶The uppercase letters string. digits ¶The string
string. hexdigits ¶The string string. letters ¶The concatenation of the strings string. lowercase ¶A string containing all the characters that are considered lowercase letters. On most systems this is the string string. octdigits ¶The string string. punctuation ¶String of ASCII characters which are considered punctuation
characters in the string. printable ¶String of characters which are considered printable. This is a combination of string. uppercase ¶A string containing all the characters that are considered uppercase letters. On most systems this is the string string. whitespace ¶A string containing all characters that are considered whitespace. On most systems this includes the characters space, tab, linefeed, return, formfeed, and vertical tab. 7.1.2. Custom String Formatting¶New in version 2.6. The built-in str and unicode classes provide the ability to do complex variable substitutions and value formatting via the string. Formatter ¶The format (format_string, *args, **kwargs)¶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 (format_string, args, kwargs)¶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 In addition, the parse (format_string)¶Loop over the
format_string and return an iterable of tuples (literal_text, field_name, format_spec, conversion). This is used by 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 get_field (field_name, args,
kwargs)¶Given field_name as returned by get_value (key, args, kwargs)¶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 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 If the index or keyword refers to an item that does not exist, then an
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. format_field (value,
format_spec)¶
convert_field (value, conversion)¶Converts the value (returned by
7.1.3. Format String Syntax¶The Format strings contain “replacement fields” surrounded by curly braces 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 See also the Format Specification Mini-Language section. 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 Changed in version 2.7: The positional argument specifiers can be omitted for
Some simple format string examples: "First, thou shalt count to {0}" # References first positional argument "Bring me a {}" # Implicitly references the first positional argument "From {} to {}" # Same as "From {0} to {1}" "My quest is {name}" # References keyword argument 'name' "Weight in tons {0.weight}" # 'weight' attribute of first positional arg "Units destroyed: {players[0]}" # First element of keyword argument 'players'. The conversion field causes a type coercion before formatting. Normally, the job of formatting a value is done by the Two conversion flags are currently supported: Some examples: "Harold's a clever {0!s}" # Calls str() on the argument first "Bring out the holy {name!r}" # Calls repr() on the argument first 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. 7.1.3.1. 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). They can also be passed directly to the built-in 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 string ( The general form of a standard format specifier is: format_spec ::= [[ 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 (“ 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 The Changed in version 2.7: Added the width is a decimal integer defining the minimum field width. 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 ( The precision is a decimal number indicating how many digits should be displayed after the decimal point for a floating point value formatted with 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 The available presentation types for floating point and decimal values are:
7.1.3.2. Format examples¶This section contains examples of the In most of the cases the
syntax is similar to the old The new format syntax also supports new and different options, shown in the following examples. Accessing arguments by position: >>> '{0}, {1}, {2}'.format('a', 'b', 'c') 'a, b, c' >>> '{}, {}, {}'.format('a', 'b', 'c') # 2.7+ only 'a, b, c' >>> '{2}, {1}, {0}'.format('a', 'b', 'c') 'c, b, a' >>> '{2}, {1}, {0}'.format(*'abc') # unpacking argument sequence 'c, b, a' >>> '{0}{1}{0}'.format('abra', 'cad') # arguments' indices can be repeated 'abracadabra' Accessing arguments by name: >>> 'Coordinates: {latitude}, {longitude}'.format(latitude='37.24N', longitude='-115.81W') 'Coordinates: 37.24N, -115.81W' >>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'} >>> 'Coordinates: {latitude}, {longitude}'.format(**coord) 'Coordinates: 37.24N, -115.81W' Accessing arguments’ attributes: >>> c = 3-5j >>> ('The complex number {0} is formed from the real part {0.real} ' ... 'and the imaginary part {0.imag}.').format(c) 'The complex number (3-5j) is formed from the real part 3.0 and the imaginary part -5.0.' >>> class Point(object): ... def __init__(self, x, y): ... self.x, self.y = x, y ... def __str__(self): ... return 'Point({self.x}, {self.y})'.format(self=self) ... >>> str(Point(4, 2)) 'Point(4, 2)' Accessing arguments’ items: >>> coord = (3, 5) >>> 'X: {0[0]}; Y: {0[1]}'.format(coord) 'X: 3; Y: 5' Replacing >>> "repr() shows quotes: {!r}; str() doesn't: {!s}".format('test1', 'test2') "repr() shows quotes: 'test1'; str() doesn't: test2" Aligning the text and specifying a width: >>> '{:<30}'.format('left aligned') 'left aligned ' >>> '{:>30}'.format('right aligned') ' right aligned' >>> '{:^30}'.format('centered') ' centered ' >>> '{:*^30}'.format('centered') # use '*' as a fill char '***********centered***********' Replacing >>> '{:+f}; {:+f}'.format(3.14, -3.14) # show it always '+3.140000; -3.140000' >>> '{: f}; {: f}'.format(3.14, -3.14) # show a space for positive numbers ' 3.140000; -3.140000' >>> '{:-f}; {:-f}'.format(3.14, -3.14) # show only the minus -- same as '{:f}; {:f}' '3.140000; -3.140000' Replacing >>> # format also supports binary numbers >>> "int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(42) 'int: 42; hex: 2a; oct: 52; bin: 101010' >>> # with 0x, 0o, or 0b as prefix: >>> "int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(42) 'int: 42; hex: 0x2a; oct: 0o52; bin: 0b101010' Using the comma as a thousands separator: >>> '{:,}'.format(1234567890) '1,234,567,890' Expressing a percentage: >>> points = 19.5 >>> total = 22 >>> 'Correct answers: {:.2%}'.format(points/total) 'Correct answers: 88.64%' Using type-specific formatting: >>> import datetime >>> d = datetime.datetime(2010, 7, 4, 12, 15, 58) >>> '{:%Y-%m-%d %H:%M:%S}'.format(d) '2010-07-04 12:15:58' Nesting arguments and more complex examples: >>> for align, text in zip('<^>', ['left', 'center', 'right']): ... '{0:{fill}{align}16}'.format(text, fill=align, align=align) ... 'left<<<<<<<<<<<<' '^^^^^center^^^^^' '>>>>>>>>>>>right' >>> >>> octets = [192, 168, 0, 1] >>> '{:02X}{:02X}{:02X}{:02X}'.format(*octets) 'C0A80001' >>> int(_, 16) 3232235521 >>> >>> width = 5 >>> for num in range(5,12): ... for base in 'dXob': ... print '{0:{width}{base}}'.format(num, base=base, width=width), ... print ... 5 5 5 101 6 6 6 110 7 7 7 111 8 8 10 1000 9 9 11 1001 10 A 12 1010 11 B 13 1011 7.1.4. Template strings¶New in version 2.4. Templates provide simpler string substitutions as described in PEP 292.
Instead of the normal
Any other appearance of The
string. Template (template)¶The constructor takes a single argument which is the template string. substitute (mapping[,
**kws])¶Performs the template substitution, returning a new string. mapping is any dictionary-like object with keys that match the placeholders in the template. Alternatively, you can provide keyword arguments, where the keywords are the placeholders. When both mapping and kws are given and there are duplicates, the placeholders from kws take precedence. safe_substitute (mapping[, **kws])¶Like
While other exceptions may still occur, this method is called “safe” because it always tries to return a usable string
instead of raising an exception. In another sense,
template ¶This is the object passed to the constructor’s template argument. In general, you shouldn’t change it, but read-only access is not enforced. Here is an example of how to use a Template: >>> from string import Template >>> s = Template('$who likes $what') >>> s.substitute(who='tim', what='kung pao') 'tim likes kung pao' >>> d = dict(who='tim') >>> Template('Give $who $100').substitute(d) Traceback (most recent call last): ... ValueError: Invalid placeholder in string: line 1, col 11 >>> Template('$who likes $what').substitute(d) Traceback (most recent call last): ... KeyError: 'what' >>> Template('$who likes $what').safe_substitute(d) 'tim likes $what' Advanced usage: you can derive subclasses of
Alternatively, you can provide the entire regular expression pattern by overriding the class attribute pattern. If you do this, the value must be a regular expression object with four named capturing groups. The capturing groups correspond to the rules given above, along with the invalid placeholder rule:
7.1.5. String functions¶The following functions are available to operate on string and Unicode objects. They are not available as string methods. string. capwords (s[,
sep])¶Split the argument into words using string. maketrans (from,
to)¶Return a translation table suitable for passing to 7.1.6. Deprecated string functions¶The following list of functions are also defined as methods of string and Unicode objects; see section String Methods for more information on those. You should consider these functions as deprecated, although they will not be removed until Python 3. The functions defined in this module are: string. atof (s)¶Deprecated since version 2.0: Use the
Convert a string to a floating point number. The string must have the standard syntax for a floating point literal in Python, optionally preceded by a sign ( Note When passing in a string, values for NaN and Infinity may be returned, depending on the underlying C library. The specific set of strings accepted which cause these values to be returned depends entirely on the C library and is known to vary. string. atoi (s[,
base])¶Deprecated since version 2.0: Use the Convert string s to an integer in the given base. The string must consist of one or more digits, optionally
preceded by a sign ( string. atol (s[,
base])¶Deprecated since version 2.0: Use the Convert string s to a long integer in the given base. The string must consist of one or more digits,
optionally preceded by a sign ( string. capitalize (word)¶Return a copy of word with only its first character capitalized. string. expandtabs (s[, tabsize])¶Expand tabs in a string replacing them by one or more spaces, depending on the current column and the given tab size. The column number is reset to zero after each newline occurring in the string. This doesn’t understand other non-printing characters or escape sequences. The tab size defaults to 8. string. find (s, sub[, start[, end]])¶Return the lowest index in s where the substring sub is found such that sub is
wholly contained in string. rfind (s, sub[, start[, end]])¶
Like string. index (s, sub[, start[, end]])¶Like
string. rindex (s, sub[, start[, end]])¶Like string. count (s, sub[, start[, end]])¶Return the number of (non-overlapping) occurrences of substring sub in string string. lower (s)¶Return a copy of s, but with upper case letters converted to lower case. string. split (s[, sep[,
maxsplit]])¶Return a list of the words of the string s. If the optional second argument sep is absent or The behavior of split on an empty string depends on the value of sep. If sep is not specified, or specified as string. rsplit (s[, sep[,
maxsplit]])¶Return a list of the words of the string s, scanning s from the end. To all intents and purposes, the resulting list of words is the same as returned by New in version 2.4. string. splitfields (s[, sep[,
maxsplit]])¶This function behaves identically to string. join (words[, sep])¶Concatenate a list or
tuple of words with intervening occurrences of sep. The default value for sep is a single space character. It is always true that string. joinfields (words[, sep])¶This function behaves identically
to string. lstrip (s[,
chars])¶Return a copy of the string with leading characters removed. If chars is omitted or Changed in version 2.2.3: The chars parameter was added. The chars parameter cannot be passed in earlier 2.2 versions. string. rstrip (s[, chars])¶Return a copy of the string with trailing characters removed. If chars is
omitted or Changed in version 2.2.3: The chars parameter was added. The chars parameter cannot be passed in earlier 2.2 versions. string. strip (s[,
chars])¶Return a copy of the string with leading and trailing characters removed. If chars is omitted or Changed in version 2.2.3: The chars parameter was added. The chars parameter cannot be passed in earlier 2.2 versions. string. swapcase (s)¶Return a copy of s, but with lower case letters converted to upper case and vice versa. string. translate (s, table[, deletechars])¶Delete all characters from s that are in deletechars (if present), and then translate the characters using table, which must be a 256-character string giving the translation
for each character value, indexed by its ordinal. If table is string. upper (s)¶Return a copy of s, but with lower case letters converted to upper case. string. ljust (s, width[, fillchar])¶ string. rjust (s, width[,
fillchar])¶ string. center (s, width[, fillchar])¶These functions respectively left-justify, right-justify and center a string in a field of given width. They return a string that is at least width characters wide, created by padding the string s with the character fillchar (default is a space) until the given width on the right, left or both sides. The string is never truncated. string. zfill (s,
width)¶Pad a numeric string s on the left with zero digits until the given width is reached. Strings starting with a sign are handled correctly. string. replace (s, old, new[, maxreplace])¶Return a copy of string s with all occurrences of substring old replaced by new. If the optional argument maxreplace is given, the first maxreplace occurrences are replaced. |