目标:通过网上下载的OpenStreetMap.xml数据格式,将该文件的格式进行统计,清洗,并导出成CSV格式的文件,最后倒入到SQLite中

本案例中所需的包

  1. import csv
  2. import codecs
  3. import pprint
  4. import re
  5. import xml.etree.cElementTree as ET
  6. from collections import defaultdict
  7. import cerberus
  8. import schema

1.统计文件中每一个标签出现的次数

思路:将xml文件使用sax解析,将每一个节点的的标签值设为字典的key,次数为value,初始化为0,

　　 循环文件,如果可以找到key,那么value的值+1,否则不变

  1. def count_tags(filename):
        #1.读文件
  2.     osm = ET.ElementTree(file=filename)
        #2.获取根节点
  3.     root = osm.getroot()
        #3.获取根节点的标签,创建一个字典来存放标签名和次数
  4.     tags_count_dic = {root.tag:0}
        #4.循环文件
  5.     for _,ele in ET.iterparse(filename,events=('start',)):
            #5.如果有元素的tag在字典中,则value的值+1,否则表示该标签只出现一次
  6.         if ele.tag in tags_count_dic:
  7.             tags_count_dic[ele.tag] += 1
  8.         else:
  9.             tags_count_dic[ele.tag] = 1
  10.     return tags_count_dic
  1. def test():
  2.     #测试函数的断言不出错,表示结果正确
  3.     tags = count_tags('example.osm')
  4.     pprint.pprint(tags)
  5.     assert tags == {'bounds': 1,
  6.                      'member': 3,
  7.                      'nd': 4,
  8.                      'node': 20,
  9.                      'osm': 1,
  10.                      'relation': 1,
  11.                      'tag': 7,
  12.                      'way': 1}
  13.  
  14. if __name__ == "__main__":
  15.     test()

2.根据正则表达式,确定各种标签类型的数量

思路:获取根据传入的element,来获取tag,获取到tag即可获取到k的值,在根据正则表达式进行匹配,将匹配成功的值放入到不同的字典中

  1. lower = re.compile(r'^([a-z]|_)*$') #仅包含小写字母且有效的标记
  2. lower_colon = re.compile(r'^([a-z]|_)*:([a-z]|_)*$') #名称中有冒号的其他有效标记
  3. problemchars = re.compile(r'[=\+/&<>;\'"\?%#$@\,\. \t\r\n]') #字符存在问题的标记
  4.  
  5. def key_type(element,keys):
        #1.找到需要处理的标签进行处理
  6.     if element.tag == 'tag':
            #2.获取带匹配的字符串
  7.         key = element.attrib['k']
            #逐次匹配,并将匹配成功的结果放到keys中,并返回
  8.         if lower.search(key):
  9.             keys['lower'] += 1
  10.         elif lower_colon.search(key):
  11.             keys['lower_colon'] += 1
  12.         elif problemchars.search(key):
  13.             keys['problemchars'] += 1
  14.         else:
  15.             keys['other'] += 1
  16.     return keys
  17.  
  18. def process_map(filename):
  19.     keys = {"lower": 0, "lower_colon": 0, "problemchars": 0, "other": 0}
  20.     for _, element in ET.iterparse(filename):
  21.         keys = key_type(element, keys)
  22.  
  23.     return keys
  1. def test():
  2.     #测试函数的断言不报错,代码正确
  3.     keys = process_map('example.osm')
  4.     pprint.pprint(keys)
  5.     assert keys == {'lower': 5, 'lower_colon': 0, 'other': 1, 'problemchars': 1}
  6.  
  7. if __name__ == "__main__":
  8.     test()

3.搜索用户,返回一组唯一的用户ID

思路:找到uid所对应的tag,循环xml文件,如果标签存在uid,就加入到set中返回

  1. def get_user(element):
        #如果标签中包含'uid'这一属性,则返回该属性的值
  2.     if 'uid' in element.attrib:
  3.         return element.attrib['uid']
  4.  
  5. def process_map(filename):
  6.     users = set()
        #循环xml文件,如果每行的元素中有'uid'这一标签,则其值取出加入到set中,返回
  7.     for _, element in ET.iterparse(filename):
  8.         if get_user(element):
  9.             users.add(get_user(element))
  10.     return users
  1. def test():
  2.     #断言不出错,程序正确
  3.     users = process_map('example.osm')
  4.     pprint.pprint(users)
  5.     assert len(users) == 6
  6.  
  7. if __name__ == "__main__":
  8.     test()

