python运算符,数据类型,数据类型操作,三目运算,深浅拷贝

算数运算符：

---

Py2中精确除法需要导入：from __future__ import division， py3不需要导入

赋值运算符：

---

比较运算符：

---

成员运算符：

---

逻辑运算符（布尔运算符）：

---

身份运算符：

---

内存的读写速度比硬盘要快，3.0里面二进制和字符型必须严格区分

python一行最多输80个字符

多线程可以并行运算

单线程串行执行

位运算符：　

---

　

六个标准的数据类型：

---

一般字符串执行一个功能，生成一个新的内容，原来内容不变，只要是被修改那就相当于再创建一个
list,tuple,dict,执行一个功能，自身进行变化

• Number（数字）

  ---

  • Python3 支持 int、float、bool、complex 　　在python2中没有布尔类型，   0表示False,  1表示True

空（None）：一个特殊的值，用None表示。None不能理解为0，因为0是有意义的

布尔类型（Boolean）：一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），None、任何数值类型中的0、空字符串“”、空元组()、空列表[]、空字典{}都被当作False，还有自定义类型，如果实现了__nonzero__()或__len__()方法且方法返回0或False，则其实例也被当作False，其他对象均为True

布尔值还可以用and、or和not运算。

1)and运算是与运算，只有所有都为True，and运算结果才是True：

2)or运算是或运算，只要其中有一个为True，or运算结果就是True：

3)not运算是非运算，它是一个单目运算符，把True变成False，False变成True：

整型(Int)：分为普通整数和长整数，普通整数长度为机器位长，32位系统是31位，64位系统是63位，py3中全是长整数。超过这个范围的整数就自动当长整数处理，而长整数的范围几乎完全没限制

浮点型(Float)：在运算中，整数与浮点数运算的结果是浮点数，整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。

> a, b, c, d = 20, 5.5, True, 4+3j >>> print(type(a), type(b), type(c), type(d)) <class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

>>> 5 + 4 # 加法 9 >>> 4.3 - 2 # 减法 2.3 >>> 3 * 7 # 乘法 21 >>> 2 / 4 # 除法，得到一个浮点数 0.5 >>> 2 // 4 # 除法，得到一个整数 0 >>> 17 % 3 # 取余 2 >>> 2 ** 5 # 乘方 32

• str（字符串）

  ---

用单引号(')或双引号(")括起来，反斜杠可以用来转义特殊字符，使用r可以让反斜杠不发生转义。

索引值从左往右以0开始，从右往左以-1开始。

加号 (+) 是字符串的连接符， 星号 (*) 表示复制当前字符串，紧跟的数字为 复制的次数

字符串是不可以修改的，修改了等于生成了一个新的内存数据

字符串(String)：字符串是以''或""括起来的任意文本，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\。换多行用'''...'''的格式表示多行内容

str = 'Runoob' print (str) # 输出字符串 print (str[0:-1]) # 输出第一个个到倒数第二个的所有字符 print (str[0]) # 输出字符串第一个字符 print (str[2:5]) # 输出从第三个开始到第五个的字符 print (str[2:]) # 输出从第三个开始的后的所有字符 print (str * 2) # 输出字符串两次 print (str + "TEST") # 连接字符串

print('Ru\noob') # 反斜杠(\)可以作为续行符，表示下一行是上一行的延续 Ru oob print(r'Ru\noob') # 加r表示原始字符串 Ru\noob

• List（列表）

  ---

List写在方括号之间，元素用逗号隔开，列表：可变元素的数据集合

列表(List)：用符号[]表示列表，中间的元素可以是任何类型，用逗号分隔

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]

