得之我幸 失之我命

when someone abandons you，it is him that gets loss because he lost someone who truly loves him but you just lost one who doesn’t love you.

| python

Python 拼接字符串的七种方式

无论啥语言，总是免不了拼接字符串的。从今天起，f-string 方式作为首选方案

几个字符串相关的小问题：

  1. {} 要怎么作为字符串输入？

    1
    2
    >>> print(f'{{}}')
    >>> {{}}

  2. 字符串前面加上 r 的作用
    在 string 前面加上 r，是为了告诉编译器这个 string 是个 raw string，不要转意 backslash '' 。 例如，\n 在 raw string 中，是两个字符，\ 和 n， 而不会转意为换行符。由于正则表达式和 \ 会有冲突，因此，当一个字符串使用了正则表达式后，最好在前面加上 r

字符串拼接方式：

  1. 来自 C 语言的 % 方式

    1
    2
    >>> print('%s %s' % ('Hello', 'world'))
    >>> Hello world

    % 号格式化字符串的方式继承自古老的 C 语言，在很多编程语言都有类似的实现。上例的%s是一个占位符，它仅代表一段字符串，并不是拼接的实际内容。实际的拼接内容在一个单独的 % 号后面，放在一个元组里

    类似的占位符还有：%d（代表一个整数）、%f（代表一个浮点数）、%x（代表一个16进制数），等等。% 占位符既是这种拼接方式的特点，同时也是其限制，因为每种占位符都有特定意义，实际使用起来太麻烦了

  2. format() 拼接方式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    # 简洁版
    >>> s = 'Hello {}! My name is {}.'.format('World', 'Python')
    >>> print(s)
    >>> Hello World! My name is Python.

    # 对号入座版
    >>> s2 = 'Hello {0}! My name is {1}.'.format('World', 'Python')
    >>> s3 = 'Hello {name1}! My name is {name2}.'.format(name1='World', name2='Python')
    >>> print(s2)
    >>> Hello World! My name is Python.
    >>> print(s3)
    >>> Hello World! My name is Python.

    这种方式使用花括号 {} 做占位符，在 format 方法中再转入实际的拼接值。这种方式在Python2.6中开始引入。上例中，简洁版的花括号中无内容，缺点是容易弄错次序。对号入座版主要有两种，一种传入序列号，一种则使用 key-value 的方式。实际使用时更推荐后一种，既不会数错次序，又更直观可读

  3. () 类似元组方式

    1
    2
    3
    4
    5
    6
    7
    8
    >>> s_tuple = ('Hello', ' ', 'world')
    >>> s_like_tuple = ('Hello' ' ' 'world')
    >>> print(s_tuple)
    >>> ('Hello', ' ', 'world')
    >>> print(s_like_tuple) 
    >>> Hello world
    >>> type(s_like_tuple) 
    >>> str

    注意，上例中 s_like_tuple 并不是一个元组，因为元素间没有逗号分隔符，这些元素间可以用空格间隔，也可以不要空格。使用 type() 查看，发现它就是一个 str 类型

    这种方式看起来很快捷，但是，括号 () 内要求元素是真实字符串，不能混用变量，所以不够灵活

    1
    2
    3
    4
    5
    6
    7
    8
    # 多元素时，不支持有变量
    >>> str_1 = 'Hello'
    >>> str_2 = (str_1 'world')
    >>> SyntaxError: invalid syntax
    >>> str_3 = (str_1 str_1)
    >>> SyntaxError: invalid syntax
    # 但是下面写法不会报错
    >>> str_4 = (str_1)

  4. 面向对象模板拼接

    1
    2
    3
    4
    >>> from string import Template
    >>> s = Template('${s1} ${s2}!') 
    >>> print(s.safe_substitute(s1='Hello',s2='world')) 
    >>> Hello world!

  5. 常用的 + 号方式

    1
    2
    3
    4
    5
    6
    >>> str_1 = 'Hello world！ ' 
    >>> str_2 = 'My name is Python.'
    >>> print(str_1 + str_2)
    >>> Hello world！ My name is Python.
    >>> print(str_1)
    >>> Hello world!

  6. join() 拼接方式

    1
    2
    3
    4
    5
    6
    7
    >>> str_list = ['Hello', 'world']
    >>> str_join1 = ' '.join(str_list)
    >>> str_join2 = '-'.join(str_list)
    >>> print(str_join1) 
    >>> Hello world
    >>> print(str_join2) 
    >>> Hello-world

    str 对象自带的 join() 方法，接受一个序列参数，可以实现拼接。拼接时，元素若不是字符串，需要先转换一下。可以看出，这种方法比较适用于连接序列对象中（例如列表）的元素，并设置统一的间隔符

    当拼接长度超过20时，这种方式基本上是首选。不过，它的缺点就是，不适合进行零散片段的、不处于序列集合的元素拼接

  7. f-string 方式

    1
    2
    3
    4
    5
    >>> name = 'world'
    >>> myname = 'python'
    >>> words = f'Hello {name}. My name is {myname}.'
    >>> print(words)
    >>> Hello world. My name is python.

    f-string 方式出自 PEP 498（Literal String Interpolation，字面字符串插值），从Python3.6 版本引入。其特点是在字符串前加 f 标识，字符串中间则用花括号 {} 包裹其它字符串变量

    这种方式在可读性上秒杀 format() 方式，处理长字符串的拼接时，速度与 join() 方法相当

be slow to promise and quick to perform.

ESC