python 分割字串_在Python中分割，连结和连结字串

python 分割字串

There are few guarantees in life: death, taxes, and programmers needing to deal with strings. Strings can come in many forms. They could be unstructured text, usernames, product descriptions, database column names, or really anything else that we describe using language.

生活中几乎没有保证：死亡，税收和程序员需要处理字符串。 字符串可以有多种形式。 它们可以是非结构化的文本，用户名，产品说明，数据库列名称，或者实际上是我们使用语言描述的其他任何内容。

With the near-ubiquity of string data, it’s important to master the tools of the trade when it comes to strings. Luckily, Python makes string manipulation very simple, especially when compared to other languages and even older versions of Python.

在字符串数据几乎无处不在的情况下，掌握有关字符串的交易工具非常重要。 幸运的是，Python使字符串操作非常简单，特别是与其他语言甚至旧版本的Python相比时。

In this article, you will learn some of the most fundamental string operations: splitting, concatenating, and joining. Not only will you learn how to use these tools, but you will walk away with a deeper understanding of how they work under the hood.

在本文中，您将学习一些最基本的字符串操作：拆分，连接和联接。 您不仅将学习如何使用这些工具，而且还将对它们在幕后的工作方式有更深入的了解。

分割字符串 (Splitting Strings)

In Python, strings are represented as str objects, which are immutable: this means that the object as represented in memory can not be directly altered. These two facts can help you learn (and then remember) how to use .split().

在Python中，字符串表示为不可更改的str对象：这意味着不能直接更改内存中表示的对象。 这两个事实可以帮助您学习（然后记住）如何使用.split() 。

Have you guessed how those two features of strings relate to splitting functionality in Python? If you guessed that .split() is an instance method because strings are a special type, you would be correct! In some other languages (like Perl), the original string serves as an input to a standalone .split() function rather than a method called on the string itself.

您是否猜想过这两个字符串功能与Python中的拆分功能有何关系？ 如果您因为字符串是一种特殊类型而猜测.split()是一个实例方法 ，那将是正确的！ 在某些其他语言（如Perl）中，原始字符串用作独立.split()函数的输入，而不是在字符串本身上调用的方法。

 # Avoid this:
# Avoid this:
strstr .. splitsplit (( 'a,b,c''a,b,c' , , ','',' )
)

What about string immutability? This should remind you that string methods are not in-place operations, but they return a new object in memory.

字符串不可变怎么办？ 这应该提醒您，字符串方法不是就地操作 ，但它们会在内存中返回一个新对象。

不带参数分割 (Splitting Without Parameters)

Before going deeper, let’s look at a simple example:

在深入探讨之前，让我们看一个简单的示例：

>>> 'this is my string'.split()
['this', 'is', 'my', 'string']

This is actually a special case of a .split() call, which I chose for its simplicity. Without any separator specified, .split() will count any whitespace as a separator.

实际上，这是.split()调用的特例，我为简单起见选择了它。 如果未指定任何分隔符， .split()会将任何空格都计为分隔符。

Another feature of the bare call to .split() is that it automatically cuts out leading and trailing whitespace, as well as consecutive whitespace. Compare calling .split() on the following string without a separator parameter and with having ' ' as the separator parameter:

对.split()的裸调用的另一个功能是，它会自动剪切掉前导和尾随的空格以及连续的空格。 比较在以下字符串上调用.split()时没有分隔符参数，并且以' '作为分隔符参数的情况：

>>> s = ' this   is  my string '
>>> s.split()
['this', 'is', 'my', 'string']
>>> s.split(' ')
['', 'this', '', '', 'is', '', 'my', 'string', '']

The first thing to notice is that this showcases the immutability of strings in Python: subsequent calls to .split() work on the original string, not on the list result of the first call to .split().

首先要注意的是，这展示了Python中字符串的不变性：对.split()后续调用在原始字符串上起作用，而不是在首次调用.split()的列表结果上起作用。

The second—and the main—thing you should see is that the bare .split() call extracts the words in the sentence and discards any whitespace.

第二个也是最主要的事情是，裸露的.split()调用会提取句子中的单词，并丢弃所有空格。

指定分隔符 (Specifying Separators)

.split(' '), on the other hand, is much more literal. When there are leading or trailing separators, you’ll get an empty string, which you can see in the first and last elements of the resulting list.

另一方面， .split(' ')更为文字。 当有前导或尾随分隔符时，您将获得一个空字符串，您可以在结果列表的第一个和最后一个元素中看到该字符串。