4.完善街道名,将街道中的一些不合法的值去除

思路:循环街道的字典,名称在mapping,则进行替换,返回替换后的字符串

  1. OSMFILE = "example1.osm"
  2. street_type_re = re.compile(r'\b\S+\.?$', re.IGNORECASE)
  3.  
  4. expected = ["Street", "Avenue", "Boulevard", "Drive", "Court", "Place", "Square", "Lane", "Road",
  5.             "Trail", "Parkway", "Commons"]
  6.  
  7. # UPDATE THIS VARIABLE
    #题目这里的字符串需要更改,否则结果错误
  8. mapping = { "Rd.": "Road",
  9.             "St.": "Street",
  10.             "Ave": "Avenue"
  11.             }
  12.  
  13. def audit_street_type(street_types,street_name):
  14.     m = street_type_re.search(street_name)
  15.     if m:
  16.         street_type = m.group()
  17.         if street_type not in expected:
  18.             street_types[street_type].add(street_name)
  19.  
  20. def is_street_name(elem):
  21.     return (elem.attrib['k'] == 'addr:street')
  22.  
  23. def audit(osmfile):
  24.     osm_file = open(osmfile,'r')
  25.     street_types = defaultdict(set)
  26.     for event,ele in ET.iterparse(osmfile,events=('start',)):
  27.         if ele.tag == 'tag' or ele.tag == 'way':
  28.             for tag in ele.iter('tag'):
  29.                 if is_street_name(tag):
  30.                     audit_street_type(street_types,tag.attrib['v'])
  31.     osm_file.close()
  32.     return street_types
  33.  
  34. def update_name(name, mapping):
  35.     #获取需要修改的key
  36.     changewords = mapping.keys()
        #如果名称相同,则替换字符,并返回
  37.     for word in changewords:
  38.         if word in name:
  39.             name = name.replace(word,mapping.get(word))
  40.     return name
  1. def test():
        #断言不出错,则结果正确
  2.     st_types = audit(OSMFILE)
  3.     assert len(st_types) == 3
  4.     pprint.pprint(dict(st_types))
  5.     for st_type, ways in st_types.iteritems():
  6.         for name in ways:
  7.             better_name = update_name(name, mapping)
  8.             print name, "=>", better_name
  9.             if name == "West Lexington St.":
  10.                 assert better_name == "West Lexington Street"
  11.             if name == "Baldwin Rd.":
  12.                 assert better_name == "Baldwin Road"
  13.  
  14. if __name__ == "__main__":
  15.     test()

5.数据清洗

目标数据的结构

node节点需要[id,user,uid,version,lat,lon,timestamp,changeset]

node节点下的tags子节点需要[id,key,value,type]

  1. {'node': {'id': 757860928,
  2.           'user': 'uboot',
  3.           'uid': 26299,
  4.        'version': '',
  5.           'lat': 41.9747374,
  6.           'lon': -87.6920102,
  7.           'timestamp': '2010-07-22T16:16:51Z',
  8.       'changeset': 5288876},
  9.  'node_tags': [{'id': 757860928,
  10.                 'key': 'amenity',
  11.                 'value': 'fast_food',
  12.                 'type': 'regular'},
  13.                {'id': 757860928,
  14.                 'key': 'cuisine',
  15.                 'value': 'sausage',
  16.                 'type': 'regular'},
  17.                {'id': 757860928,
  18.                 'key': 'name',
  19.                 'value': "Shelly's Tasty Freeze",
  20.                 'type': 'regular'}]}

way节点需要[id,user,uid,version,timestamp,changeset]

way节点下的nodes子节点需要[id,node_id,position]

