blocks|key|1474697|text|import+re
if+re.match(r"%5E[0-9\te%2B+-]%2B$",x):
+++++print+"yes"
else:
+++++print+"no"|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1474698|您可以尝试this.If，有一个匹配，它是一个传递，否则fail.Here+x将是您的字符串。|unstyled|1474699|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>import re
if re.match(r"^[0-9\te+ -]+$",x):
 print "yes"
else:
 print "no"
</code></pre>

You can try this.If there is a match,its a pass else fail.Here x will be your string.

blocks|key|1474728|text|这对于正则表达式来说很简单，使用字符类|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1474729|import+re
if+re.match(r"[0-9e+\t%2B.-]*$",+subject):
+++++#+Match!|code-block|syntax|javascript|1474730|然而，这将(根据规则)也匹配eeeee或%2B-e-%2B等.|style|CODE|1474731|如果您实际要做的是检查给定的字符串是否为有效数字，则只需使用|1474732|try:
++++num+=+float(subject)
except+ValueError:
++++print("Illegal+value")|1474733|这将处理像"%2B34"、"-4e-50"或"++++3.456e7++++++++++"这样的字符串。|1474734|entityMap|0|LINK|mutability|MUTABLE|url|http://www.regular-expressions.info/charclass.html^0|G|3|0|0|0|E|5|K|5|0|0|0|5|5|B|8|K|N|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|15|8|@$A|16|B|17|K|L]|$A|18|B|19|K|L]]|9|@]|C|$]]|$1|M|3|N|5|6|7|1A|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|1B|8|@]|9|@]|C|$G|H]]|$1|Q|3|R|5|6|7|1C|8|@$A|1D|B|1E|K|L]|$A|1F|B|1G|K|L]|$A|1H|B|1I|K|L]]|9|@]|C|$]]|$1|S|3|-4|5|6|7|1J|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]]]

That's trivial for a regex, using a <a href="http://www.regular-expressions.info/charclass.html" rel="nofollow">character class</a>:

<pre><code>import re
if re.match(r"[0-9e \t+.-]*$", subject):
 # Match!
</code></pre>

However, that will (according to the rules) also match <code>eeeee</code> or <code>+-e-+</code> etc...

If what you actually want to do is check whether a given string is a valid number, you could simply use

<pre><code>try:
 num = float(subject)
except ValueError:
 print("Illegal value")
</code></pre>

This will handle strings like <code>"+34"</code> or <code>"-4e-50"</code> or <code>" 3.456e7 "</code>.

blocks|key|1192095|text|您不需要使用正则表达式，只需使用test_list和all操作：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1192096|>>>+from+string+import+digits
>>>+test_list=list(digits)%2B['%2B','-','+','\t','e','.']
>>>+all(i+in+test_list+for+i+in+s)|code-block|syntax|javascript|1192097|演示：|1192098|>>>+s+='%2B4534e+'
>>>+all(i+in+test_list+for+i+in+s)
True
>>>+s='%2B9328a+'
>>>+all(i+in+test_list+for+i+in+s)
False
>>>+s="0.0009017041601+5.13623e-05+0.00137531+0.00124203"
>>>+all(i+in+test_list+for+i+in+s)
True|1192099|entityMap^0|Q|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

You dont need to use regular expressions just use a test_list and <code>all</code> operation :

<pre><code>&gt;&gt;&gt; from string import digits
&gt;&gt;&gt; test_list=list(digits)+['+','-',' ','\t','e','.']
&gt;&gt;&gt; all(i in test_list for i in s)
</code></pre>

Demo:

<pre><code>&gt;&gt;&gt; s ='+4534e '
&gt;&gt;&gt; all(i in test_list for i in s)
True
&gt;&gt;&gt; s='+9328a '
&gt;&gt;&gt; all(i in test_list for i in s)
False
&gt;&gt;&gt; s="0.0009017041601 5.13623e-05 0.00137531 0.00124203"
&gt;&gt;&gt; all(i in test_list for i in s)
True
</code></pre>