Where there are multiple consecutive separators (such as between “this” and “is” and between “is” and “my”), the first one will be used as the separator, and the subsequent ones will find their way into your result list as empty strings.

如果有多个连续的分隔符（例如“ this”和“ is”之间以及“ is”和“ my”之间），则第一个将用作分隔符，随后的分隔符将进入结果列表作为空字符串。

用Maxsplit限制拆分 (Limiting Splits With Maxsplit)

.split() has another optional parameter called maxsplit. By default, .split() will make all possible splits when called. When you give a value to maxsplit, however, only the given number of splits will be made. Using our previous example string, we can see maxsplit in action:

.split()具有另一个可选参数，称为maxsplit 。 默认情况下， .split()将在调用时进行所有可能的分割。 但是，当给maxsplit值时，只会进行给定的分割数。 使用前面的示例字符串，我们可以看到maxsplit的作用：

>>> s = "this is my string"
>>> s.split(maxsplit=1)
['this', 'is my string']

As you see above, if you set maxsplit to 1, the first whitespace region is used as the separator, and the rest are ignored. Let’s do some exercises to test out everything we’ve learned so far.

如上所示，如果将maxsplit设置为1 ，则第一个空格区域将用作分隔符，其余的将被忽略。 让我们做一些练习来测试到目前为止我们学到的一切。

Name,Phone,Address
Mike Smith,15554218841,123 Nice St, Roy, NM, USA
Anita Hernandez,15557789941,425 Sunny St, New York, NY, USA
Guido van Rossum,315558730,Science Park 123, 1098 XG Amsterdam, NL
Name,Phone,Address
Mike Smith,15554218841,123 Nice St, Roy, NM, USA
Anita Hernandez,15557789941,425 Sunny St, New York, NY, USA
Guido van Rossum,315558730,Science Park 123, 1098 XG Amsterdam, NL

 input_string input_string = = """Name,Phone,Address
"""Name,Phone,Address
Mike Smith,15554218841,123 Nice St, Roy, NM, USA
Mike Smith,15554218841,123 Nice St, Roy, NM, USA
Anita Hernandez,15557789941,425 Sunny St, New York, NY, USA
Anita Hernandez,15557789941,425 Sunny St, New York, NY, USA
Guido van Rossum,315558730,Science Park 123, 1098 XG Amsterdam, NL"""

Guido van Rossum,315558730,Science Park 123, 1098 XG Amsterdam, NL"""

def def string_split_exstring_split_ex (( unsplitunsplit ):
    ):
    results results = = []

    []

    # Bonus points for using splitlines() here instead, 
    # Bonus points for using splitlines() here instead, 
    # which will be more readable
    # which will be more readable
    for for line line in in unsplitunsplit .. splitsplit (( '' nn '' )[)[ 11 :]:
        :]:
        resultsresults .. appendappend (( lineline .. splitsplit (( ','',' , , maxsplitmaxsplit == 22 ))

    ))

    return return results

results

printprint (( string_split_exstring_split_ex (( inputinput ))
))

串联和连接字符串 (Concatenating and Joining Strings)

The other fundamental string operation is the opposite of splitting strings: string concatenation. If you haven’t seen this word, don’t worry. It’s just a fancy way of saying “gluing together.”

字符串的另一种基本操作与拆分字符串相反：字符串连接 。 如果您还没有看到这个词，请不要担心。 这只是说“粘合在一起”的一种奇特的方式。

与+运算符串联 (Concatenating With the + Operator)

There are a few ways of doing this, depending on what you’re trying to achieve. The simplest and most common method is to use the plus symbol (+) to add multiple strings together. Simply place a + between as many strings as you want to join together:

有几种方法可以做到这一点，具体取决于您要实现的目标。 最简单，最常见的方法是使用加号（ + ）将多个字符串加在一起。 只需在要连接的任意多个字符串之间放置一个+ ：

 >>>  'a' + 'b' + 'c'
'abc'

In keeping with the math theme, you can also multiply a string to repeat it:

与数学主题保持一致，您还可以将字符串相乘以重复该主题：

 >>>  'do' * 2
'dodo'

Remember, strings are immutable! If you concatenate or repeat a string stored in a variable, you will have to assign the new string to another variable in order to keep it.

记住，字符串是不可变的！ 如果连接或重复存储在变量中的字符串，则必须将新字符串分配给另一个变量以保留它。

 >>>  orig_string = 'Hello'
>>>  orig_string + ', world'
'Hello, world'
>>>  orig_string
'Hello'
>>>  full_sentence = orig_string + ', world'
>>>  full_sentence
'Hello, world'

