投稿
  1. 首页
  2. python

Python day6：元组字典字符串 *** 作以及三级菜单制作

code • 2022-4-27 • python • 阅读 50

Python day6：元组字典字符串 *** 作以及三级菜单制作,第1张

什么是元组 元组的定义

元组被称为只读列表，即和列表性质相同，但不能用append/sort等方法对其增删改，但是可以查，这也告诉我们元组可以进行切片。

元组用（）表示，这与列表用[ ]来表示略有不同，并且只用单独元素的元组是这么表示的：

a=('a',)

需要在元素后面加一个逗号！！！建议写单一元素的列表也一样

或者可以调用元组的族，即tuple来生成

a=tuple(('alpha','beta','gamma','zelta'))
a=tuple(['alpha','beta','gamma','zelta'])

元组的查询

同列表。

字典 字典是什么

字典是python中唯一的映射（一一对应）类型，是采用键值对（key-value）的形式存储数据。

创建字典

键和值的相对应的储存

dict1={'a':1,'b':2}

我们发现，列表是靠index来找相应的元素的，但是字典内部没有顺序（无序性），而是通过相应的键（key）来取值（value）。

！！！注意，我们知道自变量和因变量的映射关系，一个因变量可以对应多个自变量，但是一个自变量不能映射多个自变量，这在字典的使用中也是一样的，即每个键是独一无二的，而值是多样的。

字典还可以用他的族，即dict来创建

dict1=dict((('name1',1),('name2',2)))

最里面的两个括号()可以变成中括号 [],即元组和列表可以混用

数据的可变类型和不可变类型：

字典的键一定得是一个不可变类型！这是字典的第二大特性

那么可变类型和不可变类型都有什么呢

不可变类型：整型，字符串，元组-------->可以作为字典的键的数据类型

可变类型：列表，字典

字典的 *** 作

1.增

1最基本的方法

dict1={'a':1,'b':2}
dict1['c']=3

2 dict1.setdefault(键，值)

dict1=dict((('a',1),))
dict1.setdefault('a',2)
print(dict1)
ret2=dict1.setdefault('a',2)
print(ret2)

setdefault是用于增加字典中的键值的，如果setdefault中的键已经在字典中存在，则不会改变字典中相应键的值！！！你会发现上述代码输出后键‘a’的值依旧是1而不是2，并且会输出一个返回值,这个返回值是相应键的值，即1。

2.查

1. 查找字典里所有的键

dict1.keys()

dict1=dict((('a',1),))
print(dict1.keys())

dict1.keys()输出的数据类型并不是一个列表，可以通过list(dict1.keys())转化为列表

2.查找字典里所有的值

dict1.values()， *** 作方法与keys()相同，只是输出的是字典里面的值

3.提出字典里所有的键值对

dict1=dict((('a',1),))

print(dict1.items())

3.改

dict1=dict((('a',1),))
dict1['a']=55

2.update方法，把两个字典合并为一

dict1=dict((('a',1),))
dict2={'a':8,'b':2}

 update之后，若覆盖的字典与被覆盖的字典有相同键，则覆盖后相应键的值为覆盖字典中的值，美其名曰update

4.删

1. del

dict1=dict((('a',1),))
del dict1['a']

也用del dict1 把整个字典从储存中抹去

2.clear

用于把列表变成一个空列表

dict1=dict((('a',1),))
dict1.clear()

3. pop

删除键值对，并有返回值，这和列表删除的pop相似

dict1=dict((('a',1),))
dict1.pop('a')

此外还有一个popitem，用法为dict1.popitem(),用于随机删除字典中的一个键值对，似乎没啥用

5.1 fromkeys

dict2=dict.fromkeys(['k1','2','k3'],'value')

用于为字典内的多键相同值

5.2 字典嵌套

dict1={
    'dict11':{
        'dict111':1,
        'dict112':2},
    'dict12':[2,3,4]
}

5.3 排序

sorted(dict1),sort和sorted也可用于列表的排序，注意sort()只能用于字典

输出的为一个按字典键排序的列表

5.4 遍历（for 循环）

dict1={'a':1,'b':2}
for i in dict1:
    print('key',i)
    print('value',dict1[i])

遍历时，i的值为键的值

或者也可以这样

dict1={'a':1,'b':2}
for i in dict1.items():
    print('key,value',i)

直接以元组形式出键和值，但是耗时，因为.item()的处理就很麻烦。

字符串 *** 作 字符串简单 *** 作

1.重复输出字符串

print('hello'*3)

2.通过索引获取字符串的字符（把字符串当成列表）

print('hello'[2])

3.判断某字符串在一个大字符串内

