Python基础--2
1、列表2、元组3、字符串4、字典5、集合6、文件7、数字8、with语句9、练习1、列表#!/usr/bin/env python# -*- coding:utf-8 -*-# Author:Weiyc# List(列表)内容可修改# （1）特性# 可以包含任意对象的有序结合# 通过小标索引（位置偏移）访问元素# 可变长度，异质...
·
1、列表
2、元组
3、字符串
4、字典
5、集合
6、文件
7、数字
8、with语句
9、练习
1、列表
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Weiyc
# List(列表) 内容可修改
# （1）特性
# 可以包含任意对象的有序结合
# 通过小标索引（位置偏移）访问元素
# 可变长度，异质，可任意嵌套
# 支持原位改变
# 对象引用数组
# (2)常用操作
x = ["wei","hao","li",50] #包含任意对象,小数、整数、字符串组合
print(x)
# print(x[0]) #得值50，列表中第一个值
# print(x[-1]) #得值99.3，列表最后一个值
# print(x[0:1]) #得值[50,99.3],切割顾头不顾尾
# x[:]全部 x[1:]到最后 x[:4]从开始
# print(x[::2]) #从0开始，隔两位取一个值。
# print(x[-2:]) 打印最后两位值
# x.append(5) #增，x列表后面追加值5
# print(x)
# del x[0] #删除列表第一个值
# del x[:3] #删除范围 等同l[:3] = []
# del x[::2] #删除指定步长
# del x #删除列表
# print(x)
# x.remove(50) #删除x列表中左到右第一个值为50的值
# print(x)
# x.pop() #删，默认弹出并删除最后一个值。
# x.pop(1) # 根据下标位置删除
# print(x)
# x[0] = 51 #改一个值为51
# print(x)
# x.insert(0,99) #插，x列表第一个位置插入99值 x[0:0] = 99效果等同
# print(x)
# print(x.index(50)) #获取50在列表中下标
# print(x[x.index(50)]) #根据位置取值
# print(x.count(50)) #统计50出现的次数
# x.clear() #清空x列表
# print(x)
# x.reverse() #反转x序列
# print(x)
# x.sort() #排序，从小到大，字母排序(ascii码排序的)，字母和数字不能一起排序。
# x.sort(reverse=True) #排序后反转
# x.sort(key=lambda x:x[-1]) #根据单词最后字母排序，待定
# sorted(x) #排序，全局函数，待定
# sorted(x, key=lambda n:n[1]) #第二个字母排序，待定
# print(x)
# x.extend([9,11,12]) #扩展，x列表中添加其它列表到里面
# print(x)
# x = ["a","b","c",["d","e"]] #可嵌套
# y = x.copy() #浅复制，y = x[:] 一样的效果
# print(x)
# print(y)
# x[2] = "zhao" #浅复制，完全复制第一层的值，独立的，不会跟随改变
# x[3][1] = "F" #第二层的值，只复制内存地址，会跟随改变
# print(x)
# print(y)
# x = y #赋值，指向同一内存，改其中一个列表，另一个也更改。
# import copy
# y = copy.deepcopy(x) #深复制，完成复制一份，不会跟随改变，占用双内存空间，少用
# for i in x: #列表循环，while,for常用
# print(i)
# print(x[::2]) #隔2个打印一个值
# x[0:-1:2] = [99,99,99,99,99] #同上，0 -1可以省略
# (3)列表其它操作
# name = list('weiyongchao')
# print(name)
# ['w', 'e', 'i', 'y', 'o', 'n', 'g', 'c', 'h', 'a', 'o']
# list(range(6))
# [0, 1, 2, 3, 4, 5] #常应用于for、while循环
# 50 in x
# True #判断是否在序列x中，not in相反
# x + name #两个序列相连，x本身内容不变
# [50, 50, 50]
# x #重复序列
# len(x) #获取序列长度
# min(x) #获取最小值
# max(x) #获取最大值
# sum(x) #求和
# x[:3] = [9,8,7,6,5] #替换掉列表中前三个值，替换必须是列表。
# x[::2] = [99,99,99,99,99] #其实到结束，每2个值替换为99；有几个数替换就写几个99.
# （4）range(范围)
# 跟列表类似，序列中的一种
# range(1,21,2) #取值1-21，步长值为2
# r = range(1,21,2)
# for i in r:
# print(i)2、元组
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Weiyc
# Tuple（元组） 内容不可修改，又叫只读列表
# （1）特性，可用序列的通用操作
# 可包含任意对象的有序结合（字符，数字，列表，元组。。。）
# 通过下标索引（位置偏移）访问元素
# 固定长度，异质，可任意嵌套
# 对象引用数组
# 内容是列表部分可修改
# （2）元组用圆括号或不用符号，不能是单个值。
t = (1,2,'Tom',1,[99,100])
# print(t.count(1)) #统计
# print(t.index(2)) #下标位置，这有这两个方法
# t1 = 1, #必须要有逗号，不然就无法构成元组。
# t = 1,2,'Tom'
# t =[:3]
# t + t1 #两个元组相连，各元组值不变
# a,b = 5 ,10 #a元组值5，b元组值10
# a,b = b ,a #与上相反3、字符串
# (3)转移符 \
# \n 换行转义符号
# \t tab键转义符号
# # 转义转义符号 r"c:\abc\xyz\tag.txt" r开头忽略转移符，b开头以字节声明，只能是ASCII码
# \a 响铃
# \b 退格
# \r 回车
# \' \" \?
# \0 空字符
# \ooo o开头以八进制数声明字符
# \xhh x开头以十六进制数声明字符
# （4）字符串序列通用操作
#max(url) #字符串按照ASCII码判断大小。
# （5）字符串内置操作
#'38'+ str(5)
# 385 # str全局函数,转换为str型
# s = 'www.baidu.com'
# 'x' + s[1:]
# 'xww.baidu.com' #替换字符，变通法
# format() 格式化输出
# name = "weiyc"
# age = 20
# job = "IT"
# print("姓名:"+name+",年龄:"+str(age)+",工作:"+job)
# print("姓名:{0},年龄:{1},工作:{2}".format(name, age, job)) # 效果同上
# print("姓名:{0},工作:{2},部门:{department}".format(name, job, department='tech')) # 后面须指定变量值,待定
name = "my \tis {name} {age}"
# print(name.capitalize()) # 首字母大写
# print(name.count("i")) # 统计a次数
# print(name.center(50, "-")) # 字符放中间，两边用-补齐
# print(name.endswith("yc")) # 搬到字符是否以什么结尾，是返回True,否返回False
# print(name.startswith("yc")) # 同上，开头
# print(name.expandtabs(tabsize=5)) #tab键\t 转为指定数量空格，不常用
# print(name.find("m")) # 返回下标位置,左边数匹配第一个
# print("weiyongchao".rfind("o")) # 返回下标位置,左边数匹配最后一个
# print(name.format(name="weiyc", age="18")) # 占位，格式化输出，常用。
# print(name.format_map({'name': 'wieyc', 'age': 18})) #不常用
# print('-1'.isnumeric()) # 判断是否纯数字(不含小数,负数),是返回True,否返回False，不持支byte数字（单字节）
# print(name.isalpha()) # 判断是否纯字母,是返回True,否返回False
# print('-1A'.isalnum()) # 判断是否纯字母数字(不含小数，负数),是返回True,否返回False，不持支byte数字
# print("1".isdecimal()) # 判断是否十进制数,是返回True,否返回False，不持支byte数字
# print("-1".isdigit()) # 判断是否纯整数(不含小数，负数),是返回True,否返回False；支持各种编码的数字，常用
# print("1dsf".isidentifier()) # 判断是否合法标识符（变量名），
# print("-11a".islower()) # 判断是否小写,不包含大写就True
# print("A-1.1".isupper()) #判读是否大写,不包含小写就True
# print("My Name1 Is-11.2".istitle()) # 判断首字符大写
# print("1.1".isspace()) # 判断是否空格
# print("fdasf".isprintable()) # 判读是否可打印文件，linux下不存在，tty文件，驱动程序等
# print("+".join(["1","2","3"])) # 用指定间隔符包列表内容链接为字符串，不指定间隔符为空，常用。
# print(name.ljust(50,"*")) # 长度不够50，后边用指定符合补充
# print(name.rjust(50,"*")) # 长度不够50，前边用指定符合补充
# print("weiyc".upper()) # 转换大写
# print(name.lower()) # 转换小写
# print("\nnihao\n".lstrip()) # 去左边回城空格
# print("\nnihao\n".rstrip()) # 去右边回城空格
# print("\nnihao\n".strip()) # 去两边边回城空格，常用
#
# p = str.maketrans("abcdef",'123456') # 创建对应关系，两边数量一致
# print("hello".translate(p)) # 把输入的字符中含abcdef的替换为123456，创建随机密码
#
# print(name.replace('w','x')) # 替换字符串中的w为x,实际name变量值不变，可以用重新赋值，常用
# print("weiyece".replace('e','x',2)) # 替换前两个e为x,替换的可以字符串
# print("1+2+3".split('+')) # 使用指定分割符分割字符串，并形成列表，常用
# print("1+2+3\n4+5".splitlines()) # 使用换行符分割，自动识别linux和windows换行符
# print("Weiyc".swapcase()) # 大小写互转
# print("weiyc".zfill(50)) # 不够指定数量字符，左边用0填充，十六进制用到4、字典
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Weiyc
# dictionary（字典）--映射分类 内容可修改
# （1）特性，访问效率优于列表，元组；无序，key必须是唯一的，so天生去重
# 通过键（key）,而非位置偏移（下标索引）访问数据
# 可包含任意对象的无序集合
# 可变长度，异质，可任意嵌套
# 属“可变映射”分类，可变数据类型
# 对象引用表(Hash Table)
# key-value
# 声明,{}显示结果
# >>>d = {} // 空字典表
# >>>emp = {'name':'tom','age':20} // {key:value,}
# >>>emp = dict(name='tom',age=20) // dict(key=value)结果同上
# >>>keys = ['name','age','job']
# >>>emp = dict.fromkeys(keys) //导入键值到字典
#
# 访问字典：
#
# 获取所有key值：dict.keys()
# 获取所有value值：dict.values()
# 通过key值过去value: dict.[key],类似索引和切片，实际范文字典value值，不要混淆。
# 迭代获取其中key值：for key in dict：key->为字典key值dict[key]->为key对应的value值
#
#
# 判断是否存在字典：
#
# 获取所有value值：dict.values()
# dict.[key]判断方法（没有key值，返回keyError,太粗暴）
# 使用in和not in 判断，访问bool值：key in dict key not in dict
#
# （1）key区分大小写
# >>>book = {'x':1,'y':2,'z':'nihao'}
# >>>book['x'] //访问单个键值
# >>>book.get('x') //结果同上，键值不存在不返回结果，不报错
# >>>book.get('X'，'未找到') //找不到键值，返回结果未找到
# >>>book.keys() //查询所有字典表的键
# >>>keys = list(x) //转换为列表
# >>>for key in book.keys()
# print(key) //查询所有字典表键，并打印，返回结果类型是视图
# >>>book.values() //查询所有字典表值
# >>>book.items() //查询所有字典表键和值
# >>>c = book.copy //复制
# >>>c.clear() //清除
# >>>book['x'] = 3 //修改键值
# >>>book.update(c) //合并，c不变
# >>>del book['x'] //删除键
# >>>c1 = book.pop('x') //删除并返回删除的键值
# >>>book.pop('X',None) //弹出不存在键，不返回报错信息，结果空
# >>>book = {'name':'weiyc','hello':hanshu}
# >>>def hanshu():
# print('hello.wei') //定义函数
# >>>book['hello']() //获取hello键的函数值
# >>>book.get('hello')() //结果同上
info = {
'stu1101':"TengLan Wu",
'stu1102':"LongZe Luola",
'stu1103':"XiaoZe Maliya",
}
info2 = {
'stu1101':"CangJingKong",
1:2,
3:4,
}
print(info)
# print(info['stu1101'])
# info['stu1101'] = "武藤兰" # 查，key不存在报错,尽量不用
# print(info.get("stu1101")) # 常用查，不存在返回None
# print('stu1101' in info) # 查，key存在字典中，返回True,否则返回False
# info["stu1104"] = "CangJingKong" # 改增
# info.setdefault("stu1101","aaa") # 查增,key不在返回None,并添加要查询的值，存在返回初始值
# info.update(info2) # 交叉增，info2字典合并到info字典，存在交叉的部分覆盖
# del info["stu1101"] # 通用删，不加key删除整个字典
# info.pop("stu1101") # 标准删，删除指定key,必须指定不然报错
# info.popitem() # 随机删,不能添加key,尽量不用
# print(info.values()) # 获取所有values值
# print(info.keys()) # 获取所有key值
# print(info.items()) # 报字典生产新的列表，列表中是按key-value生成各自元组
# print(info.fromkeys([6,7,8],'test')) # 少用，初始化新得字典，并给每个key初始化一个相同的value值；
# 跟info字没每关系，可改为dict.fromkeys；如果初始value值为列表，则共享内存地址，修改value值，其它key的value也修改
# dict 循环
# 方法1，只用这个
# for i in info:
# print(i,info[i]) #只有i的话，循环key值
#
# #方法2，需要转换为列表，资源消耗严重，不要用
# for k,v in info.items():
# print(k,v)
# 多级字典嵌套及操作
# av_catalog = {
# "欧美":{
# "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
# "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
# "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
# "x-art.com":["质量很高,真的很高","全部收费,屌比请绕过"]
# },
# "日韩":{
# "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
# },
# "大陆":{
# "1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]
# }
# }
# print(av_catalog)
# av_catalog["大陆"]["1024"][1] = "可以在国内做镜像" # 多件嵌套下修改
# av_catalog["大陆"]["1024"][1] += ",可以用爬虫爬下来"
# print(av_catalog["大陆"]["1024"])
#ouput
# ['全部免费,真好,好人一生平安', '服务器在国外,慢,可以用爬虫爬下来']5、集合
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Weiyc
# Sets（集合）
# （1）特性
# 集合的概念：是一个无序的，不重复的数据组合
# 去重：把一个列表变成集合，就自动去重
# 关系测试：测试两组数据的交集、并集、差集等关系
# 集合：把不同的组合在一起形成一个数据集合
# 集合分两种，可变集合（set）,不可变集合（frozenset）
# 集合内部结构和字典类似，但是不存储value,其中的元素也会进行hash运算，可以称得上是没有value的字典。
# 集合聚重
# 创建集合：
# 大括号包裹创建：b = {1,2,3,4,5} 这样创建的是可变集合
# 工厂方式创建：b = set([1,2,3,,4,5]), b = frozenset([1,2,3,4,5]) 不可变集合
#
#
# 访问集合：
# 迭代访问集合
# for var in set:
# print(var)
#
#
# 更新集合：
# set.add():更新可hash数据类型到集合，并维持原样。
# set.update()：如果传入的是一个序列，将被拆分为单个元素，并且去掉重复
# 由于集合中的数据元素需要进行hash运算，可变数据类型是不可以进行hash运算的，也就不能传递进来被更新
# 可变集合支持更新操作，不可变集合不支持该操作
# (2)常用操作
list_1 = [1,2,3,4,5,5,6,6,7]
set_1 = set(list_1) # 变为集合后自动去重
# print(set_1,type(set_1))
#
set_2 = set([11,2,33,44,2,55,66,55])
print(set_1,set_2)
#
# print(set_1.intersection(set_2)) # 交集，结果为set_1和set_2中相同的值
# print(set_1 & set_2) # 交集，符号法
#
# print(set_1.union(set_2)) # 并集，结果为set_1和set_2并为一个集合并去重
# print(set_1 | set_2) # 并集，符号法
#
# print(set_1.difference(set_2)) # 差集，结果为set_1有的值，但是在set_2中没有的值
# print(set_1 - set_2) # 差集，符号法
#
# set_3 = set([1,2,3,4,5])
# print(set_3.issubset(set_1)) # 子集，判断set_3是否为set_1的子集，返回bool值
# print(set_3 < set_1) # 子集，符号法
# print(set_1.issuperset(set_3)) # 父集，判断set_1是否为set_3的父集，返回bool值
# print(set_1 > set_3) # 父集，符号法
# print(set_1.symmetric_difference(set_2)) # 对称差集，两个集合在对方都没有的值，实际就是去掉重复的
# print(set_1 ^ set_2) #对称差集，符号法
#
# set_4 = set([6,7,8])
# print(set_3.isdisjoint(set_4)) # 互斥集，判断set_3和set_4的值都不同，返回bool值
#
# set_1.add(999) # 添加一项，更新可hash数据类型到集合，并维持原样
# set_1.update([888,333]) # 添加多项,如果传入的是一个序列，将被拆分为单个元素，并且去掉重复
# print(set_1)
# del set_1 # 删除集合，通用法
# set_1.remove(2) # 删除集合指定值，不指定值报错，删除后不返回删除值（返回None）
# print(set_1)
# print(set_1.pop()) # 随机删除值并返回改值，指定值报错
# set_1.clear() # 删除集合中所有数据元素，使其成为一个空集合
# print(set_1)
# print(set_1.discard(999) ) # 如果999是集合中的元素，从集合中删除对象,否则返回None
# print(1 in set_1) # in和not in可以判断某个元素是否在集合中，返回bool值，通用操作6、文件
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Weiyc
# data = open("yestterday",encoding="utf-8").read() # 打开文件，非正常操作
# f = open("yesterday2",'a',encoding="utf-8") # 变量赋值，文件句柄,指定读写模式、编码（windows默认gbk）
# 文件模式:
# f = open("yesterday2",'r',encoding="utf-8") # r 只读；
# f = open("yesterday2",'w',encoding="utf-8") # w 创建覆盖文件写，不能读
# f = open("yesterday2",'a',encoding="utf-8") # a 追加文件写不覆盖，不能读
# f = open("yesterday2",'r+',encoding="utf-8") # r+ 读写，追加的方式打开，在最后写
# f = open("yesterday2",'w+',encoding="utf-8") # w+ 写读，创建覆盖方式打开，在最后写，不常用
# f = open("yesterday2",'a+',encoding="utf-8") # a+追加读写
# f = open("yesterday2",'rb') # rb 二进制编码读,不能加编码，网络传输任务文件必须二进制，跨平台；开头有b标识
# f = open("yesterday2",'wb') # wb 二进制编码写
# f.write("hello\n".encode()) # 转换编码格式后写入，encode告诉现在用的是什么编码（默认utf-8），然后转为二进制
# data = f.read(5) # 读，默认读所有，可以指定字符长度，读完指针不归零
# print(data)
# f.write("himmmmm3\n") # 写，创建覆盖，慎用
# f.flush() # 强制刷新缓存到硬盘，用于实时文件写
# f.write("nihao\n")
# for i in range(5):
# print(f.readline()) # readlinde按行读
# print(f.readlines()) # readlines读全部行到一个列表,文件全部读到内存，只适合小文件
# low loop，尽量不用这种循环读文件
# for index,line in enumerate(f.readlines()):
# if index == 9:
# print('-------分割线--------')
# continue # 读到十行停止
# print(line.strip()) # 按行循环读，strip去掉换行符
# high big 尽量用这种循环读文件
# count = 0
# for line in f: # 按行循环读，读一行删一行，不占内存,使用的是迭代器
# if count == 9:
# print('-----分割线----')
# count += 1
# print(line)
# count += 1
# print(f.tell()) # 查看指针位置
# f.seek(0) # 指针归零
# print(f.seekable()) # 判断指针是否可移动，返回bool值，tty等文件不行，字符串、二进制等可以
# print(f.readable()) # 判断文件是否可读，返回bool值
# print(f.writable()) # 判断文件是否可写，返回bool值
# print(f.encoding) # 打印字符编码
# print(f.fileno()) # 打印在内存中的编号，基本不用
# print(f.errors) # 处理异常错误，底层使用，基本不用
# f.truncate(10) # 截断,默认从0开始截断，可指定位置开始截断，后面清空
# f.close() # 关闭保存，默认不关闭也保存
# print(f.closed) # 判断文件是否关闭，返回bool值# 文件修改
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Weiyc
# f = open("yesterday", 'r', encoding="utf-8")
# f_new = open("yesterday2", 'w', encoding="utf-8")
#
#
# for line in f:
# if "昨日当我年少轻狂" in line:
# line = line.replace("昨日当我年少轻狂", "昨天当我年少轻狂")
# f_new.write(line)
# f.close()
# f_new.close()
# def shell_sed(old_files,new_files,old,new):
# f = open(old_files,'r',encoding="utf-8")
# f_new = open(new_files,'w',encoding="utf-8")
# for line in f:
# if old in line:
# line = line.replace(old,new)
# f_new.write(line)
# f.close()
# f_new.close()
#
#
# shell_sed("yesterday","yesterday2","昨日当我年少轻狂", "昨天当我年少轻狂")7、数字
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Weiyc
# Number（数字）
# Python 支持int（整数）、float（浮点数）、bool（布尔值）、complex（复数）。long已取消。
# 2 是一个整数的例子。
# 长整数 不过是大一些的整数。
# 3.23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里，52.3E-4表示52.3 * 10-4。
# (-5+4j)和(2.3-4.6j)是复数的例子，其中-5,4为实数，j为虚数，数学中表示复数是什么？。
# （1）int（整数），var = 1 var = 10
# 在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
# 在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
# long（长整型） 3.x版本取消，统一为整数
# 跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
# 注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。
# math 数学模块
# >>>import math //导入模块
# >>>math.floor() //取最小整数，左移
# >>>math.ceil() //取最大整数，右移
# >>>math.trunc() //取整数
# >>>round(3.14) //四舍五入
#
# （2）float（浮点数）, var = 1.0 ,浮点数类似小数，包含小数。
# 十进制直接显示，8进制0o,十六进制0x,二进制0b.例，0o10
# 十进制转换其它，hex(number)转16进制,oct(number)转8进制,bin(number)转二进制。
# 10 + "10",不对；10 + int("10")强制转换整数，int("10",2)转换2进制；float强制转换浮点类型。
# decimal 浮点数模块
# >>>0.1 + 0.1 + 0.1 得5.55...不对
# >>>import decimal
# >>>decimal.Decimal('0.1') + decimal.Decimal('0.1') +decimal.Decimal('0.1') - decimal.Decimal('0.3') >>>Decimal('0.0') //正确
# >>>from decimal import Decimal
# >>>Decimal('0.1') + Decimal('0.1') //可以这样写，必须'0.1',不加引号得值不对
# （3） bool（布尔值） ,布尔值和布尔代数表示完全一致，一个布尔值只有True、False两种值。要么True,要么False。>>>type(5>3) //得值True.
# True对应值1，False对应值0.
# bool函数转换其它为bool值
# 非空非0为真
# o空（None）为假
# >>>bool(3)
# >>>bool(-3)
# >>>bool('sdfa') //得值True,真值为True
# >>>bool(0) () [] //0、0.0或空值，得值为Flase,None8、with语句
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Weiyc
f = open("yesterday", 'r', encoding="utf-8")
f2 = open("yesterday2", 'r', encoding="utf-8")
with open("yesterday",'r',encoding="utf-8") as f , \
open("yesterday", 'r', encoding="utf-8") as f2: # with语句有自动关闭文件功能 可以打开多个文件
print(f.readline())9、练习
（1）进度条
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Weiyc
import sys,time
for i in range(20):
sys.stdout.write("#") # stdout标准输出（屏幕输出），stdin标准输入（屏幕输入）
sys.stdout.flush() # 不刷新，会读到缓存后一次刷出
time.sleep(0.1) # 每隔0.1秒刷一个
# 该方法在linux中才能用（2）购物车
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Weiyc
phone = [
('ifhone',5000),
('mac',10000),
('watch',2000)
]
# print(phone)
shop_list = []
salary = input("请输入你的工资:")
if salary.isdigit(): # isdigit判断是否是数字，是返回True,否返回False
salary = int(salary)
# print(salary)
while True:
print("商品清单如下")
for index,item in enumerate(phone): # enumerate,将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
# 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(phone) and user_choice >= 0:
p_item = phone[user_choice]
if p_item[1] <= salary:
shop_list.append(p_item)
salary -= p_item[1]
print("add %s into shopping car,you current balnce is \033[31;1m %s \033[0m" % (p_item,salary))
print("已购商品清单",shop_list)
else:
print("\033[41;1m你的余额只剩%s\033[0m" % salary)
else:
print("product cdoe [%s] is not exist!" % user_choice)
elif user_choice == "q":
print("-----shopping list------")
for i in shop_list:
print(i)
print("your current is \033[31;1m %s \033[0m" % salary)
exit()
else:
print("invalid option")
CSDN联合极客时间，共同打造面向开发者的精品内容学习社区，助力成长！
更多推荐
4
0- 0
已为社区贡献1条内容
所有评论(0)