tinylist = [123, 'runoob'] print (list) # 输出完整列表 print (list[0]) # 输出列表第一个元素 print (list[1:3]) # 从第二个开始输出到第三个元素 print (list[2:]) # 输出从第三个元素开始的所有元素 print (tinylist * 2) # 输出两次列表 print (list + tinylist) # 连接列表 以上实例输出结果： ['abcd', 786, 2.23, 'runoob', 70.2] abcd [786, 2.23] [2.23, 'runoob', 70.2] [123, 'runoob', 123, 'runoob'] ['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob'] 与Python字符串不一样的是，列表中的元素是可以改变的： a = [1, 2, 3, 4, 5, 6] a[0] = 9 a[2:5] = [13, 14, 15] a [9, 2, 13, 14, 15, 6] a[2:5] = [] # 删除 a [9, 2, 6]

• Tuple（元组）

  ---

元组（tuple）与列表类似，不同之处在于元组的元素不能增删改只能切片查，所以也叫只读列表。元组写在小括号(())里，元素之间用逗号隔开

tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )

tinytuple = (123, 'runoob') print (tuple) # 输出完整元组 print (tuple[0]) # 输出元组的第一个元素 print (tuple[1:3]) # 输出从第二个元素开始到第三个元素 print (tuple[2:]) # 输出从第三个元素开始的所有元素 print (tinytuple * 2) # 输出两次元组 print (tuple + tinytuple) # 连接元组 以上实例输出结果： ('abcd', 786, 2.23, 'runoob', 70.2) abcd (786, 2.23) (2.23, 'runoob', 70.2) (123, 'runoob', 123, 'runoob') ('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')

• Sets（集合）

  ---

集合（set）是一个无序不重复元素的序列。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号({})或者 set()函数创建集合，注意：创建一个空集合必须 用 set() 而不是 { }，因为 { } 是用来创建一个空字典。也可以使用列表，元祖做为参数

1. 去重，把一个列表变成集合，就自动去重
2. 关系测试，测试两组数据之间的交集，差集，并集等关系

student = set("Tom")

print(student) # 输出集合，重复的元素被自动去掉

# 成员测试

if('T' in student) :

print('T 在集合中')

else :

print('T 不在集合中')

# set可以进行集合运算

a = set('abc')

b = set('abcd')

print(a)

print(a - b) # a和b的差集

print(a | b) # a和b的并集

print(a & b) # a和b的交集

print(a ^ b) # a和b中不同时存在的元素

• Dictionary（字典）

  ---

字典（dictionary）内置数据类型，"{ }"标识

列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

它是一个无序的键(key) : 值(value)对集合，键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。

dict = {} dict['one'] = "1 - 菜鸟教程" dict[2] = "2 - 菜鸟工具" tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'} print (dict['one']) # 输出键为 'one' 的值 print (dict[2]) # 输出键为 2 的值 print (tinydict) # 输出完整的字典 print (tinydict.keys()) # 输出所有键 print (tinydict.values()) # 输出所有值

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠(\)来实现多行语句，在 [], {}, 或 () 中的多行语句，不需要使用反斜杠(\)例如：

aaa='1231231' \

'3131'

print (aaa)

print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：

# 不换行输出 print( x, end=" " ) print( y, end=" " ) print()

字符串操作
name='my \tname is {name} and i am {year} old'

