字典转换工具

最新推荐文章于 2022-09-06 17:22:30 发布
最新推荐文章于 2022-09-06 17:22:30 发布
阅读量340 收藏
点赞数
文章标签： java maven hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/k_k_0_0/article/details/122220324
版权

记录一下字典转换的使用，对于状态或者类型必不可少的要使用字典

Mapper

@Slf4j
public class BaseMapper {

    public static String dictItemIsExists(String dictConstants, String code) {
        log.info("dictConstants: {}, code: {}", dictConstants, code);
        String value = DictHelper.getDicItemNameByDicTypeCodeAndDicItemCode(dictConstants, code);
        if (value == null) {
            throw new AsolSearchException(Message.getMessage("dictItem.not.found", new Object[]{dictConstants + " --- " + code}));
        }
        return value;
    }

}

DicHelper

@Component
public class DictHelper {
    private final Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private DictItemService dictItemService;
    @Autowired
    private DictCacheConfig dictCacheConfig;

    @Autowired
    private DictTypeService dictTypeService;

    private static DictHelper dictHelper;
    private static Long effperiod;

    @PostConstruct
    public void init() {
        logger.info("------------初始化字典数据工具类-------------------");
        dictHelper = this;
        dictHelper.dictItemService = this.dictItemService;
        dictHelper.dictCacheConfig = this.dictCacheConfig;

        /**
         * 取得设定的时效
         */
        effperiod = new Long(dictHelper.dictCacheConfig.getEffperiod() == null ? "0" : dictHelper.dictCacheConfig.getEffperiod());
    }

    /**
     * 保存时效起始时间
     */
    private static Map<String, Long> periods = new HashMap<>();

    /**
     * 缓存代码
     */
    private static Map<String, Map<String, DictItemDto>> parameters = new HashMap<>();


    /**
     * List转换为Map
     *
     * @param dictItemList
     * @return
     */
    private static Map<String, DictItemDto> dictListToMap(List<DictItemDto> dictItemList) {
        if (dictItemList == null || dictItemList.size() <= 0)
            return null;
        Map<String, DictItemDto> dicItemMap = new HashMap<>();
        for (DictItemDto dicItem : dictItemList) {
            dicItemMap.put(dicItem.getDictItemCode(), dicItem);
        }
        return dicItemMap;
    }

    /**
     * Map转换为List
     *
     * @param dictItemMap
     * @return
     */
    private static List<DictItemDto> dictMapToList(Map<String, DictItemDto> dictItemMap) {
        if (dictItemMap == null || dictItemMap.size() <= 0)
            return null;
        List<DictItemDto> list = new LinkedList<>();
        list.addAll(dictItemMap.values());
        return list;
    }

    /**
     * 从数据库 加载/重新加载 字典到缓存（重新加载缓存）
     *
     * @param dictTypeCode 字典类型编码
     */
    private static void setEffective(String dictTypeCode) {
        List<DictItemDto> dictItems = dictHelper.dictItemService.findDictItemListByTypeId(dictTypeCode);
        if (dictItems != null) {
            parameters.put(dictTypeCode, dictListToMap(dictItems));
            periods.put(dictTypeCode, Long.valueOf((System.currentTimeMillis())));
        }
    }

    /**
     *  与劳务系统对接的特殊情况
     *  需要Value获取Code
     * @param dictTypeCode
     * @param dictItemName
     * @return
     */
    public static String getDicItemCodeByDicTypeCodeAndDicItemName(String dictTypeCode, String dictItemName) {

        loadDic(dictTypeCode);
        Map<String, DictItemDto> mapList = parameters.get(dictTypeCode);
        for(Map.Entry<String, DictItemDto> entry : mapList.entrySet()){
            String mapKey = entry.getKey();
            DictItemDto mapValue = entry.getValue();
            if (mapValue.getDictItemName().equalsIgnoreCase(dictItemName)) {
                return mapKey;
            }

        }
        return null;
    }



