基本功总结,Python数据结构

  • 元组相加

    t1 = (1,2,3)
    t2 = (4,5,6)

    print(id(t1))
    print(id(t2))

    t一 += t二 #即t1=t一+t2,将t壹与t二元组相加,t一指向相加之后的新元组,该操作合法,因为元素内容不可能改改,不过能够针对新的地址

    print(t一)
    print(id(t一)) #相加之后的t壹指向3个新的地点

  • 变量

1.实践python脚本的三种方式:

答:1、./run.py.shell直接调用python脚本

二、python run.py 调用python 解释器来调用python脚本

 

Python 3.6

 输出为

python通过=实行变量赋值,表明变量时不要求注脚数据类型

5.python单行注释和多行注释分别是如何?

 答:单行注释用#,多行注释用三引号

运算符

  • + – * / 肆则运算 % 求余 **乘方
  • // 用于整除
2583036379208
2583036379280
(1, 2, 3, 4, 5, 6)
2583035574600
#-*- coding:utf -8-*-
#/usr/bin/python3

#在声明变量时不需要声明变量类型

counter = 100        #整型变量  

miles = 1000.0       #浮点型变量

name = "runobb"   #字符串 

#打印变量:print()

print(counter)

print(miles)

print(name)

#查看数据类型:type()

print(type(counter))

print(type(miles))

print(type(name))

#同时为多个变量赋值
#创建一个整型对象,值为1,三个变量被分配到相同的内存空间
a = b = c = 1
#id()查看该变量的内存空间地址

6.扬言变量注意事项有何样?

 答:壹.变量名只好是数字、字母、下划线的即兴组合

贰.变量名的第一个字符不可能为数字

三.python重大字无法用作变量名

字符串

  • 字符串用单引号或双引号括起来。
  • 三引号(单引号或双引号均可)表示多行字符串,行末加反斜杠表示换行不算在字符串之内。
  • 字符串加上前缀 r 表示原生字符串。
  • + 用于连接字符串。
  • * 用于重复字符串。
  • 隔壁的字符串字面量会活动连接。
  • 字符串存在部分(slice)语法(使用下标获取子串),但字符串自个儿不可变。
  • 1对语法中下标 0 指向第伍个成分,下标 -一 指向最终一个成分。

    ‘a’ * 3
    ‘aaa’
    ‘b’ ‘a’
    ‘ba’
    ‘b’ + “a”
    ‘ba’
    print(r’C:\some\name’)
    C:\some\name
    print(“””\
    a
    b
    c\
    “””)
    a
    b
    c
    “abcde”[1:]
    ‘bcde’
    “abcde”[:4]
    ‘abcd’
    “abcde”[:]
    ‘abcde’
    “abcde”[-3:]
    ‘cde’

  •  元组相乘

    t1 = (1,2,3)
    print(id(t1))
    t1 = t1 * 三 #运算之后生成新的元组,t一指向所生成的因素新鸿基土地资金财产点
    print(t一) #输出(壹, 二, 3, 一, 二, 三, 一, 2, 三)
    print(id(t一)) #t1指向了3个新的地方

  •  双层元组的遍历

    t = ((1,2,3),(6,7,8),(“i”,”love”,”you”))
    for i in t:

    print(i)
    

    print(“20)

    for k,v,w in t:

    print(k,"...",v,"...",w)
    

In [16]: print(id(a))
1658082080

八.哪些查看变量在内部存款和储蓄器中的地址?

答:用id(变量名) 就可以查看变量在内部存款和储蓄器中的地址

 