print(name.capitalize())#首字母大写，
print(name.count('a'))#统计a的数量
print(name.center(50,'-'))#打印50个字符不够使用-
print(name.encode)#转换二进制
print(name.endswith('chao'))#以什么结尾，
print(name.expandtabs(tabsize=30))#转换多少个空格，字符串上必须加  ‘\t’
print(name[name.find('name'):9])#切片9之前的所有字符
print(name.format(name='zhangchao',year=29))#格式化，与下语句输出一致，原字符串必须增加name,year
print(name.format_map({'name':'zhangchao','year':''}))#格式化，与上语句输出一致
print('ab123'.isalnum())#包含字母数字，
print('aB'.isalpha())#包含大小写英文，
print(''.isdecimal())#10进制
print(''.isdigit())#是否整数，
print('A'.isidentifier())#判断是否为合法的变量名，
print('a'.islower())#判断是否小写 ，
print('A'.isupper())#判断是否大写，
print(''.isnumeric())#判断是否是数字，必须整数 ，
print(' '.isspace())#判断是否是空格 ，
print('My Name Is '.istitle())#判断每个首字母大写
print('My Name Is' .isprintable())#判断打印字符串，tty设备 file，drive file 无法打印
print('+'.join(['','','','']))#可以使用+号逗号隔开字符串， 连接 参加
print(name.ljust(50,'*'))#长度50不够用*号补充，字符串在左边 ，
print(name.rjust(50,'-'))#长度50不够用-号补充,字符串在右边
print('Alex'.lower())#所有改为小写，
print('Alex'.upper())#所有改为大写，
print('\nAlex'.lstrip())# 去掉左边的空格和回车，
print('Alex\n'.rstrip())# 去掉右边的空格和回车，
print('   Alex\n'.strip())# 去掉空格和回车，
print('---')
p = str.maketrans('abcdef','')#转换的意思
print("xiaaaaa".translate(p))#将对应的字母翻译成数字，
print('alex li'.replace('a','A',1))#将第一个小写a改成大写A,
print('alex li'.rfind('l'))#返回最右边的值下标
print('alex lil'.split())#以空格分割为字符串，
print('1+2+3+4'.split('+'))#以+号分割字符串
print('1+2\n+3+4'.splitlines())#以\n为分隔符
print('Alex Li'.swapcase())#大写转小写，小写转大写，
print('alex li'.title())#首字母大写
print('lex li'.zfill(50))#50字符不够用0填充左边
字符串无参数创建空字符串，一个参数创建普通字符串，两个参数，int（字节，编码）
字符串格式化
name='''
name='zhangchao'
name2=name
print('my name is',name , name2)
name='wangchao'
print (name)
'''
print (name)

Name=input('name:')
Age=int(input('age:'))
print(type(Age), type(str(Age)))
Job=input('job:')
Salary=input('salary:')
#  %s(字符串的占位符,全部类型都可以接收),字符串里面有占位符时必须使用两个%%才能表示一个%号.
#  .format(字符串格式化方法，使格式化的意思)
#  3个引号连接打印的意思
#    %d只能接收整数数字
# %f 接收小数,如不是小数也不会报错,会自动在末尾加小数
info='''
----------info of %s------
Name:%s
Age:%s
Job:%s
Salary:%s
'''%(Name,Name,Age,Job,Salary)
print(info)

name = "Tom"
print ("Hello %s" % name)#打印格式化字符串，把name变量的内容替换到%s处

info2='''
----------info of {_Name}------
Name:{_Name}
Age:{_Age}
Job:{_Job}
Salary:{_Salary}
'''.format(_Name=Name,
           _Age=Age,
           _Job=Job,
           _Salary=Salary)
print(info2)

info3='''
----------info of {0}------
Name:{0}
Age:{1}
Job:{2}
Salary:{3}
'''.format(Name,Age,Job,Salary)
print(info3)

s = 'i am %(n1)s  age %(n2)d '% {'n1':'zc','n2':19}#给位置设置名字
print(s)

s = 'i am %.3f sfsasas' % 1.2
print(s)#保留小数,打印1.200

class foo(object):#面向对象里面的自动调用
    def __str__(self):
        return 'aaa'
    def __repr__(self):
        return 'bbb'
s = 'i am %s, age %d' % (foo(),18)
s = 'i am %r, age %d' % (foo(),18)
print(s)#输出aaa,输出bbb

s = 'i am %c' % (6)
print(s)#输出i am ,转化为uncode码

s = 'i am %o %x' % (6,15)#整数转为8进制,16进制
print(s)

s = 'i am %e ' % (6)#转为科学计数法
print(s)