    /**
     * 判断时效性
     *
     * @param dictTypeCode 字典类型编码
     * @return
     */
    private static boolean isEffective(String dictTypeCode) {
        if (!periods.containsKey(dictTypeCode))
            return false;
        if (effperiod == 0)
            return true;
        return System.currentTimeMillis() - (periods.get(dictTypeCode)).longValue() < effperiod;
    }

    /**
     * 加载指定代码到缓存
     *
     * @param dictTypeCode 字典类型编码
     */
    private static void loadDic(String dictTypeCode) {
        List<DictItemDto> dicItems = dictHelper.dictItemService.findDictItemListByTypeId(dictTypeCode);
        if (dicItems != null) {
            parameters.put(dictTypeCode, dictListToMap(dicItems));
        }
    }

    /**
     * 过滤掉失效的的字典项
     *
     * @param items
     * @return
     */
    public static List<DictItemDto> filterDisabled(List<DictItemDto> items) {
        if (items == null || items.size() <= 0)
            return null;
        List<DictItemDto> dis = new LinkedList<>();
        for (DictItemDto di : items) {
            if (di.getIsActive()) {
                dis.add(di);
            }
        }
        return dis;
    }

    /**
     * 通过字典类型编码获取字典项列表（已缓存）
     *
     * @param dictTypeCode   字典类型编码
     * @param filterDisabled 是否包含失效的
     * @return
     */
    public static List<DictItemDto> listAllDictItemDTOByDictTypeCode(String dictTypeCode, boolean filterDisabled) {

        List<DictItemDto> items = null;
        if (!isEffective(dictTypeCode)) {
            setEffective(dictTypeCode);
        }
        if (parameters.containsKey(dictTypeCode)) {
            items = dictMapToList(parameters.get(dictTypeCode));
        }
        Collections.sort(items, new SortCollections());
        return filterDisabled ? items : filterDisabled(items);
    }

    /**
     * 通过字典类型编码获取所有有效的字典项列表（已缓存、已过滤）
     *
     * @param dicTypeCode 字典类型编码
     * @return
     */
    public static List<DictItemDto> listEffectiveDicItemDTOByDicTypeCode(String dicTypeCode) {
        List<DictItemDto> list = listAllDictItemDTOByDictTypeCode(dicTypeCode, false);
        Collections.sort(list, new SortCollections());
        return list;
    }

    /**
     * 通过字典类型编码获取字典类型名称
     */
    public static String getDicTypeNameByDicTypeCode(String dictTypeCode){
        if (dictTypeCode.trim().length() == 0 || "null".equalsIgnoreCase(dictTypeCode)) {
            return null;
        }
        if (!isEffective(dictTypeCode)) {
            setEffective(dictTypeCode);
        }
        return dictHelper.dictTypeService.findDictTypeNameByTypecode(dictTypeCode);

    }


    /**
     * 通过字典类型编码和字典项编码获取字典项名称（已缓存）
     *
     * @param dictTypeCode 字典类型编码
     * @param dictItemCode 字典项编码
     * @return
     */
    public static String getDicItemNameByDicTypeCodeAndDicItemCode(String dictTypeCode, String dictItemCode) {
        if (dictItemCode.trim().length() == 0 || "null".equalsIgnoreCase(dictItemCode)) {
            return null;
        }
        if (!isEffective(dictTypeCode)) {
            setEffective(dictTypeCode);
        }
        if (!parameters.containsKey(dictTypeCode)) {
            loadDic(dictTypeCode);
        }
        Map<String, DictItemDto> mapList = parameters.get(dictTypeCode);
        if (mapList != null && mapList.containsKey(dictItemCode)) {
            return mapList.get(dictItemCode).getDictItemName();
        }
        return null;
    }

