xls5-解析properties文件，在python中基本没有遇到

标签：opened   rmi   erro   新建   new   cep   error   other   ase   

 xls5-解析properties文件，在python中基本没有遇到

https://www.runoob.com/python3/python3-dictionary.html

要解析properties文件，在python中基本没有遇到这中情况，今天用python跑深度学习的时候，发现有些参数可以放在一个global.properties全局文件中，这样使用的时候更加方便。原理都是加载文件，然后用line方法进行解析判断”=”,自己从网上找到一个工具类，记录一下。

工具类 PropertiesUtiil.py
# -*- coding:utf-8 -*-
class Properties(object):

def __init__(self, fileName):
self.fileName = fileName
self.properties = {}

def __getDict(self,strName,dictName,value):

if(strName.find(‘.‘)>0):
k = strName.split(‘.‘)[0]
dictName.setdefault(k,{})
return self.__getDict(strName[len(k)+1:],dictName[k],value)
else:
dictName[strName] = value
return
def getProperties(self):
try:
pro_file = open(self.fileName, ‘Ur‘)
for line in pro_file.readlines():
line = line.strip().replace(‘\n‘, ‘‘)
if line.find("#")!=-1:
line=line[0:line.find(‘#‘)]
if line.find(‘=‘) > 0:
strs = line.split(‘=‘)
strs[1]= line[len(strs[0])+1:]
self.__getDict(strs[0].strip(),self.properties,strs[1].strip())
except Exception, e:
raise e
else:
pro_file.close()
return self.properties

通过上面的代码就可以解析了properties文件了。新建一个文件

global.properties 文件
a.name.last=jie
b.name.first=shi
#b.name=shijie
1
2
3
测试 test.py
from PropertiesUtil import Properties
dictProperties=Properties("global.properties").getProperties()
print dictProperties

控制台打印：

/usr/bin/python2.7 /home/tengxing/rude-carnie/test.py
{‘a‘: {‘name‘: {‘last‘: ‘jie‘}}, ‘b‘: {‘name‘: {‘first‘: ‘shi‘}}}

Process finished with exit code 0

我感觉还是挺方便的
————————————————
版权声明：本文为CSDN博主「牧羊人影视」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/tengxing007/java/article/details/72466187

https://www.runoob.com/python3/python3-dictionary.html

工作需要将Java项目的逻辑改为python执行，Java的很多配置文件都是.properties的，文件内容的格式是“键.键.键。。。＝值”的格式例如A.B.C=value1，D.F=value2等。并且“＃”用来注视。python没有专门处理properties格式的包，只有处理标准的ini格式的包。所以需要自己写一个python程序来处理。不说了上程序。

这里参考前面一篇：//www.jb51.net/article/137390.htm

主要在前文的基础上，增加key.key.key=value的形式的支持

Util.py文件：

filename.properties文件：

测试文件text.py：

输出：

{‘a‘: {‘c‘: ‘v2‘, ‘b‘: {‘d‘: ‘v1‘}}, ‘d‘: {‘e‘: ‘v3‘}, ‘f‘: ‘v4‘}

更多关于Python

#! /usr/bin/env python

"""
A Python replacement for java.util.Properties class
This is modelled as closely as possible to the Java original.

Created - Anand B Pillai <abpillai@gmail.com>
"""

import sys,os
import re
import time

class IllegalArgumentException(Exception):

def __init__(self, lineno, msg):
self.lineno = lineno
self.msg = msg

def __str__(self):
s=‘Exception at line number %d => %s‘ % (self.lineno, self.msg)
return s

class Properties(object):
""" A Python replacement for java.util.Properties """

def __init__(self, props=None):

# Note: We don‘t take a default properties object
# as argument yet

# Dictionary of properties.
self._props = {}
# Dictionary of properties with ‘pristine‘ keys
# This is used for dumping the properties to a file
# using the ‘store‘ method
self._origprops = {}

# Dictionary mapping keys from property
# dictionary to pristine dictionary
self._keymap = {}

self.othercharre = re.compile(r‘(?<!\\)(\s*\=)|(?<!\\)(\s*\:)‘)
self.othercharre2 = re.compile(r‘(\s*\=)|(\s*\:)‘)
self.bspacere = re.compile(r‘\\(?!\s$)‘)

def __str__(self):
s=‘{‘
for key,value in self._props.items():
s = ‘‘.join((s,key,‘=‘,value,‘, ‘))

s=‘‘.join((s[:-2],‘}‘))
return s

def __parse(self, lines):
""" Parse a list of lines and create
an internal property dictionary """

# Every line in the file must consist of either a comment
# or a key-value pair. A key-value pair is a line consisting
# of a key which is a combination of non-white space characters
# The separator character between key-value pairs is a ‘=‘,
# ‘:‘ or a whitespace character not including the newline.
# If the ‘=‘ or ‘:‘ characters are found, in the line, even
# keys containing whitespace chars are allowed.

# A line with only a key according to the rules above is also
# fine. In such case, the value is considered as the empty string.
# In order to include characters ‘=‘ or ‘:‘ in a key or value,
# they have to be properly escaped using the backslash character.

# Some examples of valid key-value pairs:
#
# key value
# key=value
# key:value
# key value1,value2,value3
# key value1,value2,value3 \
# value4, value5
# key
# This key= this value
# key = value1 value2 value3

# Any line that starts with a ‘#‘ is considerered a comment
# and skipped. Also any trailing or preceding whitespaces
# are removed from the key/value.

# This is a line parser. It parses the
# contents like by line.

lineno=0
i = iter(lines)

for line in i:
lineno += 1
line = line.strip()
# Skip null lines
if not line: continue
# Skip lines which are comments
if line[0] == ‘#‘: continue
# Some flags
escaped=False
# Position of first separation char
sepidx = -1
# A flag for performing wspace re check
flag = 0
# Check for valid space separation
# First obtain the max index to which we
# can search.
m = self.othercharre.search(line)
if m:
first, last = m.span()
start, end = 0, first
flag = 1
wspacere = re.compile(r‘(?<![\\\=\:])(\s)‘)
else:
if self.othercharre2.search(line):
# Check if either ‘=‘ or ‘:‘ is present
# in the line. If they are then it means
# they are preceded by a backslash.

# This means, we need to modify the
# wspacere a bit, not to look for
# : or = characters.
wspacere = re.compile(r‘(?<![\\])(\s)‘)
start, end = 0, len(line)

m2 = wspacere.search(line, start, end)
if m2:
# print ‘Space match=>‘,line
# Means we need to split by space.
first, last = m2.span()
sepidx = first
elif m:
# print ‘Other match=>‘,line
# No matching wspace char found, need
# to split by either ‘=‘ or ‘:‘
first, last = m.span()
sepidx = last - 1
# print line[sepidx]


# If the last character is a backslash
# it has to be preceded by a space in which
# case the next line is read as part of the
# same property
while line[-1] == ‘\\‘:
# Read next line
nextline = i.next()
nextline = nextline.strip()
lineno += 1
# This line will become part of the value
line = line[:-1] + nextline

# Now split to key,value according to separation char
if sepidx != -1:
key, value = line[:sepidx], line[sepidx+1:]
else:
key,value = line,‘‘

self.processPair(key, value)

def processPair(self, key, value):
""" Process a (key, value) pair """

oldkey = key
oldvalue = value

# Create key intelligently
keyparts = self.bspacere.split(key)
# print keyparts

strippable = False
lastpart = keyparts[-1]

if lastpart.find(‘\\ ‘) != -1:
keyparts[-1] = lastpart.replace(‘\\‘,‘‘)

# If no backspace is found at the end, but empty
# space is found, strip it
elif lastpart and lastpart[-1] == ‘ ‘:
strippable = True

key = ‘‘.join(keyparts)
if strippable:
key = key.strip()
oldkey = oldkey.strip()

oldvalue = self.unescape(oldvalue)
value = self.unescape(value)

self._props[key] = value.strip()

# Check if an entry exists in pristine keys
if self._keymap.has_key(key):
oldkey = self._keymap.get(key)
self._origprops[oldkey] = oldvalue.strip()
else:
self._origprops[oldkey] = oldvalue.strip()
# Store entry in keymap
self._keymap[key] = oldkey

def escape(self, value):

# Java escapes the ‘=‘ and ‘:‘ in the value
# string with backslashes in the store method.
# So let us do the same.
newvalue = value.replace(‘:‘,‘\:‘)
newvalue = newvalue.replace(‘=‘,‘\=‘)

return newvalue

def unescape(self, value):

# Reverse of escape
newvalue = value.replace(‘\:‘,‘:‘)
newvalue = newvalue.replace(‘\=‘,‘=‘)

return newvalue

def load(self, stream):
""" Load properties from an open file stream """

# For the time being only accept file input streams
if type(stream) is not file:
raise TypeError,‘Argument should be a file object!‘
# Check for the opened mode
if stream.mode != ‘r‘:
raise ValueError,‘Stream should be opened in read-only mode!‘

try:
lines = stream.readlines()
self.__parse(lines)
except IOError, e:
raise

def getProperty(self, key):
""" Return a property for the given key """

return self._props.get(key,‘‘)

def setProperty(self, key, value):
""" Set the property for the given key """

if type(key) is str and type(value) is str:
self.processPair(key, value)
else:
raise TypeError,‘both key and value should be strings!‘

def propertyNames(self):
""" Return an iterator over all the keys of the property
dictionary, i.e the names of the properties """

return self._props.keys()

def list(self, out=sys.stdout):
""" Prints a listing of the properties to the
stream ‘out‘ which defaults to the standard output """

out.write(‘-- listing properties --\n‘)
for key,value in self._props.items():
out.write(‘‘.join((key,‘=‘,value,‘\n‘)))

def store(self, out, header=""):
""" Write the properties list to the stream ‘out‘ along
with the optional ‘header‘ """

if out.mode[0] != ‘w‘:
raise ValueError,‘Steam should be opened in write mode!‘

try:
out.write(‘‘.join((‘#‘,header,‘\n‘)))
# Write timestamp
tstamp = time.strftime(‘%a %b %d %H:%M:%S %Z %Y‘, time.localtime())
out.write(‘‘.join((‘#‘,tstamp,‘\n‘)))
# Write properties from the pristine dictionary
for prop, val in self._origprops.items():
out.write(‘‘.join((prop,‘=‘,self.escape(val),‘\n‘)))

out.close()
except IOError, e:
raise

def getPropertyDict(self):
return self._props

def __getitem__(self, name):
""" To support direct dictionary like access """

return self.getProperty(name)

def __setitem__(self, name, value):
""" To support direct dictionary like access """

self.setProperty(name, value)

def __getattr__(self, name):
""" For attributes not found in self, redirect
to the properties dictionary """

try:
return self.__dict__[name]
except KeyError:
if hasattr(self._props,name):
return getattr(self._props, name)

if __name__=="__main__":
p = Properties()
p.load(open(‘test2.properties‘))
p.list()
print p
print p.items()
print p[‘name3‘]
p[‘name3‘] = ‘changed = value‘
print p[‘name3‘]
p[‘new key‘] = ‘new value‘
p.store(open(‘test2.properties‘,‘w‘))

参考来源：http://blog.csdn.net/bobzhangshaobo/article/details/47617107 我们都是在java里面遇到要解析properties文件，在python中基本没有遇到这中情况，今天用python跑深度学习的时候，发现有些参数可以放在一个global.properties全局文件中，这样使用的时候更加方便。原理都是加载文件，然后用line方法进行解析判断”=”,自己从网上找到一个工具类，记录一下。

工具类 PropertiesUtiil.py

# -*- coding:utf-8 -*-
class Properties(object):  

    def __init__(self, fileName):  
        self.fileName = fileName  
        self.properties = {}  

    def __getDict(self,strName,dictName,value):  

        if(strName.find(‘.‘)>0):  
            k = strName.split(‘.‘)[0]  
            dictName.setdefault(k,{})  
            return self.__getDict(strName[len(k)+1:],dictName[k],value)  
        else:  
            dictName[strName] = value  
            return  
    def getProperties(self):  
        try:  
            pro_file = open(self.fileName, ‘Ur‘)  
            for line in pro_file.readlines():  
                line = line.strip().replace(‘\n‘, ‘‘)  
                if line.find("#")!=-1:  
                    line=line[0:line.find(‘#‘)]  
                if line.find(‘=‘) > 0:  
                    strs = line.split(‘=‘)  
                    strs[1]= line[len(strs[0])+1:]  
                    self.__getDict(strs[0].strip(),self.properties,strs[1].strip())  
        except Exception, e:  
            raise e  
        else:  
            pro_file.close()  
        return self.properties  

通过上面的代码就可以解析了properties文件了。新建一个文件

global.properties 文件

a.name.last=jie
b.name.first=shi
#b.name=shijie

测试 test.py

from PropertiesUtil import Properties
dictProperties=Properties("global.properties").getProperties()
print dictProperties

控制台打印：

/usr/bin/python2.7 /home/tengxing/rude-carnie/test.py
{‘a‘: {‘name‘: {‘last‘: ‘jie‘}}, ‘b‘: {‘name‘: {‘first‘: ‘shi‘}}}

Process finished with exit code 0

我感觉还是挺方便的，就对做深度学习来说吧，把模型的的位置，训练数据放在一个global.properties文件中，方便管理。

# -*- coding:utf-8 -*-
class Properties(object):

    def __init__(self, fileName):
        self.fileName = fileName
        self.properties = {}

    def __getDict(self,strName,dictName,value):

        if(strName.find(‘.‘)>0):
            k = strName.split(‘.‘)[0]
            dictName.setdefault(k,{})
            return self.__getDict(strName[len(k)+1:],dictName[k],value)
        else:
            dictName[strName] = value
            return
    def getProperties(self):
        try:
            pro_file = open(self.fileName, ‘r‘)
            for line in pro_file.readlines():
                line = line.strip().replace(‘\n‘, ‘‘)
                if line.find("#")!=-1:
                    line=line[0:line.find(‘#‘)]
                if line.find(‘=‘) > 0:
                    strs = line.split(‘=‘)
                    strs[1]= line[len(strs[0])+1:]
                    self.__getDict(strs[0].strip(),self.properties,strs[1].strip())
        except:
            raise
        else:
            pro_file.close()
        return self.properties


#
# from PropertiesUtil import Properties
# dictProperties=Properties("global.properties").getProperties()
# print dictProperties
#

file_path = r‘D:\backup\PycharmProjects\charm123\prop.properties‘
dictProperties=Properties(file_path).getProperties()
print (dictProperties)
print (type(dictProperties))
print (len(dictProperties))
print (dictProperties[‘url‘])
print (dictProperties[‘driver‘])
hang1=1
try:
    hang1=dictProperties[‘hang1‘]
except :
    hang1=0

print (hang1)

dict = {‘Name‘: ‘Runoob‘, ‘Age‘: 7, ‘Class‘: ‘First‘}

dict[‘Age‘] = 88  # 更新 Age
dict[‘School‘] = "添加信息"  # 添加信息

print("dict[‘Age‘]: ", dict[‘Age‘])
print("dict[‘School‘]: ", dict[‘School‘])

del dict[‘Name‘]  # 删除键 ‘Name‘
dict.clear()  # 清空字典
del dict  # 删除字典

print("dict[‘Age‘]: ", dict[‘Age‘])
print("dict[‘School‘]: ", dict[‘School‘])

xls5-解析properties文件，在python中基本没有遇到

标签：opened   rmi   erro   新建   new   cep   error   other   ase   

原文地址：https://www.cnblogs.com/xinxihua/p/12636650.html