way节点下的tag子节点需要[id,key,value,type]

  1. {'way': {'id': 209809850,
  2.          'user': 'chicago-buildings',
  3.          'uid': 674454,
  4.          'version': '',
  5.          'timestamp': '2013-03-13T15:58:04Z',
  6.          'changeset': 15353317},
  7.  'way_nodes': [{'id': 209809850, 'node_id': 2199822281, 'position': 0},
  8.                {'id': 209809850, 'node_id': 2199822390, 'position': 1},
  9.                {'id': 209809850, 'node_id': 2199822392, 'position': 2},
  10.                {'id': 209809850, 'node_id': 2199822369, 'position': 3},
  11.                {'id': 209809850, 'node_id': 2199822370, 'position': 4},
  12.                {'id': 209809850, 'node_id': 2199822284, 'position': 5},
  13.                {'id': 209809850, 'node_id': 2199822281, 'position': 6}],
  14.  'way_tags': [{'id': 209809850,
  15.                'key': 'housenumber',
  16.                'type': 'addr',
  17.                'value': ''},
  18.               {'id': 209809850,
  19.                'key': 'street',
  20.                'type': 'addr',
  21.                'value': 'West Lexington St.'},
  22.               {'id': 209809850,
  23.                'key': 'street:name',
  24.                'type': 'addr',
  25.                'value': 'Lexington'},
  26.               {'id': '',
  27.                'key': 'street:prefix',
  28.                'type': 'addr',
  29.                'value': 'West'},
  30.               {'id': 209809850,
  31.                'key': 'street:type',
  32.                'type': 'addr',
  33.                'value': 'Street'},
  34.               {'id': 209809850,
  35.                'key': 'building',
  36.                'type': 'regular',
  37.                'value': 'yes'},
  38.               {'id': 209809850,
  39.                'key': 'levels',
  40.                'type': 'building',
  41.                'value': ''},
  42.               {'id': 209809850,
  43.                'key': 'building_id',
  44.                'type': 'chicago',
  45.                'value': ''}]}

思路: 1.使用iterparse便利xml中每一个顶层标签

2.使用自定义函数将每个元素变成多个数据结构

3.利用架构和验证库保证数据格式的正确