format格式化:
tpl = "i am {}, age {}, {}".format("seven", 18, 'alex')
print(tpl)#输出i am seven, age 18, alex
tpl = "i am {}, age {}, {}".format(*["seven", 18, 'alex'])
print(tpl)#输出i am seven, age 18, alex
tpl = "i am {0}, age {1}, really {0}".format("seven", 18)
print(tpl)#输出i am seven, age 18, really seven
tpl = "i am {0}, age {1}, really {0}".format(*["seven", 18])
print(tpl)#输出i am seven, age 18, really seven
tpl = "i am {name}, age {age}, really {name}".format(name="seven", age=18)
print(tpl)#输出i am seven, age 18, really seven
tpl = "i am {name}, age {age}, really {name}".format(**{"name": "seven", "age": 18})
print(tpl)#输出i am seven, age 18, really seven
tpl = "i am {0[0]}, age {0[1]}, really {0[2]}".format([1, 2, 3], [11, 22, 33])
print(tpl)#输出i am 1, age 2, really 3
tpl = "i am {:s}, age {:d}, money {:f}".format("seven", 18, 88888.1)
print(tpl)#输出i am seven, age 18, money 88888.100000
tpl = "i am {:s}, age {:d}".format(*["seven", 18])
print(tpl)#输出i am seven, age 18
tpl = "i am {name:s}, age {age:d}".format(name="seven", age=18)
print(tpl)#输出i am seven, age 18
tpl = "i am {name:s}, age {age:d}".format(**{"name": "seven", "age": 18})
print(tpl)#输出i am seven, age 18
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
print(tpl)#输出numbers: 1111,17,15,f,F, 1587.623000%
tpl = "numbers: {:b},{:o},{:d},{:x},{:X}, {:%}".format(15, 15, 15, 15, 15, 15.87623, 2)
print(tpl)#输出numbers: 1111,17,15,f,F, 1587.623000%
tpl = "numbers: {0:b},{0:o},{0:d},{0:x},{0:X}, {0:%}".format(15)
print(tpl)#输出numbers: 1111,17,15,f,F, 1500.000000%
tpl = "numbers: {num:b},{num:o},{num:d},{num:x},{num:X}, {num:%}".format(num=15)
print(tpl)#输出numbers: 1111,17,15,f,F, 1500.000000%
字典操作
字典的的索引就是它的键，无法切片，循环默认输出为key
info={
    '':'',
    '':'',
    '':'',
}
print(info)#打印字典
print(info.get(''))#建议安全的查找方法，有，返回，没有，为none
print(info.get(''，''))#若1不存在将显示1111
print (info[''])#查找，有查找，没有报错
print(''in info)#python3查找有返回为真，意思与下相同
#print(info.has_key('1'))#Python2查找，意思与上相同
info['']='张超'#修改字典
info['']='张超'#修改，没有的话添加
#del #python内置通用删除方法，
del info ['']#删除
info.pop('')#删除
info.popitem()#随机删除

av_catlog = {
    "欧美":{
        "www.youporn.com": ["很多","一般"],
        "www.pornhub.com": ["也很大","质量"],
        "letmedothistoyou.com": ["多是自拍"],
        "x-art.com":["很高,请绕过"]
    },
    "日韩":{
        "tokyo-hot":["不清楚,"]
    },
    "大陆":{
        "":["全部","慢"]
    }
}
av_catlog['大陆'][''][1]='快'#修改字典的多级菜单
av_catlog.setdefault('大',{'www.1.com':[1,2]})#在整个字典中取‘大’能取到就返回，无法取到键就创建新的，

print (av_catlog)

dict = { 1 : 2, 'a' : 'b', 'hello' : 'world' }
print (dict.values())#返回所有值
print (dict.keys())##返回所有键
print (dict.items())#遍历整个字典列表并字典转换列表

info ={
    1:2,
    2:3,
    'nihao':'buhao'
}
b={
    'n':'Aluex',
    1:2,
    2:3
}
info.update(b)#合并两个字典，没有重复值就加进去，有重复就覆盖
print(info)

