顺便聊一下python str模块

str字符串

str
转义字符
格式化
内建函数

字符串

表示文字信息
用单引号，双引号，三引号括起来

s = 'I love '
print(s)

I love

s = "I love "
print(s)

I love

s = """
I
Love
"""

print(s)

Love

转义字符

用一个特色的方法表示出一系列不方便写出的内容，比如回车键，换行符，退格键
借助反斜杠字符，一旦字符串中出现反斜杠，则反斜杠后面一个或几个字符表示已经不是原来的意思了，进行了转义
在字符串中，一旦出现反斜杠就要加倍小心，可能有转义字符出现
不同系统对换行操作有不同的表示
- Windows：\n
- Linux：\r\n

# 转义字符的案例
# 想表达Let's Go
# 使用转义字符
s = 'Let\'s Go'
print(s)


# 使用单双引号嵌套
s = "Let's Go"
print(s)

# 表示斜杠
# 比如表示C:\User\Augsnano
s = "C:\\User\\Augsnano"
print(s)

# 回车换行
# 想表达的效果是：
# I
# Love
# You
# windows 下也可以使用\r\n，效果相同
s = "I\r\nLove\r\nYou"
print(s)

Let's Go

Let's Go

C:\User\Augsnano

Love

You

常用的转义字符

         转义字符   描述

        \（在行尾时） 续行符

        \\  反斜杠符号

        \'  单引号

        \"  双引号

        \a  响铃

        \b  退格（Backspa）

        \e  转义

        \000   空

        \n  换行

        \v  纵向制表符

        \t  横向制表符

        \r  回车

        \f  换页

        \oyy   八进制数，yy代表的字符，例如：\o12代表换行

        \xyy   十六进制，yy代表的字符。例如：\x0a代表换行

        \other 其他的字符以普通格式输出

# 单个斜杠的做法
# 在python中，单个反斜杠表示未结束，出于美观，需要下一行继续
# 理论上应该写成 def maDemo (int x, int y, int z):
def maDemo(x, \
           y, \
           z):
    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 表示简单的字符串
# 占位符可以单独使用
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)
# 以下打印会报错
#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格式化

使用函数形式进行格式化，代替以前的百分号

# 不能指定位置，按顺序读取
# 方式1
s = "{} {}!"
print(s.format("Hello", "world"))

# 方式2
s = "{} {}!".format("Hello", "World")
print(s)    # 相当于打印"Hello World!"

# 设置指定位置
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 = "I love {} and {} 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))

# ^, <, > 分别是居中、左对齐、右对齐，后面带宽度
# ：号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充
# + 表示在正数前显示 +，负数前显示 -；  （空格）表示在正数前加空格
# b、d、o、x 分别是二进制、十进制、八进制、十六进制
# 此外我们可以使用大括号 {} 来转义大括号

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.

正文完

发表至： Python 技术教程

2022-10-14

今天来聊聊【ES三周年】ElasticSearch数据库简单介绍

知识分享 – 干货|揭秘四大行业率先抢占小程序红利，小程序运营成关键因素？