4.将每个数据结构写入相应的csv文件

  1. OSM_PATH = "example1.osm"
  2.  
  3. NODES_PATH = "nodes.csv"  #node标签生成的文件名
  4. NODE_TAGS_PATH = "nodes_tags.csv"  #node下的tag标签生成的文件名
  5. WAYS_PATH = "ways.csv"  #way标签生成的文件名
  6. WAY_NODES_PATH = "ways_nodes.csv" #way标签下的node生成的文件名
  7. WAY_TAGS_PATH = "ways_tags.csv" #way标签下的tag生成的文件名
  8.  
  9. LOWER_COLON = re.compile(r'^([a-z]|_)+:([a-z]|_)+') #字符串中有冒号和小写字母的标记
  10. PROBLEMCHARS = re.compile(r'[=\+/&<>;\'"\?%#$@\,\. \t\r\n]')#字符存在问题的标记
  11. SCHEMA = schema.schema #模板文件
  12.  
  13. # Make sure the fields order in the csvs matches the column order in the sql table schema
    #每一个生成的文件的表头
  14. NODE_FIELDS = ['id', 'lat', 'lon', 'user', 'uid', 'version', 'changeset', 'timestamp']
  15. NODE_TAGS_FIELDS = ['id', 'key', 'value', 'type']
  16. WAY_FIELDS = ['id', 'user', 'uid', 'version', 'changeset', 'timestamp']
  17. WAY_TAGS_FIELDS = ['id', 'key', 'value', 'type']
  18. WAY_NODES_FIELDS = ['id', 'node_id', 'position']
  19.  
  20. def shape_element(element, node_attr_fields=NODE_FIELDS, way_attr_fields=WAY_FIELDS,
  21.                   problem_chars=PROBLEMCHARS, default_tag_type='regular'):
  22.     """Clean and shape node or way XML element to Python dict"""
  23.  
  24.     node_attribs = {}  #存放生成node的key和value,key作表头,value作内容
  25.     way_attribs = {}  #存放生成way的key和value,key作表头,value作内容
  26.     way_nodes = []    #存放生成way标签下的nd子标签的值,[{...},{...}]
  27.     tags = []  #存放node和way下的tag子标签的值 ,[{...},{...},]# Handle secondary tags the same way for both node and way elements
  28.  
  29.     # YOUR CODE HERE
        #先提取node字段
  30.     if element.tag == 'node':
            #1.循环node_field表头,如果element中有key所对应的属性,则放入到node_attribs字典中
  31.         for key in NODE_FIELDS:
  32.             node_attribs[key] = element.attrib[key]
            #2.循环子节点,获取tags元素的值
  33.         for child in element:
  34.             Node_Tags = {} 
                #匹配字母和冒号
  35.             colon = re.match(LOWER_COLON,child.attrib['k'])
                #匹配异常字符
  36.             problem = re.match(PROBLEMCHARS,child.attrib['k'])
                #异常字符直接跳过,进行下一次查找
  37.             if problem:
  38.                 continue
                #如果tag是包含字母和冒号<tag k="addr:housenumber" v="1412"/>需要解析成{'id': 12345, 'key': 'housenumber', 'value': '1412', 'type': 'addr'}
  39.             elif colon:
                    #从父节点获取id属性的值
  40.                 Node_Tags['id'] = element.attrib['id']
                    #获取k="addr:housenumber"的值,以:拆分,第一个值为type的值
  41.                 type_value = child.attrib['k'].split(':',1)[0]
  42.                 Node_Tags['type'] = type_value
                    #获取k="addr:housenumber"的值,以:拆分,第二个值为key的值
  43.                 Node_Tags['key'] = child.attrib['k'].split(':',1)[1]
                    #获取v=1412的值,为value的值
  44.                 Node_Tags['value'] = child.attrib['v']
                    #将处理后的数据加入到字典中
  45.                 tags.append(Node_Tags)
                #tag不包含冒号<tag k="building" v="yes"/>
  46.             else:
                    #从父节点获取id属性的值
  47.                 Node_Tags['id'] = element.attrib['id']
                    #type的值是 regular
  48.                 Node_Tags['type'] = 'regular'
                    #获取k=building的值,为key的值
  49.                 Node_Tags['key'] = child.attrib['k']
                    #获取v=yes的值,为value的值
  50.                 Node_Tags['value'] = child.attrib['v']
                    #将处理后的数据加入到字典中
  51.                 tags.append(Node_Tags)
            #返回node处理之后的结果
  52.         return {'node': node_attribs, 'node_tags': tags}
        #在提取way字段
  53.     elif element.tag == 'way':
            1.循环way_field表头,如果element中有key所对应的属性,则放入到way_attribs字典中
  54.         for key in WAY_FIELDS:
  55.             way_attribs[key] = element.attrib[key]
  56.         counter = 0 #计数,用于填充way下面nd子标签的position的值
            #循环父节点下的子节点
  57.         for child in element:
  58.             Way_Nodes = {} #存放nd子标签
  59.             Way_Tags = {}  #存放tag子标签
                #处理nd子标签
  60.             if child.tag == 'nd':
                    #从父节点获取id属性的值
  61.                 Way_Nodes['id'] = element.attrib['id']
                    #从自身的ref,来获取该属性的值
  62.                 Way_Nodes['node_id'] = child.attrib['ref']
                    #获取position的值,每循环一次nd,counter + 1
  63.                 Way_Nodes['position'] = counter
  64.                 counter += 1
                    将处理后的nd子节点数据加入到字典中
  65.                 way_nodes.append(Way_Nodes)
                #处理tag子标签
  66.             elif child.tag == 'tag':
                    #同处理node下的tag子节点
  67.                 colon = re.match(LOWER_COLON,child.attrib['k'])
  68.                 problem = re.match(PROBLEMCHARS,child.attrib['k'])
  69.                 if problem:
  70.                     continue
  71.                 elif colon:
  72.                     Way_Tags['id'] = element.attrib['id']
  73.                     type_value = child.attrib['k'].split(':',1)[0]
  74.                     Way_Tags['key'] = child.attrib['k'].split(':',1)[1]
  75.                     Way_Tags['type'] = type_value
  76.                     Way_Tags['value'] = child.attrib['v']
  77.                     tags.append(Way_Tags)
  78.                 else:
  79.                     Way_Tags['id'] = element.attrib['id']
  80.                     Way_Tags['key'] = child.attrib['k']
  81.                     Way_Tags['type'] = 'regular'
  82.                     Way_Tags['value'] = child.attrib['v']
  83.                     tags.append(Way_Tags)
  84.         return {'way': way_attribs, 'way_nodes': way_nodes, 'way_tags': tags}
  85.  
  86. def get_element(osm_file, tags=('node', 'way', 'relation')):
  87.     """Yield element if it is the right type of tag"""
  88.     """如果是正确的类型时,返回标签中的tag"""
  89.     context = ET.iterparse(osm_file, events=('start', 'end'))
  90.     _, root = next(context)
  91.     for event, elem in context:
  92.         if event == 'end' and elem.tag in tags:
  93.             yield elem
  94.             root.clear()
  95.  
  96. def validate_element(element, validator, schema=SCHEMA):
  97.     """Raise ValidationError if element does not match schema"""
        """当和schema的数据格式不匹配时,抛出异常"""
  98.     if validator.validate(element, schema) is not True:
  99.         field, errors = next(validator.errors.iteritems())
  100.         message_string = "\nElement of type '{0}' has the following errors:\n{1}"
  101.         error_string = pprint.pformat(errors)
  102.  
  103.         raise Exception(message_string.format(field, error_string))
  104.  
  105. class UnicodeDictWriter(csv.DictWriter, object):
  106.     """Extend csv.DictWriter to handle Unicode input"""
  107.     """扩展csv下的DictWriter方法的去支持Unicode输入"""
  108.     def writerow(self, row):
  109.         super(UnicodeDictWriter, self).writerow({
  110.             k: (v.encode('utf-8') if isinstance(v, unicode) else v) for k, v in row.iteritems()
  111.         })
  112.  
  113.     def writerows(self, rows):
  114.         for row in rows:
  115.             self.writerow(row)
  116.  
  117. def process_map(file_in, validate):
  118.     """Iteratively process each XML element and write to csv(s)"""
  119.     """将处理好的xml文件写入到csv中"""
  120.     with codecs.open(NODES_PATH, 'w') as nodes_file, \
  121.          codecs.open(NODE_TAGS_PATH, 'w') as nodes_tags_file, \
  122.          codecs.open(WAYS_PATH, 'w') as ways_file, \
  123.          codecs.open(WAY_NODES_PATH, 'w') as way_nodes_file, \
  124.          codecs.open(WAY_TAGS_PATH, 'w') as way_tags_file:
  125.  
  126.         nodes_writer = UnicodeDictWriter(nodes_file, NODE_FIELDS)
  127.         node_tags_writer = UnicodeDictWriter(nodes_tags_file, NODE_TAGS_FIELDS)
  128.         ways_writer = UnicodeDictWriter(ways_file, WAY_FIELDS)
  129.         way_nodes_writer = UnicodeDictWriter(way_nodes_file, WAY_NODES_FIELDS)
  130.         way_tags_writer = UnicodeDictWriter(way_tags_file, WAY_TAGS_FIELDS)
  131.  
  132.         nodes_writer.writeheader()
  133.         node_tags_writer.writeheader()
  134.         ways_writer.writeheader()
  135.         way_nodes_writer.writeheader()
  136.         way_tags_writer.writeheader()
  137.  
  138.         validator = cerberus.Validator()
  139.  
  140.         for element in get_element(file_in, tags=('node', 'way')):
  141.             el = shape_element(element)
  142.             if el:
  143.                 if validate is True:
  144.                     validate_element(el, validator)
  145.  
  146.                 if element.tag == 'node':
  147.                     nodes_writer.writerow(el['node'])
  148.                     node_tags_writer.writerows(el['node_tags'])
  149.                 elif element.tag == 'way':
  150.                     ways_writer.writerow(el['way'])
  151.                     way_nodes_writer.writerows(el['way_nodes'])
  152.                     way_tags_writer.writerows(el['way_tags'])