    /**
     * 通过字典类型和父级字典项编码获取子级字典项列表（已缓存、已过滤）
     *
     * @param dictTypeCode       字典类型编码
     * @param parentDictItemCode 父级字典项编码
     * @param filterDisabled     是否包含失效的
     * @return
     * @throws DataAccessException
     */
    public static List<DictItemDto> listDicItemDTOByDicTypeCodeAndParentDicItemCode(String dictTypeCode,
                                                                                    String parentDictItemCode, boolean filterDisabled) {
        if (dictTypeCode.trim().length() == 0 || "null".equalsIgnoreCase(dictTypeCode)) {
            return null;
        }
        if (!isEffective(dictTypeCode)) {
            setEffective(dictTypeCode);
        }
        if (!parameters.containsKey(dictTypeCode)) {
            loadDic(dictTypeCode);
        }
        Map<String, DictItemDto> mapList = parameters.get(dictTypeCode);
        List<DictItemDto> childrenItems = new LinkedList<>();
        if (mapList != null) {
            for (DictItemDto dto : mapList.values()) {
                if (parentDictItemCode.trim().length() == 0) {
                    if (dto.getParentDictItemCode().trim().length() == 0) {
                        childrenItems.add(dto);
                    }
                } else {
                    if (dto.getParentDictItemCode().trim().length() != 0 && parentDictItemCode.equals(dto.getParentDictItemCode())) {
                        childrenItems.add(dto);
                    }
                }
            }
        }
        Collections.sort(childrenItems, new SortCollections());
        return childrenItems.size() == 0 ? null : (filterDisabled ? childrenItems : filterDisabled(childrenItems));
    }

    /**
     * 字典项排序规则定义类
     *
     * @author wangx
     */
    static class SortCollections implements Comparator<DictItemDto> {
        @Override
        public int compare(DictItemDto dto1, DictItemDto dto2) {
            if (dto1.getSort() == null && dto2.getSort() == null) {
                return dto1.getDictItemCode().compareTo(dto2.getDictItemCode());
            } else if (dto1.getSort() == null) {
                return -1;
            } else if (dto2.getSort() == null) {
                return 1;
            } else {
                return dto1.getSort().compareTo(dto2.getSort());
            }
        }
    }

    public static String getDictItemCodeByDictTypeCodeAndDictItemName(String dictTypeCode, String dictItemName) {
        if (dictItemName.trim().length() == 0 || "null".equalsIgnoreCase(dictItemName)) {
            return null;
        }
        if (!isEffective(dictTypeCode)) {
            setEffective(dictTypeCode);
        }
        if (!parameters.containsKey(dictTypeCode)) {
            loadDic(dictTypeCode);
        }
        Map<String, DictItemDto> mapList = parameters.get(dictTypeCode);
        if (mapList != null) {
            for (String key : mapList.keySet()) {
                if (dictItemName.equals(mapList.get(key).getDictItemName())) return key;
            }
        }
        return null;
    }

    /**
     * 取得代码表示的中文释义（已缓存、已过滤）
     *
     * @param dictTypeCode 代码类型
     * @param dictItemCode 要翻译的代码值
     * @return
     */
    public static String viewName(String dictTypeCode, String dictItemCode) {
        if (StringUtils.isEmpty(dictItemCode) || "null".equalsIgnoreCase(dictItemCode)) {
            return null;
        }
        if (!isEffect(dictTypeCode)) {
            setEffect(dictTypeCode, true);
        }
        if (!parameters.containsKey(dictTypeCode)) {
            loadDic(dictTypeCode, true);
        }
        if (parameters.containsKey(dictTypeCode)) {
            Map<String, DictItemDto> mapList = parameters.get(dictTypeCode);
            if (mapList != null && mapList.containsKey(dictItemCode)) {
                return mapList.get(dictItemCode).getDictItemName();
            }
        }
        return null;
    }

    /**
     * 判断时效性
     *
     * @return
     */
    private static boolean isEffect(String dictTypeCode) {
        if (!periods.containsKey(dictTypeCode))
            return false;
        if (effperiod == 0)
            return true;
        return System.currentTimeMillis() - (periods.get(dictTypeCode)).longValue() < effperiod;
    }