If we didn’t have immutable strings, full_sentence would instead output 'Hello, world, world'.

如果我们没有不变的字符串， full_sentence会输出'Hello, world, world' 。

Another note is that Python does not do implicit string conversion. If you try to concatenate a string with a non-string type, Python will raise a TypeError:

另一个注意事项是Python不执行隐式字符串转换。 如果您尝试将非字符串类型的字符串连接起来，Python将引发TypeError ：

 >>>  'Hello' + 2
Traceback (most recent call last):
  File "<stdin>" , line 1 , in <module>
TypeError : must be str, not int

This is because you can only concatenate strings with other strings, which may be new behavior for you if you’re coming from a language like JavaScript, which attempts to do implicit type conversion.

这是因为您只能将字符串与其他字符串连接在一起，如果您来自尝试进行隐式类型转换JavaScript之类的语言，那么这对于您来说可能是新的行为。

与.Join()串联 (Concatenating With .Join())

There is another, more powerful, way to join strings together: the join() method.

还有另一种将字符串连接在一起的更强大的方法： join()方法。

The common use case here is when you have an iterable—like a list—made up of strings, and you want to combine those strings into a single string. Like .split(), .join() is a string instance method. If all of your strings are in an iterable, which one do you call .join() on?

这里的常见用例是当您有一个由字符串组成的可迭代对象（如列表），并且想要将这些字符串组合成一个字符串时。 与.split() ， .join()是一个字符串实例方法。 如果您所有的字符串都处于可迭代状态，则对.join()调用哪一个？

This is a bit of a trick question. Remember that when you use .split(), you call it on the string or character you want to split on. The opposite operation is .join(), so you call it on the string or character you want to use to join your iterable of strings together:

这是一个技巧问题。 请记住，当您使用.split() ，会在您想分割的字符串或字符上调用它。 相反的操作是.join() ，因此您在要用于将可迭代的字符串连接在一起的字符串或字符上调用它：

 >>>  strings = [ 'do' , 're' , 'mi' ]
>>>  ',' . join ( strings )
'do,re,mi'

Here, we join each element of the strings list with a comma (,) and call .join() on it rather than the strings list.

在这里，我们使用逗号（ , ）将strings列表的每个元素连接在一起,并在其上调用.join()而不是strings列表。

 >>>  strings = [ 'do' , 're' , 'mi' ]
>>>  ', ' . join ( strings )
'do, re, mi'

.join() is smart in that it inserts your “joiner” in between the strings in the iterable you want to join, rather than just adding your joiner at the end of every string in the iterable. This means that if you pass an iterable of size 1, you won’t see your joiner:

.join()很聪明，因为它将“ joiner”插入到要联接的可迭代对象的字符串之间，而不是仅将joiner添加到可迭代对象的每个字符串的末尾。 这意味着，如果传递的大小为1 ，则您将看不到您的连接器：

 >>>  'b' . join ([ 'a' ])
'a'

 """
"""
Boston,MA,76F,65% Precip,0.15in
Boston,MA,76F,65% Precip,0.15in
San Francisco,CA,62F,20% Precip,0.00 in
San Francisco,CA,62F,20% Precip,0.00 in
Washington,DC,82F,80% Precip,0.19 in
Washington,DC,82F,80% Precip,0.19 in
Miami,FL,79F,50% Precip,0.70 in
Miami,FL,79F,50% Precip,0.70 in
"""
"""

绑在一起 (Tying It All Together)

While this concludes this overview of the most basic string operations in Python (splitting, concatenating, and joining), there is still a whole universe of string methods that can make your experiences with manipulating strings much easier.

虽然本文概述了Python中最基本的字符串操作（拆分，连接和联接），但仍然有大量的字符串方法可以使您处理字符串的经验更加轻松。

Once you have mastered these basic string operations, you may want to learn more. Luckily, we have a number of great tutorials to help you complete your mastery of Python’s features that enable smart string manipulation:

掌握了这些基本的字符串操作后，您可能需要了解更多信息。 幸运的是，我们有许多很棒的教程可以帮助您完成对Python功能的精通，这些功能可实现智能字符串操作：

• Python 3’s f-Strings: An Improved String Formatting Syntax
• Python String Formatting Best Practices
• Strings and Character Data in Python

• Python 3的f字符串：改进的字符串格式语法
• Python字符串格式化最佳实践
• Python中的字符串和字符数据

翻译自: https://www.pybloggers.com/2018/10/splitting-concatenating-and-joining-strings-in-python/

python 分割字串