c=dict.fromkeys([3,4,5],[1,{'name':1},1])#中括号是key,对应取所有同一值,初始化一个字典
print (c)

c[3][1]['name']='张超'#修改字典，因三个key共享一个内存地址，如果有多层会全部更改
print(c)

for i in a:
    print (i,a[i])#字典循环使用这种更高效

for k,v in a.items():#字典循环，数据量大非常慢，会将字典转换为列表耗时
    print(k,v)
#字典创建
a={'k1':'v1'}
a=dict(k2=123,k3=234)
print(a)

li=[11,22,33]
new=dict(enumerate(li,10))
print(new)

列表操作（切片/增删改查）
m=['zc',['zc1','zc2',['zc3']]]#列表嵌套，解析
def printm(listin):
    for i in listin:
        if isinstance(i,list):#(判断某个对象是否是某个类创建的)，例子
            printm(i)
        else:
            print (i)
printm(m)

names=['zhangchao','zhnagyang','zhangpan']#列表
names.append('lichao') #append  追加列表值
names.insert(1,'wangchao')#插入列表值，在哪个位置插入加位置序号
names[1]='liuchao'# 改列表中序号1的值
names.remove('liuchao')#删除列表中的值
del names[1]#删除列表中的值
names.pop()#删除列表中的最后一个值
del names[1]=names.pop(1)# 效果相等
print(names.index('huchao'))#查找到位置序号
print( names[names.index('huchao')])#查找到
print(names.count('huchao'))#计数
names.reverse()#反转，头尾反转，
names.clear()#清空列表
names.sort()#按照ASSIC码排序
names.extend(names2)#扩展，合并另一个列表 ,
print(names[:3])=print(names[0:3])#效果相等
print(names[-2:])#切片倒数1,2值
print(names[0:3])#切片0,1,2值，顾头不顾尾
print(names[-3:-1])#切片倒数2,3值

　　

列表使用（浅深copy）

---

浅拷贝：没有拷贝子对象，所以原始数据改变，子对象会改变，只拷贝最外层，用处：创建联合账号，A改动B也跟着

深拷贝：包含对象里面的自对象的拷贝，所以原始对象的改变不会造成深拷贝里任何子元素的改变，独立的copy一份，在内存中将所有数据重新创建一份最后一层除了字符串和数字。，

深浅拷贝都是对源对象的复制，占用不同的内存空间。

1，    切片可以应用于：列表、元组、字符串，但不能应用于字典。

2，    深浅拷贝，既可应用序列（列表、元组、字符串），也可应用字典。

3，    Str,int深浅拷贝都一样

import copy #导入深copy模块
names=['zhang1','zhang2','zhang3',['nihao','nihao2'],'zhang4','zhang5']
names2 = copy.deepcopy(names) #将names列表复制一份赋值names2 ，深copy，（深copy需要导入copy模块deepcopy函数）
names2=names.copy() # 将names列表复制一份赋值names2 ，是浅copy（浅copy不用导模块）
names[3][0] = 'NIHAO' #修改列表中嵌套列表的值
print (names[0:-1:2]) #打印列表全部，步长值2（偶数执行全部），
print (names[::2])  #打印列表全部，步长值2
print (names[:])   #打印列表全部
for i in names:
    print (i)     # 列表for循环

person=['names',['a',100],'张超']
p1=copy.copy(person)#第一种浅copy
p2=person[:]#第二种浅copy
p3=list(person)#第三种浅copy,格式工厂

元祖操作：

---

#创建元祖
t=(1,2,3,'zc')
t=tuple((1,2,3,'zc'))
t=tuple([])#嵌套字符串，列表，字典

#元祖嵌套（内在元素不可修改，但元素的元素可能可以修改，如嵌套的是其它类型就可修改）
t=('zc',11,['张超',{'k1':11}])
t[2][1]['k2']=22#第一种追加方法
print(t)