第二种方法

高阶解法

  1. def shape_tag(el, tag): 
        #tag标签返回的格式(el是父节点标签指的是node标签,tag是子节点指的是tag标签)
  2.     tag = {
  3.         'id'   : el.attrib['id'],
  4.         'key'  : tag.attrib['k'],
  5.         'value': tag.attrib['v'],
  6.         'type' : 'regular'
  7.     }
  8.  
  9.     if LOWER_COLON.match(tag['key']):
            #如果tag的key中出现冒号<tag k="addr:housenumber" v="1412"/>,则根据:进行拆分,获取type和key
  10.         tag['type'], _, tag['key'] = tag['key'].partition(':')
  11.     return tag
  12.  
  13. def shape_way_node(el, i, nd):
        #way下的nd标签返回的格式(el是父节点标签指的是way标签,nd是子节点指的是nd标签)
  14.     return {
  15.         'id'       : el.attrib['id'],
  16.         'node_id'  : nd.attrib['ref'],
  17.         'position' : i
  18.     }
  19.  
  20. def shape_element(element, node_attr_fields=NODE_FIELDS, way_attr_fields=WAY_FIELDS,
  21.                   problem_chars=PROBLEMCHARS, default_tag_type='regular'):
  22.     """Clean and shape node or way XML element to Python dict"""
  23.  
  24.     node_attribs = {}
  25.     way_attribs = {}
  26.     way_nodes = []
        #直接获取所有的tag子标签
  27.     tags = [shape_tag(element, t) for t in element.iter('tag')]  # Handle secondary tags the same way for both node and way elements
  28.  
  29.     # YOUR CODE HERE
  30.     if element.tag == 'node':
  31.         node_attribs = {f: element.attrib[f] for f in node_attr_fields}
  32.         return {'node': node_attribs, 'node_tags': tags}
  33.     elif element.tag == 'way':
  34.         way_attribs = {f: element.attrib[f] for f in way_attr_fields}
  35.         #获取way标签下nd标签的各个值
  36.         way_nodes = [shape_way_node(element, i, nd)
  37.                      for i, nd
  38.                      in enumerate(element.iter('nd'))]
  39.         return {'way': way_attribs, 'way_nodes': way_nodes, 'way_tags': tags}