blocks|key|2712532|text|检查字符串是否只有所需字符的最简单方法是使用string.translate方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2712533|num+=+"1234e%2B5"
if+num.translate(None,+"0123456789e%2B-+\t"
++++print+"pass"
else:
++++print+"Wrong+character+present!!!"|code-block|syntax|javascript|2712534|您可以在翻译方法中的第二个参数添加除我前面提到的任何字符。|2712535|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Easiest way to check whether the string has only required characters is by using the string.translate method.

<pre><code>num = "1234e+5"
if num.translate(None, "0123456789e+- \t"
 print "pass"
else:
 print "Wrong character present!!!"
</code></pre>

You can add any character at the second parameter in the translate method other than that I mentioned.

blocks|key|2712579|text|就性能而言，运行正则表达式检查要花费很大的代价，这取决于表达式。另外，对每个有效行(即值应该是“True”的行)运行regex检查将花费很大的代价，特别是因为您将用regex解析每一行并再次解析同一行以获得数字。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2712580|你没有说出你想用这些数据做什么，所以我会根据经验假设一些事情。|2712581|首先，在这种情况下，我将确保数据源总是以相同的方式格式化。然后，使用您的示例作为模板，定义以下约定：|2712582|忽略第一个非空白字符为散列符号的任何行。|ordered-list-item|2712583|任何空行都会被忽略。|2712584|只包含空格的任何行都会被忽略。|2712585|这种约定使得解析更加容易，因为您只需要一个正则表达式就可以将规则1.与3.：%5E\s*(#%7C$)相匹配，即任意数量的空间，后面跟着散列符号或行尾。在性能方面，这个表达式只在包含空格和只是空格的情况下才扫描整行，这种情况不会经常发生。在其他情况下，表达式扫描一行并在第一个非空格字符处停止，这意味着将快速检测到注释，因为当遇到哈希时，扫描将立即停止，大部分时间位于0位置。|offset|length|style|CODE|2712586|如果还可以强制执行以下约定：|2712587|其余行的第一个非空白行是具有列名的标头。|unordered-list-item|2712588|样品之间没有空白行。|2712589|样品中没有注释。|2712590|然后，您的代码将执行以下操作：|2712591|将行读入line，只要re.match(r'%5E\s*(#%7C$)',+line)的计算结果为True；|2712592|继续，将标题从下一行读取到line：headers+=+line.split()中，并在列表中包含标头。|2712593|您可以为您的行布局使用一个namedtuple+--我假设在相同的数据表中它是常量的：|2712594|class+WindSample(namedtuple('WindSample',+'time,+force_x,+force_y,+force_z')):
++++def+__new__(cls,+time,+force_x,+force_y,+force_z):
++++++++return+super(WindSample,+cls).__new__(
++++++++++++cls,
++++++++++++float(time),
++++++++++++float(force_x),
++++++++++++float(force_y),
++++++++++++float(force_z)
++++++++)|code-block|syntax|javascript|2712595|然后，对每个line解析有效行，包括以下内容|2712596|try:
++++data+=+WindSample(*line.split())
except+ValueError,+e:
++++print+e|2712597|变量数据将保存如下内容：|2712598|>>>+print+data
WindSample(time=0.0009017041601,+force_x=5.13623e-05,+force_y=0.00137531,+force_z=0.00124203)|2712599|其优点有两方面：|2712600|您只为最小的一行(即空行和注释)运行代价高昂的正则表达式；|2712601|您的代码分析会浮动，每当解析结果无效时就会引发异常。|2712602|entityMap^0|0|0|0|0|0|0|W|2|Z|2|12|9|50|1|0|0|0|0|0|0|4|4|B|S|19|4|0|D|4|I|M|0|D|A|0|0|6|4|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1W|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|1X|8|@]|9|@]|A|$]]|$1|I|3|J|5|H|7|1Y|8|@]|9|@]|A|$]]|$1|K|3|L|5|H|7|1Z|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|20|8|@$O|21|P|22|Q|R]|$O|23|P|24|Q|R]|$O|25|P|26|Q|R]|$O|27|P|28|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|29|8|@]|9|@]|A|$]]|$1|U|3|V|5|W|7|2A|8|@]|9|@]|A|$]]|$1|X|3|Y|5|W|7|2B|8|@]|9|@]|A|$]]|$1|Z|3|10|5|W|7|2C|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|2D|8|@]|9|@]|A|$]]|$1|13|3|14|5|H|7|2E|8|@$O|2F|P|2G|Q|R]|$O|2H|P|2I|Q|R]|$O|2J|P|2K|Q|R]]|9|@]|A|$]]|$1|15|3|16|5|H|7|2L|8|@$O|2M|P|2N|Q|R]|$O|2O|P|2P|Q|R]]|9|@]|A|$]]|$1|17|3|18|5|6|7|2Q|8|@$O|2R|P|2S|Q|R]]|9|@]|A|$]]|$1|19|3|1A|5|1B|7|2T|8|@]|9|@]|A|$1C|1D]]|$1|1E|3|1F|5|6|7|2U|8|@$O|2V|P|2W|Q|R]]|9|@]|A|$]]|$1|1G|3|1H|5|1B|7|2X|8|@]|9|@]|A|$1C|1D]]|$1|1I|3|1J|5|6|7|2Y|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|1B|7|2Z|8|@]|9|@]|A|$1C|1D]]|$1|1M|3|1N|5|6|7|30|8|@]|9|@]|A|$]]|$1|1O|3|1P|5|H|7|31|8|@]|9|@]|A|$]]|$1|1Q|3|1R|5|H|7|32|8|@]|9|@]|A|$]]|$1|1S|3|-4|5|6|7|33|8|@]|9|@]|A|$]]]|1T|$]]

