Python3中的动态字典递归

Question

我已经为此工作了很长时间，需要一些帮助。 我正在尝试使用fakerr创建字典。 如果只是那么简单。 最初，字典是平的。 钥匙和物品。 如果键的第一个字母为'B'或'M'，它将把该字符串转换为包含5个键的字典，并继续执行此操作，直到找不到以这两个字母中的任何一个开头的字母为止。 我知道，现在没有递归发生。 这就是为什么我需要帮助。 我试图找出如何正确递归而不是对深度进行硬编码。

Starting Dictionary:
{
     "Marcia": "https://www.skinner.biz/categories/tags/terms.htm",
     "Nicholas": "https://scott-tran.com/",
     "Christopher": "https://www.ellis.com/",
     "Paul": "https://lopez.com/index/",
     "Jennifer": "https://www.sosa.com/wp-content/main/login.php"
}

Marcia应该扩展到这个...

Example:
    "Marcia": {
        "Alexander": "http://hicks.net/home.html",
        "Barry": {
            "Jared": "https://www.parker-robinson.com/faq.html",
            "Eddie": "https://www.smith-thomas.com/",
            "Ryan": "https://www.phillips.org/homepage/",
            "Mary": {
               "Alex": "http://www.perry.com/tags/explore/post.htm",
               "Joseph": "https://www.hansen.com/main/list/list/index/",
               "Alicia": "https://www.tran.biz/wp-content/explore/posts/",
               "Anna": "http://lee-mclaughlin.biz/search/login/",
               "Kevin": "https://blake.net/main/index/"
            }
           "Evan": "http://carroll.com/homepage.html"
        }
        "Sharon": "https://www.watson.org/categories/app/login/",
        "Hayley": "https://www.parks.com/",
        "William": "https://www.wyatt-ware.com/"
    }

我的代码比动态代码更具手动性，因为我必须明确地知道现在字典中有很多层次，而不是动态地找出它。

这是我可以在2级深度下工作的东西，但是我想找到任何以'B'或'M'开头并对其进行操作的键。

import json
from build_a_dictionary import add_dic
from faker import Faker

dic = add_dic(10)
dic1 = {}
dic2 = {}

def build_dic(dic_len):
  dic1 = {}
  fake = Faker()
  if len(dic1) == 0:
    dic1 = add_dic(dic_len)
  print(json.dumps(dic1, indent=4))
  for k, v in dic1.items():
    dic2[k] = add_dic(dic_len)
    for key in dic2[k].keys():
      for f in key:
        if f == 'B' or f == 'M':
          dic2[k][key] = add_dic(dic_len)
  return dic2

这是我写的add_dic（）中的代码：

import string, time
from faker import Faker  #had to install with pip
fake = Faker()
dic = {}
dics = {}
key = ""
def add_dic(x):
  dic={}
  start = time.time()
  if x > 690:
    print("Please select a value under 690")
    sys.exit()
  for n in range(x):
    while len(dic) < x:
      key = fake.first_name()
      if key in dic.keys():
        break
      val = fake.uri()
      dic[key] = val
  end = time.time()
  runtime = end - start
  return dic

Answer 1

您只是在做错事情，如果您希望它是递归的，则将该函数编写为递归函数。 本质上，它是字典的自定义（递归）映射函数。 至于您期望的字典，我不确定您是如何让Faker每次确定性地给您同样的输出的。 这是随机的...

注意：对此没有任何“动态”，它只是一个递归映射函数。

from faker import Faker
import pprint

pp = pprint.PrettyPrinter(indent=4)
fake = Faker()

def map_val(key, val):
    if key[0] == 'M' or key[0] == 'B':
        names = [(fake.first_name(), fake.uri()) for i in range(5)]
        return {k : map_val(k, v) for k,v in names}
    else:
        return val

#uncomment below to generate 5 initial names
#names = [(fake.first_name(), fake.uri()) for i in range(5)]
#initial_dict = {k : v for k,v in names}

