Python基础-week02 Python的常用数据类型
2024-08-29 23:35:49
一.模块初识
import导入Py自带模块例如os,sys等及其自己编写的Py文件，导入到其他文件中，默认查找当前目录。如果不在同一目录，会报错，将该自定义py文件模块放到site-packages目录里，其他方法会在后面笔记中中讲解。
Python的强大之处在于他有非常丰富和强大的标准库和第三方库，几乎你想实现的任何功能都有相应的Python库支持，以后的课程中会深入讲解常用到的各种库，现在，我们先来象征性的学2个简单的:
#sys模块
import sys
print(sys.argv)
#os模块
import os
os.system("df -h") #调用系统命令
import os sys
os.system(''.join(sys.argv[1:])) #把用户的输入的参数当作一条命令交给os.system来执行
二.pyc是什么?
在说这个问题之前，我们先来说两个概念，PyCodeObject和pyc文件。
我们在硬盘上看到的pyc自然不必多说，而其实PyCodeObject则是Python编译器真正编译成的结果。我们先简单知道就可以了，继续向下看。
当python程序运行时，编译的结果则是保存在位于内存中的PyCodeObject中，当Python程序运行结束时，Python解释器则将PyCodeObject写回到pyc文件中。
当python程序第二次运行时，首先程序会在硬盘中寻找pyc文件，如果找到，则直接载入，否则就重复上面的过程。
所以我们应该这样来定位PyCodeObject和pyc文件，我们说pyc文件其实是PyCodeObject的一种持久化保存方式。
总结：pyc其实就是Python 预编译的的一个文件，每次运行py文件时候，会检测该pyc文件是否存在，如果不存在重新编译生成，如果存在会检查pyc和源文件哪个更新时间最新，如果源文件没有更新直接从Pyc文件执行速度快，如果源文件已经更新了呢，则会编译最新源文件生成Pyc文件。
三.python数据类型
1.数值型
整型(int):在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
浮点型(float):浮点数用来处理实数，即带有小数的数字。类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。
浮点数的例子:3.14和52.3E-4，其中E表示10幂次方，这里表示52.3*10**-4次方的缩写。
复数(complex):例如3+4j,由实数和虚数构成，如果要遍历复数，需要分别遍历实数和虚数部分。
2.字符串
python中的字符串在C语言中体现为是一个字符数组，每次创建字符串时候需要在内存中开辟一块连续的空，并且一旦需要修改字符串的话，就需要再次开辟空间，万恶的+号每出现一次就会在内从中重新开辟一块空间。
字符串格式化输出
name = "alex"
print ("i am %s " % name) #输出: i am alex
PS: 字符串是 %s;整数 %d;浮点数%f
字符串常用功能：
移除空白:strip()去首尾,lstrip()去左边,rstrip()去右边
分割:split(',')
长度:len()
索引:zifucuan[i]
切片:zifucuan[1:4]
替换:replace('c1','c2')：把字符串里的c1替换成c2。故可以用replace(' ','')来去掉字符串里的所有 ,逗号
3.列表
创建列表：
name_list = ['alex', 'seven', 'eric']或name_list ＝ list(['alex', 'seven', 'eric'])
基本操作：
索引:从0开始，list[-1]为非空列表最后一个，list.index('a')查找a第一次出现的索引号。
切片:list[1:5]
追加:list.append()在末尾增加
删除:list.pop()删除末尾/list.remove('')删除某个元素 /del list 删除列表list /list.clear()清空列表内容
插入:insert(),list.insert(1,'a'),在1号索引位置前插入a值。
长度:len()
循环:for i in list:
反转:reverse()，再次恢复需要再调用reserser()
排序:sort(),顺序为特殊符号>数字>大写字母>小写字母(按照ASCII码的排序规则)
扩展:extend(),list1.extend(list2),将list2扩展到list1中，list2依然存在保持不变，list1已经扩展。
包含:(元组)
4.元祖(不可变的列表)
常用操作：与列表操作一样。
ages = (11, 22, 33, 44, 55)或ages = tuple((11, 22, 33, 44, 55))
5.字典
创建字典：
person = {"name": "mr.wu", 'age': 18}或person = dict({"name": "mr.wu", 'age': 18})
常用操作：
索引
新增
删除
键、值、键值对
循环
长度
6.布尔类型
True/False
7.None
略.
***************数据运算符及其优先级：
**********拾遗：
1.三元运算
格式:retsult =值1 if 条件 else 值2
条件为真，输出result=值1
条件为假，输出result=值2
例子:
a,b,c=1,3.5
d=a if a>b else c
会输出d=5
d=a if a<b else c
会输出d=1
2.进制
a.二进制 01
b.八进制 01234567
c.十进制 0123456789
d.十六进制 0123456789ABCDEF，前缀表示法BH,后缀表示法0x53
了解一下二进制转换成16进制的方法!
3.对象
你找到对象了吗？
在python里一切事物皆对象，以后别再告诉别人你没有对象啦，对象基于类创建，例如清纯类、成熟类、萌妹子类，魅惑类，知性类......
******************bytes数据类型：
（1）Python 3最重要的新特性之一是对字符串和二进制数据流做了明确的区分。文本总是Unicode，由str类型表示，二进制数据则由bytes类型表示。Python 3不会以任意隐式的方式混用str和bytes，你不能拼接字符串和字节流，也无法在字节流里搜索字符串（反之亦然），也不能将字符串传入参数为字节流的函数（反之亦然）。
（2）bytes和str的差异:
回到bytes和str的身上。bytes是一种比特流，它的存在形式是01010001110这种。我们无论是在写代码，还是阅读文章的过程中，肯定不会有人直接阅读这种比特流，它必须有一个编码方式，使得它变成有意义的比特流，而不是一堆晦涩难懂的01组合。因为编码方式的不同，对这个比特流的解读也会不同，对实际使用造成了很大的困扰。下面让我们看看Python是如何处理这一系列编码问题的：
>>> s = "中文" >>> s '中文' >>> type(s) <class 'str'> >>> b = bytes(s, encoding='utf-8') >>> b b'\xe4\xb8\xad\xe6\x96\x87' >>> type(b) <class 'bytes'>
(3).如上图bytes与str的相互转换：我们都知道，字符串类str里有一个encode()方法，它是从字符串向比特流的编码过程。而bytes类型恰好有个decode()方法，它是从比特流向字符串解码的过程。除此之外，我们查看Python源码会发现bytes和str拥有几乎一模一样的方法列表，最大的区别就是encode和decode。
从实质上来说，字符串在磁盘上的保存形式也是01的组合，也需要编码解码。
如果，上面的阐述还不能让你搞清楚两者的区别，那么记住下面两几句话：
在将字符串存入磁盘和从磁盘读取字符串的过程中，Python自动地帮你完成了编码和解码的工作，你不需要关心它的过程。
使用
bytes类型，实质上是告诉Python，不需要它帮你自动地完成编码和解码的工作，而是用户自己手动进行，并指定编码格式。Python已经严格区分了
bytes和str两种数据类型，你不能在需要bytes类型参数的时候使用str参数，反之亦然。这点在读写磁盘文件时容易碰到。
在bytes和str的互相转换过程中，实际就是编码解码的过程，必须显式地指定编码格式。
#Author Jame-Mei msg1='我爱中国'
print (msg1) print ("\n将str转换成bytes编码：")
print (msg1.encode(encoding='utf-8'))
#python3默认为utf-8，python2.x如果没有utf-8会报错！！ print ('\n将bytes转换成str：')
print(b'\xe6\x88\x91\xe7\x88\xb1\xe4\xb8\xad\xe5\x9b\xbd'.decode(encoding='utf-8'))
(4).为何要bytes和str相互转换呢？
涉及python网络编程，将str字符串类型转换成bytes类型进行通信和传输。
四.列表1-2的使用
1.常见方法(增删改查)
#Author Jame-Mei list=[] '''增
list.append('a') #在末尾添加一个元素
list.insert(1,'b') #在1号位置添加b元素
list.insert(2,[1,2,3]) #向list列表的2号位置中添加一个列表 ''' '''删
list.remove('a') #删除指定值a
list.pop() #删除末尾一个元素
del list[1] #删除list列表中1号索引的元素
del list #删除List变量
list.clear() #清空List内的值
''' '''改
list2=['e','d','c']
list.extend(list2) #扩展List，扩展后List变大，list2不变
list.sort() #排序，特殊符号>>数字>>大写字母>小写字母
list.reverse() #反转,需要再次调用才能恢复原样
''' '''查
列表循环 for x in list: print(x)
print(list.index('e')) #查e元素第一次出现的索引位置
print (len(list)) #查list列表的长度
print (len(list2))
print (list[-3:]) #切片倒数三个元素
print (list[0]) #切片第一个元素
print (list[-1]) #切片最后一个元素
print (list[:]) #切片所有元素
print (list[1:6]) #顾头不顾尾(不包括6号元素)
'''
2.其他使用方法：
1):浅copy:
#Author Jame-Mei names1=['jame','tom','alice']
names2=names1.copy()
其他浅copy的表示方法:
list1=[1,2,['a',3,4]] #另外三种表示方法
#p2=copy.copy(list1)
#p2=list1[:]
#p2=list(list1) list1[2][0]='b'
print (list1,p2) #修改names1的tom
names1[1]='汤姆' #打印发现names1改变了，Names2没有改变，这是正常状态的copy.
print ('names1列表:',names1)
print ('names2列表:',names2)
>names1列表: ['jame', '汤姆', 'alice']
>names2列表: ['jame', 'tom', 'alice'] #向names1中添加一个列表
names1.insert(3,['alex','oldboy'])
names2=names1.copy() #再次修改Names1列表的值
names1[3][0]='ALEX' #打印出来发现，names1列表和names2列表都同时改变了，ALEX。这叫浅copy，只copy列表的第一层，第二层为一个内存位置。
print ('names1列表:',names1)
print ('names2列表:',names2)
>names1列表: ['jame', '汤姆', 'alice', ['ALEX', 'oldboy']]
>ames2列表: ['jame', '汤姆', 'alice', ['ALEX', 'oldboy']] 如果直接用"="等于号呢：
#names2=names1 等于将names1的内存地址同样赋值给names2，改动其中的任何一个列表的任何一个值，两个列表同时变。 #如果names1和names2只是为简单的数字、字符串，则不会发生这样的改变,可以动手试一试！
浅copy的假设用途:关联账号的资金，主卡名字叫Jame,子卡名字叫Tom，里面的资金无论是主卡取钱还是存钱，或者是子卡取钱，两个都会同步。
2).深copy
import copy
names2=copy().deepcopy(names1) #深copy
names1[3][0]='ALEX' #修改names1列表中3号列表中的0号元素值
print ('names1列表:',names1)
print ('names2列表:',names2)
names1列表: ['jame', '汤姆', 'alice', ['ALEX', 'oldboy']]
names2列表: ['jame', '汤姆', 'alice', ['alex', 'oldboy']]
#发现names2没有改变，只有修改的names1发生改变了。所以names2列表深度完全的copy了names1的列表值，在内存中重新开辟了存放空间，不会因为names1列表而改变!
3):列表循环和列表步长
#列表循环
print ("=========循环=======================>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>") for name in names1:
print (name) #列表的按步长切片
print (names1[0:-1:2])
#简化为
print (names1[::2]) 输出:
jame
汤姆
alice
['alex', 'oldboy']
pycharm
aux #按照步长输出 ['jame', 'alice', 'pycharm']
['jame', 'alice', 'pycharm']
五.元组
元组是一种特殊的列表，一旦创建不可以修改，所以元组又叫做只读列表!
(1.)创建
name=('tom','男',340321198908251345)
(2).查找，切片方法与列表一致。
(3).count方法，index方法
#Author Jame-Mei
name=('Jame','男',340321)
print (name.index('Jame')) #查找第一个jame的位置
print (name.count('男')) #统计name元组中的男有几个
（4）.购物车练习:
练习代码如下:
#Author Jame-Mei
"""购物车练习:
需求：
1.启动程序后，让用户输入工资，然后打印商品列表
2.运行用户根据商品编号购买商品
3.用户选择商品后，检测余额是否足够，足够就直接扣款，不够提示
4.可以随时退出，退出时，打印已经购买的商品和余额
"""
goods=[['牛奶',45],['咖啡',37],['鸡蛋',58],['大米',88],['花生油',189],['面条',60],['鸡脯肉',40],['排骨',99],['牛肉',135],['烤鸭',49]]
money=0
flag=True
buygoods=[]
money =input('请输入您的工资(数字):')
if money.isdigit():
money=int(money)
while flag:
print("<<<<<<============商品列表:===============>>>>>>")
for index,good in enumerate(goods):
#print(goods.index(good), good)
print (index,good)
buynum=input("---------->>请输入要购买的商品编号(q 退出):")
if buynum=='q':
print('您已经购买的商品:', buygoods, '余额：', money)
exit()
elif buynum.isdigit():
buynum=int(buynum)
if buynum < len(goods) and buynum >= 0:
if goods[buynum][1] >money:
print ('余额',money,"不足以购买",goods[buynum][0],'请选择其他商品!')
continue
else:
money=money-goods[int(buynum)][1]
buygoods.append(goods[int(buynum)])
print ("购买",goods[int(buynum)],"成功！")
else:
print ("该商品编号不存在...")
flag=False
else:
print ('输入未知符号...')
exit(1)
else:
print ('您输入的不是数字，exit...')
exit()
六.字符串常见操作
常见方法见操作代码：
#Author:Jame Mei
name='my name is {_name} and age is {_age} old.'
hello='您好,\twelcome to shanghai，welcome to welcome'
varchars='meijinmeng@126.com' '''c开头的方法
print(name.capitalize()) #首字母
print (name.count('a')) #统计'字符'的个数
print (name.center(20,'+')) #打印50个字符，不够用'+'填补，并把name居中。 输出:
My name is {_name} and age is {_age} old.
5
++++my name is {_name} and age is {_age} old.+++++
''' '''
#e开头的方法
print (hello.encode()) #将str字符串转换成bytes字节码类型
print (varchars.endswith('.com')) #判断varchars是否以'.com'结尾
print (hello.expandtabs(tabsize=20)) #给\t键转换成20个空格 输出:
b'\xe6\x82\xa8\xe5\xa5\xbd,\twelcome to shanghai\xef\xbc\x8cwelcome to welcome'
True
您好, welcome to shanghai，welcome to welcome '''
#f开头的方法
print (hello.find('welcome')) #查找welcome的索引位置，其中\t也占一个位置。
print (name.format(_name='alice',_age=27)) #格式化输出字符串，常用！
print (name.format_map({'_name':'Tom','_age':26})) #format_map里面放的是一个字典(键值对) 输出:
4
my name is alice and age is 27 old.
my name is Tom and age is 26 old. '''
#i开头
print (name.index('name')) #查找'name'所在字符串索引位置，常用!!
print ('123'.isdigit()) #检查是否为数字，常用!!!
print ('Abc'.islower()) #判断是否为小写,常用！
print ('abc'.isupper()) #判断是否为大写，常用
print ('My Name Is Tom'.istitle()) #判断字符串中开头是否为大写！ 输出:
3
True
False
False
True print ('abc123'.isalnum()) #是否是阿拉伯字符(所有英文字母和数字)
print ('_1abc'.isidentifier()) #检查是否为合法的变量名,不能以数字和其他特殊符号开头则为false！ 输出:
True
True print ('ab c'.isalnum()) #有空格或者特殊符号，就为False
print ('abcdef'.isalpha()) #检车是否所有都为英文字母 print ('123'.isdecimal()) #检查是否为整数，带小数点为False
print('123'.isnumeric()) #判断是否为纯整数，带小数点为False,和isdecimal()功能差不多。 print (' '.isspace()) #判断是否是一个空格
print ('abc'.isprintable())#linux终端tty文件或者driver驱动文件不可打印的，返回 False，普通文件都可以打印。 输出:
False
True
True
True
True
True '' '''
#j开头方法
print ('+'.join('abc')) #连接字符串或者列表的每个元素
print ('-'.join(['a','b','c'])) 输出:
a+b+c
a-b-c ''' '''
#m开头的方法(不常用)
p=str.maketrans('jamepwd','')
print ('jane'.translate(p)) #根据p的编码规则，来加密jane 输出:
12n4
''' '''
#l开头的方法
print ('my name is tom'.ljust(50,'*')) #打印50个字符，不够字符串向左移动，*号在右边填充。
print ('my age is 26'.rjust(50,'+')) #打印50给字符，不够字符串向右移动，+号左边填充。 print ('XIAOXIE'.lower()) #把大写边小写
print ('daxie'.upper()) #把小写变大写 print (' abc'.lstrip()) #去掉左边的空格,换行，制表\t等
print ('ghy\n'.rstrip()) #去掉右边的空格,换行，制表\t等
print ('\tcedf\n'.strip()) #去首尾空格 输出: my name is tom************************************
++++++++++++++++++++++++++++++++++++++my age is 26 xiaoxie
DAXIE abc
ghy
cedf ''' '''
#r开头的方法
print (hello.replace('welcome','hello')) #将hello变量中的全部welcome替换成hello
print (hello.replace('welcome','hello',1)) #将hello变量中的welcome替换1一个hello
print ('nihao xiaoming'.rfind('hao')) #从左往右查找元素的位置号
#print ('ghy\n'.rstrip()) #去掉右边的空格,换行，制表\t等
#print ('my age is 26'.rjust(50,'+')) 输出：
您好, hello to shanghai，hello to hello
您好, hello to shanghai，welcome to welcome
2 ''' '''
#s开头的方法
print ('nihao,xiaoming'.split(',')) #以','逗号为分隔符将字符串,分割成一个列表。
print ('1+2\n3+4\n5+6'.splitlines()) #识别不同系统的换行，分割成列表。
print ('Alice'.swapcase()) #除首字母外，其他的都大写! 输出：
['nihao', 'xiaoming']
['1+2', '3+4', '5+6']
aLICE ''' '''
#t开头的方法
print ('alice is a girl!'.title()) #每行 输出:
Alice Is A Girl! '''
七.字典的使用
字典是一种key-value的数据类型，有点像我们用过的字典，通过笔画、字母来查找需要的词语或者单词。
1.字典的语法：
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
dic={'id':110,
'sid':14567,
'name':'防盗门'
}
2.字典的特性：
1).字典是无序的，所以字典没有下标，不会像列表和元祖一样通过下标来查找或者删除元素。
另外它的无序还体现在，遍历或者打印出来，它的排序可能是会变化，没有固定的顺序!!
通过dic['key01']来进行取值。
2):键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
所以，不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住。
键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行。
3.字典的增删改查和多层嵌套操作
1):增删改查操作:
#Author:Jame Mei
dic1={
'stu1101':'caiyuanhua',
'stu01':'Alex',
'stu02':'Oldboy',
} '''增加,修改字典的value值：
dic1['stu120']='Canglaoshi' #如果stu120键不存在，则创建并新增到字典中。 dic1['stu02']='alex' #stu02已存在，则其值修改 print (dic1)
输出：
{'stu1101': 'caiyuanhua', 'stu01': 'Alex', 'stu02': 'Oldboy'}
{'stu1101': 'caiyuanhua', 'stu01': 'Alex', 'stu02': 'alex', 'stu120': 'Canglaoshi'} '''#查看字典的value的值: print (dic1['stu120']) #要确定字典中有'stu120及其对应的值'
print (dic1.get('stu121')) #如果没有stu121,不会报错，打印返回一个None，一般安全的获取用该方法。 输出:
Canglaoshi
None #查看某字符是否包含在字典中
print (dic1)
print ('stu120' in dic1) #在py2.x中是dic1.has_key('stu120') 输出:
{'stu1101': 'caiyuanhua', 'stu01': 'Alex', 'stu02': 'alex', 'stu120': 'Canglaoshi'}
True '''#删除
del dic1['stu1101'] #删除指定的key-value !! dic1.pop('stu120') #不同于列表删除末尾的，字典需要指定key来删除!
dic1.popitem() #随机删除，意义不大，不能轻易使用。 #del dic1 #删除后，再print会报错，连整个变量都删除了! '''
2):多层嵌套操作:
#Author:Jame Mei
#多层嵌套操作
citys={
"上海":{
"长宁区":['中山公园','愚园路'],
"普陀区":['金山江'],
"松江区":['松江大学城'] },
"杭州":{
"西湖区":['西湖'],
"上城区":['杭州火车站']
},
"南京":{
"玄武区":['玄武湖'],
"鼓楼区":['鼓楼医院']
} } #Add:
citys['上海']['长宁区'][0] +='免费开放，鲜花盛开绿草如茵'
print (citys['上海']['长宁区']) output:
['中山公园免费开放，鲜花盛开绿草如茵', '愚园路'] #update
dic2={'stu01':'tomcat','stu02':'nginx'}
a={1:2}
dic2.update(a)
print (dic2) output:
{'stu01': 'tomcat', 'stu02': 'nginx', 1: 2} #items
dic2={'stu01':'tomcat','stu02':'nginx'}
print(dic2.items()) output:
dict_items([('stu01', 'tomcat'), ('stu02', 'nginx')]) #通过一个列表生成默认dict,有个没办法解释的坑，少用吧这个
print(dict.fromkeys([1,2,3],'testd')) output:
{1: 'testd', 2: 'testd', 3: 'testd'} #循环输出字典
#方法1:
for key in dic2:
print(key,dic2[key]) output:
stu01 tomcat
stu02 nginx #方法2:
for key,value in dic2.items():
print(key,value) output:
stu01 tomcat
stu02 nginx #key 打印字典中所有key值
print (citys.keys()) output:
dict_keys(['上海', '杭州', '南京']) #value 打印字典所有value
print (citys.values()) output:
dict_values([{'长宁区': ['中山公园免费开放，鲜花盛开绿草如茵', '愚园路'], '普陀区': ['金山江'], '松江区': ['松江大学城']}, {'西湖区': ['西湖'], '上城区': ['杭州火车站']}, {'玄武区': ['玄武湖'], '鼓楼区': ['鼓楼医院']}])
{'上海': {'长宁区': ['中山公园免费开放，鲜花盛开绿草如茵', '愚园路'], '普陀区': ['金山江'], '松江区': ['松江大学城']}, '杭州': {'西湖区': ['西湖'], '上城区': ['杭州火车站']}, '南京': {'玄武区': ['玄武湖'], '鼓楼区': ['鼓楼医院']}, '昆山': ['华东地区工业基地', '上海11号线花桥接轨']} #setdefault默认在末尾添加一个字典及其列表
citys.setdefault("昆山",{"花桥":["花桥地铁站"],"千灯镇":["千灯碧桂园"]})
citys.setdefault("无锡",{"华西村":["中国第一村"],"三国影视基地":"拍戏的地方"})
for x,y in citys.items():
print (x,y) output:
上海 {'长宁区': ['中山公园免费开放，鲜花盛开绿草如茵', '愚园路'], '普陀区': ['金山江'], '松江区': ['松江大学城']}
杭州 {'西湖区': ['西湖'], '上城区': ['杭州火车站']}
南京 {'玄武区': ['玄武湖'], '鼓楼区': ['鼓楼医院']}
昆山 {'花桥': ['花桥地铁站'], '千灯镇': ['千灯碧桂园']}
无锡 {'华西村': ['中国第一村'], '三国影视基地': '拍戏的地方'}
4.练习：三级菜单
1):入门简陋版：
#Author:Jame Mei
#实现三级菜单的练习
citys={
"上海":{
"长宁区":{
"中山公园":{'中山公园','龙之梦购物中心'},
"愚园路":{'优秀历史建筑','愚园路第一小学'}
},
"松江区":{
"松江大学城":{'大学城美女如云'},
"佘山":{'佘山度假区','水上公园'}
}
},
"杭州":{
"西湖区":{
"西湖":{'杭州西湖','雷峰塔'},
"太子湾":{'龙船'}
},
"上城区":{
"清河坊":{'中华老字号第一街'},
"钱学森故居":{'杭州之子'}
} },
"南京":{
"玄武区":{
"总统府":{'孙中山总统府'},
"玄武湖":{'玄武湖及公园'}, },
"鼓楼区":{
"鼓楼公园":{'鼓楼医院和鼓楼公园'},
"南京长江大桥":{'宏伟的南京长江大桥耸立'} }
} } while True:
for x1 in citys:
print (x1) choice1=input("请选择进入1级菜单>>>>>>>:")
if choice1 in citys:
while True:
for x2 in citys[choice1]:
print ('\t',x2) choice2=input("请选择进入2级菜单,b返回上一层>>>>>>:")
if choice2 in citys[choice1]:
while True:
for x3 in citys[choice1][choice2]:
print ('\t',x3) choice3=input("请选择进入3级菜单,b返回上一层>>>>>>>>:")
if choice3 in citys[choice1][choice2]:
for x4 in citys[choice1][choice2][choice3]:
print ('\t',x4) choice4=input("最后一层，按b返回上一层!>>>:")
if choice3=='b':
pass if choice3=='b':
break if choice2=='b':
break else:
print ("已经是最上层，请输入菜单中的名称!")
2):入门简陋+退出版
#Author:Jame Mei
#实现三级菜单的练习
citys={
"上海":{
"长宁区":{
"中山公园":{'中山公园','龙之梦购物中心'},
"愚园路":{'优秀历史建筑','愚园路第一小学'}
},
"松江区":{
"松江大学城":{'大学城美女如云'},
"佘山":{'佘山度假区','水上公园'}
}
},
"杭州":{
"西湖区":{
"西湖":{'杭州西湖','雷峰塔'},
"太子湾":{'龙船'}
},
"上城区":{
"清河坊":{'中华老字号第一街'},
"钱学森故居":{'杭州之子'}
} },
"南京":{
"玄武区":{
"总统府":{'孙中山总统府'},
"玄武湖":{'玄武湖及公园'}, },
"鼓楼区":{
"鼓楼公园":{'鼓楼医院和鼓楼公园'},
"南京长江大桥":{'宏伟的南京长江大桥耸立'} }
} } exit_flag=False while not exit_flag:
for x1 in citys:
print (x1) choice1=input("请选择进入1级菜单>>>>>>>:")
if choice1 in citys:
while not exit_flag:
for x2 in citys[choice1]:
print ('\t',x2) choice2=input("请选择进入2级菜单,b返回上一层>>>>>>:")
if choice2 in citys[choice1]:
while not exit_flag:
for x3 in citys[choice1][choice2]:
print ('\t',x3) choice3=input("请选择进入3级菜单,b返回上一层>>>>>>>>:")
if choice3 in citys[choice1][choice2]:
for x4 in citys[choice1][choice2][choice3]:
print ('\t',x4) choice4=input("最后一层，按b返回上一层!>>>:")
if choice4=='b':
pass
elif choice4=='q':
exit_flag=True if choice3=='b':
break
elif choice3=='q':
exit_flag =True
if choice2=='b':
break
elif choice2=='q':
exit_flag =True elif choice1=='q':
exit_flag=True else:
print ("已经是最上层，请输入菜单中的名称!")
照葫芦画瓢，在每个for循环都有一个while无限循环也可以实现b上一层，q退出的效果：
#Author:Jame Mei
#自己练习三级菜单,实现随时退出，输入b返回上一层，根据输入的名称，打印它的下一级菜单。 menus={
"上海":{
"长宁区":{
"中山公园":{'中山公园','龙之梦购物中心'},
"愚园路":{'优秀历史建筑','愚园路第一小学'}
},
"松江区":{
"松江大学城":{'大学城美女如云'},
"佘山":{'佘山度假区','水上公园'}
}
},
"杭州":{
"西湖区":{
"西湖":{'杭州西湖','雷峰塔'},
"太子湾":{'龙船'}
},
"上城区":{
"清河坊":{'中华老字号第一街'},
"钱学森故居":{'杭州之子'}
} },
"南京":{
"玄武区":{
"总统府":{'孙中山总统府'},
"玄武湖":{'玄武湖及公园'}, },
"鼓楼区":{
"鼓楼公园":{'鼓楼医院和鼓楼公园'},
"南京长江大桥":{'宏伟的南京长江大桥耸立'} }
} } not_exit=True while not_exit:
for m1 in menus:
print (m1)
choice1=input("请输入列表名称(q 退出)>>>>>>:")
if choice1 in menus:
while not_exit:
for m2 in menus[choice1]:
print (m2) choice2=input("请输入列表名称(q 退出 b返回上一层))>>>>>>:")
if choice2 in menus[choice1]:
while not_exit:
for m3 in menus[choice1][choice2]:
print (m3) choice3=input("请输入列表名称(q 退出 b返回上一层)>>>>>>:")
if choice3 in menus[choice1][choice2]:
while not_exit:
for m4 in menus[choice1][choice2][choice3]:
print (m4) choice4=input("已经到底啦,(q 退出 b返回上一层)>>>>>>:")
if choice4=='q':
not_exit=False
elif choice4=='b':
break elif choice3=='q':
not_exit=False
elif choice3 == 'b':
break elif choice2=='q':
not_exit=False
elif choice2 == 'b':
break elif choice1=='q':
not_exit=False
else:
print ("已经是顶层菜单了，请输入菜单中的名称(q 退出)>>>>>>:")
3):Alex版本,没有退出功能，b 返回次数过多会报错，希望有大神解答留言！
#Author Jame-Mei
'''
程序: 三级菜单
要求:
打印省、市、县三级菜单
b 可返回上一级
q 可随时退出程序''' menu = {
'北京':{
'海淀':{
'五道口':{
'soho':{},
'网易':{},
'google':{}
},
'中关村':{
'爱奇艺':{},
'汽车之家':{},
'youku':{},
},
'上地':{
'百度':{},
},
},
'昌平':{
'沙河':{
'老男孩':{},
'北航':{},
},
'天通苑':{},
'回龙观':{},
},
'朝阳':{},
'东城':{},
},
'上海':{
'闵行':{
"人民广场":{
'炸鸡店':{}
}
},
'闸北':{
'火车战':{
'携程':{}
}
},
'浦东':{},
},
'山东':{},
} exit_flag = False
current_layer = menu layers = [menu] while not exit_flag:
for k in current_layer:
print(k)
choice = input(">>:").strip()
if choice == "b":
current_layer = layers[-1]
print("change to laster", current_layer)
layers.pop() elif choice not in current_layer:
continue
else:
layers.append(current_layer)
current_layer = current_layer[choice]
八.作业:购物车优化
1.未把商品信息存入文件版，其他功能都已实现:
#Author: http://www.cnblogs.com/Jame-mei
'''
week02的购物车优化：
分为用户入口1 和 商家入口2：
模块需求:
启动后提示用户和商家，输入并判断属于用户还是商家。 1.用户入口:{1.商品信息存到文件里？？ 2.退出的时候打印已购商品和余额}
模块需求：
1.启动程序后，让用户输入工资，然后打印商品列表
2.运行用户根据商品名称购买商品
3.用户选择商品后，检测余额是否足够，足够就直接扣款，不够提示
4.可以随时退出，退出时，打印已经购买的商品和余额 2.商家入口:{1.可以添加商品 2.修改商品价格}
模块需求:
1.进入商家入口后，有2个选项:添加商品(添加新商品:商品名称，价格)，修改商品价格(修改已经存在的商品，输入对应商品名称，并修改价格)
2.退出q
''' #1.用户模块编写
goods={'牛奶':45,'咖啡':37,'鸡蛋':58,'大米':88,'花生油':189,'面条':60,'鸡脯肉':40,'排骨':99,'牛肉':135,'烤鸭':46}
money=0
flag=True
buygoods=[] while flag:
select=input("欢迎您访问员工福利商城 1.用户 2商家(q 退出):")
if select.isdigit():
select=int(select)
if select==1:
money = input('请输入您的工资(数字):')
if money.isdigit():
money = int(money)
while flag:
print("<<<<<<============商品列表:===============>>>>>>")
for index, good in enumerate(goods):
# print(goods.index(good), good)
print(index, good)
buyname = input("---------->>请输入要购买的商品名称(q 退出):")
if buyname == 'q':
print('您已经购买的商品:', buygoods, '余额：', money)
exit(0)
elif buyname in goods.keys(): if goods[buyname] > money:
print('余额', money, "不足以购买", buyname, '请选择其他商品!')
continue
else:
money = money - goods[buyname]
buygoods.append(buyname)
print("购买", buyname, "成功！",' 余额：',money)
else:
print("该商品不存在...")
flag = False else:
print('您输入的不是数字，exit...')
exit(0) elif select==2:
# 商家模块
business_flag = True
while business_flag:
mod = input("1.添加商品 2.修改商品价格(q 退出)>>>>")
if mod.isdigit():
mod = int(mod)
if mod == 1:
good = input("请输入添加的商品名称:")
price = input("请输入添加商品的价格:")
if good in goods.keys():
print("商品已经存在，请勿重复添加!")
else:
goods.update({good:price})
print("添加商品成功!") else:
good = input("请输入商品名称:")
price = input("请输入商品的价格:")
if good in goods.keys():
goods.update({good: price})
else:
print("你要修改的商品不存在！") elif mod == 'q':
exit(0)
else:
print("请输入数字1或者2,q退出") elif select =='q':
exit(0) else:
print("请输入指定的编号或内容 1.用户 2.商家(q 退出):")
continue #尚未做完，未把商品信息存入文件中，后期继续改造！
2.添加打印用户的购买东西的清单(商品名,数量,花费金额)，商品库存数量，商家的(查看商品列表，下架商品)。
#Author: http://www.cnblogs.com/Jame-mei
'''
week02的购物车优化：
分为用户入口1 和 商家入口2：
模块需求:
启动后提示用户和商家，输入并判断属于用户还是商家。 1.用户入口:{1.商品信息存到文件里？？ 2.退出的时候打印已购商品和余额}
模块需求：
1.启动程序后，让用户输入工资，然后打印商品列表
2.运行用户根据商品名称购买商品
3.用户选择商品后，检测余额是否足够，足够就直接扣款，不够提示
4.可以随时退出，退出时，打印已经购买的商品(名称、价格、数量)和余额(花费金额) 2.商家入口:{1.可以添加商品 2.修改商品价格}
模块需求:
1.进入商家入口后，有2个选项:添加商品(添加新商品:商品名称，价格)，修改商品价格(修改已经存在的商品，输入对应商品名称，并修改价格)
2.退出q
3.查看商品列表
4.下架商品
''' #1.用户模块编写
goods={
'iphone7':{'单价':4999,'库存':2},
'iphone8':{'单价':5999,'库存':3},
'iphonex':{'单价':7999,'库存':4},
'MacbookPro':{'单价':12999,'库存':1},
'Thinkpad':{'单价':7999,'库存':2},
'Dell':{'单价':4999,'库存':5},
'电冰箱':{'单价':2999,'库存':9},
'洗衣机':{'单价':2888,'库存':2},
} money=0
flag=True
buygoods={} while flag:
select=input("欢迎您访问员工福利商城 1.用户 2商家(q 退出):")
if select.isdigit():
select=int(select)
if select==1:
money= input('请输入您的工资(数字):')
if money.isdigit():
money=int(money)
sum=money
buynum = 0
while flag:
print("<<<<<<============商品列表:===============>>>>>>")
for good,goodprice in goods.items():
print('商品名:',good,'单价:',goodprice['单价'],'库存:',goodprice['库存'])
buyname = input("---------->>请输入要购买的商品名称(q 退出):").strip() if buyname == 'q':
print('>>>>>>请查看您的购物清单>>>>>>>:')
for key,value in buygoods.items():
print ('购买商品:',key,value)
print ('您共消费:',(sum-money),'元','余额为:',money)
print ('谢谢您的光临，请下次再来！') exit(0)
elif buyname in goods.keys(): if goods[buyname]['单价'] > money:
print('您的余额为:', money, "不足以购买", buyname, '请选购其他商品!')
continue
else:
if goods[buyname]['库存']>0:
buynum+=1
money= money - goods[buyname]['单价'] buygoods.update({buyname:{'单价':goods[buyname]['单价'],'数量':buynum}})
goods[buyname]['库存'] = goods[buyname]['库存'] - 1
print("购买", buyname, "成功！",' 余额：',money) else:
print ('该商品已经被抢购一空，请购买其他商品吧....')
continue
else:
print("您输入的该商品名称不存在,请确认后重新输入...")
continue else:
print('您输入的不是数字，exit...')
exit(0) elif select==2:
# 商家模块
business_flag = True
while business_flag:
mod = input("1.添加商品 2.修改商品价格 3.查看现有商品列表 4.下架商品 (q 退出)>>>>")
if mod.isdigit():
mod = int(mod)
if mod == 1:
good = input("请输入添加的商品名称:").strip()
if good in goods.keys():
print("商品已经存在，请勿重复添加!")
else:
price = input("请输入添加商品的价格:")
goodnum = input("请输入添加商品的库存:")
goods.update({good:{'单价':price,'库存':goodnum}})
print("添加商品成功!") elif mod==2:
good = input("请输入商品名称:").strip()
price = input("请输入商品的价格:")
if good in goods.keys():
goods.update({goods,{'单价':price}})
else:
print("你要修改的商品不存在,请确认后重新输入！") elif mod==3:
print("<<<<<<============商品列表:===============>>>>>>")
for good, goodprice in goods.items():
# print(goods.index(good), good)
print('商品名:', good, '单价:', goodprice['单价'], '库存:', goodprice['库存']) elif mod==4:
good = input("请输入商品名称:").strip()
del goods[good] elif mod == 'q':
exit(0)
else:
print("请输入数字1,2,3,4, q退出") elif select =='q':
exit(0) else:
print("请输入指定的编号或内容 1.用户 2.商家(q 退出):")
continue #尚未做完，未把商品信息存入文件中，后期继续改造！
3.添加功能把商品信息存入文件(操作file,def 函数分模块版本,ps抄的)
#Author:http://www.cnblogs.com/Jame-mei
'''week02的购物车优化：
分为用户入口1 和 商家入口2：
模块需求:
启动后提示用户和商家，输入并判断属于用户还是商家。 1.用户入口:{1.商品信息存到文件里？？ 2.退出的时候打印已购商品和余额}
模块需求：
1.启动程序后，让用户输入工资，然后打印商品列表
2.运行用户根据商品名称购买商品
3.用户选择商品后，检测余额是否足够，足够就直接扣款，不够提示
4.可以随时退出，退出时，打印已经购买的商品和余额 2.商家入口:{1.可以添加商品 2.修改商品价格}
模块需求:
1.进入商家入口后，有2个选项:添加商品(添加新商品:商品名称，价格)，修改商品价格(修改已经存在的商品，输入对应商品名称，并修改价格)
2.退出q
''' product_list = [
('Iphone',5288),
('Mac pro',12000),
('Bike',800),
('Watch',36000),
('Coffe',39),
('Python book',120),
] #将商品信息打印到console窗口下
def print_write_product():
print_list()
# 将商品信息写入product.txt文件
f = open("product.txt", 'w')
f.write(str(product_list) + "\n")
f.close() #用户输入自己的薪水
def choose_product():
salary = input("Please input your salary :")
if salary.isdigit():
salary = int(salary)
#用户选择要购买的商品
shopping_list = []
while True:
user_choice = input('Please input your wanna product number(q 退出):')
if user_choice.isdigit():
user_choice = int(user_choice)
if user_choice >=0 and user_choice <= len(product_list):
p_item = product_list[user_choice]
if salary >= p_item[1]:
shopping_list.append(p_item)
salary -= p_item[1]
print("Added %s into shopping cart,your current balance is %s " % (p_item, salary))
else:
print('Your salary is not enough !Your balabce only [%s] !'%salary)
else:
print("Product code [%s] is not exist !" % user_choice)
elif user_choice =='q':
f = open("shopping_record.txt", 'w')
print('--------------shopping_list---------------')
for p in shopping_list: # python 中直接使用的变量初始化的 就是0，不用定义再使用
print(p)
f.write(str(p) + "\n")
f.write(str(salary) + "\n")
print('Your balance :', salary)
f.close()
print('exit....')
exit()
else:
print('Invalide choice ') #专门给商家提供的入口：
#增加货物
def add_product(tuple):
product_list.append(tuple)
print_list() #修改价格
def modify_price(i):
print('Input the changed product and price:')
product_list[i] = input(tuple)
print_list() #请用户输入自己是商家还是用户
def identity():
i = input('business商家 输入：b | client用户 输入：c | other其他 退出 ： ''\n')
return i #商家可执行菜单选项
def select_service():
i = input('adding goods--------------------------> a:''\n'
'change the price of the product-------> c:''\n')
return i def print_list():
for index, item in enumerate(product_list): #enumerate 能把下标取出来
print(index, item) # 主函数 i = identity()
if i == 'b':
j = select_service()
if j == 'a':
print_list()
a = input('Input adding product and price:')
add_product(a)
f = open("c_product.txt", 'w')
f.write(str(product_list) + "\n")
f.close()
elif j == 'c':
print_list()
c = int(input('Input what you wanna changed number:'))
modify_price(c)
f = open("c_product.txt", 'w')
f.write(str(product_list) + "\n")
f.close()
elif i == 'c':
print_write_product()
choose_product()
else:
print('Invalied input !')
最新文章
- 《Django By Example》第一章 中文 翻译 （个人学习，渣翻）
- highcharts的简单使用
- 黄聪：NaviCat通过Http方式连接服务器的MySQL数据库（转）
- 【推介】TMS的控件之“TMS Unicode Component Pack”和“TMS Advanced Toolbars & Menus”
- 数往知来 SQL SERVER 基本语法<七>
- Android环境搭建的步骤
- AVL树的python实现
- android小文章——手机照片上传服务器方法
- ASP.NET MVC+EF框架+EasyUI实现权限管理系列(3)-面向接口的编程
- iOS应用 跳转到系统的设置界面
- Project 4:Longest Ordered Subsequence
- 理解性能的奥秘——应用程序中慢，SSMS中快（6）——SQL Server如何编译动态SQL
- 带着新人学springboot的应用11（springboot+Dubbo+Zookeeper 上）
- scrapy pipelines导出各种格式
- 分布式服务管理框架 ZooKeeper
- IBM X 3650 M3服务器RAID0设置
- c# 数据结构 ArrayList
- Redis高可用详解：持久化技术及方案选择
- django 同步数据库出现 No changes detected 的可能原因
- ng-table