6.数据清洗(准备数据库 MonogoDB版本)

处理数据并将数据形状变成我们之前提到的模型。输出应该是字典列表，如下所示

  1. {
  2. "id": "",
  3. "type: "node",
  4. "visible":"true",
  5. "created": {
  6.           "version":"",
  7.           "changeset":"",
  8.           "timestamp":"2013-08-03T16:43:42Z",
  9.           "user":"linuxUser16",
  10.           "uid":""
  11.         },
  12. "pos": [41.9757030, -87.6921867],
  13. "address": {
  14.           "housenumber": "",
  15.           "postcode": "",
  16.           "street": "North Lincoln Ave"
  17.         },
  18. "amenity": "restaurant",
  19. "cuisine": "mexican",
  20. "name": "La Cabana De Don Luis",
  21. "phone": "1 (773)-271-5176"
  22. }

要求:

1.node下的tag子标签处理如下

  1. <tag k="addr:housenumber" v=""/>
  2. <tag k="addr:street" v="North Lincoln Avenue"/>
  3. <tag k="addr:street:name" v="Lincoln"/>
  4. <tag k="addr:street:prefix" v="North"/>
  5. <tag k="addr:street:type" v="Avenue"/>
  6. <tag k="amenity" v="pharmacy"/>
  7.  
  8. 应该改写为：
  9.  
  10. {...
  11. "address": {
  12.     "housenumber": 5158,
  13.     "street": "North Lincoln Avenue"
  14. }
  15. "amenity": "pharmacy",
  16. ...
  17. }

