Python基于递归实现电话号码映射功能示例

本文实例讲述了Python基于递归实现电话号码映射功能。分享给大家供大家参考,具体如下:

问题

电话按键上面的每个数字都对应着几个字母,如果按下一个数字键代表输入一个字母,那么输入一个数字组成的字符串,它所产生的所有的可能的字母串是什么,有多少种

思路:

这个是一个递归的问题

下面是具体的实现,为了更清晰看懂递归调用的过程,这里打印出来了每一次递归的过程:

#!usr/bin/env python
#encoding:utf-8
'''''
__Author__:沂水寒城
功能:电话号码映射
'''
phone_dict={'2':'abc','3':'def','4':'ghi','5':'jkl','6':'mno','7':'pqrs','8':'tuv','9':'wxyz'}
def phone_num_map(one_str,phone_dict):
  '''''
  电话号码映射
  '''
  res_list=[]
  deep(one_str, "", res_list)
  return res_list
def deep(one_str, tmp_str, res_list):
  '''''
  递归的遍历过程
  '''
  if not one_str:
    res_list.append(tmp_str)
    return
  for c in phone_dict[one_str[0]]:
    deep(one_str[1:], tmp_str + c, res_list)
    print 'deep({0}, {1}, {2})'.format(one_str[1:], tmp_str + c, res_list)
if __name__ == '__main__':
  one_str_list=['23','567','47','89','44']
  for one_str in one_str_list:
    one_list=phone_num_map(one_str,phone_dict)
    print one_list
    print len(one_list)

结果如下:

