python字符串的分割,python字符串分割成单个字母

　　在给定的字符集出现之前拆分字符串的pythonic方法是什么？

　　例如，我想分裂

　　“漫长而曲折的道路”

　　当大写字母出现时(也许除了首字母)，得到

　　[The ， Long ， And ， Winding ， Road].

　　编辑：它还应该分割单个事件，即

　　我想从“ABC”得到它

　　[甲，乙，丙].

　　不幸的是，在Python中不可能分割成零宽度的匹配。但是您可以使用re.findall来代替：

　　进口re

　　re.findall([A-Z][^A-Z]*，《漫长而黑暗的道路》

　　[The ， Long ， And ， Winding ， Road]

　　re.findall([A-Z][^A-Z]*，“ABC”)

　　[A ， B ， C]

　　请注意，这将删除第一个大写字母之前的所有字符。这条长长的弯弯曲曲的路通向

　　@MarcSchulder:如果需要这种情况，就用[a-za-z] [a-z] *作为正则表达式。

　　不使用大写字母也能进行同样的操作吗？

　　要拆分小写驼峰字打印(re。查找全部([a-z] [a-z] [a-z] *，longandwindingroad))

　　这是另一个正则表达式解决方案。你可以把问题改写成‘拆分前，如何在每个大写字母前插入一个空格’:

　　s= thelongandwinding road ABC a123b 45

　　re(r ([A-Z])，r \1 ，s)。拆分()

　　[The ， Long ， And ， Winding ， Road ， A ， B ， C ， A123 ， B45]

　　这样做的好处是，所有非空白字符都会保留，而大多数其他解决方案则不会。

　　能解释一下1前的空格为什么起作用吗？是因为split方法还是和正则表达式有关？

　　进口re

　　re.findall([A-Z][a-z]* ， TheLongAndWindingRoad )

　　[The ， Long ， And ， Winding ， Road]

　　re.findall([A-Z][a-z]*， SplitAString )

　　[Split ， A ， String]

　　re.findall([A-Z][a-z]*， ABC )

　　[A ， B ， C]

　　如果要将 ItsATest 拆分成[Its ， A ， Test]，请将rexeg改为[A-Z][a-z]*

　　1:让ABC先工作。Ive现在也更新了我的回答。

　　Re.findall([A-Z] [a-z] *，占经济的70%左右)-[IT，经济]

　　@ChristopheD .OP没说怎么处理非字母字符。

　　没错，但是这个当前的正则表达式也会删除所有不以大写字母开头的正则(纯Alpha)单词。我怀疑这就是《任择议定书》的意图。

　　@ Christopher解决方案的变体

　　s=TheLongAndWindingRoad

　　pos=[i for i，e in enumerate(s A )if e . I supper()]

　　parts=[s[pos[j]:pos[j 1]]for j in x range(len(pos)-1)]

　　打印零件

　　一个很好的例子——也适用于非拉丁字符。这里显示的正则表达式解决方案没有。

　　进口re

　　过滤器(无，re.split(([a-z][^a-z]*),thelongandwindingroad))

　　或者

　　【s在re.split(([a-z][^a-z]*),thelongandwindingroad代表s)如果s】

　　过滤器完全没有必要，正则表达式可以通过捕捉组直接拆分成任何东西： show [a-z] *))。split( thelongandwindingroad )if s]给出[the [The，Long，And，Winding，Road]]

　　@ smci:filter的这种用法和对有条件列表的理解是一样的。你有什么异议吗？

　　我知道我可以用一个有条件理解的列表来代替，因为我只是发布了代码，然后你就复制了。最好用以下三个理由来理解list comprehension: a)清晰易懂的成语：list comprehension是一个更Python的成语，它比filter(lambdaconditionfunc，)从左往右读。b)在Python 3中，filter()返回一个迭代器。因此，它们不会完全等同。c)希望filter()也慢。

　　src=TheLongAndWindingRoad

　　glue=

　　结果=“”。join(glue x if x . I supper()else x for x in src)。长条(胶水)。拆分(粘合)

　　能不能补充一个解释，说明为什么这是解决问题的好办法。

　　很抱歉我忘了最后一步。

　　在我看来，言简意赅，简明易懂。

　　解决方案(如果你不喜欢显式正则表达式):

　　s=TheLongAndWindingRoad

　　pos=[i for i，e in enumerate(s) if e.isupper()]

　　零件=[]

　　对于xrange中的j(len(pos)):

　　尝试：

　　parts.append(s[pos[j]:pos[j 1]])

　　除了索引错误：

　　parts.append(s[pos[j]:])

　　打印零件

　　提前使用：

　　在Python 3.7中，您可以执行以下操作：

　　re.split((？=[A-Z])， theLongAndWindingRoad )

　　它产生：

　　[The ， Long ， And ， Winding ， Road]

　　使用more_itertools.split_before工具可以做到这一点。

　　将更多_itertools作为麻省理工学院导入

　　iterable= TheLongAndWindingRoad

　　[.在mit.split_before(iterable，pred=lambda s: s.isupper())中为我加入]

　　# [The ， Long ， And ， Winding ， Road]

　　它还应该拆分单个事件，即从“ABC”中获取[“甲”、“乙”、“丙]].