2.way标签下的子标签的处理应该改为

  1. <nd ref=""/>
  2. <nd ref=""/>
  3. 应该改为
  4. "node_refs": ["", ""]
  1. lower = re.compile(r'^([a-z]|_)*$')
  2. lower_colon = re.compile(r'^([a-z]|_)*:([a-z]|_)*$')
  3. problemchars = re.compile(r'[=\+/&<>;\'"\?%#$@\,\. \t\r\n]')
  4.  
  5. CREATED = [ "version", "changeset", "timestamp", "user", "uid"]
  6.  
  7. def shape_element(element):
  8.     node = {}
  9.     if element.tag == "node" or element.tag == "way" :
  10.         # YOUR CODE HERE
  11.  
  12.         #1.获取非父子节点的key和value
  13.         node = {tag.attrib['k']:tag.attrib['v']
  14.                for tag in element.iter('tag')
  15.                if not tag.attrib['k'].startswith('addr:')
  16.                and not problemchars.search(tag.attrib['k'])}
  17.         #2.获取address节点的key和value
            #例:<tag k="addr:street:name" v="Lincoln"/>
            #1)将addr:后面的字符作为key,v的值作为value
            #2)如果标签中的key值以addr:开头,且:的数量等于1
            #3)且没有特殊字符的存在
  18.         node['address'] = {tag.attrib['k'][5:]: tag.attrib['v']
  19.                            for tag in element.iter('tag')
  20.                            if tag.attrib['k'].startswith('addr:')
  21.                            and tag.attrib['k'].count(':') == 1
  22.                            and not problemchars.search(tag.attrib['k'])}
  23.         #3.获取element节点的属性
    　　　　 attr = element.attrib
  24.         node['id'] = attr['id'] #获取id
  25.         node['type'] = element.tag #获取类型type
  26.         node['visible'] = attr.get('visible') #获取visible
  27.  
  28. 　　　　 #4.获取created节点中的key和value
  29.         node['created'] = {c:attr[c] for c in CREATED}
            #5.如果标签的类型是way,则从该标签获取ref的值封装到node_refs中,否则直接从node中获取lat,lon的值填充到pos中
  30.         if element.tag == 'way':
  31.             node['node_refs'] = [nd.attrib['ref'] for nd in element.iter('nd')]
  32.         else:
  33.             node['pos'] = [float(attr['lat']),float(attr['lon'])]
  34.         return node
  35.     else:
  36.         return None
  37.  
  38. def process_map(file_in, pretty = False):
  39.     # You do not need to change this file
  40.     file_out = "{0}.json".format(file_in)
  41.     data = []
  42.     with codecs.open(file_out, "w") as fo:
  43.         for _, element in ET.iterparse(file_in):
  44.             el = shape_element(element)
  45.             if el:
  46.                 data.append(el)
  47.                 if pretty:
  48.                     fo.write(json.dumps(el, indent=2)+"\n")
  49.                 else:
  50.                     fo.write(json.dumps(el) + "\n")
  51.     return data
  1. def test():
  2.     #如果测试代码不出错,则结果正确
  3.     correct_first_elem = {
  4.         "id": "",
  5.         "visible": "true",
  6.         "type": "node",
  7.         "pos": [41.9730791, -87.6866303],
  8.         "created": {
  9.             "changeset": "",
  10.             "user": "bbmiller",
  11.             "version": "",
  12.             "uid": "",
  13.             "timestamp": "2012-03-28T18:31:23Z"
  14.         }
  15.     }
  16.     assert data[0] == correct_first_elem
  17.     assert data[-1]["address"] == {
  18.                                     "street": "West Lexington St.",
  19.                                     "housenumber": ""
  20.                                       }
  21.     assert data[-1]["node_refs"] == [ "", "",  "", "",
  22.                                     "", "", ""]
  23.  
  24. if __name__ == "__main__":
  25.     test()