deep(, ad, ['ad'])
deep(, ae, ['ad', 'ae'])
deep(, af, ['ad', 'ae', 'af'])
deep(3, a, ['ad', 'ae', 'af'])
deep(, bd, ['ad', 'ae', 'af', 'bd'])
deep(, be, ['ad', 'ae', 'af', 'bd', 'be'])
deep(, bf, ['ad', 'ae', 'af', 'bd', 'be', 'bf'])
deep(3, b, ['ad', 'ae', 'af', 'bd', 'be', 'bf'])
deep(, cd, ['ad', 'ae', 'af', 'bd', 'be', 'bf', 'cd'])
deep(, ce, ['ad', 'ae', 'af', 'bd', 'be', 'bf', 'cd', 'ce'])
deep(, cf, ['ad', 'ae', 'af', 'bd', 'be', 'bf', 'cd', 'ce', 'cf'])
deep(3, c, ['ad', 'ae', 'af', 'bd', 'be', 'bf', 'cd', 'ce', 'cf'])
['ad', 'ae', 'af', 'bd', 'be', 'bf', 'cd', 'ce', 'cf']
9
deep(, jmp, ['jmp'])
deep(, jmq, ['jmp', 'jmq'])
deep(, jmr, ['jmp', 'jmq', 'jmr'])
deep(, jms, ['jmp', 'jmq', 'jmr', 'jms'])
deep(7, jm, ['jmp', 'jmq', 'jmr', 'jms'])
deep(, jnp, ['jmp', 'jmq', 'jmr', 'jms', 'jnp'])
deep(, jnq, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq'])
deep(, jnr, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr'])
deep(, jns, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns'])
deep(7, jn, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns'])
deep(, jop, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop'])
deep(, joq, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq'])
deep(, jor, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor'])
deep(, jos, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos'])
deep(7, jo, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos'])
deep(67, j, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos'])
deep(, kmp, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp'])
deep(, kmq, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq'])
deep(, kmr, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr'])
deep(, kms, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms'])
deep(7, km, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms'])
deep(, knp, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp'])
deep(, knq, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq'])
deep(, knr, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr'])
deep(, kns, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns'])
deep(7, kn, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns'])
deep(, kop, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop'])
deep(, koq, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq'])
deep(, kor, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor'])
deep(, kos, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor', 'kos'])
deep(7, ko, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor', 'kos'])
deep(67, k, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor', 'kos'])
deep(, lmp, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor', 'kos', 'lmp'])
deep(, lmq, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor', 'kos', 'lmp', 'lmq'])
deep(, lmr, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor', 'kos', 'lmp', 'lmq', 'lmr'])
deep(, lms, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor', 'kos', 'lmp', 'lmq', 'lmr', 'lms'])
deep(7, lm, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor', 'kos', 'lmp', 'lmq', 'lmr', 'lms'])
deep(, lnp, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor', 'kos', 'lmp', 'lmq', 'lmr', 'lms', 'lnp'])
deep(, lnq, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor', 'kos', 'lmp', 'lmq', 'lmr', 'lms', 'lnp', 'lnq'])
deep(, lnr, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor', 'kos', 'lmp', 'lmq', 'lmr', 'lms', 'lnp', 'lnq', 'lnr'])
deep(, lns, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor', 'kos', 'lmp', 'lmq', 'lmr', 'lms', 'lnp', 'lnq', 'lnr', 'lns'])
deep(7, ln, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor', 'kos', 'lmp', 'lmq', 'lmr', 'lms', 'lnp', 'lnq', 'lnr', 'lns'])
deep(, lop, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor', 'kos', 'lmp', 'lmq', 'lmr', 'lms', 'lnp', 'lnq', 'lnr', 'lns', 'lop'])
deep(, loq, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor', 'kos', 'lmp', 'lmq', 'lmr', 'lms', 'lnp', 'lnq', 'lnr', 'lns', 'lop', 'loq'])
deep(, lor, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor', 'kos', 'lmp', 'lmq', 'lmr', 'lms', 'lnp', 'lnq', 'lnr', 'lns', 'lop', 'loq', 'lor'])
deep(, los, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor', 'kos', 'lmp', 'lmq', 'lmr', 'lms', 'lnp', 'lnq', 'lnr', 'lns', 'lop', 'loq', 'lor', 'los'])
deep(7, lo, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor', 'kos', 'lmp', 'lmq', 'lmr', 'lms', 'lnp', 'lnq', 'lnr', 'lns', 'lop', 'loq', 'lor', 'los'])
deep(67, l, ['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor', 'kos', 'lmp', 'lmq', 'lmr', 'lms', 'lnp', 'lnq', 'lnr', 'lns', 'lop', 'loq', 'lor', 'los'])
['jmp', 'jmq', 'jmr', 'jms', 'jnp', 'jnq', 'jnr', 'jns', 'jop', 'joq', 'jor', 'jos', 'kmp', 'kmq', 'kmr', 'kms', 'knp', 'knq', 'knr', 'kns', 'kop', 'koq', 'kor', 'kos', 'lmp', 'lmq', 'lmr', 'lms', 'lnp', 'lnq', 'lnr', 'lns', 'lop', 'loq', 'lor', 'los']
36
deep(, gp, ['gp'])
deep(, gq, ['gp', 'gq'])
deep(, gr, ['gp', 'gq', 'gr'])
deep(, gs, ['gp', 'gq', 'gr', 'gs'])
deep(7, g, ['gp', 'gq', 'gr', 'gs'])
deep(, hp, ['gp', 'gq', 'gr', 'gs', 'hp'])
deep(, hq, ['gp', 'gq', 'gr', 'gs', 'hp', 'hq'])
deep(, hr, ['gp', 'gq', 'gr', 'gs', 'hp', 'hq', 'hr'])
deep(, hs, ['gp', 'gq', 'gr', 'gs', 'hp', 'hq', 'hr', 'hs'])
deep(7, h, ['gp', 'gq', 'gr', 'gs', 'hp', 'hq', 'hr', 'hs'])
deep(, ip, ['gp', 'gq', 'gr', 'gs', 'hp', 'hq', 'hr', 'hs', 'ip'])
deep(, iq, ['gp', 'gq', 'gr', 'gs', 'hp', 'hq', 'hr', 'hs', 'ip', 'iq'])
deep(, ir, ['gp', 'gq', 'gr', 'gs', 'hp', 'hq', 'hr', 'hs', 'ip', 'iq', 'ir'])
deep(, is, ['gp', 'gq', 'gr', 'gs', 'hp', 'hq', 'hr', 'hs', 'ip', 'iq', 'ir', 'is'])
deep(7, i, ['gp', 'gq', 'gr', 'gs', 'hp', 'hq', 'hr', 'hs', 'ip', 'iq', 'ir', 'is'])
['gp', 'gq', 'gr', 'gs', 'hp', 'hq', 'hr', 'hs', 'ip', 'iq', 'ir', 'is']
12
deep(, tw, ['tw'])
deep(, tx, ['tw', 'tx'])
deep(, ty, ['tw', 'tx', 'ty'])
deep(, tz, ['tw', 'tx', 'ty', 'tz'])
deep(9, t, ['tw', 'tx', 'ty', 'tz'])
deep(, uw, ['tw', 'tx', 'ty', 'tz', 'uw'])
deep(, ux, ['tw', 'tx', 'ty', 'tz', 'uw', 'ux'])
deep(, uy, ['tw', 'tx', 'ty', 'tz', 'uw', 'ux', 'uy'])
deep(, uz, ['tw', 'tx', 'ty', 'tz', 'uw', 'ux', 'uy', 'uz'])
deep(9, u, ['tw', 'tx', 'ty', 'tz', 'uw', 'ux', 'uy', 'uz'])
deep(, vw, ['tw', 'tx', 'ty', 'tz', 'uw', 'ux', 'uy', 'uz', 'vw'])
deep(, vx, ['tw', 'tx', 'ty', 'tz', 'uw', 'ux', 'uy', 'uz', 'vw', 'vx'])
deep(, vy, ['tw', 'tx', 'ty', 'tz', 'uw', 'ux', 'uy', 'uz', 'vw', 'vx', 'vy'])
deep(, vz, ['tw', 'tx', 'ty', 'tz', 'uw', 'ux', 'uy', 'uz', 'vw', 'vx', 'vy', 'vz'])
deep(9, v, ['tw', 'tx', 'ty', 'tz', 'uw', 'ux', 'uy', 'uz', 'vw', 'vx', 'vy', 'vz'])
['tw', 'tx', 'ty', 'tz', 'uw', 'ux', 'uy', 'uz', 'vw', 'vx', 'vy', 'vz']
12
deep(, gg, ['gg'])
deep(, gh, ['gg', 'gh'])
deep(, gi, ['gg', 'gh', 'gi'])
deep(4, g, ['gg', 'gh', 'gi'])
deep(, hg, ['gg', 'gh', 'gi', 'hg'])
deep(, hh, ['gg', 'gh', 'gi', 'hg', 'hh'])
deep(, hi, ['gg', 'gh', 'gi', 'hg', 'hh', 'hi'])
deep(4, h, ['gg', 'gh', 'gi', 'hg', 'hh', 'hi'])
deep(, ig, ['gg', 'gh', 'gi', 'hg', 'hh', 'hi', 'ig'])
deep(, ih, ['gg', 'gh', 'gi', 'hg', 'hh', 'hi', 'ig', 'ih'])
deep(, ii, ['gg', 'gh', 'gi', 'hg', 'hh', 'hi', 'ig', 'ih', 'ii'])
deep(4, i, ['gg', 'gh', 'gi', 'hg', 'hh', 'hi', 'ig', 'ih', 'ii'])
['gg', 'gh', 'gi', 'hg', 'hh', 'hi', 'ig', 'ih', 'ii']
9
[Finished in 0.4s]

更多关于Python相关内容感兴趣的读者可查看本站专题:《Python数据结构与算法教程》、《Python函数使用技巧总结》、《Python字符串操作技巧汇总》、《Python入门与进阶经典教程》及《Python文件与目录操作技巧汇总》

希望本文所述对大家Python程序设计有所帮助。

您可能感兴趣的文章:

  • python映射列表实例分析
  • 详解Python中映射类型的内建函数和工厂函数
  • 详解Python中映射类型(字典)操作符的概念和使用
  • Python中字典映射类型的学习教程
  • Python cookbook(数据结构与算法)在字典中将键映射到多个值上的方法
  • Python cookbook(数据结构与算法)将名称映射到序列元素中的方法
  • python使用递归解决全排列数字示例
  • Python通过递归遍历出集合中所有元素的方法
  • Python递归遍历列表及输出的实现方法
  • Python 递归函数详解及实例
(0)

相关推荐

  • 详解Python中映射类型的内建函数和工厂函数

    1.基本函数介绍 (1)标准类型函数[type().str()和 cmp()]         对一个字典调用type()工厂方法,会返回字典类型:"<type 'dict'>".调用str()工厂方法将返回该字典的字符串表示形式.         字典是通过这样的算法来比较的:首先是字典的大小,然后是键,最后是值.可是用cmp()做字典的比较一般不是很有用. 算法按照以下的顺序: 首先比较字典长度         如果字典的长度不同,那么用cmp(dict1, dict2

  • Python通过递归遍历出集合中所有元素的方法

    本文实例讲述了Python通过递归遍历出集合中所有元素的方法.分享给大家供大家参考.具体实现方法如下: 复制代码 代码如下: '''''通过递归遍历出集合中的所有元素 Created on 2013-9-29 @author: L.Eric '''  def print_List(list_nums):      for each_item in list_nums :           if isinstance(each_item,list):              print_Lis

  • Python cookbook(数据结构与算法)在字典中将键映射到多个值上的方法

    本文实例讲述了Python在字典中将键映射到多个值上的方法.分享给大家供大家参考,具体如下: 问题:一个能将键(key)映射到多个值的字典(即所谓的一键多值字典[multidict]) 解决方案:如果想让键映射到多值,需要将这多个值保持到另一个容器如列表或集合中: >>> d={'a':[1,2,3],'b':[4,5]} >>> d {'b': [4, 5], 'a': [1, 2, 3]} >>> e={'a':{1,2,3,3},'b':{4,5

  • Python递归遍历列表及输出的实现方法

    本文实例讲述了Python递归遍历列表及输出的实现方法.分享给大家供大家参考.具体实现方法如下: def dp(s): if isinstance(s,(int,str)): print(s) else: for item in s: dp(item) l=['jack',('tom',23),'rose',(14,55,67)] dp(l) 运行结果如下: jack tom 23 rose 14 55 67 希望本文所述对大家的Python程序设计有所帮助.

  • python使用递归解决全排列数字示例

    第一种方法:递归 复制代码 代码如下: def perms(elements):    if len(elements) <=1:        yield elements    else:        for perm in perms(elements[1:]):            for i in range(len(elements)):                yield perm[:i] + elements[0:1] + perm[i:] for item in li

  • Python中字典映射类型的学习教程

    字典是python语言中唯一的映射类型,用花括号{}表示,一个字典条目就是一个键值对,方法keys()返回字典的键列表,values()返回字典的值列表,items()返回字典的键值对列表.字典中的值没有任何限制,它们可以是任意python对象,但字典中的键是有类型限制的,每个键只能对应一个值,且键必须是可哈系的,所有不可变类型都是可哈希的.不可变集合frozenset的元素可作为字典的键,但可变集合set就不行了. 以下是字典类型的常用方法. clear():删除字典中所有元素. copy()

  • 详解Python中映射类型(字典)操作符的概念和使用

    映射类型操作符 (1)标准类型操作符 字典可以和所有的标准类型操作符一起工作,但却不支持像拼接(concatenation)和重复(repetition)这样的操作.这些操作对序列有意义,可对映射类型行不通.         字典是如何比较的呢? 与列表和元组一样,这个过程比数字和字符串的比较更复杂些. (2)映射类型操作符 字典的键查找操作符([ ])         键查找操作符是唯一仅用于字典类型的操作符,它和序列类型里单一元素的切片(slice)操作符很相象.对序列类型来说,用索引做唯一

  • Python 递归函数详解及实例

    Python 递归函数 如果一个函数体直接或者间接调用自己,那么这个函数就称为递归函数.也就是说,递归函数体的执行过程中可能会返回去再次调用该函数.在python里,递归函数不需要任何特殊的语法,但是它需要付出一定的努力去理解和创建. 我们会以一个简单的例子开始:写一个函数求一个自然数中所有数字的和.在设计递归函数的时候,我们会寻找能把问题分解成简单的问题的方法.在这道题中,运算符%和//可以用来把一个数分成两部分:最低位和不包含最低位数字两部分. 18117的数字和为:1+8+1+1+7=18

  • python映射列表实例分析

    本文实例讲述了python映射列表.分享给大家供大家参考.具体分析如下: 列表映射是个非常有用的方法,通过对列表的每个元素应用一个函数来转换数据,可以使用一种策略或者方法来遍历计算每个元素. 例如: 复制代码 代码如下: params = {"server":"mpilgrim", \                 "database":"master", \                 "uid":

  • Python cookbook(数据结构与算法)将名称映射到序列元素中的方法

    本文实例讲述了Python将名称映射到序列元素中的方法.分享给大家供大家参考,具体如下: 问题:希望通过名称来访问元素,减少结构中对位置的依赖性 解决方案:使用命名元组collections.namedtuple().它是一个工厂方法,返回的是python中标准元组类型的子类,提供给它一个类型名称以及相应的字段名称,它就返回一个可实例化的类,为你以定义好的字段名称传入值等. 命名元组的主要作用在于将代码同它所控制的元素位置间进行解耦 >>> from collections import

随机推荐