Python基础-week02 Python的常用数据类型
一.模块初识
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 !')
Python基础-week02 Python的常用数据类型的更多相关文章
- python基础语法（变量与数据类型）
python基础语法(变量与数据类型) 一.python变量 python中的变量不需要声明.每个变量在使用钱都需要赋值,变量赋值以后,该变量才会被创建 在python中,变量就是变量,它没有类型,我 ...
- 二十一. Python基础(21)--Python基础(21)
二十一. Python基础(21)--Python基础(21) 1 ● 类的命名空间 #对于类的静态属性: #类.属性: 调用的就是类中的属性 #对象.属性: 先从自己的内存空间里找名 ...
- Python基础篇(二)_基本数据类型
Python基础篇——基本数据类型 数字类型:整数类型.浮点数类型.复数类型 整数类型:4种进制表示形式:十进制.二进制.八进制.十六进制,默认采用十进制,其他进制需要增加引导符号 进制种类 引导符号 ...
- Day1 Python基础学习——概述、基本数据类型、流程控制
一.Python基础学习 一.编程语言分类 1.简介 机器语言:站在计算机的角度,说计算机能听懂的语言,那就是直接用二进制编程,直接操作硬件 汇编语言:站在计算机的角度,简写的英文标识符取代二进制去编 ...
- python基础（一）—— 核心数据类型
Hello World程序 [root@mysql ~]# python3 Python 3.6.5 (default, Jul 8 2018, 11:41:23) [GCC 4.4.7 20120 ...
- Python基础(二)：操作基本数据类型
Python是一门解释型语言,它的优势在于代码简洁,易于理解,可以通过大量已封装好的内建方法和第三方模块方法完成日常所需的操作. 字符串 索引 起始下标为0 (从前往后数),末尾下标为-1(从后往前数 ...
- Python基础篇(四)_组合数据类型的基本概念
Python基础篇——组合数据类型的基本概念 集合类型:元素的集合,元素之间无序 序列类型:是一个元素向量,元素之间存在先后关系,通过序号进行访问,没有排他性,具体包括字符串类型.元组类型.列表类型 ...
- 5000字2021最新Python基础知识第一阶段：数据类型
1 编程规范 注释 python注释也有自己的规范,在文章中会介绍到.注释可以起到一个备注的作用,团队合作的时候,个人编写的代码经常会被多人调用,为了让别人能更容易理解代码的通途,使用注释是非常有效的 ...
- python基础学习（一）--数据类型
Python一个 高级语言 2017-09-19 1.1 Python背景简介(感谢伟大的廖雪峰大佬带我们走上一条光头路,嘿嘿) 写了大半年Python代码,感觉收获不是很大,都是现学现卖,没有系统 ...
随机推荐
- GBase数据库存储过程——批量查询多个数据表的磁盘占用情况
--清理历史表,可选 DROP TABLE IF EXISTS `dap_model`.`data_statics`; CREATE TABLE `dba`.`data_statics` ( `TAB ...
- maven+jenkins发布环境
安装java省略,下面是环境变量 export JAVA_HOME=/usr/java/jdk1.8.0_65/ export PATH=$JAVA_HOME/bin:$PATH export CLA ...
- AppSettings和ConnectionStrings的辨析
1.<connectionStrings> <connectionStrings> <add name="ConnectionStringName" ...
- SQL 使用触发器常见错误
今天做代码审查时,看见以下一段触发器的创建脚本,我们一起来分析一下 create trigger [trigger_puClassRoomType] on [dbo].[puClassRoomType ...
- pat甲级1020中序后序求层序
1020 Tree Traversals (25)(25 分) Suppose that all the keys in a binary tree are distinct positive int ...
- java Vamei快速教程17 多线程
作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明.谢谢! 多线程 多线程(multiple thread)是计算机实现多任务并行处理的一种方 ...
- 2018.6.1 oracle数据库乱码问题
执行select * from v$controlfile;为什么结果是未选定行? 显示连接了但是select * from dba_data_files; 显示中文乱码: shutdown star ...
- iOS 中push和pop到底系统做了些什么事
iOS中的push和pop是一个很常用的视图切换方法,他们是成对出现的, 简而言之,push就是压栈,pop就是出栈! [self.navigationController pushViewContr ...
- LAMP PHP 详解
目录 LAMP PHP 详解 LAMP 请求流程与原理 PHP 简介 PHP Zend Engine Opcode php 配置详解 php 加速器 部署LAMP 使用 php 连接 mysql 最基 ...
- vue 中有时候是数据没有同步的问题
1,在项目中,在做表格的数据渲染的时候,表格中有input标签的数据来进行双向绑定, this.$set(this.tableTitle.money, index, money[index]+isMo ...