print('el' in 'hello')

返回一个布尔值

4.字符串拼接

print('abc'+'123')

join 方法：'a和b之间的字符'.jion([a,b,c])

a='wawa'
b='dada'
c='gaga'
d='***'.join([a,b,c])
print(d)

输出结果为： wawa***dada***gaga

字符串内置方法

1. count

st='hello kitty'
print(st.count('l'))

用于计算相应字符串出现数目

2. capitalize

st='hello kitty'
print(st.capitalize())

用于首字母大写

3.center

st='hello kitty'
print(st.center(20,'-'))

目标字符串居中，两边打印center()中调用的相应字符

st.center(一侧字符重复数目，两侧所要打印字符)

4.endswith

st='hello kitty'
print(st.endswith('y'))

以什么为结尾判断，输出结果为一个布尔值

5.1startswith

st='hello kitty'
print(st.startswith('he'))

以什么为开头判断，输出结果为布尔值

5.2expandtabs

st='hello \t kitty'
print(st.expandtabs(10))

设置字符串中\t所代表的空格数

5.3find

st='hello kitty'
print(st.find('h'))

查找你要找的字符在字符串的第一个索引值index（碰到有多个相同字符的字符串输出的是第一个的索引值），若没有相应字符，则输出-1

5.4format和format_map

st='hello {name} and {name2}'
print(st.format(name='kitty',name2='kitty2'))
print(st.format_map({'name':'kitty','name2':'kitty2'}))

 另一种比较方便的格式化输出方法，可以和%str的方法比较一下

5.5index

st='hello kitty'
print(st.index('h'))

和find差不多，只是没有要找的字符会报错

5.6isalnum

a='123456a'
print(a.isalnum())

是 is all number 的简称，顾名思义，就是判断字符串是否完全由数字构成,返回一个布尔值

5.7isdecimal

a='123456a'
print(a.isdecimal())

判断字符串是否为一个十进制的数，输出为一个布尔值，没咋用到

5.8isdigit和isnumeric

a='123456a'
print(a.isdigit())
print(a.isnumeric())

判断是否为一个整数，输出为一个布尔值

5.9isidentifier

a='123456a'
print(a.isidentifier())

判断是否为一个非法字符，这是用于判断该字符串是否可以作为变量名使用，即看开头是否为数字或内部有非法符号。输出为一布尔值

5.10islower

a='Abc'
print(a.islower())

判断字符串结果是否为纯小写，输出结果为一布尔值

5.11isupper

用法和islower一样，但是用来判断字符串是否为纯大写 

5.12isspace

a='123 456a'
print(a.isspace())

判断字符串是否只有空格，输出为一布尔值

5.13istitle

a='My Title'
print(a.istitle())

我们知道标题每个单词的首字母都是大写，这个函数就是来判断这个的，输出为一布尔值

5.14lower

a='AaBbCc'
print(a.lower())

所有字母变小写 

5.15upper

和lower一样用法，只是把小写变大写

5.16swapcase

h和lower和upper,只是把小写变大写、把大写变小写

5.17ljust

st='hello kitty'
print(st.ljust(20,'-'))

left just的意思，相当于.center()用法的改版，字符串对象print在最左端，ljust()内的调用字符在有段重复

5.18rjust

right just，举一反三.ljust()

5.19strip

a='123 456a\twdsa\nwawa wa'
print(a.strip())

把字符串首和尾的空格、换行、tab都删除

lstrip 只去左边rstrip只去右边

5.20replace

a='123 456a'
print(a.replace('1','one'))