    /**
     * 从数据库 加载/重新加载 字典到缓存（重新加载缓存）
     *
     * @param isInDelete true：加载所有的字典，false：过滤掉已删除的字典
     */
    private static void setEffect(String dictTypeCode, boolean isInDelete) {
        List<DictItemDto> dicItems = listDicItemFromDb(dictTypeCode, isInDelete);
        if (dicItems != null) {
            parameters.put(dictTypeCode, dictListToMap(dicItems));
            periods.put(dictTypeCode, Long.valueOf((System.currentTimeMillis())));
        }
    }

    /**
     * 查找所有下级字典代码，从数据库查找最新代码（已排序、未缓存）
     *
     * @param dicTypeCode
     * @param isInDelete  true：加载所有的字典，false：过滤掉已删除的字典
     * @return
     */
    public static List<DictItemDto> listDicItemFromDb(String dicTypeCode, boolean isInDelete) {
        return dictHelper.dictItemService.findDictItemListByTypeId(dicTypeCode, isInDelete);
    }

    /**
     * 加载指定代码到缓存（已排序、未缓存、已过滤）
     *
     * @param dictTypeCode
     * @param isInDelete   true：加载所有的字典，false：过滤掉已删除的字典
     */
    private static void loadDic(String dictTypeCode, boolean isInDelete) {
        List<DictItemDto> dicItems = listDicItemFromDb(dictTypeCode, isInDelete);
        if (dicItems != null) {
            parameters.put(dictTypeCode, dictListToMap(dicItems));
        }
    }
}

DicItemService 

public interface DictItemService {


    /**
     * 通过字典类型编码获取字典项列表
     *
     * @param dictTypeCode
     * @return
     */
    List<DictItemDto> findDictItemListByTypeId(String dictTypeCode);

    List<DictItemDto> findDictItemListByTypeId(String dictTypeCode, boolean isInDelete);


    /**
     * 获取数据字典项列表
     *
     * @param dictTypeId
     * @param dictItemCode
     * @param dictItemName
     * @param page
     * @param size
     * @return
     */
    List<DictItemDto> findDicItemListByCondition(Long dictTypeId, String dictItemCode, String dictItemName, int page, int size);

    /**
     * 获取数据字典项列表
     *
     * @param dictTypeId
     * @param dictItemCode
     * @param dictItemName
     * @param page
     * @param size
     * @return
     */
    Page<DictItemDto> pageFindDicItemListByCondition(Long dictTypeId, String dictItemCode, String dictItemName, int page, int size);

    /**
     * 新增字典项信息
     *
     * @param dictItemDto
     * @return
     */
    DictItemDto create(DictItemDto dictItemDto);

    /**
     * 删除字典项信息,需要删除的字典项id，如果删除多个使用,号分割
     *
     * @param ids
     */
    void delete(List<Long> ids);

    /**
     * 修改字典项信息
     *
     * @param dictItemDto
     * @return
     */
    DictItemDto update(DictItemDto dictItemDto);

    /**
     * 获取字典项信息
     *
     * @param dictItemId
     * @return
     */
    DictItemDto get(Long dictItemId);
}

DicItemServiceImpl

@Service
public class DictItemServiceImpl implements DictItemService {
    private final Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    DictItemRepository dictItemRepository;



    @Override
    @Transactional
    public List<DictItemDto> findDictItemListByTypeId(String dictTypeCode) {
        List<DictItem> dictItemDtoList = dictItemRepository.listDictItemByDictTypeCodeAndIsActive(dictTypeCode.trim(), true);
        if (dictItemDtoList.isEmpty()) {
            throw new AsolResourceNotFoundException(Message.getMessage("dictItem.not.found", new Object[]{dictTypeCode}));
        }
        return BeanHelper.copyProperties(dictItemDtoList, DictItemDto.class);
    }

    @Override
    @Transactional
    public List<DictItemDto> findDictItemListByTypeId(String dictTypeCode, boolean isInDelete) {
        List<DictItem> dictItemDtoList = dictItemRepository.listDictItemByDictTypeCodeAndIsActive(dictTypeCode.trim(), isInDelete);
        if (dictItemDtoList.isEmpty()) {
            throw new AsolResourceNotFoundException(Message.getMessage("dictItem.not.found", new Object[]{dictTypeCode}));
        }
        return BeanHelper.copyProperties(dictItemDtoList, DictItemDto.class);
    }