t[2][1].update({'k3':111})#第二种追加方法
print(t)

enumerate:

---

range:

---

py2中是：xrange,

除能被自身和1整除外不能被其他数整除的数，比如13，只能被1和13整除，其他数都不能整除它，所以13就是一个质数(素数), .质数只外的数称为合数。

集合操作set
无序且不重复的集合, 基本功能包括关系测试和消除重复元素
创建空集合两种方式：S=set()  ，   s={11,222,11,222}     s={} 默认类型为字典
集合转换：l=[11,11,22]， l=(11,44,44)，l=''，print(set(l))
list_1=[1,2,3,45,3]
list_1=set(list_1)

list_2=set([1,2,3,45,54,66])
print (list_1,list_2,type(list_1))

print(list_1.intersection(list_2))#交集,(交接，)，两个都存在的取出来
print(list_1.intersection_update(list_2))#取交集把自己也更新成交集
print(list_1.union(list_2))#并集，(结合)，两个表合并去重
print(list_1.difference(list_2))#差集,(差异)1里面有2里面没有的取出来,以1为主
print(list_2.difference(list_1))#差集,(差异)2里面有1里面没有的取出来，以2为主
print(list_1.difference_update(list_2))# 1里面有2里面没有的取出来,以1为主
更新自己，为None
list_3 = set([1,2,3])
list_4 = set([4,5,6,2])
print(list_1.issubset(list_2))#子集(一部分，)
print(list_1.issuperset(list_2))#父集(超集)
print(list_3.issubset(list_1))#子集
print(list_1.issuperset(list_3))#父集
print(list_1.symmetric_difference(list_2))#对称差集，(相称的，)取出两个列表中互相都没有的，放在一起
print(list_1.symmetric_difference_update(list_2))# 取出两个列表中互相都没有的，更新给自己
print('-------')
print (list_3.isdisjoint(list_4))# 没有交集(不相交的,)两个列表没有交集返回True,有交集返回False

#关系测试符号
print (list_1 & list_2)#交集
print (list_1 | list_2)#并集
print (list_1 - list_2)#差集
print (list_1 ^ list_2)#对称差集

