用一个特色的方法表示出一系列不方便写出的内容，比如回车键，换行符，退格键
借助反斜杠字符，一旦字符串中出现反斜杠，则反斜杠后面一个或几个字符表示已经不是原来的意思了，进行了转义
在字符串中，一旦出现反斜杠就要加倍小心，可能有转义字符出现
不同系统对换行操作有不同的表示
Windows：\n
Linux：\r\n
s = 'Let\'s Go'
print(s)
s = "Let's Go"
print(s)
s = "C:\\User\\Augsnano"
print(s)
s = "I\r\nLove\r\nYou"
print(s)
Let
Let
C:\User\Augsnano
常用的转义字符
转义字符 描述
\（在行尾时） 续行符
\\ 反斜杠符号
\' 单引号
\" 双引号
\a 响铃
\b 退格（Backspa）
\e 转义
\000 空
\n 换行
\v 纵向制表符
\t 横向制表符
\r 回车
\f 换页
\oyy 八进制数，yy代表的字符，例如：\o12代表换行
\xyy 十六进制，yy代表的字符。例如：\x0a代表换行
\other 其他的字符以普通格式输出
def maDemo(x, \
print("hahahahaha")
maDemo(1,2,3)
hahahahaha
把字符串按照一定格式进行打印或者填充
格式化的分类：
传统格式化
format
s = "I love you"
print(s)
s = "I love you"
print(s)
s = "I love you"
print(s)
I love you
I love you
I love you
字符串的传统格式化方法
使用%进行格式化
%（百分号）也叫占位符
%s: 字符串
%r: 字符串，但是是使用repr而不是str
%c: 整数转换为单个字符
%d: 十进制整数
%u: 无符号整数
%o: 表示八进制
%x: 十六进制，字母为小写（x为小写）
%X: 十六进制，字母为大写（X为大写）
%e: 浮点数（e为小写），例如2.87e+12
%E: 浮点数（E为大写），例如2.87E+12
%f,%F: 浮点数十进制形式
%g,%G: 十进制形式浮点或者指数浮点自动转换
格式字符前出现整数表示此字符所所占位置的宽度
格式字符前边出现‘-’表示左对齐
格式字符前边出现‘+’表示右对齐
0位数不足用‘0’补齐
width表示宽度
pricision精度
s = "I love %s"
print(s)
s = "I love %s"
print(s%"you")
print(s%"ss")
I love %s
I love you
I love ss
print("I love %s"%"you")
print("I love %s"%100)
I love you
I love 100
s = "我今年 %d 岁了"
print(s%19)
我今年 19 岁了
s = "I am %fKG weight, %fm Heigh"
print(s)
print(s%(60.3, 1.76))
s = "I am %.2fKG weight, %.2fm Heigh"
print(s%(60.3, 1.76))
I am %fKG weight, %fm Heigh
I am 60.300000KG weight, 1.760000m Heigh
I am 60.30KG weight, 1.76m Heigh
format格式化
使用函数形式进行格式化，代替以前的百分号
s = "{} {}!"
print(s.format("Hello", "world"))
s = "{} {}!".format("Hello", "World")
print(s)
s = "{0} {1}".format("Hello", "World")
print(s)
s = "{1} {0}".format("Hello", "World")
print(s)
s = "I love {0} and {0} loves me".format("you")
print(s)
s = "我们是{school_name}，我们的网址是{url}，{teacher}最帅"
s = s.format(school_name = "A", url = "B", teacher = "C")
print(s)
Hello world!
Hello World!
Hello World
World Hello
I love you and you loves me
我们是A，我们的网址是B，C最帅
s = "我们是{school_name}，我们的网址是{url}，{teacher}最帅"
s_dict = {"school_name":"A",\
"url":"B",\
"teacher":"C"}
s = s.format(**s_dict)
print(s)
我们是A，我们的网址是B，C最帅
s = "A is {:.2f}m heigh, {:.2f}KG weight"
print(s.format(1.84, 76.45))
s = "format函数是使用{}来进行占位的"
print(s)
A is 1.84m heigh, 76.45KG weight
format函数是使用{}来进行占位的
str内置函数
很多语言字符串使用string表示，但是python中用str表示字符串
help(str)
Help on class str in module builtins:
class str(object)
| str(object='') -> str
| str(bytes_or_buffer[, encoding[, errors]]) -> str
| Create a new string object from the given object. If encoding or
| errors is specified, then the object must expose a data buffer
| that will be decoded using the given encoding and error handler.
| Otherwise, returns the result of object.__str__() (if defined)
| or repr(object).
| encoding defaults to sys.getdefaultencoding().
| errors defaults to 'strict'.
| Methods defined here:
| __add__(self, value, /)
| Return self+value.
| __contains__(self, key, /)
| Return key in self.
| __eq__(self, value, /)
| Return self==value.
| __format__(self, format_spec, /)
| Return a formatted version of the string as described by format_spec.
| __ge__(self, value, /)
| Return self>=value.
| __getattribute__(self, name, /)
| Return getattr(self, name).
| __getitem__(self, key, /)
| Return self[key].
| __getnewargs__(...)
| __gt__(self, value, /)
| Return self>value.
| __hash__(self, /)
| Return hash(self).
| __iter__(self, /)
| Implement iter(self).
| __le__(self, value, /)
| Return self<=value.
| __len__(self, /)
| Return len(self).
| __lt__(self, value, /)
| Return self<value.
| __mod__(self, value, /)
| Return self%value.
| __mul__(self, value, /)
| Return self*value.
| __ne__(self, value, /)
| Return self!=value.
| __repr__(self, /)
| Return repr(self).
| __rmod__(self, value, /)
| Return value%self.
| __rmul__(self, value, /)
| Return value*self.
| __sizeof__(self, /)
| Return the size of the string in memory, in bytes.
| __str__(self, /)
| Return str(self).
| capitalize(self, /)
| Return a capitalized version of the string.
| More specifically, make the first character have upper case and the rest lower
| case.
| casefold(self, /)
| Return a version of the string suitable for caseless comparisons.
| center(self, width, fillchar=' ', /)
| Return a centered string of length width.
| Padding is done using the specified fill character (default is a space).
| count(...)
| S.count(sub[, start[, end]]) -> int
| Return the number of non-overlapping occurrences of substring sub in
| string S[start:end]. Optional arguments start and end are
| interpreted as in slice notation.
| encode(self, /, encoding='utf-8', errors='strict')
| Encode the string using the codec registered for encoding.
| encoding
| The encoding in which to encode the string.
| errors
| The error handling scheme to use for encoding errors.
| The default is 'strict' meaning that encoding errors raise a
| UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
| 'xmlcharrefreplace' as well as any other name registered with
| codecs.register_error that can handle UnicodeEncodeErrors.
| endswith(...)
| S.endswith(suffix[, start[, end]]) -> bool
| Return True if S ends with the specified suffix, False otherwise.
| With optional start, test S beginning at that position.
| With optional end, stop comparing S at that position.
| suffix can also be a tuple of strings to try.
| expandtabs(self, /, tabsize=8)
| Return a copy where all tab characters are expanded using spaces.
| If tabsize is not given, a tab size of 8 characters is assumed.
| find(...)
| S.find(sub[, start[, end]]) -> int
| Return the lowest index in S where substring sub is found,
| such that sub is contained within S[start:end]. Optional
| arguments start and end are interpreted as in slice notation.
| Return -1 on failure.
| format(...)
| S.format(*args, **kwargs) -> str
| Return a formatted version of S, using substitutions from args and kwargs.
| The substitutions are identified by braces ('{' and '}').
| format_map(...)
| S.format_map(mapping) -> str
| Return a formatted version of S, using substitutions from mapping.
| The substitutions are identified by braces ('{' and '}').
| index(...)
| S.index(sub[, start[, end]]) -> int
| Return the lowest index in S where substring sub is found,
| such that sub is contained within S[start:end]. Optional
| arguments start and end are interpreted as in slice notation.
| Raises ValueError when the substring is not found.
| isalnum(self, /)
| Return True if the string is an alpha-numeric string, False otherwise.
| A string is alpha-numeric if all characters in the string are alpha-numeric and
| there is at least one character in the string.
| isalpha(self, /)
| Return True if the string is an alphabetic string, False otherwise.
| A string is alphabetic if all characters in the string are alphabetic and there
| is at least one character in the string.
| isascii(self, /)
| Return True if all characters in the string are ASCII, False otherwise.
| ASCII characters have code points in the range U+0000-U+007F.
| Empty string is ASCII too.
| isdecimal(self, /)
| Return True if the string is a decimal string, False otherwise.
| A string is a decimal string if all characters in the string are decimal and
| there is at least one character in the string.
| isdigit(self, /)
| Return True if the string is a digit string, False otherwise.
| A string is a digit string if all characters in the string are digits and there
| is at least one character in the string.
| isidentifier(self, /)
| Return True if the string is a valid Python identifier, False otherwise.
| Use keyword.iskeyword() to test for reserved identifiers such as "def" and
| "class".
| islower(self, /)
| Return True if the string is a lowercase string, False otherwise.
| A string is lowercase if all cased characters in the string are lowercase and
| there is at least one cased character in the string.
| isnumeric(self, /)
| Return True if the string is a numeric string, False otherwise.
| A string is numeric if all characters in the string are numeric and there is at
| least one character in the string.
| isprintable(self, /)
| Return True if the string is printable, False otherwise.
| A string is printable if all of its characters are considered printable in
| repr() or if it is empty.
| isspace(self, /)
| Return True if the string is a whitespace string, False otherwise.
| A string is whitespace if all characters in the string are whitespace and there
| is at least one character in the string.
| istitle(self, /)
| Return True if the string is a title-cased string, False otherwise.
| In a title-cased string, upper- and title-case characters may only
| follow uncased characters and lowercase characters only cased ones.
| isupper(self, /)
| Return True if the string is an uppercase string, False otherwise.
| A string is uppercase if all cased characters in the string are uppercase and
| there is at least one cased character in the string.
| join(self, iterable, /)
| Concatenate any number of strings.
| The string whose method is called is inserted in between each given string.
| The result is returned as a new string.
| Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
| ljust(self, width, fillchar=' ', /)
| Return a left-justified string of length width.
| Padding is done using the specified fill character (default is a space).
| lower(self, /)
| Return a copy of the string converted to lowercase.
| lstrip(self, chars=None, /)
| Return a copy of the string with leading whitespace removed.
| If chars is given and not None, remove characters in chars instead.
| partition(self, sep, /)
| Partition the string into three parts using the given separator.
| This will search for the separator in the string. If the separator is found,
| returns a 3-tuple containing the part before the separator, the separator
| itself, and the part after it.
| If the separator is not found, returns a 3-tuple containing the original string
| and two empty strings.
| replace(self, old, new, count=-1, /)
| Return a copy with all occurrences of substring old replaced by new.
| count
| Maximum number of occurrences to replace.
| -1 (the default value) means replace all occurrences.
| If the optional argument count is given, only the first count occurrences are
| replaced.
| rfind(...)
| S.rfind(sub[, start[, end]]) -> int
| Return the highest index in S where substring sub is found,
| such that sub is contained within S[start:end]. Optional
| arguments start and end are interpreted as in slice notation.
| Return -1 on failure.
| rindex(...)
| S.rindex(sub[, start[, end]]) -> int
| Return the highest index in S where substring sub is found,
| such that sub is contained within S[start:end]. Optional
| arguments start and end are interpreted as in slice notation.
| Raises ValueError when the substring is not found.
| rjust(self, width, fillchar=' ', /)
| Return a right-justified string of length width.
| Padding is done using the specified fill character (default is a space).
| rpartition(self, sep, /)
| Partition the string into three parts using the given separator.
| This will search for the separator in the string, starting at the end. If
| the separator is found, returns a 3-tuple containing the part before the
| separator, the separator itself, and the part after it.
| If the separator is not found, returns a 3-tuple containing two empty strings
| and the original string.
| rsplit(self, /, sep=None, maxsplit=-1)
| Return a list of the words in the string, using sep as the delimiter string.
| sep
| The delimiter according which to split the string.
| None (the default value) means split according to any whitespace,
| and discard empty strings from the result.
| maxsplit
| Maximum number of splits to do.
| -1 (the default value) means no limit.
| Splits are done starting at the end of the string and working to the front.
| rstrip(self, chars=None, /)
| Return a copy of the string with trailing whitespace removed.
| If chars is given and not None, remove characters in chars instead.
| split(self, /, sep=None, maxsplit=-1)
| Return a list of the words in the string, using sep as the delimiter string.
| sep
| The delimiter according which to split the string.
| None (the default value) means split according to any whitespace,
| and discard empty strings from the result.
| maxsplit
| Maximum number of splits to do.
| -1 (the default value) means no limit.
| splitlines(self, /, keepends=False)
| Return a list of the lines in the string, breaking at line boundaries.
| Line breaks are not included in the resulting list unless keepends is given and
| true.
| startswith(...)
| S.startswith(prefix[, start[, end]]) -> bool
| Return True if S starts with the specified prefix, False otherwise.
| With optional start, test S beginning at that position.
| With optional end, stop comparing S at that position.
| prefix can also be a tuple of strings to try.
| strip(self, chars=None, /)
| Return a copy of the string with leading and trailing whitespace remove.
| If chars is given and not None, remove characters in chars instead.
| swapcase(self, /)
| Convert uppercase characters to lowercase and lowercase characters to uppercase.
| title(self, /)
| Return a version of the string where each word is titlecased.
| More specifically, words start with uppercased characters and all remaining
| cased characters have lower case.
| translate(self, table, /)
| Replace each character in the string using the given translation table.
| table
| Translation table, which must be a mapping of Unicode ordinals to
| Unicode ordinals, strings, or None.
| The table must implement lookup/indexing via __getitem__, for instance a
| dictionary or list. If this operation raises LookupError, the character is
| left untouched. Characters mapped to None are deleted.
| upper(self, /)
| Return a copy of the string converted to uppercase.
| zfill(self, width, /)
| Pad a numeric string with zeros on the left, to fill a field of the given width.
| The string is never truncated.
|
| Static methods defined here:
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
| maketrans(x, y=None, z=None, /)
| Return a translation table usable for str.translate().
| If there is only one argument, it must be a dictionary mapping Unicode
| ordinals (integers) or characters to Unicode ordinals, strings or None.
| Character keys will be then converted to ordinals.
| If there are two arguments, they must be strings of equal length, and
| in the resulting dictionary, each character in x will be mapped to the
| character at the same position in y. If there is a third argument, it
| must be a string, whose characters will be mapped to None in the result.
复制代码