    @Override
    @Transactional
    public List<DictItemDto> findDicItemListByCondition(Long dictTypeId, String dictItemCode, String dictItemName, int page, int size) {
        final StringBuffer hql = new StringBuffer();
        final Map<String, Object> hqlParams = new HashMap<String, Object>();

        hql.append("from DictItem di where 1=1 ");
//        StringMap params=ttb.getCondition();
        if (dictTypeId != null) {
            hql.append(" and di.dictTypeId = :dictTypeId");
            hqlParams.put("dictTypeId", dictTypeId);
        }
        if (dictItemName != null) {
            hql.append(" and di.dictItemName like :dictItemName");
            hqlParams.put("dictItemName", "%" + dictItemName.trim() + "%");
        }
        if (dictItemCode != null) {
            hql.append(" and di.dictItemCode = :dictItemCode");
            hqlParams.put("dictItemCode", dictItemCode.trim());
        }

//        if (size != 0) {
//            ttb.setTotal(DaoUtil.countHQLQueryByCondition(
//                    new StringBuilder().append("select count(*) ").append(hql)
//                            .toString(), hqlParams));
//        }
//        if (ttb.getTotal() == 0) {
//            return null;
//        }
        hql.append(" order by di.sort");
        return BeanHelper.copyProperties(DaoUtil.listHQLQueryByCondition(
                String.valueOf(hql), hqlParams,
                page, size), DictItemDto.class);
    }

    @Override
    @Transactional
    public Page<DictItemDto> pageFindDicItemListByCondition(Long dictTypeId, String dictItemCode, String dictItemName, int page, int size) {
        Pageable pageable = PageRequest.of(page - 1, size);
        Specification<DictItem> searchSpec = new AsolSpecification<DictItem>();
        if (dictTypeId != null) {
            AsolSpecification<DictItem> spec = new AsolSpecification<DictItem>();
            spec.add(new SearchCriteria("dictTypeCode", dictTypeId, SearchOperation.EQUAL));
            searchSpec = searchSpec.and(spec);
        }
        if (dictItemCode != null && !dictItemCode.isEmpty()) {
            AsolSpecification<DictItem> spec = new AsolSpecification<DictItem>();
            spec.add(new SearchCriteria("dictItemCode", dictItemCode.trim(), SearchOperation.EQUAL));
            searchSpec = searchSpec.and(spec);
        }
        if (dictItemName != null && !dictItemName.isEmpty()) {
            AsolSpecification<DictItem> spec = new AsolSpecification<DictItem>();
            spec.add(new SearchCriteria("dictItemName", dictItemName.trim(), SearchOperation.MATCH));
            searchSpec = searchSpec.and(spec);
        }
        Page<DictItem> result = dictItemRepository.findAll(searchSpec, pageable);
        return result.map(dictItem -> BeanHelper.copyProperties(dictItem, DictItemDto.class));
    }

    @Override
    @Transactional
    public DictItemDto create(DictItemDto dictItemDto) {
        if (dictItemDto != null) {
            DictItem di = dictItemRepository.findByDictItemCodeAndDictTypeId(dictItemDto.getDictItemCode(), dictItemDto.getDictTypeId());
            if (di != null) {
                throw new AsolResourceFoundException(Message.getMessage("dictItem.found", new Object[]{dictItemDto.getDictTypeId(), dictItemDto.getDictItemCode()}));
            }
            DictItem dictItem = BeanHelper.copyProperties(dictItemDto, DictItem.class);
            return BeanHelper.copyProperties(dictItemRepository.save(dictItem), DictItemDto.class);
        }
        return null;
    }

    @Override
    @Transactional
    public void delete(List<Long> ids) {
        if (ids != null) {
            // 批量删除字典项
            dictItemRepository.deleteByIdIn(ids);
        }
    }