Performance wise, running a regular expression check is costly, depending on the expression. Also running a regex check for each valid line (i.e. lines which the value should be "True") will be costly, especially because you'll end up parsing each line with a regex and parse the same line again to get the numbers.

You did not say what you wanted to do with the data so I will empirically assume a few things.

First off in a case like this I would make sure the data source is always formatted the same way. Using your example as a template I would then define the following convention:

<ol>
<li>any line, which first non-blank character is a hash sign is ignored</li>
<li>any blank line is ignored</li>
<li>any line that contains only spaces is ignored</li>
</ol>

This kind of convention makes parsing much easier since you only need one regular expression to fit rules <code>1.</code> to <code>3.</code> : <code>^\s*(#|$)</code>, i.e. any number of space followed by either a hash sign or an end of line. On the performance side, this expression scans an entire line only when it's comprised of spaces and just spaces, which shall not happen very often. In other cases the expression scans a line and stops at the first non-space character, which means comments will be detected quickly for the scanning will stop as soon as the hash is encountered, at position <code>0</code> most of the time.

If you can also enforce the following convention:

<ul>
<li>the first non blank line of the remaining lines is the header with column names</li>
<li>there is no blank lines between samples</li>
<li>there are no comments in samples</li>
</ul>

Your code would then do the following:

<ol>
<li>read lines into <code>line</code> for as long as <code>re.match(r'^\s*(#|$)', line)</code> evaluates to <code>True</code>;</li>
<li>continue, reading headers from the next line into <code>line</code>: <code>headers = line.split()</code> and you have headers in a list.</li>
</ol>

You can use a <code>namedtuple</code> for your line layout — which I assume is constant throughout the same data table:

<pre><code>class WindSample(namedtuple('WindSample', 'time, force_x, force_y, force_z')):
 def __new__(cls, time, force_x, force_y, force_z):
 return super(WindSample, cls).__new__(
 cls,
 float(time),
 float(force_x),
 float(force_y),
 float(force_z)
 )
</code></pre>

Parsing valid lines would then consist of the following, for each <code>line</code>:

<pre><code>try:
 data = WindSample(*line.split())
except ValueError, e:
 print e
</code></pre>

Variable data would hold something such as:

<pre><code>&gt;&gt;&gt; print data
WindSample(time=0.0009017041601, force_x=5.13623e-05, force_y=0.00137531, force_z=0.00124203)
</code></pre>

The advantage is twofold:

<ol>
<li>you run costly regular expressions only for the smallest set of lines (i.e. blank lines and comments);</li>
<li>your code parses floats, raising an exception whenever parsing would yield something invalid.</li>
</ol>

I would like to find the most efficient and simple way to test in python if a string passes the following criteria:

<ul>
<li>contains nothing except:
<ul>
<li>digits (the numbers 0-9)</li>
<li>decimal points: '.'</li>
<li>the letter 'e'</li>
<li>the sign '+' or '-'</li>
<li>spaces (any number of them)</li>
<li>tabs (any number of them)</li>
</ul></li>
</ul>

I can do this easily with nested 'if' loops, etc., but i'm wondering if there's a more convenient way...

For example, I would want the string:

<pre><code>0.0009017041601 5.13623e-05 0.00137531 0.00124203
</code></pre>

to be 'true' and all the following to be 'false':

<pre><code># File generated at 10:45am Tuesday, July 8th
# Velocity: 82.568
# Ambient Pressure: 150000.0

 Time(seconds) Force_x Force_y Force_z
</code></pre>

Elegant way test in python if string contains nothing except 0-9,e,+,-,spaces,tabs

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我希望找到在python中测试字符串是否通过以下条件的最有效和最简单的方法：除了：之外，什么都不包含数字(数字0-9)小数点：“.”字母“e”符号“+”或“-”空间(其中任何数目)选项卡(任意数量)​我可以很容易地使用嵌套的' if‘循环，等等，但我想知道是否有更方便的方法.例如，我想要字符串：0.0009017041...

问python中优雅的方法测试如果字符串只包含0-9，e，+，-，空格，制表符
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问python中优雅的方法测试如果字符串只包含0-9，e，+，-，空格，制表符EN