OpenStreetMap数据清洗(SQL&MonogoDB版本)的更多相关文章

  1. 使用的 SQL Server 版本不支持数据类型“datetime2”.

    错误原因,在使用ado.net entity的时候,entity使用的数据库是sqlserver 2008, 但后来实际使用中使用的数据库是sqlserver 2005, 使用的 SQL Server ...

  2. sql server版本、组件和管理工具

    以下信息由何问起收集,希望有帮助. SQL Server 版本 定义 Enterprise 作为高级版本, SQL Server Enterprise 版提供了全面的高端数据中心功能,性能极为快捷.虚 ...

  3. SQL SERVER版本补丁体系及升级

    首先了解几个定义: RTM : 表示 Release to Manufacturing ,这是产品的原始发布版本,当从光盘或 MSDN 下载的默认版本.不过现在下载 SQL Server 版本时,也有 ...

  4. ef SQL Server 版本不支持数据类型“datetime2”

    我遇到这个问题是在用数据库模型的时候.当时我电脑上是sql2008 通过vs2010建立了一个ADO.net数据库模型,之后在项目上线的时候,临时把数据库换成了sql2005,在添加新闻的时候出现了“ ...

  5. PIVOT 和 UNPIVOT 命令的SQL Server版本

    I:使用 PIVOT 和 UNPIVOT 命令的SQL Server版本要求 1.数据库的最低版本要求为 SQL Server 2005 或 更高 2.必须将数据库的兼容级别设置为 90 或 更高 3 ...

  6. C#检验IIS版本、SQL Server版本、SilverLight版本

    之前做一个小项目,使用C#检验这些软件的版本,到处找了一些代码,也能作用,记录一下,以防以后用到. 一.检验IIS版本 public static bool checkIIS(string destV ...

  7. sql server2005版本中，len函数计算了字符串末尾的空格

    sql server2005版本中,len函数计算了字符串末尾的空格的长度,以下是测试脚本: print @@version declare @v varchar(max) set @v = 'hp, ...

  8. PCB MS SQL SERVER版本管控工具source_safe_for_sql_server

    PCB由于业务关系复杂,业务触发一个事件时,可能需与数据库多个表进行关连处理才能拿到数据结果, 而表关连并不是简单的关连,实际是要进行大量数据筛选,逻辑判断,转换等过程...这个过程是复杂的 想一想, ...

  9. [转帖]sql server版本特性简介、版本介绍简介

    sql server版本特性简介.版本介绍简介 https://www.cnblogs.com/gered/p/10986240.html 目录 1.1.sql server的版本信息 1.2.版本重 ...

随机推荐

  1. orm查询

    all:models.表名.objects.all() 结果是queryset集合 filter: models.表名.objects.filter() 结果是queryset集合 get: mode ...

  2. python os 模块

    os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径os.chdir("dirname") 改变当前脚本工作目录:相当于shell下cdos.curdir ...

  3. cin与cout详解

    输入和输出并不是C++语言中的正式组成成分｡C和C++本身都没有为输入和输出提供专门的语句结构｡输入输出不是由C++本身定义的,而是在编译系统提供的I/O库中定义的｡C++的输出和输入是用" ...

  4. Kubernetes存储之Persistent Volumes简介

    简介 管理存储和管理计算有着明显的不同.PersistentVolume子系统给用户和管理员提供了一套API,从而抽象出存储是如何提供和消耗的细节.在这里,我们介绍两种新的API资源:Persiste ...

  5. Linux 用户组及用户管理

    查看所有组的信息:(信息保存在/etc/group文件中) 其中每段信息用:分割 ,每段的含义如下: 用户名组名:密码:用户组的id:用户组所包含的用户(多个用户用,分割) 查看所有的用户信息:(信息 ...

  6. [国嵌攻略][091][TCP网络程序设计]

    server.c #include <sys/socket.h> #include <netinet/in.h> #include <strings.h> #inc ...

  7. SQL语句整理1

    THEN '月卡' THEN '周卡' THEN '季度卡' THEN '年卡' ELSE '未知卡类型' END AS '卡类型' FROM SL_Register_Info Left join用法 ...

  8. TP传输的两种模式

      主动模式(active):   我们知道,FTP是由TCP封包的模式连接,TCP 这种封包由于需要经过 Server 端与 Client 端两边的『三次握手』之后,才能确定联机,也就是需要执行AC ...

  9. linux下卸载apache方法小结

    方法一 代码如下: 1. root@server ~]# rpm -qa|grep httpd  httpd-2.2.3-11.el5_2.centos.4  httpd-manual-2.2.3-1 ...

  10. 虚拟主机导入MySQL出现Unknown character set: ‘utf8mb4’

    http://www.lmlblog.com/14.html 前几天进行网站搬家,MySQL导入数据的时候,出现以下错误(没有定义的编码集utf8mb4): SQL 查询: ; MySQL 返回:文档 ...