initial_dict = {
     "Marcia": "https://www.skinner.biz/categories/tags/terms.htm",
     "Nicholas": "https://scott-tran.com/",
     "Christopher": "https://www.ellis.com/",
     "Paul": "https://lopez.com/index/",
     "Jennifer": "https://www.sosa.com/wp-content/main/login.php"
}

dict_2 = {k : map_val(k,v) for k,v in initial_dict.items()}

pp.pprint(dict_2)

输出：

rpg711$ python nested_dicts.py 

{   'Christopher': 'https://www.ellis.com/',
    'Jennifer': 'https://www.sosa.com/wp-content/main/login.php',
    'Marcia': {   'Chelsea': 'http://francis.org/category.jsp',
                  'Heather': 'http://www.rodgers.com/privacy.jsp',
                  'Jaime': 'https://bates-molina.com/register/',
                  'John': 'http://www.doyle.com/author.htm',
                  'Kimberly': 'https://www.harris.org/homepage/'},
    'Nicholas': 'https://scott-tran.com/',
    'Paul': 'https://lopez.com/index/'
}

Answer 2

谢谢大家的帮助。 我设法弄清楚了。 现在，它可以根据需要构建动态字典或动态json。

import sys, json
from faker import Faker
fake = Faker()

def build_dic(dic_len, dic):
  if isinstance(dic, (list, tuple)):
    dic = dict(dic)
  if isinstance(dic, dict):
    for counter in range(len(dic)):
      for k,v in dic.items():
        if k[0] == 'B' or k[0] == "M":
          update = [(fake.first_name(), fake.uri()) for i in range(5)]
          update = dict(update)
          dic.update({k: update})
  return dic

def walk(dic):
  for key, item in dic.items():
      #print(type(item))
      if isinstance(item, dict):
        build_dic(5, item)
        walk(item)
  return dic

a = build_dic(10, ([(fake.first_name(), fake.uri()) for i in range(10)]))
walk(a)
print(json.dumps(a, indent=4))

Answer 3

递归是函数调用自身时； 设计递归函数时，牢记退出条件（即递归何时停止）很重要。

让我们考虑一个人为设计的示例，它增加一个数字直到达到某个值：

def increment_until_equal_to_or_greater_than_value(item, target):
    print 'item is', item,
    if item < target:
        print 'incrementing'
        item += 1
        increment_until_equal_to_or_greater_than_value(item, target)
    else:
        print 'returning'
        return item


increment_until_equal_to_or_greater_than_value(1, 10)

和输出

item is 1 incrementing
item is 2 incrementing
item is 3 incrementing
item is 4 incrementing
item is 5 incrementing
item is 6 incrementing
item is 7 incrementing
item is 8 incrementing
item is 9 incrementing
item is 10 returning

您可以看到我们已经在if语句中定义了递归部分，并在else定义了退出条件。

我整理了一个在嵌套数据结构上显示递归函数的代码段。

它不能完全解决您的问题，因此您可以通过剖析并使其适合您的用例来学习。

# our recursive method
def deep_do_something_if_string(source, something):
    # if source is a dict, iterate through it's values
    if isinstance(source, dict):
        for v in source.itervalues():
            # call this method on the value
            deep_do_something_if_string(v, something)

    # if source is a list, tuple or set, iterate through it's items
    elif isinstance(source, (list, tuple, set)):
        for v in source:
            deep_do_something_if_string(v, something)

    # otherwise do something with the value
    else:
        return something(source)


# a test something to do with the value
def print_it_out(value):
    print value


# an example data structure
some_dict = {
    'a': 'value a',
    'b': [
        {
            'c': 'value c',
            'd': 'value d',
        },
    ],
    'e': {
        'f': 'value f',
        'g': {
            'h': {
                'i': {
                    'j': 'value j'
                }
            }
        }
    }
}

deep_do_something_if_string(some_dict, print_it_out)

和输出

value a
value c
value d
value j
value f