替换字符串内部的部分字符，a.replace(原字符，被替换字符，被替换次数）一般有几个原字符就默认所有都替换掉，但是第三个参数可以修改选择替换次数

5.21rfind

a='123 456a 123456'
print(a.rfind('1'))

从右往左找第一个字符，可以理解查找方向跟find相反

5.22split

a='123 456a 123456'
print(a.split())

分割的重要方法，默认.split()是将字符串按空格或者换行、tab进行分割并放入列表，而 .split(‘作为分割符’,分割次数)内可设置一参数，来作为分割符；而分割次数默认为-1，即把整个字符串全部过一遍。例如

a='123 456a 123456'
print(a.split('2'))

输出结果会在‘2’的周围进行分割。这可以看成.join()函数的反向形式

5.23title

a='a23 456a c23456'
print(a.title())

所有单词首字母大写 

练习

三级菜单

要求：

1.打印省、市、县

2.可返回上一级

3.可随时退出程序

我的答案 
'''
思路：：：

建立省份市区镇区字典

while循环
    打印省
    input选择省，或退出
        打印并选择市，或返回上一级，或退出
            打印并选择区，或返回上一级，或退出

'''

dict_ShenShiXian={
    'GuangXi':{
        'NanNing':{'XingNing':{},'QingXiu':{},'MaShan':{}},
        'LiuZhou':{'ChenZhong':{},'YuFeng':{},'LiuNan':{}},
        'GuiLin':{'XiuFeng':{},'DieCai':{},'XiangShan':{}}
        },

    'GuangDong':{
        'GuangZhou':{'LiWan':{},'YueXiu':{},'HaiZhu':{}},
        'ShaoGuan':{'WuJiang':{},'QuJiang':{},'ShiXing':{}},
        'ShenZheng':{'LuoHu':{},'FuTian':{},'NanShan':{}}
        },
    
    'FuJian':{'FuZhou':{'GuLou':{},'TaiJiang':{},'CangShan':{}},
              'XiaMeng':{'SiMing':{},'HaiCang':{},'HuLi':{}},
              'PuTian':{'ChengXiang':{},'HanJiang':{},'LiCheng':{},}}
    
    
    }


Loop1=True

while Loop1:
    Loop2=True

    print('省份:',list(dict_ShenShiXian.keys()))
    ChooseShen=input('输入所要查看省份，退出请按quit：')
    if ChooseShen=='quit':
        Loop1=False
    elif ChooseShen in dict_ShenShiXian.keys():
        Shen=dict_ShenShiXian[ChooseShen]
        while Loop2:
            Loop3=True
            
            print('{name}省所辖市为：'.format(name=ChooseShen),list(Shen.keys()))
            ChooseShi=input('输入所要查看市区，退出请按quit,返回上层请按last：')
            if ChooseShi=='quit':
                Loop1,Loop2=False,False
            elif ChooseShi=='last':
                Loop2=False
            elif ChooseShi in Shen.keys():
                Shi=Shen[ChooseShi]
                print('{name}市所辖县为：'.format(name=ChooseShi),list(Shi.keys()))
                while Loop3:
                    judge=input('退出quit或返回上级菜单last：')
                    if judge=='quit':
                        Loop1,Loop2,Loop3=False,False,False
                    elif judge=='last':
                        Loop2,Loop3=False,False
                    else:
                        print('输入有效字符')
            else:
                print('输入有效字符')
                    

    
    
    
    else:
        print('输入有效字符')
print('再见')
改进：

其实可以看出来，我们只需要用一个循环就能写出三级菜单！ 

dict_ShenShiXian={
    'GuangXi':{
        'NanNing':{'XingNing':{},'QingXiu':{},'MaShan':{}},
        'LiuZhou':{'ChenZhong':{},'YuFeng':{},'LiuNan':{}},
        'GuiLin':{'XiuFeng':{},'DieCai':{},'XiangShan':{}}
        },
 
    'GuangDong':{
        'GuangZhou':{'LiWan':{},'YueXiu':{},'HaiZhu':{}},
        'ShaoGuan':{'WuJiang':{},'QuJiang':{},'ShiXing':{}},
        'ShenZheng':{'LuoHu':{},'FuTian':{},'NanShan':{}}
        },
    
    'FuJian':{'FuZhou':{'GuLou':{},'TaiJiang':{},'CangShan':{}},
              'XiaMeng':{'SiMing':{},'HaiCang':{},'HuLi':{}},
              'PuTian':{'ChengXiang':{},'HanJiang':{},'LiCheng':{},}}
    
    
    }
 
 

Loop=True
SanJiName=['省份','市区','乡镇']
SanJiIndex=0
SanJiLocate=dict_ShenShiXian
add1=['输入所要查看','输入所要查看','已显示']
add2=['',',返回上级菜单按last',',返回上级菜单按last']
while Loop:
    print('{name}:'.format(name=SanJiName[SanJiIndex]),list(SanJiLocate.keys()))
    InputContent='{add1}{name}，退出请按quit{add2}：'.format(add1=add1[SanJiIndex],name=SanJiName[SanJiIndex],add2=add2[SanJiIndex])
    Choose1=input(InputContent)
    if Choose1=='quit':
        Loop=False
    elif Choose1 in SanJiLocate:
        SanJiLocateBefore=SanJiLocate
        SanJiLocate=SanJiLocate[Choose1]

        SanJiIndex+=1
    elif Choose1=='last' and SanJiIndex!=0:
        SanJiIndex-=1
        SanJiLocate=SanJiLocateBefore
    else:
        print('输入有效字符')
print('再见')

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/729691.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
code code 管理员组
0 0
上一篇 2022-04-27
下一篇 2022-04-27

发表评论

登录后才能评论

评论列表（0条）

保存