list_1.add(999)#增加单个集合
list_1.update([1,12,223,34]#多个集合，给list_1增加
#list_1.remove(1)#删除list_1中的1，如果不存在将报错
#print (list_1.pop())#随机删除
#print (list_1.discard(2222))#删除，(抛弃，)不存在也不会报错，执行完不返回
print (list_1)
练习：
old_dict={
    '#1':11,
    '#2':22,
    '#3':100,}
new_dict={'#1':33,
          '#4':22,
          '#7':100,}
old_keys=old_dict.keys()
new_keys=new_dict.keys()
old_set=set(old_keys)
new_set=set(new_keys)
del_set=old_set.difference(new_set)
print(del_set)
add_set=new_set.difference(old_set)
print(add_set)
update_set=old_set.intersection(new_set)
print(update_set)

三目运算，三元运算/进制：

---

name='zc' if 1==1 else 'zc0'
print(name)

作业：

---

assert_all=0 #(资产)
li=input('请输入总资产:')
assert_all=int(li)
goods=[
    {'name':'电脑','price':1999},
    {'name':'鼠标','price':10},
    {'name':'游艇','price':20},
    {'name':'美女','price':998},]
for i in goods:
    print(i['name'],i['price'])
car_dict={}
while True:
    i2=input('请选择商品(Y/y结算)：')
    if i2.lower()=='y':
        break
    for item in goods:
        if item['name']==i2:
            name=item['name']
            if name in car_dict.keys():
                car_dict[name]['number']=car_dict[name]['number']+1
            else:
                car_dict[name]={'number':1,'single_price':item['price']}
print(car_dict)
all_price=0#总价
for k,v in car_dict.items():
    n=v['single_price']
    m=v['number']
    all_sum=m*n
    all_price=all_price+all_sum
if all_price>assert_all:
    print('你个穷逼这点钱毛的买不到')
else:
    print('你是大款购买成功了')

product_list = [ #产品
    ('iphone',6000),
    ('mac pro',10000),
    ('bike',800),
    ('watch',12000),
    ('coffee',30),
    ('zhangchao',29),
]
shopping_list = []#定义空列表，存取商品
salary = input('input your salary:')#输入工资
if salary.isdigit():#判断工资是不是十进制数字，计算机用二进制，生活中用十进制
    salary = int(salary)#如果是数字，给成整型
    while True:#进入死循环
        for index, item in enumerate(product_list):#取出下标，列举，
            #print(product_list.index(item),item)取下标
            print(index,item)#打印商品列表
        user_choice = input('选择要买什么：')#输入要买的东西，选择，
        if user_choice.isdigit():#判断用户输入的是不是数字类型
             user_choice =int(user_choice)#如果是数字，转成整型
             if user_choice < len(product_list) and user_choice >=0:#判断用户选择商品序号长度小于列表长度并且大于等0
                 p_item = product_list[user_choice]#通过下标把商品取出来
                 if p_item[1] <=salary:#判断是否买的起，如果小于当前工资就买的起
                     shopping_list.append(p_item)#能买的起添加到商品列表中
                     salary -= p_item[1]#扣钱
                     print('Added %s into shopping cart,your current balance is \033[31;1m%s\033[0m' %(p_item,salary) )#买的起打印这句话,
                 else:
                     print('\33[41;1m你的余额只剩下[%s]啦,\33[0m'% salary)#买不起打印
             else:
                 print ('product code [%s] is not exist'% user_choice)#输入的商品序号不存在
        elif user_choice=='q':#如果是q就打印已经买的东西
            print ('----shopping_list------')#打印已经输出的列表
            for p in shopping_list:
                print(p)
            print ('you current balance',salary)#打印剩下的余额
            exit()#退出
        else:
            print('invalid option')#如果不是q打印错误选项(invalid,无效，)(option,选项，)
else:
    print ('invalid option')#开始输入的不是数字打印

data = {
    '北京':{
        '朝阳':{'群众':['大妈','大爷'],'群众1':['大妈1','大爷1']},
        '天安门':{'国旗':{'旗杆','旗台'},'国旗1':{'旗杆1','旗台1'}},},
    '山东':{'德州':{},},
    '广东':{'东莞':{},}}
exit_flag = False #退出标识(flag标识.  exit退出，)
while not exit_flag:#首先开始循环，not False 为True
    for i in data:#打印第一级
        print(i)

    choice = input('选择进入：')
    if choice in data:#判断是不是在字典里
        while not exit_flag:#在字典里面继续循环
            for i2 in data[choice]:#打印第二层
                print ('\t',i2)
            choice2 = input('选择进入：')
            if choice2 in data[choice]:#判断是不是在字典里
                while not exit_flag:#在字典里面继续循环
                    for i3 in data[choice][choice2]:  # 打印第三层
                        print('\t\t', i3)
                    choice3 = input('选择进入：')
                    if choice3 in data[choice][choice2]:##判断是不是在字典里
                        for i4 in data[choice][choice2][choice3]:# 打印第四层
                            print('\t\t',i4)
                        choice4 = input('最后一层，按b返回:')
                        if choice4 =='b':#返回上一层
                            pass#占位，代码不出错，会返回本层while循环
                        elif choice4 =='q':#判断是否退出
                            exit_flag = True#如果退出 exit_flag=True
                    if choice3 =='b':
                        break
                    elif choice3 == 'q':
                        exit_flag = True
            if choice2 == 'b':
                break
            elif choice2 == 'q':
                exit_flag = True
    else:
        print('输入不存在')
        exit()
    if choice == 'b':
        break
    elif choice == 'q':
        exit_flag = True