    @Override
    @Transactional
    public DictItemDto update(DictItemDto dictItemDto) {
        if (dictItemDto != null) {
            DictItem di = dictItemRepository.findByDictItemCodeAndDictTypeId(dictItemDto.getDictItemCode(), dictItemDto.getDictTypeId());
            if (di != null && di.getId().longValue() != dictItemDto.getId().longValue()) {
                throw new AsolResourceFoundException(Message.getMessage("dictItem.found", new Object[]{dictItemDto.getDictTypeId(), dictItemDto.getDictItemCode()}));
            }
            DictItem dictItem = BeanHelper.copyProperties(dictItemDto, DictItem.class);
            return BeanHelper.copyProperties(dictItemRepository.save(dictItem), DictItemDto.class);
        }
        return null;
    }

    @Override
    @Transactional
    public DictItemDto get(Long dictItemId) {
        if (dictItemId != null) {
            Optional<DictItem> optionalDictItem = dictItemRepository.findAllById(dictItemId);
            if (optionalDictItem.isPresent()) {
                return BeanHelper.copyProperties(optionalDictItem.get(), DictItemDto.class);
            }
        }
        return null;
    }
}

DicItemServiceRepository

@Repository
public interface DictItemRepository extends JpaRepository<DictItem, Long>, AsolJpaRepository<DictItem>, JpaSpecificationExecutor<DictItem> {
    void deleteByDictTypeId(Long dicTypeId);

    @Query(value = "select di.* from it_sys_dict_item di,it_sys_dict_type dt where di.dict_type_id=dt.id and dt.dict_type_code=?1 and di.is_active=?2 order by di.sort", nativeQuery = true)
    List<DictItem> listDictItemByDictTypeCodeAndIsActive(String dictTypeCode, boolean isActive);

    DictItem findByDictItemCodeAndDictTypeId(String itemCode, Long itemTypeId);

    void deleteByIdIn(List<Long> ids);

}

有了这些以后只需要将DicTypeCode保存为静态常量就可以了，使用时只需要带着DicTypeCode去调用字典就可以帮我们转换了。

