Python ConfigParser - 引号之间的值
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/1311367/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
Python ConfigParser - values between quotes
提问by
When using ConfigParsermodule I would like to use values containing of multiple words set in cfg file. In this case seems trivial for me to surround the string with quotes like (example.cfg):
使用ConfigParser模块时，我想使用包含在 cfg 文件中设置的多个单词的值。在这种情况下，我用像 ( example.cfg)这样的引号将字符串括起来似乎微不足道：
[GENERAL]
onekey = "value in some words"
My problem is that in this case python appends the quotes to the string as well when using the value like this:
我的问题是，在这种情况下，python 在使用这样的值时也会将引号附加到字符串：
config = ConfigParser()
config.read(["example.cfg"])
print config.get('GENERAL', 'onekey')
I am sure there is an in-built feature to manage to print only 'value in some words'instead of '"value in some words"'. How is it possible? Thanks.
我确信有一个内置功能可以管理打印'value in some words'而不是'"value in some words"'. 这怎么可能？谢谢。
回答by Mark Rushakoff
I didn't see anything in the configparser manual, but you could just use the .stripmethod of strings to get rid of the leading and trailing double quotes.
我在configparser 手册中没有看到任何内容，但是您可以使用.strip字符串的方法来摆脱前导和尾随双引号。
>>> s = '"hello world"'
>>> s
'"hello world"'
>>> s.strip('"')
'hello world'
>>> s2 = "foo"
>>> s2.strip('"')
'foo'
As you can see, .stripdoes not modify the string if it does not start and end with the specified string.
如您所见，.strip如果字符串不以指定字符串开头和结尾，则不会修改该字符串。
回答by Anatoly Orlov
import ConfigParser
class MyConfigParser(ConfigParser.RawConfigParser):
def get(self, section, option):
val = ConfigParser.RawConfigParser.get(self, section, option)
return val.strip('"')
if __name__ == "__main__":
#config = ConfigParser.RawConfigParser()
config = MyConfigParser()
config.read(["example.cfg"])
print config.get('GENERAL', 'onekey')
回答by Anatoly Orlov
Sorry, the solution was trivial as well - I can simply leave the quotes, it looks python simply takes the right side of equal sign.
抱歉，解决方案也很简单 - 我可以简单地留下引号，看起来 python 只是在等号的右侧。
回答by estani
The question is quite old already, but in 2.6 at least you don't need to use quotes as spaces are retained.
这个问题已经很老了，但至少在 2.6 中，您不需要使用引号，因为保留了空格。
from ConfigParser import RawConfigParser
from StringIO import StringIO
s = RawConfigParser()
s.readfp(StringIO('[t]\na= 1 2 3'))
s.get('t','a')
> '1 2 3'
That doesn't apply though either to leading or trailing spaces! If you want to retain those, you will need to enclose them in quotes an proceed as suggested. Refrain from using the evalkeyword as you'll have a huge security hole.
这不适用于前导或尾随空格！如果您想保留这些，您需要按照建议将它们括在引号中。避免使用eval关键字，因为你会有一个巨大的安全漏洞。
回答by Jabba
I had to face the same problem. Instead of a configparser object, I prefer to work with normal dictionaries. So first I read the .inifile, then convert the configparser object to dict, and finally I remove quotes (or apostrophes) from string values. Here is my solution:
我不得不面对同样的问题。我更喜欢使用普通字典而不是 configparser 对象。所以首先我读取.ini文件，然后将 configparser 对象转换为 dict，最后我从字符串值中删除引号（或撇号）。这是我的解决方案：
preferences.ini
首选项.ini
[GENERAL]
onekey = "value in some words"
[SETTINGS]
resolution = '1024 x 768'
example.py
例子.py
#!/usr/bin/env python3
from pprint import pprint
import preferences
prefs = preferences.Preferences("preferences.ini")
d = prefs.as_dict()
pprint(d)
preferences.py
首选项.py
import sys
import configparser
import json
from pprint import pprint
def remove_quotes(original):
d = original.copy()
for key, value in d.items():
if isinstance(value, str):
s = d[key]
if s.startswith(('"', "'")):
s = s[1:]
if s.endswith(('"', "'")):
s = s[:-1]
d[key] = s
# print(f"string found: {s}")
if isinstance(value, dict):
d[key] = remove_quotes(value)
#
return d
class Preferences:
def __init__(self, preferences_ini):
self.preferences_ini = preferences_ini
self.config = configparser.ConfigParser()
self.config.read(preferences_ini)
self.d = self.to_dict(self.config._sections)
def as_dict(self):
return self.d
def to_dict(self, config):
"""
Nested OrderedDict to normal dict.
Also, remove the annoying quotes (apostrophes) from around string values.
"""
d = json.loads(json.dumps(config))
d = remove_quotes(d)
return d
The line d = remove_quotes(d)is responsible for removing the quotes. Comment / uncomment this line to see the difference.
该行d = remove_quotes(d)负责删除引号。注释/取消注释此行以查看差异。
Output:
输出：
$ ./example.py
{'GENERAL': {'onekey': 'value in some words'},
'SETTINGS': {'resolution': '1024 x 768'}}
回答by Rajeshwar Mukund
can write configuration reading function as follows, which returns configuration in dictionary form.
可以编写如下配置读取函数，以字典形式返回配置。
def config_reader():
"""
Reads configuration from configuration file.
"""
configuration = ConfigParser.ConfigParser()
configuration.read(__file__.split('.')[0] + '.cfg')
config = {}
for section in configuration.sections():
config[section] = {}
for option in configuration.options(section):
config[section][option] = (configuration.get(section, option)).strip('"').strip("'")
return config
回答by Jim Dennis
Davey,
戴维，
As you say you can just leave the quotes off your string.
正如您所说，您可以将引号从字符串中删除。
For a project I'm working on I wanted to be able to represent almost any Python string literal as a value for some of my config options and more to the point I wanted to be able to handle some of them as raw string literals. (I want that config to be able to handle things like \n, \x1b, and so on).
对于我正在处理的一个项目，我希望能够将几乎任何 Python 字符串文字表示为我的一些配置选项的值，而且我希望能够将其中一些作为原始字符串文字处理。（我希望该配置能够处理 \n、\x1b 等内容）。
In that case I used something like:
在那种情况下，我使用了类似的东西：
def EvalStr(s, raw=False):
r'''Attempt to evaluate a value as a Python string literal or
return s unchanged.
Attempts are made to wrap the value in one, then the
form of triple quote. If the target contains both forms
of triple quote, we'll just punt and return the original
argument unmodified.
Examples: (But note that this docstring is raw!)
>>> EvalStr(r'this\t is a test\n and only a \x5c test')
'this\t is a test\n and only a \ test'
>>> EvalStr(r'this\t is a test\n and only a \x5c test', 'raw')
'this\t is a test\n and only a \x5c test'
'''
results = s ## Default returns s unchanged
if raw:
tmplate1 = 'r"""%s"""'
tmplate2 = "r'''%s'''"
else:
tmplate1 = '"""%s"""'
tmplate2 = "'''%s'''"
try:
results = eval(tmplate1 % s)
except SyntaxError:
try:
results = eval(tmplate2 %s)
except SyntaxError:
pass
return results
... which I think will handle anything that doesn't contain both triple-single and triple-double quoted strings.
...我认为它将处理不包含三重单引号和三重双引号字符串的任何内容。
(That one corner case is way beyond my requirements).
（那个角落案例远远超出了我的要求）。
There is an oddity of this code here on SO; the Syntax highlighter seems to be confused by the fact that my docstring is a rawstring. That was necessary to make doctest happy for this particular function).
这段代码在 SO 上很奇怪；语法荧光笔似乎对我的文档字符串是原始字符串这一事实感到困惑。这对于使 doctest 对这个特定功能感到满意是必要的）。
回答by Eacon
At this situation, the most simple solution is "eval()".
在这种情况下，最简单的解决方案是“eval()”。
However, you may worry about the security stuff.But you could still do this by:
但是，您可能会担心安全问题。但您仍然可以通过以下方式做到这一点：
def literal_eval(node_or_string):
"""
Safely evaluate an expression node or a string containing a Python
expression. The string or node provided may only consist of the following
Python literal structures: strings, numbers, tuples, lists, dicts,booleans,
and None.
"""
as a sample:
作为示例：
import ast
config = ConfigParser()
config.read(["example.cfg"])
print ast.literal_eval(config.get('GENERAL', 'onekey'))
# value in some words