列表(Lists)

  • 列表:1种成员的门类相同但个数不限的数据结构。
  • 列表接纳中括号加逗号的非正规语法。
  • + 连接几个列表。
  • 列表存在1些(slice)语法(使用下标获取子列表),列表片段可变(能够由此赋值被轮换)。
  • 有的语法中下标 0 指向第叁个要素,下标 -1 指向最终1个要素。

    [1,2,3][1:]
    [2, 3]
    [1,2,3][-2:]
    [2, 3]
    a = [1,2,3,4]
    a[2:] = [4,5,6]
    a
    [1, 2, 4, 5, 6]
    a[2:] = []
    a
    [1, 2]

  • append 方法添欧成分。

  • extend 方法连接另二个列表。
  • insert 方法插入成分。
  • remove 方法移除钦命元素。
  • pop 方法弹出最前面包车型大巴元素。
  • clear 方法清空驶列车表。
  • index 方法搜索内定成分的下标。
  • count 方法重返列表的长短。
  • reverse 方法翻转列表。
  • copy 方法复制列表。

    fruits = [‘orange’, ‘apple’, ‘pear’, ‘banana’, ‘kiwi’, ‘apple’, ‘banana’]
    fruits.count(‘tangerine’)
    0
    fruits.index(‘banana’)
    3
    fruits.reverse()
    fruits
    [‘banana’, ‘apple’, ‘kiwi’, ‘banana’, ‘pear’, ‘apple’, ‘orange’]
    fruits.sort()
    fruits
    [‘apple’, ‘apple’, ‘banana’, ‘banana’, ‘kiwi’, ‘orange’, ‘pear’]

  • 列表解析(List Comprehensions)

    [x**2 for x in range(10)]
    [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
    [(x, y) for x in [1,2,3] for y in 基本功总结,Python数据结构。[3,1,4] if x != y]
    [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

 输出为

In [17]: print(id(b))
1658082080

9.实践python程序时,自动生成的.pyc文件的效益是什么?

答:pyc是一种二进制文件,是由py文件通过编写翻译后,生成的文本,是1种byte code,py文件变成pyc文件后,加载的快慢有所提升,而且pyc是1种跨平台的字节码,是由python的虚拟机来实施的,py文件是足以直接看到源码的,所以就必要编写翻译为pyc后,再揭橥出去,完成部分源码的隐藏.

元组(Tuples)

  • 元组:壹种成员数量和顺序固定但项目相差相当大的数据结构。
  • 元组采纳小括号加逗号的超过常规规语法。(最外层元组的小括号可粗略)
  • 元组是不可变的。
  • 元组存在下标语法。
  • 留存未有其余成员的元组 () 以及唯有一个分子的元组 a,
    (成分后跟一个逗号表示元组)

    t = 123,”123″
    t[0]
    123
    t[1]
    ‘123’
    u = t, 456
    u
    ((123, ‘123’), 456)
    v = 1,
    v
    (1,)

(1, 2, 3)
(6, 7, 8)
('i', 'love', 'you')
********************
1 ... 2 ... 3
6 ... 7 ... 8
i ... love ... you

In [18]: print(id(c))
1658082080

10.写代码

解构语法

>>> a,b = [1,2]
>>> a,b
(1, 2)
>>> a,b = (1,2)
>>> a,b
(1, 2)
>>> a,b = b,a
>>> a,b
(2, 1)
  •  八个变量调换

    a = (1,2,3)
    b = (7,8,9)
    print(a) #输出(1, 2, 3)
    print(b) #输出(7, 8, 9)
    print(“20)
    a,b = b,a #多个元组调换,同样适用于任何各样型变量(比如int,list等等)
    print(a) #输出(七, 捌, 玖)
    print(b) #输出(一, 二, 三)

  • 数值运算

a.贯彻用户输入用户名和密码,当用户名称为seven且密码为123时,展现登伍分三功,不然呈现登陆退步.

 

name=input("请输入用户名:").strip()
pwd=input("请输入密码:").strip()
if name=="seven" and pwd=="123":
    print("登陆成功")
else:
    print("登陆失败")

 

 

集合(Sets)

  • 会合:1种不设有重复成分的哈希表数据结构。
  • 集结选拔大括号加逗号的奇特语法。
  • 常用操作包涵求差集,并集,交集,对称差集。
  • 存在集合的解析表达式。(set comprehensions)

    basket = {‘apple’, ‘orange’, ‘apple’, ‘pear’, ‘orange’, ‘banana’}
    basket
    {‘pear’, ‘orange’, ‘banana’, ‘apple’}
    a = set(‘abracadabra’)
    b = set(‘alacazam’)
    a
    {‘c’, ‘a’, ‘r’, ‘d’, ‘b’}
    b
    {‘l’, ‘c’, ‘a’, ‘m’, ‘z’}
    a – b # 差集
    {‘b’, ‘d’, ‘r’}
    a | b # 并集
    {‘m’, ‘l’, ‘c’, ‘a’, ‘r’, ‘d’, ‘b’, ‘z’}
    a & b # 交集
    {‘c’, ‘a’}
    a ^ b # 对称差集
    {‘d’, ‘b’, ‘l’, ‘m’, ‘z’, ‘r’}
    {x for x in ‘abracadabra’ if x not in ‘abc’}
    {‘d’, ‘r’}

 

 

b.落成用户输入用户名和密码,当用户名叫seven且密码为123时,显示登陆成功,否则展现登陆退步.战败时允许再一次输入三回

count=0
while count<3:
    count+=1
    name=input("请输入用户名:").strip()
    pwd=input("请输入密码:").strip()
    if name=="seven" and pwd=="123":
      print("登陆成功")
      break
    else:
        print("登陆失败")
        continue

 

字典(Dictionaries)

  • 字典:一种存放键值对的哈希表数据结构。
  • 字典选用大括号加冒号和逗号的尤其语法。
  • 澳门葡京备用网址,留存字典的辨析表明式。(dictionary comprehensions)

    tel = {‘jack’: 4098, ‘sape’: 4139}
    tel
    {‘jack’: 4098, ‘sape’: 4139}
    tel[‘jack’]
    4098
    tel[‘guido’] = 4127
    tel
    {‘jack’: 4098, ‘sape’: 4139, ‘guido’: 4127}
    {x: x**2 for x in (2, 4, 6)}
    {2: 4, 4: 16, 6: 36}

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

c.落到实处用户输入用户名和密码,当用户名叫seven且密码为1二3时,彰显登六成功,不然显示登陆退步.败北时允许再一次输入一次

 

 

count=0
while count<3:
    count+=1
    name=input("请输入用户名:").strip()
    pwd=input("请输入密码:").strip()
    if name=="seven"or name=="alex" and pwd=="123":
      print("登陆成功")
      break
    else:
        print("登陆失败")
        continue

 

range 函数

>>> list(range(5,10))
[5, 6, 7, 8, 9]
>>> list(range(0,10,3))
[0, 3, 6, 9]
>>> list(range(-10,-100,-30))
[-10, -40, -70]

注意:

11.写代码

语句

  • while 语句
  • for 语句(实质上是 foreach)
  • if … elif … else 语句
  • 代码块采纳冒号加缩进来表示
  • pass 语句(空语句)
  • break continue 语句
  • 循环 + else语句(表示循环正常结束,未有被 break)

    for n in range(2, 10):
    for x in range(2, n):
    if n % x == 0:
    print(n, ‘equals’, x, ‘*’, n//x)
    break
    else:
    print(n, ‘is a prime number’)

2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3
  1. python能够而且为三个变量赋值如 a , b = 1 , 2
  2. 2个变量能够由此赋值指向差异档次的指标
  3. 数值的除法(/)总是回到3个浮点数,要赢得整数使用(//)操作符
  4. 在混合总计时,python会把整型转换为浮点型

a.运用while循环输出2-三+肆-伍+六..+100的和

count=1
s=0
while count<100:
    count+=1
    s+=(-1)**count*count
print(s)

 

函数

  • 概念函数使用 def。
  • 形参的非正规格局有:带缺省值的形参 arg=value,元组形参
    *args,字典形参 **args。
  • 实参的独特殊形体式有:带关键字的实参 kwarg=value,列表/元组实参
    *args,字典实参 **args。

    def f(a, b=二): # 带缺省值的形参
    print(a,b)

    f(三)
    三 2f(a=四) # 带关键字的实参
    4 2d = {“a”:三,”b”:5}
    f(d) # 字典实参,调用时张开三 伍def f(k, *args, kws): # 元组形参,字典形参
    print(k)
    for arg in args:
    print(arg)
    for kw in kws:
    print(kw, “:”, kws[kw])

>>> f("a", 1,2,3, c=4,d="abc") # 调用时 1,2,3 打包成元组,c=4,d="abc" 打包成字典
a
1
2
3
c : 4
d : abc
>>> args = [3,6]
>>> list(range(*args)) # 列表实参,调用时展开
[3, 4, 5]
>>> args = (3,6)
>>> list(range(*args)) # 元组实参,调用时展开
[3, 4, 5]
  • 字符串(String)

    1 #-– coding:utf-8 –
    2 #!/usr/bin/python3 三
    四 str = “keatiuny”
    5 print(str) #打字与印刷变量str
    陆 print(str[0]) #通过下标的艺术获取str中对应的value,0:第一个值 -一:最终叁个 7 print(str[0:3]) #取得str中率先位到第多少人的中档的值(不分包第2人)
    八 print(str[0:-一]) #取得str中第二个人到结尾一个人中间的值,不蕴涵最后壹个人 玖 print(str*二) #打字与印刷1次十 print(str+”name”) #拼接字符串
    1一
    1二 #输出结果
    一三 keatiuny
    1四 k
    1伍 kea
    16 keatiun
    一七 keatiunykeatiuny
    18 keatiunyname

b.使用for循环和range实现1-2+3-4+5-6…+99的和

s=0
for i in range(1,100):
    s+=-(-1)**i*i
print(s)

 

 

注意:

C.使用while循环输出一,2,三,肆,伍  七,八,玖  1一,1二

count=0
while count<12:
    count+=1
    if count==6 or count==10:
        continue
    print(count,end=" ")

 

 

  1. 反斜杠能够用来转义,使用r能够让反斜杠不发生转义 例: print(r’Ru\noob’),输出结果中富含\
  2. 字符串可以用 + 连接在共同,用 *
    重复
  3. python中字符串不能够改换

d.使用while循环输出一-100内的拥有基数

count=0
while count<100:
    count+=1
    if count%2!=0:
        print(count)

 

  • 列表(list):

e.使用while循环输出1-十0内的具有偶数

count=0
while count<100:
    count+=1
    if count%2==0:
        print(count)

 

11.**分别书写数字5,拾,3二,柒的二进制

**

#5=2**2+2**0
#5对应的二进制为 101
print(bin(5))

#10=2**3+2**1
#10对应的二进制为1010
print(bin(10))

#32=2**5
#32对应的二进制为100000
print(bin(32))

#7=2**2+2**1+2**0
#7对应的二进制 111
print(bin(7))

 

 

list是python中运用最频仍的数据类型

14.近期有如下三个变量,请简述n一和n2是怎么着关系?

n1=123

n2=123

答: n一和n二的id(内部存款和储蓄器地址) 值
和type都非常

 

list凉月素的档次可以差别等,list扶助数字、字符串、嵌套列表

15.当今有如下三个变量,请简述n一和n二是何等关系?

n1=123456

n2=123456

答:n一和n二的id(内部存款和储蓄器地址)不等 type不相同,值相同,分别指向七个一样的数值123456

list = ['keatiuny',1,'1.15']            #多个value的可变的集合,是一个可迭代对象
list2 = ['hello python',456]
#切片
print(list)                 #打印整个list
print(list[0])              #取list中第一个value
print(list[0:2])            #取list中0:2的值(不包含2)
print(list[-1])             #取list中最后一个值
print(list[0:])             #取整个list中的值

#遍历list
#方法一:for循环
for value in list:
    print(value)
#方法二:while 循环:
i = 0
while i < len(list):
    print(list[i])
    i += 1
#对list的操作(增删改查)
"""
列表操作包含以下函数:
1、cmp(list1, list2):比较两个列表的元素 
2、len(list):列表元素个数 
3、max(list):返回列表元素最大值 
4、min(list):返回列表元素最小值 
5、list(seq):将元组转换为列表 
列表操作包含以下方法:
1、list.append(obj):在列表末尾添加新的对象
2、list.count(obj):统计某个元素在列表中出现的次数
3、list.extend(seq):在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
4、list.index(obj):从列表中找出某个值第一个匹配项的索引位置
5、list.insert(index, obj):将对象插入列表
6、list.pop(obj=list[-1]):移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
7、list.remove(obj):移除列表中某个值的第一个匹配项
8、list.reverse():反向列表中元素
9、list.sort([func]):对原列表进行排序
"""

16.最近有如下八个变量,请简述n①和n2是怎么样关系?

 n1=123456

 n2=n1

 

答:n1和n贰的id(内部存款和储蓄器地址) 值
和type都卓殊

  • 元组(tuple)

17.固然有贰个变量n=伍,请使用int提供的法子,获得该变量最少能够用有些个二进制表示?

n=5
print(n.bit_length())

 

元组同list基本相似,只是元组1旦生完了不也许改动,不可能修改增加和删除改,可以查

18.布尔值分别有啥?

答:布尔值有True和False

小心:定义当定义的元组中唯有二个因素时,供给在要素的末端增多逗号  tup1 =
(20,)

19.翻阅代码,写出执行结果:

a=”alex”
b=a.capitalize()
print(a)
print(b)

 

答:alex  Alex

20.写代码,有如下代码,按要求落到实处各样功效:

name=” aleX”

__author__ = 'Administrator'
name=" aleX"
#a.移除两边对应的空格,并输入移除后的内容
print(name.strip())
#b.判断name变量对应的值是否以“al”开头,并输出结果
print(name.startswith("al"))
#c.判断name变量对应的值是否以“X”结尾,并输出结果
print(name.endswith("X"))
#d.将name变量值中的“l”替换为“p‘并输出结果
print(name.replace("l","p"))
#e.将name变量对应的值根据”l“切分,并输出结果
print(name.split("l"))
#f.上一题e中分割之后的值是什么类型
print(type(name.split("l")))
#g.将name变量对应的值变为大写,并输出值
print(name.upper())
#h.将name变量对应的值变为小写,并输出值
print(name.lower())
#i请输出name变量对应的值的第二个字符
print(name[1])
#j请输出name变量对应的值的前3个字符
print(name[:3])
#k请输出name变量对应的值的后2个字符
print(name[-2:])
#l 请输出name变量对应的值中”e“所在的索引位置
print(name.index("e"))

 

 

 

  • 字典(dic)
  • 集合(set)

21.字符串是还是不是足以迭代,倘若能够请使用否循环迭代每三个要素。

答:可以的

a=”abcdefg”
for i in range(len(a)):
    print(a[i])

集合(set)是一个冬天不重复的成分集合。

22.写代码,按供给达成效益

__author__ = 'Administrator'
li=["alex","erin","rain","aa","bb","cc"]
#a.计算列表的长度并输出
print(len(li))
#b.列表中追加元素”seven“,并输出添加后的列表
li.append("seven")
print(li)
#c.请在列表的第一个位置插入元素”tony“,并输出添加后的列表
li.insert(0,"Tony")
print(li)
#d.请修改列表第二个元素为"kelly",并输出修改后的列表
li[1]="kelly"
print(li)
#e.请删除列表中的”eric“,并输出修改后的列表
li.remove("erin")
print(li)
#f.删除列表的第二个元素,并输出删除的元素和删除后的列表
aa=li.pop(1)
print(aa)
print(li)
#g请删除列表中的第三个元素,并输出删除后的列表
li.pop(2)
print(li)
#h.请删除列表中的第2-4个元素,比输出删除后的列表
li.pop(1)
li.pop(1)
li.pop(1)
print(li)
#i将列表所有元素反转,并输出反转后的列表
li.reverse()
print(li)
#j请使用for in range 输出列表的索引
for i  in range(len(li)):
    print(i)
#k请使用enumberate输出列表元素和序号(序号从100开始)
for i,j in enumerate(li,start=100):
    print(i,j)
#l请使用for循环输出所有元素
for i in  li:
    print(i)

 

能够接纳{  }或然set( )函数成立集合

二三.写代码,按要求贯彻效益:

li=[“hello”,”seven”,[“moon”,[“h”,”kelly”],”all”],123,456]

__author__ = 'Administrator'
li=["hello","seven",["moon",["h","kelly"],"all"],123,456]
#a.请输出kelly
print(li[2][1][1])
#b.请使用索引找到”all”元素,并将其修改为“ALL”
print(li[2][2].upper())

 

)

  • 数据类型转变

24.写代码,有下边元组.按供给贯彻效益

 

__author__ = 'Administrator'
tu=("alex","eric","rain")
#a.计算元组长度并输出
print(len(tu))
#b.获取元组的第二个元素,并输出
print(tu[1])
#c.获取元组的第1-2个元素,并输出
print(tu[:2])
#d.请使用for循环输出元组的元素
for i in tu:
    print(i)
#e.请使用 for len range 输出元组的索引
for i in range(len(tu)):
    print(i)
#f使用enumberate输出元组的元素和序号。序号从10开始
for i,j in  enumerate(tu,10):
    print(i,j)

 

 

二5 有如下元组,按须要完结以下职能

tu=(“alex”,[11,22,{“k1″:”v1″,”k2”:[“age”,”name”],”k3″:(11,22,33)},44])

 

a.叙述元组的风味:

答:壹、有序的集聚,可以存放四个值

二、通过偏移来取多少

叁、属于不可变的靶子,不能够在修改内容

b.元组里的率先个要素”alex”能够不得以修改?

答:不得以修改

C.tu中的元素k2对应的值是何许项目,行还是不行修改,假诺能改改,则向其丰裕一个因素seven。

答:k二对应的值是list(列表).可以修改

tu=("alex",[11,22,{"k1":"v1","k2":["age","name"],"k3":(11,22,33)},44])
print(tu[1][2]["k2"])
print(type(tu[1][2]["k2"]))
tu[1][2]["k2"].append("seven")
print(tu)

 

 

d.tu中的成分k叁对应的值是何等类型,可不得以修改,固然能改改,则向其丰裕三个成分seven。

答:k三对应的值类型是元组,不得以修改

 

26字典

dic={“k1″:”v1″,”k2″:”v2″,”k3”:[11,22,33]}

__author__ = 'Administrator'
dic={"k1":"v1","k2":"v2","k3":[11,22,33]}
#a.请循环输出所有key
for k in  dic:
    print(k)
#b.请循环输出所有value
for v in dic.values():
    print(v)
#c.请循环输出所有key,value
for k,v in dic.items():
    print(k,v)
#d.请在字典中添加一个键值对k4,v4,输出添加后的字典
dic["k4"]="v4"
print(dic)
#e.请修改字典中k1对应的值为alex,输出修改过后的字典
dic["k1"]="alex"
print(dic)
#f.请在k3对应的值中添加一个元素44,输出修改后的字典
dic["k3"].append(44)
print(dic)
#g.请在k3对应的值的第一个位置插入18,输出修改后的字典
dic["k3"].insert(0,18)
print(dic)

 

 

 

27 转换

#1.将字符串s=”alex”,转换成列表

s="alex"
l=list(s)
print(l)

#2.将字符串s=”alex”,转换成元组

s="alex"
t=tuple(s)
print(t)



#3.将列表li=[“selx”,”seven”]转换成元组

l=["alex","seven"]
t=tuple(l)
print(t)



#4.将元组tu=(“alex”,”seven”)转换成列表

t=("alex","seven")
l=list(t)
print(l)



#5..将列表li=[“selx”,”seven”]转换成字典且字典的key按照10开始向后递增



l=["alex","seven"]
d={}
for i,j in enumerate(l,start=10):
    d[i]=j
print(d)

 

28.求壹-拾0拥有的和

s=0
for i in range(1,101):
     s+=i
print(s)

 

2九.成分分类

有如下集合[11,22,33,44,55,66,77,88,99],将超越6陆的位于集合的首先个key中,小于6陆的放在集合的第一个key中

l=[11,22,33,44,55,66,77,88,99]
d={"k1":[],"k2":[]}
for i in l:
    if i>66:
        d["k1"].append(i)
    elif i<66:
        d["k2"].append(i)
print(d)

 

 

 

 

30.购物车

成效供给:

   必要用户输入总财力:如三千

   呈现商品列表;用户按序号选用商品,参预购物车

   购买,借使商品总金额当先总资金财产.则提示余额不足,不然购买成功

 

 

goods=[
{"name":"电脑","price":1999},
{"name":"鼠标","price":10},
{"name":"游艇","price":20},
{"name":"美女","price":998}
]
good_d={}
good_l=[]
tag=True
flag=True
while tag:
    allmoney=input("请输入总资产:").strip()
    if allmoney.isdigit():
        for good in  goods:
            print("{}.name:{name} price:{price}".format(goods.index(good)+1,name=good["name"],price=good["price"]))
            good_d[goods.index(good)+1]=[good["name"],good["price"]]

        while tag:
            number=int(input("请输入要购买商品的序号:").strip())
            if not number  or number not in good_d:
                print("输入错误。请重新输入:")
                continue
            else:
                flag=True
                while flag:
                    count=input("请输入要购买商品的件数:").strip()
                    if count.isdigit():
                        allprice=good_d[number][1]*int(count)
                        if allprice<=int(allmoney):
                            good_l.append((good_d[number][0],good_d[number][1],count))
                            allmoney=int(allmoney)- allprice
                            print("你的余额为",allmoney)
                            print(good_l)
                            break
                        else:
                            print("你的余额不足,请重新选择商品")
                            while True:
                                cmd=input("请输入命令,输入Y表示继续购物,输入N表示退出结账")
                                if cmd=="Y":
                                    flag=False
                                    break
                                elif cmd=="N":
                                    flag=False
                                    tag=False
                                    break

                                else:
                                    print("输入命令有误")
                                    continue


                    else:
                        print("输入有误。请重新输入:")
                        continue


    else:
        print("总金额必须是数字且不能为空!")

 

 

 

 

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website