k_k_0_0
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
vue中前端数据字典格式化的简单实现
玉之之的博客
06-29 1126
如图，目前需要将code转化为汉字 再对应所需要更改的表头上加上 :formatter="forstatus" 其中forstatus为自定义替换的方法 //过滤流转状态 forStatus(row,column,cellValue,index){ // if(cellValue === '1'){ // return "流转中" // } else if(cellValue === '2'){
Java后端数据字典转换
weixin_50723472的博客
12-11 2199
Java后端数据字典转换（非注解处理）
Python 将字典(dict)转换为DataFrame
pumpkin96的博客
09-06 2万+
我们将使用 from_dict 将 dict 转换为 dataframe，在这里我们将 orient = index 设置为使用字典键作为行并使用 rename() 方法来更改列名。Pandas 的 DataFrame 构造函数pd.DataFrame()如果将字典的 items 作为构造函数的参数而不是字典本身，则将字典转换为 dataframe。我们将使用 pandas 的字典推导和 concat 来合并所有的字典，然后传递列表以使用新的列名。1.将字典转换为 Pandas DataFame 的方法。
开心字典转换工具 V2.41
11-03
“开心字典转换工具 V2.41”现在支持的字典格式: Resource Modifier 字典 ( *.dat ) 中文工具箱字典 ( *.dat ) SeaToos字典 (汉化集成工具) ( *.txt ) VISUAL LOCALIZE 导出文本 ( *.txt ) LANGUAGE ...
mac-dictionary-kit, Mac OS X 10.5和上版本的字典转换工具.zip
09-18
mac-dictionary-kit, Mac OS X 10.5和上版本的字典转换工具 Mac字典工具包，a.k.a，DictUnifierMac OS X 10.5和上版本的字典转换工具。下载从发布版下载它，v2.1.生成指令在构建之前安装 static 构建：brew install ...
kettle实现字典转换实例
10-20
利用kettle工具进行原始字典和标准字典的映射，将原始数据进行标准化处理。
汉化字典转换工具，常用的软件
05-18
汉化字典转换工具，常用的软件。PASSOLO，sisulizer还有其他的软件间字典转换。
字典库和转换工具
移动编程
09-10 154
http://abloz.com/huzheng/stardict-dic/zh_CN/ http://code.google.com/p/mac-dictionary-kit/downloads/detail?name=DictUnifier-2.1.zip&amp;can=2&amp;q=
将字符串格式的字典转换为字典格式
qq_40661240的博客
06-12 1634
例如：将字符串格式的字典转换为字典格式，我的字符串如下： 例如：将字符串转换为字典,按照网上的ast.literal_eval和json.loads，eval的处理方法都失败了 json.loads方法报错： ast.literal_eval方法报错（eval方法同，未尝试）： 例如：网上搜了好多的原因，都无法解决，有一个方法写的是通过正则将字符串里面的不符合JSON格式的引号替换掉，但是我原始数据是没有太多问题的，另外正则也不太会，就暂时放弃了使用 pip install pyyaml import y
注解实现字典值转换
东坡居士的博客
03-24 1168
字典值转换
python列表字典转换_python 列表与字典相互转换
weixin_30209891的博客
01-29 1387
1. 2个列表转换为字典#encoding=utf-8list1=["a","b","c"]list2=[1,2,3]d={}for i in range(len(list1)):d[list1[i]]=list2[i]print (d)2. 使用内置函数 zip3.求一个列表中所有数据类型的次数#encoding=utf-8l = [1,2,"s",[1,23],{1:2},(1,2),set...
【Python】将字典（dict）转化为Dataframe
热门推荐
张欣的博客
04-17 11万+
【Python】将Dataframe转化为字典 偶现在知道的将字典转换为DataFrame主要有两种方法。 第一种方法，直接使用pd.DataFrame()。需要注意的是这种方法需要先将字典变为list。 >>> dict = {'a':'apple','b':'banana'} >>> dict {'a': 'apple', 'b': 'banana'...
pandas 把字典转换成DataFrame
张帅的博客
03-09 9万+
把dictd = {'A':0}转换成DataFrame， 首先，DataFrame的语法格式应为： import pandas as pd df = pd.DataFrame({'A':[0]})#'A'是columns，对应的是list 输出: A 0 0 但是如果是： df = pd.DataFrame({'A':0})#直接输入dict 会报错 ValueError...
sql更新，字典值转换，
沉淀的博客
06-18 2003
update population set education_degree = (CASE when education_degree='博士' THEN 0 when education_degree='研究生' THEN 1 when education_degree='本科' THEN 2 when education_degree='大专' THEN 3 when educatio...
数据库字典转换
嘟嘟的博客
10-31 589
字典转换工具类 package com.example.demo; import lombok.extern.slf4j.Slf4j; import org.apache.commons.lang.StringUtils; import org.springframework.beans.BeanUtils; import org.springframework.util.Assert; im...
字典转换模型
Ring
06-28 672
     （1）模型就是专门用来存放数据的对象，即数据模型         优点：模型设置数据都是通过它的属性，属性名如果写错了，编译器会马上报错，因此保证了数据的正确性              使用模型访问属性时，编译器会提供一系列的提示，提高编码效率         - (NSArray *)dataArr{             //加载数据             if (_dataA...
字典 元组 列表之间相互转化(python)
thinkinjava1的博客
10-29 1907
#--coding:utf-8-- #1、字典 dict = {‘name’: ‘Zara’, ‘age’: 7, ‘class’: ‘First’} #字典转为字符串，返回：&amp;lt;type ‘str’&amp;gt; {‘age’: 7, ‘name’: ‘Zara’, ‘class’: ‘First’} print type(str(dict)), str(dict) #字典可以转为元组，返回：(‘...
自定义注解完成字典转换
最新发布
08-04
为了完成字典转换，可以使用一个字典转换工具类。这个工具类可以根据注解的定义，将属性值转换为对应的字典值。具体实现可以根据注解的key值，在字典中查找对应的值，并将其赋给属性。如果属性值为null，则可以使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值