Explication détaillée du menu de requête récursive Python et conversion en exemple de code json

Cet article présente principalement le menu de requête récursive python et le convertit en un exemple json. Il a une certaine valeur de référence. Les amis intéressés peuvent s'y référer.

Récemment, j'ai eu besoin d'écrire un menu en python, et il m'a fallu deux ou trois jours pour le faire. Maintenant, je l'enregistre ici, et les amis qui en ont besoin peuvent en tirer des leçons.

Remarque : L'article cite le code non exécutable complet et n'en extrait que les parties clés

Environnement

• Base de données : mysql

• python : 3.6

Structure des tables

CREATE TABLE `tb_menu` (
 `id` varchar(32) NOT NULL COMMENT '唯一标识',
 `menu_name` varchar(40) DEFAULT NULL COMMENT '菜单名称',
 `menu_url` varchar(100) DEFAULT NULL COMMENT '菜单链接',
 `type` varchar(1) DEFAULT NULL COMMENT '类型',
 `parent` varchar(32) DEFAULT NULL COMMENT '父级目录id',
 `del_flag` varchar(1) NOT NULL DEFAULT '0' COMMENT '删除标志 0：不删除 1：已删除',
 `create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
 `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
 PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='菜单表';

Code Python

Dans l'objet Menu, il y a une référence à la liste de sous-menu "subMenus", le type est liste

Code de base

def set_subMenus(id, menus):
  """
  根据传递过来的父菜单id，递归设置各层次父菜单的子菜单列表

  :param id: 父级id
  :param menus: 子菜单列表
  :return: 如果这个菜单没有子菜单，返回None;如果有子菜单，返回子菜单列表
  """
  # 记录子菜单列表
  subMenus = []
  # 遍历子菜单
  for m in menus:
    if m.parent == id:
      subMenus.append(m)

  # 把子菜单的子菜单再循环一遍
  for sub in subMenus:
    menus2 = queryByParent(sub.id)
    # 还有子菜单
    if len(menus):
      sub.subMenus = set_subMenus(sub.id, menus2)

  # 子菜单列表不为空
  if len(subMenus):
    return subMenus
  else: # 没有子菜单了
    return None

Méthode de test

  def test_set_subMenus(self):
    # 一级菜单
    rootMenus = queryByParent('')
    for menu in rootMenus:
      subMenus = queryByParent(menu.id)
      menu.subMenus = set_subMenus(menu.id, subMenus)

Remarque : Le processus de base est le suivant : interrogez d'abord le menu de premier niveau, puis transmettez l'identifiant du menu à ce niveau et la liste de sous-menus de ce menu de niveau à la méthode set_subMenus pour définir de manière récursive les menus de niveau inférieur de la liste de sous-menus. ;

prend en charge la transmission de l'identifiant des menus, interrogez tous les sous-menus de ce menu. Si vous passez un caractère nul, la requête démarre à partir du répertoire racine

Dans l'objet "rootMenus", vous pouvez voir l'arborescence complète du menu

convertir en Json

Le framework ORM que j'utilise est : sqlalchemy L'objet Menu interrogé directement depuis la base de données signalera une erreur lors de sa conversion en Json. Une classe DTO doit être redéfinie pour convertir l'objet Menu en objet Dto.

MenuDto

class MenuDto():
  def __init__(self, id, menu_name, menu_url, type, parent, subMenus):
    super().__init__()
    self.id = id
    self.menu_name = menu_name
    self.menu_url = menu_url
    self.type = type
    self.parent = parent
    self.subMenus = subMenus

  def __str__(self):
    return '%s(id=%s,menu_name=%s,menu_url=%s,type=%s,parent=%s)' % (
      self.__class__.__name__, self.id, self.menu_name, self.menu_url, self.type, self.parent)

  __repr = __str__

Ainsi, la méthode de définition récursive des sous-menus est redéfinie

def set_subMenuDtos(id, menuDtos):
  """
  根据传递过来的父菜单id，递归设置各层次父菜单的子菜单列表

  :param id: 父级id
  :param menuDtos: 子菜单列表
  :return: 如果这个菜单没有子菜单，返回None;如果有子菜单，返回子菜单列表
  """
  # 记录子菜单列表
  subMenuDtos = []
  # 遍历子菜单
  for m in menuDtos:
    m.name = to_pinyin(m.menu_name)
    if m.parent == id:
      subMenuDtos.append(m)

  # 把子菜单的子菜单再循环一遍
  for sub in subMenuDtos:
    menus2 = queryByParent(sub.id)
    menusDto2 = model_list_2_dto_list(menus2,
                     "MenuDto(id='', menu_name='', menu_url='', type='', parent='', subMenus='')")
    # 还有子菜单
    if len(menuDtos):
      if len(menusDto2):
        sub.subMenus = set_subMenuDtos(sub.id, menusDto2)
      else: # 没有子菜单，删除该节点
        sub.__delattr__('subMenus')

  # 子菜单列表不为空
  if len(subMenuDtos):
    return subMenuDtos
  else: # 没有子菜单了
    return None

Remarques :

1. Lorsqu'un menu n'a pas de sous-menu, supprimez l'attribut "subMenus", sinon une valeur nulle apparaîtra lors de la conversion en Json

2. La méthode model_list_2_dto_list peut convertir la liste Menu en liste MenuDto

3. to_pinyin est une méthode pour convertir les caractères chinois en pinyin, pas besoin d'y prêter attention ici

La couche d'affichage renvoie la méthode Json

  def get(self):
    param = request.args
    id = param['id']
    # 如果id为空，查询的是从根目录开始的各级菜单
    rootMenus = queryByParent(id)
    rootMenuDtos = model_list_2_dto_list(rootMenus,
                       "MenuDto(id='', menu_name='', menu_url='', type='', parent='', subMenus='')")
    # 设置各级子菜单
    for menu in rootMenuDtos:
      menu.name = to_pinyin(menu.menu_name)
      subMenus = queryByParent(menu.id)
      if len(subMenus):
        subMenuDtos = model_list_2_dto_list(subMenus,
                          "MenuDto(id='', menu_name='', menu_url='', type='', parent='', subMenus='')")
        menu.subMenus = set_subMenuDtos(menu.id, subMenuDtos)
      else:
        menu.__delattr__('subMenus')

    menus_json = json.dumps(rootMenuDtos, default=lambda o: o.__dict__, sort_keys=True, allow_nan=false,
                skipkeys=true)
    # 需要转字典，否则返回的字符串会带有“\”
    menus_dict = json_dict(menus_json)
    return fullResponse(menus_dict)
fullResponse

from flask import jsonify


def fullResponse(data='', msg='', code=0):
  if msg == '':
    return jsonify({'code': code, 'data': data})
  elif data == '':
    return jsonify({'code': code, 'msg': msg})
  else:
    return jsonify({'code': code, 'msg': msg, 'data': data})

Remarque : les significations de json et du dictionnaire en python sont similaires , à la fin Lorsque vous renvoyez json à la page, vous devez d'abord utiliser la méthode json_dict pour le convertir en type dict, sinon la chaîne renvoyée contiendra ""

résultats de la requête

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!