　　iterable=ABC

　　[.在mit.split_before(iterable，pred=lambda s: s.isupper())中为我加入]

　　# [A ， B ， C]

　　更多_itertools是带有60多种有用工具的第三方程序包，其中包括所有原始循环器配方的实现，从而避免了它们的手动实现。

　　另一个没有正则表达式，并且如果需要，可以保持连续的大写

　　def split_on_uppercase(s，keep_contiguous=False):

　　参数：

　　s (str):字符串

　　保持连续(布尔值):表示我们希望

　　将连续的大写字符放在一起

　　退货：

　　字符串长度=长度

　　is_lower_around=(lambda: s[i-1].islower()或

　　字符串长度(i 1)和s[i 1].islower())

　　开始=0

　　零件=[]

　　对于范围内的I(1，string_length):

　　如果s[i].isupper()和(不保持连续)或is_lower_around()):

　　parts.append(s[start: i])

　　开始=我

　　parts.append(s[start:])

　　退回零件

　　split _ on _ upper case( theLongWindingRoad )

　　[the ， Long ， Winding ， Road]

　　split _ on _ upper case( TheLongWindingRoad )

　　[The ， Long ， Winding ， Road]

　　split _ on _ upper case( thelongwindingroad ，True)

　　[The ， Long ， WINDING ， Road ， T]

　　拆分开大写(“ABC”)

　　[A ， B ， C]

　　split_on_uppercase(ABCD ，True)

　　[ABCD]

　　split_on_uppercase( )

　　[]

　　split _ on _ upper case("hello world ")

　　[你好，世界]

　　计算机编程语言方式可能是：

　　.join([( I if I . is upper()else I)for I in TheLongAndWindingRoad ]).剥离()。拆分()

　　[The ， Long ， And ， Winding ， Road]

　　适用于Unicode，避免re/re2。

　　.在]).加入([( i if i.isupper() else i) for i剥离()。拆分()

　　[, , , ]

　　分享我阅读帖子时想到的内容。与其他职位不同。

　　strs=TheLongAndWindingRoad

　　#抓取潜艇用热中子反应堆（submarine thermal reactor的缩写）中大写字母的索引

　　start_idx=[i for i，j in enumerate(strs)if j . I super()]

　　#创建空列表

　　strs_list=[]

　　#启动计数器

　　cnt=1

　　对于start_idx中的位置：

　　start_pos=pos

　　#使用计数器抓取下一个位置元素并忽略指数误差

　　尝试：

　　end_pos=start_idx[cnt]

　　除了索引错误：

　　继续

　　#追加到空列表

　　strs _ list。追加(strs[开始位置：结束位置])

　　cnt=1

　　使用列举和isupper()的替代方法

　　码：

　　strs=TheLongAndWindingRoad

　　ind=0

　　计数=0

　　new_lst=[]

　　对于index，val in enumerate(strs[1:]，1):

　　if val.isupper():

　　new_lst.append(strs[ind:索引])

　　ind=索引

　　如果找到

　　new_lst.append(strs[ind:])

　　打印新列表

　　输出：

　　[The ， Long ， And ， Winding ， Road]

　　不使用正则表达式或枚举的另一种方法：

　　word=TheLongAndWindingRoad

　　list=[x for x in word]

　　对于列表中的字符：

　　如果夏尔！=列表[0]和char.isupper():

　　list[list.index(char)]= char

　　fin_list=" " .加入（列表)。拆分("")

　　我认为这无需链接太多方法或使用难以理解的长列表理解就更清楚，更简单。

　　将给定的每个大写字母我替换为一个空格加上该字母我是。我们可以使用列表理解来做到这一点，或者我们可以如下定义一个函数来做到这一点。

　　s=漫长而曲折的道路ABC a123b 45

　　.join([char if (char.islower()或不是char。列表中的字符是否为alpha())else char].剥离()。拆分()

　　[The ， Long ， A ， N ， D ， Winding ， Road ， A ， B ， C ， A123 ， B45]

　　如果您选择按功能执行，则方法如下。

　　def splitAtUpperCase(文本):

　　结果=

　　对于文本中字符：

　　if char.isupper():

　　result= char

　　否则：

　　结果=字符

　　返回result.split()

　　在给定示例的情况下：

　　print(splitatupper case( TheLongAndWindingRoad ))

　　[The ， Long ， A ， N ， D ， Winding ， Road]

　　但在大多数情况下，当我们将一个句子拆分成大写字母时，通常情况下我们希望保留缩写，缩写通常是一个连续的大写字母流。下面的代码会有所帮助。

　　定义拆分大小写：

　　对于范围内的I(len(s)-1)[:-1]:

　　如果s[i]。isupper()和s[i 1]。islower():

　　s=s[:i] s[i:]

　　如果s[i]。isupper()和s[i-1]。islower():

　　s=s[:i] s[i:]

　　return s.split()

　　splitatupper case(“TheLongANDWindingRoad”)

　　[The ， Long ， AND ， Winding ， Road]

　　谢谢你。

　　@MarkByers我不知道为什么有人不同意我的回答，但我希望你能帮我看一看。非常感谢您的反馈。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。