废弃共享单车现身二手交易平台：ofo车座卖19元
共享单车、共享充电宝、共享雨伞、共享KTV、共享睡眠舱……共享经济在过去的一年显得异常耀眼。而当资本的热潮退去，各种凑热闹、赶风口、投机套利、被过度催熟的公司开始退出市场。据不完全统计，目前共有19家投身共享经济的企业宣告倒闭或终止服务。与此同时，有人却打起了这批或报废或暂无运营方的产品的主意。
近日，北京晚报记者调查发现，有不少废品回收站回收报废或无主共享单车当做废铝卖，一些个人也“收集”废弃或经营方倒闭的共享单车、共享充电宝等在二手网站上自行交易。律师表示，大量收集、转卖超出无产权证明的共享产品并以此牟利，轻则构成侵权，重则有可能涉嫌构成盗窃罪。
共享单车现身二手交易平台
“我琢磨着还是买辆二手自行车出行方便，毕竟不是每次都能遇到共享单车，谁知上网一看，竟有共享单车公然出售。”市民汪先生表示。当天中午，记者在该线索提示下，通过检索“共享单车”等关键词，在二手物品交易平台“闲鱼”、“转转”上均发现与之有关的商品信息。值得注意的是，此前58集团旗下58同城、赶集网以及转转平台曾表示，全平台禁售共享单车二手买卖。
在“闲鱼”上，根据卖家“没心某人”发布的信息，其出售的车辆位于山东聊城，售价为180元，并表示“量大可议价，车架子全铝，九成新没有锁”。该卖主在信息下方配有多辆小蓝单车照片，这些单车车架均布满灰尘。而在“转转”平台上，另一位卖主“老马某途”发布的信息显示，他所售车辆位于湖北潜江，价格为140元，并表示“批量处理共享单车，九成新，发泡轮胎免打气，免修补，智能扫码锁也被本人改装。”
记者以收车人的身份联系到上述卖车人。据“没心某人”介绍，他通过“闲鱼”出售的小蓝单车是通过一位中间人搞到的，目前手里存了150余辆，“我只做小蓝单车，因为车架全铝，至于单车来源我不知道，我找的那个中间人说基本是从社会上收来的，部分来自北京。”
所售共享单车大多来源不明
随后，记者联系到该名中间商李某。李某表示，在他眼中，小蓝单车基本属于废品回收一类，他手里有大批量的废弃单车，大多直接拆掉当做铝来卖，“没心某人”是从他那里挑了些七八成新，还能骑的单车当做二手自行车来卖。记者了解到，老式自行车车架以铬钼钢制的为主流，价格便宜，但重量很重，又容易被氧化。而铝合金车架因轻且刚性强，抗锈效果也不错而被很多共享单车广泛采用。
“当初小蓝单车造的时候用全铝车架，还是6061铝合金棒，比广泛用于建筑门窗、幕墙的6063铝合金棒还要贵不少，即使现在又当成铝来回收，价格、销路也不错。”李某表示，他专挑全铝车身的共享单车做回收，除了小蓝单车，摩拜单车、哈罗单车等也有涉及，但拒绝透露具体来源。而卖主“老马某途”则声称自己的共享单车是厂商处理给他的，但无法出示任何交易证明或合法手续。
值得注意的是，记者在“闲鱼”、“转转”上均发现多位网友兜售零星共享单车，品牌涉及酷骑、小鸣、小蓝等，表示可挑选、可改装、包开锁。而这些网友的理由大多是公司倒闭，押金无法退还，只能扣留几辆兜售，希望以卖车的方式弥补损失。
化整为零拆成零部件卖
除了将八九成新的共享单车解除电子锁后直接在二手网站上交易，记者还发现，有不少人将电子锁重新改造乃至将共享单车零部件单独拆出后公然售卖。“这个智能扫码锁，我经过研究其原理已经成功改装，GPS定位系统也已破坏，可以放心使用。”卖主“老马某途”表示，凡是在本店购买共享单车的只收取工本费20元，包安装，外地包邮则为35元，“你如果手里有打不开的智能扫码锁也可以联系我来货改装，收费20元一个。”
由于共享单车的智能锁均内置锂电池、减速电机马达等，这些零部件也被人单独拆出售卖。来自广西桂林的阿咏表示，摩拜2017年产的3.7伏、容量为7800毫安的锂电池售价为48元，10000毫安的锂电池售价为58元，ofo2017年产的6伏、容量为2400毫安的电池售价为15元，“绝对好货，质量就不用说了，这种上千元的单车一把锁价值也是三百多元以上的，拆机下来后都没用过。”
在“闲鱼”平台上，记者还看到有单独出售ofo单车车座的信息。该名卖家表示，低价转让4箱共100个小黄车车座，不带共享单车的图标，售价为19元一个。但当记者联系上卖家咨询时，该卖家则拒绝透露车座来源。
近段时间洗牌相当激烈的共享充电宝也被不少人拆解回收。“我手里有一批共享充电宝拆下来的18650锂电池，是之前加盟某品牌共享充电宝的人做不下去处理给我的，由于锂电池的制造商为业内有名的飞毛腿电池有限公司，价格也还行，能卖50元左右。”位于石家庄的刘某对记者表示，自己拆解锂电池也冒了不小风险，“这玩意儿稍不注意容易炸，你要得多的话，外地走物流快递也不方便。”
卖车者称押金难退还
在“闲鱼”、“转转”等二手交易平台上，记者注意到有一群“特殊”的卖家，他们大多是共享单车的普通用户，手中却也扣留了两三辆共享单车用于售卖。“兜售酷骑单车！60元一辆！公司倒闭跑路，卖车弥补损失！可解锁！可挑选！可改装！不包邮。”一位来自郑州的冯先生表示，自己兜售共享单车实属无奈之举，此前花了298元注册的酷骑单车已经无法退押金，“已经投诉过，但是没有用，电话已经打了三个月，就没打通过。”
类似的情况也出现在南京网友“汽车卡卡”身上。“酷骑单车倒闭，卖车啦！欠我300元卖车弥补亏损。”“汽车卡卡”表示，自己售卖的单车还是曾经红极一时的“酷骑土豪金”，每辆售价60元，目前手里就存了两辆，“说实话，我即使把车都卖出去，也还是亏损一百多，只不过相比投诉，直接变卖还省点时间精力。”
记者注意到，在“汽车卡卡”、冯先生等卖家下面聚集了不少评论。有的网友表示支持：“早知道我押金退不出来也该直接变卖，省得去投诉，之前找中介办理还差点再被骗”。但也有网友表示质疑：“这车也能卖？”
这里面也不乏浑水摸鱼者。在“闲鱼”上，记者留意到有来自安徽的卖家以弥补押金为名，扣留了大量自行车，其中多为“酷骑单车”、“小鸣单车”等品牌。面对有网友质疑怎么囤了这么多辆车时，该名卖家表示：“扣一辆也是扣，扣十辆还是扣，要是都能卖出去，多出来的钱算酷骑弥补我的精神损失费和误工费。”
非产权人出售共享产品涉嫌犯罪
上海海耀律师事务所主任万文志表示，回收废旧的共享产品是否合法，主要要看出卖人是谁，以及出卖的单车的来源。如果是共享单车产权人（比如企业本身）因为维修成本过高而直接选择出售，则回收没有问题，但此种情形回收站应当要求出卖人提供产权证明。反之，如果出售人并非权利人，在此情况下，出售人涉嫌构成盗窃罪（如偷车来卖），或者涉嫌构成侵占罪（如平台用户把骑了的共享单车藏起来拿去卖），回收站老板或二手网站用户也有可能涉嫌构成收购赃物罪。
此外，万文志表示，从法律上讲，当经营方倒闭之后，经营方的所有财产（包括共享充电宝、共享单车）一般应当经过破产清算程序来进行处理。如果用户本身在向企业缴纳押金之后，获得了共享单车或充电宝的使用权，在押金与用户所占有的共享单车或充电宝实物等值的情况下，如果企业不向或无法向用户退回押金，用户对合法占有的共享单车或充电宝可以行使留置权，依法处理以维护自身的权益。
但是，如果用户以“维权”的名义，大量收集、转卖超出自己在平台支付未退的押金范畴的单车或充电宝，并以此牟利，轻则构成侵权（对他人合法物权的侵害），重则有可能涉嫌构成盗窃罪。值得注意的是，二手交易平台也负有监督管理责任，对网友涉嫌出售的非法商品有审查义务。
作者：北京晚报
责任编辑：
声明：本文由入驻搜狐号的作者撰写，除搜狐官方账号外，观点仅代表作者本人，不代表搜狐立场。
今日搜狐热点拒绝访问 | www.qizuang.com | 百度云加速
请打开cookies.
此网站 (www.qizuang.com) 的管理员禁止了您的访问。原因是您的访问包含了非浏览器特征(3fadc76fb0eb44f3-ua98).
重新安装浏览器，或使用别的浏览器第A06版：今日聚焦&&&&
第A01版第A02版第A03版第A04版第A05版第A06版第A07版第A08版第A09版第A10版第A11版第A12版第A13版第A14版第A15版第A16版
学生老师看过来 ofo可5元包月啦
&&&&马上又要开学了，记者17日从ofo昆明方面获悉，2月19日0时至2月28日24时，全国ofo师生认证用户，可在ofo共享单车APP端或官方微信用车界面购买9.9元包学期套餐或5元包月套餐，在套餐有效期内用车无需再另付车费。此外，和上周一样，认证用户也可在周末免费骑行ofo。本报记者&&张勇
<INPUT type=checkbox value=0 name=titlecheckbox sourceid="SourcePh" style="display:none">
新闻爆料热线：7 4156165 手机彩信爆料请发内容至： 短信爆料请发内容至：
云南日报报业集团版权所有，未经书面授权请勿转载或建立镜像，违者依法必究
YearPh-MonthPh-DayPh HourPh:MinutePh:SecondPh
云南网　滇ICP备　 经营许可证编号：滇B-2-4- (R) yunnan.cn All Rights Reserved since 2003.08
<input type="hidden" name="PubTime" id="PubTime" value=" YearPh-MonthPh-DayPh " />二进制转十进制
二进制：用 0和1 表示
二进制对应十进制对应计算关系：
& & &1 & & 1 & & 1 & &1 & &1 & 1 & 1 & 1
& 128 & 64 & 32 &16 & 8 & 4 & 2 & 1
第一排的1 和第二排的数字一一对应关系；第一排属于二进制；
第一排的8个1 等于 第二排8个数的总和 255；第二排属于十进制；
来看个例子：
例1：十进制200转成二进制
首先：200-128 = 72　　那么 128对应的1 有了
　　 & 72 - 64 = 8 & & & & & &那么64 对应的1有了
& & & & & 8 - 8 =0&　　 & & & & 那么8 对应的1 有了
那么没有匹配上的怎么办呢，别忘了二进制是由0和1组成的，没有匹配上的 用0 &补齐；
那么十进制200对应的二进制就计算出来了，如下图：
例2：二进制转成十进制
首先：先把对应关系写出来：
再来计算：
把所有二进制1对应的值相加起来，所有0对应的十进制忽略不计，所有1对应值的总和就是最终的十进制171。
python 求二进制：
得出二进制：'0b'
&&& bin(342)
'<span style="color: #b'
ASCII码与二进制
文件转二进制
文字--十进制--二进制（这里的十进制：指的是 文字所对应的ASCII码里边所对应的十进制）
计算机容量单位
每个字符由8位二进制组成
每一位0或者1所占的空间单位叫做bit(比特)，这是计算机中最小的表示单位
8bit = 1bytes字节，最小的存储单位，1bytes缩写为1B
1KB = 1024B
1MB = 1024KB
1GB =1024MB
1TB = 1024GB
1PB = 1024TB
1EB = 1024PB
1ZB = 1024EB
1YB = 1024ZB
1BB = 1024YB
字符编码的演化
ASCII GB2312 GBK1.0 GB18030 BIG5(台湾繁体)
后来有了：
Unicode(国际标准字符集 万国码 所有字符最少用16位（2个字节）来表示 。2**16 = 65535)
unicode两个作用：
　　支持了全球的语言，大家都可以用unicode
　　unicode包含了所有语言的映射关系
unicode优点：unicode解决了字符合二进制的对应关系。一个字符用2个空间。
unicode缺点：浪费很多存储空间和网络传输带宽
再后来，有了：
UTF-8(unicode编码的压缩和优化 目前使用最广泛)
UTF-8所有的字符和符号占用字节进行分类：
　　ascii码中的内容用1个字节保存
　　欧洲的字符用2个字节保存
　　东亚的字符用3个字节保存
UTF-16：使用2/4个字节表示左右字符；优先使用2个字节，否则使用4个字节表示。
UTF-32：使用4个字节表示所有字符。
windows系统中文版 默认编码：GBK
Mac OS \ Linux 系统默认编码：UTF-8
总结：UTF是为unicode编码 设计的一种在存储和传输时节省空间的编码方案。
python里使用编码
默认ASCII编码，默认不支持中文，支持中文需要加：#_*_ coding:utf-8 _*_ & &或者 &#!encoding:utf-8
默认UTF-8编码，默认支持中文，
浮点数和科学计算法、复数
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。
复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
浮点数的精确度问题
&？？？？？？？？？？？？？？？？？？？？？？？？？？？
问题：如何通过一个变量存储公司所有员工的名字？
列表是什么？
列表是一个数据的集合，集合内可以放任何数据类型，可对集合进行方便的增删改查。
L1 = [] 　　#定义空列表
列表的方法：
方法一：list1 = ["a","b"]　　#常用
方法二：list2 = list() 　　　#一般不用这种方法
列表的索引(也称下标)：
　　列表从左到右 下标是 从0开始0 1 2 3...
　　列表从右到左 下标是 从-1开始-1 -2 -3...
查询索引值：
list1.index(a) 　　#index查询找到第一个a程序就不走了，
list1[0] 　　#通过a的索引 得出a
list1[-1]　　#通过b的下标 得出b
当list1 = [1,2,3,4,4,4,4,4,4] 列表里出现元素相同时，统计相同次数
list1.count(4) 　　#统计得出:6
代表列表有6个4
切片：通过索引(或下标)截取列表中一段数据出来。
list1 = [1,2,3,4,4,4,4,4,4]
list1[0:2] 　　#得出 [1,2] ，列表切片顾头不顾尾，也可成list1[:2]
list1[-5:] 　　#得出[4,4,4,4,4]，取最后5个元素，只能从左往右取
按步长取元素：
list1 = [1,2,3,4,5,6,1,2,3,4,5]
list1[:6:2] 　　#得出:[1, 3, 5] 　　:2 代表步长 ，每隔两步取一个元素
list1[::2] 　　#得出:[1, 3, 5, 1, 3, 5] 　在列表所有元素中，每隔2步取一个数
list1 = ["a","b","c"]
list1.append("d") 　　#追加d到列表list1的最后 结果:['a', 'b', 'c', 'd']
list1.insert(1,"aa") 　　#插入aa到列表下标为1的之前 　　得出结果:['a', 'aa', 'b', 'c', 'd']
list1[1] = "bb" 　　#直接给对应位置赋值，即是修改 结果:['a', 'bb', 'b', 'c', 'd']
把['a', 'bb', 'b', 'c', 'd']里的前两个元素替换掉
list1[0:2] = "boy" 　　#结果:['b', 'o', 'y', 'b', 'c', 'd']
list1 = ['b', 'o', 'y', 'b', 'c', 'd']
list1.pop() 　　#默认删除最后一个元素 d
list1.remove("o") 　　#删除元素O remove只能一个一个删除
list1.remove(0) 　　#删除下标为0的元素 b
del list1[0] 　　#删除下标为0的元素 del是一个全局删的方法
del list1[0:2] 　　#del可以批量删除
7、for循环列表
list1 = [1,2,3,4,5,6,1,2,3,4,5]
使用for循环 循环列表list1里边的元素
range(10) 　　#生成0到10 的数字
使用for循环生成0 - 10 的数字
list1 = ["<span style="color: #","<span style="color: #","<span style="color: #","a","b","f","c","d","A","C","B"]
list1.sort()
结果：['<span style="color: #', '<span style="color: #', '<span style="color: #', 'A', 'B', 'C', 'a', 'b', 'c', 'd', 'f']
排序是按照ASCII码对应排序。
list1.reverse()
结果：['f', 'd', 'c', 'b', 'a', 'C', 'B', 'A', '<span style="color: #', '<span style="color: #', '<span style="color: #']
9、两个列表拼一块
list1 = [1,2,3,4,5]
list2 = [6,7,8,9]
list1 + list2 结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]
list1.extend(list2) 　　#把列表2扩展到list1中
结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]
list2.clear() 　　#清空list2
复制列表 list2 = list1.copy()
当列表只有一层数据，没有列表嵌套列表的情况下，复制后的列表和原来的列表是完全独立的。
当列表有多层嵌套的时候，列表嵌套里边的列表的内容是和 原有列表是共享的。
所以这个叫做：浅copy list1.copy()
需要借助python模块
import copy
list2 = copy.deepcopy(list1)
深copy 后，新的列表和旧的列表，不管有没有列表嵌套列表，都是完全独立的个体。
可以通过查看列表名对应的内存地址分辨 两个列表是否独立
查看python解释器里边的内存地址：id(变量名)
列表的特点
1、可以重复的
列表练习题
1、创建一个空列表，命名为names，往里面天添加old_driver，rain，jack，shanshan，peiqi，black，black_girl元素
names = []
names.append("old_driver")
names.append("rain")
names.append("jack")
names.append("shanshan")
names.append("peiqi")
names.append("black")
names.append("black_girl")
print(names)
#['old_driver', 'rain', 'jack', 'shanshan', 'peiqi', 'black', 'black_girl']
2、往names列表里black_girl前面插入一个alex
names.insert(names.index("black_girl"),"alex")
print(names)
#['old_driver', 'rain', 'jack', 'shanshan', 'peiqi', 'black', 'alex', 'black_girl']
3、把shanshan的名字改成中文 姗姗
names[names.index("shanshan")] = "姗姗"
print(names)
#['old_driver', 'rain', 'jack', '姗姗', 'peiqi', 'black', 'alex', 'black_girl']
4、往names列表里rain的后面插入一个子列表[oldboy,oldgirl]
names.insert(names.index("rain"),["oldboy","oldgirl"])
print(names)
#['old_driver', ['oldboy', 'oldgirl'], 'rain', 'jack', '姗姗', 'peiqi', 'black', 'alex', 'black_girl']
5、返回peiqi的索引
print(names.index("peiqi"))
6、创建新列表[1,2,3,4,2,5,6,2]，合并入names列表
list1 = [1,2,3,4,2,5,6,2]
names = names + list1
print(names)
['old_driver', ['oldboy', 'oldgirl'], 'rain', 'jack', '姗姗', 'peiqi', 'black', 'alex', 'black_girl', 1, 2, 3, 4, 2, 5, 6, 2]
7、取出names列表中索引4-<span style="color: #的元素
print(names[4:7])
#['姗姗', 'peiqi', 'black']
8、取出names列表中索引2-<span style="color: #的元素，步长为2
print(names[2:10:2])
#['rain', '姗姗', 'black', 'black_girl']
9、取出names列表中最后3个元素
print(names[-3:])
# [5, 6, 2]
10、循环names列表，打印每个元素的索引值，和元素
for i in names:
print(count,i)
count += 1
#另一方法：enumerate(names) 枚举
print(enumerate(names)) #直接取索引
for i in enumerate(names):
#打印的值是一个小列表
for index,i in enumerate(names):
print(index,i)
#打印的值不是列表了
11、循环names列表，打印每个元素的索引值和元素，当索引值为偶数，把对应的元素改成-1
for i in names:
if count%2 == 0 :
names[count] = -1
print(count,i)
count += 1
print(count,i)
count += 1
print(names)
for index,i in enumerate(names):
if index % 2 == 0:
# 代表偶数
names[index] = -1
print(index,i)
#打印的值不是列表了
print(names)
12、names里有3个2，请返回第2个2的索引值，不要人肉数，要动态找（提示，找到第一个2的位置，在此基础上再找第2个）
for i in names[names.index(2)+1:]:
if i == 2:
print(names.index(2)+1+ count )
count += 1
first_indext = names.index(2)
#第一个2的索引值
new_list = names[first_indext+1:]
#从第一个2的位置+1 开始切片，重新赋值给新的列表
second_index = new_list.index(2)
#查询2 在新的列表中的索引值
last_index = first_indext + second_index +1 #第一个的索引值+ '第二个的索引值+切片时候的+1'
print("第二个2 的index:",last_index)
13、现有商品列表如下：
products = [ ['Iphone8',6888],['MacPro',14800], ['小米6',2499],['Coffee',31],['Book',80],['Nike Shoes',799] ]
需打印出这样的格式
---------商品列表----------
0. Iphone8
5. Nike Shoes
print("---------商品列表----------")
for Index, i in enumerate(products):
print("%s %s
%s" % (str(Index) + ".", i[0], i[1]))
14、写一个循环，不断的问用户想买什么，用户选择一个商品编号，就把对应的商品添加到购物车里，最终用户输入q退出时，打印购物车里边的商品列表
shopping_car = []
while True:
print("---------商品列表----------")
for Index, i in enumerate(products):
print("%s %s
%s" % (str(Index) + ".", i[0], i[1]))
want = input("您想要买什么，请输入对象商品编号： 例&2&,输入&q&退出 &&")
if want.isdigit():
want = int(want)
if want & len(products)-1:
print("输入商品编号错误，没有该编号!!")
shopping_car.append(products[want])
print("已经将%s加入购物车"%products[want])
elif want == "q":
if len(shopping_car) & 0:
print("您已购买以下商品：")
for Index,i in enumerate(shopping_car):
print("%s %s
%s" % (str(Index) + ".", i[0], i[1]))
print("输入不正确！")
知识补充：
判断字符串是否是一个数字
"<span style="color: #".isdigit()
查看列表的长度
len(names)
break 退出也可以用标志位 来设置True False 进行循环判断退出
flag = True
while True:
flag = False
#标志位 设置False 结束循环
for循环和while循环的区别
while可以是死循环
for循环是有边界的
数据类型-字符串
字符串是一个有序的字符的集合，用于存储和标识基本的文本信息，
一对单引号、双引号、三引号中间包含的内容称之为字符串。
s = “abcd”
不可变（一旦声明，不能修改）
字符串的基本方法
s = "abcd"
print(s.swapcase())
#都变成大写字母
print(s.capitalize())
#都变成首字母大写
print(s.center(50,"*"))
#打印变量s的字符串 指定长度为50，字符串长度不够的用*号补齐
print(s.count("a",0,5))
#统计字符串a在变量里有几个；0,5代表统计范围是下标从0-5的范围
print(s.endswith("!"))
#是否是以什么结尾的。
print(s.startswith("a"))
#判断以什么开始
字符串中间的\t 被认为是tab 是4个或者8个空格
#整体意思是：a 有一个tab 然后 又有一个b
print(s.expandtabs(20))
#相当于在a和b中间的tab长度变成了20个字符，交互模式可看出效果
s.find("a",0,5)
#查找字符串，并返回索引
s.format()
#字符串格式化
s1 = "my name is {0},i am {1} years old"
print(s1.format("aaa",22))
#分别把{0}替换成aaa
{1}替换成22
#也可以写成如下
s1 = "my name is {name},i am {age} years old"
s1.format(name="aaa",age = 22)
#字典形式赋值
#s.format_map()
print(s.index("a"))
#返回索引值
print(s.isalnum())
#查看是否是一个阿拉伯字符 包含数字和字母
print(s.isalpha())
#查看是否是一个阿拉伯数字 不包含字母
print(s.isdecimal())
#判断是否是一个整数
print(s.isdigit())
#判断是否是一个整数
print(s.isidentifier())
#判断字符串是否是一个可用的合法的变量名
print(s.islower())
#判断是否是小写字母
print(s.isnumeric())
#判断只有数字在里边
print(s.isprintable())
#判断是否可以被打印，linux的驱动不能被打印
print(s.isspace())
#判断是否是一个空格
print(s.istitle())
#判断是否是一个标题
每个字符串的首字母大写
Hello Worlld
print(s.isupper())
#判断是否都是大写
# s.join()
name = ["a","b","<span style="color: #","<span style="color: #"]
name2 = "".join(name)
#列表转成字符串，把列表里边的元素都join到字符串中
print(name2)
s = "Hello World"
print(s.ljust(50,"-"))
#给字符串从左往右设置长度为50，字符串长度不够用 - 补充
print(s.lower())
#字符串都变成小写
print(s.upper())
print(s.strip())
#脱掉括号里边的，可以是空格 换行 tab ...
s.lstrip()
#只脱掉左边的空格
s.rstrip()
#只拖点右边的空格
# s.maketrans()
str_in = "abcdef"
#必须是一一对应
str_out = "!@#$%^"
#必须是一一对应
tt = str.maketrans(str_in,str_out)
#生成对应表，就像密码表一样
#结果：{97: 33, 98: 64, 99: 35, 100: 36, 101: 37, 102: 94}
print(s.translate(tt))
# s.translate方法调用 加密方法tt 给 s的字符串加密
#结果：H%llo Worl$
# s.partition()
s = "Hello World"
print(s.partition("o")) #把字符串用 从左到右第一个o把 字符串分成两半
#结果：('Hell', 'o', ' World')
s.replace("原字符","新字符",2)
#字符串替换，也可以写换几次 默认全换，可以设置count次数
s.rfind("o")
#查找最右边的字符，也有开始和结束
print(s.rindex("o") )
#查找最右边的字符的索引值
s.rpartition("o")
#从最右边的字符开始 把字符串分成两半
#已括号里边的把字符串分成列表，括号里可以是空格、等字符来分成列表
s.rsplit()
#从最右边以 某字符 来分开字符串
s.splitlines()
#设置以换行的形式 把字符串分成列表
print(s.swapcase())
#字母换成相反的大小写，大的变成小，小的变成大
#结果“：hELLO wORLD
#原来的“hello World”
#把字符串变成title格式
Hello World
s.zfill(40)
#把字符串变成40，字符串不够，从左往右用0 补齐
必须要会的
元组跟列表差不多，也是存一组数，只要一旦创建，就不能修改，所以也叫只读列表。
names = ("abc","ABC")
不可变的，如果元组中还包含其他可变元素，这些可变元素可以改变
index　　索引
count　　统计
切片　　[0,5]
显示的告知别人，此处数据是不可修改的
数据库连接配置信息等
hash，一般翻译为“散列”，也有直接翻译为“哈希”的，就是把任意长度的输入，通过散列算法，变成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不通的输入可能会散列成相同的输出，所以不可能从散列值来确定唯一的输入值，简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
hash值的计算过程是依据这个值的一些特征计算的，这就要求被hash的值必须固定，因此被hash的值必须是不可变的。
（不能保证输出的数据唯一的，容易造成冲突）
&&& hash("abc")
&&& hash((1,2,3))
数据类型分类
不可变类型
　　字符串
案例：如何在一个变量存储公司每个员工的个人信息？
names = [ &
["aaa",22,] &
["bbb",33,] &
["ccc",44,] &
...]？？？怎么查找 ？太麻烦了吧 &
字典是一种key ：value的数据类型，使用就像我们上学使用的字典，通过笔画、字母来查找对应页的详细信息
定义空字典info = {}
info = { &
"student01":"aaa", &
"student02":"bbb", &
"student03":"ccc"}查询：print(info["student01"])输出：aaa
key:value 结构
key 必须可hash、必须是不可变数据类型、必须唯一
value 可存放任意多个值、可修改、可以不唯一
无序的 （通过key查询）
字典查找速度快，为什么快？
因为：字典把每个key通过hash变成一个数字（数字是按照ASCII码表进行排序的），查询变快了，
list1 = ["<span style="color: #2","-343434","<span style="color: #4","A","<span style="color: #6","<span style="color: #7","C","<span style="color: #5666","<span style="color: #73777","<span style="color: #"]
list1.sort()
print(list1)
#打印list1
#结果： ['-343434', '122', '33', '434', '665666', '666', '777', '7773777', 'A', 'C']
# 字典方法
"student01":"aaa" ,
"student02":"bbb",
"student03":"ccc"
info["student04"] = "ddd"
info["student05"] = "eee"
info["student06"] = "fff"
# 判断student01在不在info字典里
print("student01" in info
# 返回True
print(info.get("student01"))
# 返回aaa，没有返回None
info["student01"]
# 获取对应的value ，如果没有这个key 就报错，所以一般用get
print(info.pop("student01"))
print(info.popitem())
# 随机删除一个key
del info["student02"]
# 删除的key ，如果没有删除的key 就报错 KeyError: 'student01'
info.clear()
# 清空字典
# 多级字典嵌套
dic1 = {"aaa": {"aa": 11}, "bbb": {"bb": 22}}
# 其他方法
"name1": [22, "it"],
"name2": [24, "hr"],
"name3": 33
"name1": 44,
"name4": 33,
info.keys() # 打印所有的key
info.values()
# 打印所有的value
info.items()
# 把字典转成一个列表
info.update(info2)
# 把两个字典合成一个,如果有重复的key ，info2里边的重复key会覆盖info里边的key
info.setdefault("student07","abcdef")
# 设置一个默认的key:value ,
# 如果info字典里没有key student07 ，那么info字典里有添加 student07:abcdef
# 如果info字典里已经手动添加了student07的key value，那么这里的student07:abcdef 就不起作用
print(info.fromkeys(["name1","name2"],"aaa") )
# 从一个可迭代的对象中批量生成key和相同的value
# 字典的循环
# 高效循环
for k in info:
print(k,info[k])
# 打印key value
# 另外一种方法 低效
for k,v in info.items():
# 先把字典转成列表，在循环，所以低效
print(k,v)
name2 [24, 'hr']
student07 abcdef
&字典练习题
#写代码，有如下字典，按照要求实现每一个功能
"k1":"v1",
"k2":"v2",
#<span style="color: #、请循环遍历出所有的key
for k in dic:
#<span style="color: #、请循环遍历出所有的value
for k in dic:
print(dic[k])
#<span style="color: #、请循环便利出所有的key 和value
for k in dic:
print(k,dic[k])
#<span style="color: #、请在字典中添加一个键值对 "k4":"v14",输出添加后的字典
dic["k4"] = "v4"
print(dic)
#结果：{'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'k4': 'v4'}
#<span style="color: #、请删除字典中键值对"k1","v1" 并输出删除后的自恋
dic.pop("k1")
print(dic)
#结果：{'k2': 'v2', 'k3': 'v3', 'k4': 'v4'}
#<span style="color: #、请删除字典中的键值“k5”，如果字典中不存在键“k5” ，则不报错，返回None
# dic.pop("k5") #返回None
#<span style="color: #、请获取字典中“k2”对应的值
print(dic.get("k2"))
#<span style="color: #、请获取字典中“k6”对应的值，如果键“k6”不存在，则不报错，并且让其返回None
print(dic.get("k6"))
#<span style="color: #、现有dic2 = {"k1":"v111","a":"b"} 通过一行操作使 dic2 ={'k1': 'v1', 'a': 'b', 'k2': 'v2', 'k3': 'v3'}
dic2 = {"k1":"v111","a":"b"}
dic = {"k1":"v1","k2":"v2","k3":"v3"}
dic2.update(dic)
print(dic2)
#<span style="color: #、组合嵌套题，写代码，有如下列表，按照要求实现每一个功能
lis = [["k",["que",20,{"k1":["tt",3,"<span style="color: #"]},89],"ab"]]
#<span style="color: #.1 将列表lis中的“tt”变成大写（用两种方式）
lis[0][1][2]["k1"][0] = "TT"
print(lis)
lis[0][1][2]["k1"]= ["TT",3,"<span style="color: #"]
print(lis)
#<span style="color: #.2 将列表中的数字3变成字符串“100”（用两种方式）
lis[0][1][2]["k1"][1] = "<span style="color: #0"
print(lis)
#<span style="color: #.3 将列表中的字符串“1”变成数字101（用两种方式）
lis[0][1][2]["k1"][2] = 101
print(lis)
#<span style="color: #、按照要求实现以下功能
#现有一个列表li = [1,2,3,"a","b",4,"c"],有一个字典（此字典是动态生成的，你并不知道他里面偶多少键值对，所以用dic = {}模拟此字典）；现在需要完成这样的操作，如果该字典没有“k1”这个键，那就创建这个“k1”和其对应的值（该键对应的值设置为空列表），并将列表li中的索引位为奇数对应的元素，添加到“k1”这个键对应的空列表中。如果该字典中有“k1 ”这个键，且k1对应的value是列表类型，那就将列表li中的索引位为奇数对应的元素，添加到“k1”这个键对应的值中。
li = [1,2,3,"a","b",4,"c"]
if "k1" not in dic :
dic["k1"] = []
for i in li:
if li.index(i)%2 == 0:
dic["k1"].append(i)
for i in li:
if li.index(i)%2 == 0:
dic["k1"].append(i)
print(dic)
如何找出同时买了iphone7和iphone8的人
iphone7 = ["alex","rain","jack","old_driver"]
iphone8 = ["alex","shanshan","jack","old_boy"]
both_list = []
for name in iphone8:
if name in iphone7:
both_list.append(name)
print(both_list)
这个方法很麻烦，需要写两个循环，而集合可以更方便来实现。
集合是一个无序的，不重复的数据组合。
去重，把一个列表变成集合，就自动去重了。
关系测试，测试两组数据之间的交集、差集、并集等关系
s = {} #如果为空，就是字典
s = {1,2,3,4} #就成了集合 set
s = {1,2,3,4,1,2} #有重复数据，显示结果就直接去重{1, 2, 3, 4}
列表转成给一个字典
l = [1,2,3,4,1,2]
l2 = set(l)
s = {1,2,3,4,5}
#定义一个集合
#{1, 2, 3, 4, 5, 6}
#{2, 3, 4, 5, 6}
#指定删除,如果不存在，就报错
s.remove(6)
#{2, 3, 4, 5}
#指定删除，如果不存在，不报错
s.discard(6)
#联合其他集合，可以添加多个值
s.update([7,8,9])
#{2, 3, 4, 5, 7, 8, 9}
#集合的关系测试
iphone7 = {"alex","rain","jack","old_driver"}
iphone8 = {"alex","shanshan","jack","old_boy"}
print(iphone7.intersection(iphone8))
print(iphone7 & iphone8)
{'jack', 'alex'}
{'jack', 'alex'}
print(iphone7.difference(iphone8))
print(iphone7 - iphone8)
{'rain', 'old_driver'}
{'rain', 'old_driver'}
#并集 把两个列表加起来
print(iphone7.union(iphone8))
print(iphone7 | iphone8)
{'rain', 'jack', 'old_driver', 'alex', 'shanshan', 'old_boy'}
{'rain', 'jack', 'old_driver', 'alex', 'shanshan', 'old_boy'}
把不交集的取出来
print(iphone7.symmetric_difference(iphone8))
{'rain', 'old_driver', 'shanshan', 'old_boy'}
s = {1,2,3,4}
s2 = {1,2,3,4,5,6,}
#超集 谁是谁的父集
print(s2.issuperset(s))
#s2是s的父集
print(s2 &= s)
print(s.issubset(s2)) #s是s2的子集
print(s &= s2)
#判断两个集合是否不相交
print(s.isdisjoint(s2))
#代表两个集合是相交的
s = {1,2,3,-1,-2}
s2 = {1,2,3,4,5,6}
s.difference_update(s2)
#求出s和s2 的差集，并把差集 覆盖给 s
结果：{-2, -1}
s.intersection_update(s2)
#求出s和s2的交集，并把交集 覆盖给 s
{1, 2, 3, 4, 5, 6}
16进制运算
二进制 0 1
十进制 0 1 2 3 4 5 6 7 8 9
八进制0 1 2 3 4 5 6 7
十六进制 ABCDEF
十进制转8 16的语法
oct(1) 　　#得出“0o1” 　　0o 代表八进制（很少用了）
hex(1) 　　#得出"0x1" 　　0x代表16进制（还经常在用） 或者后缀是BH
为什么要用16进制？ 本质上还是二进制。
16进制方便看
由于字节(byte)在计算机内部出现的频率较高，如果可以使用一种简洁的方式将它的内在含义准确表达出来，将会给我们带来很多方便。选择十六进制，是因为8位二进制的数字可以方便的转换为2个十六进制的数字。一个字节能且只能由一对十六进制来表示，比如可以表示为B6。如果使用4进制的话则需要使用4个数字来表示一个字节，不够简洁；使用8进制的话，最靠左的8进制数是由2位二进制数字来表示的，相比于使用16进制有些美中不足。
16进制转二进制
var = input("请输入十六进制：")
b = bin(int(var, 16))
补充知识：
chr(97) 　　#查看97在ascii里边对应的值
字符怎么存到硬盘上的
无论以什么编码在内存里显示字符，存到硬盘上都是二进制。
ascii编码(美国)：
GBK编码(中国)：
Shift_JIS编码(日本)：
ks_c_5601-<span style="color: #87编码(韩国)：
TIS-<span style="color: #0编码(泰国)：
不同编码的二进制是不一样的
要注意：存到硬盘上以何种编码存的，那么读的时候还得以同样的编码读，否则就乱码了。
字符编码的转换
在中国写个软件用的是gbk编码写的，那么放在美国的电脑上就乱码了，如果想显示中文，解决办法有：
1、让美国人的电脑上都装上gbk编码
2、把写的软件编码都改成utf-8
第1种方法不可能实现，第2种方法又太费时费力，所以以上两种方法是行不通的。
但是 由于所有系统的编码默认都支持unicode，unicode第二大功能是包含了与所有语言的编码映射关系，那么gbk的软件放在美国人的电脑上，加载到内存里，变成unicode编码，中文就可以正常显示了。
&unicode与gbk的映射表：
下载如下红圈中的han 就行
python3代码执行流程
python3默认文件编码：utf-8（解释器编码）
python3的内存里：全部是unicode
python3执行代码的过程：
1、解释器找到代码文件，把代码字符串按文件头定义的编码加载到内存，转成unicode
2、把代码字符串按照python语法规则进行解释
3、所有的变量字符都会以unicode编码声明
写一个实例，python3默认文件编码utf-8
在windows下打印一下，windows的默认编码是gbk
看图说明，打印出来的“路飞学城”已经变成了unicode编码，否则打印就乱码了。
而在python2里边，默认编码是ASCII编码，那么文件头声明是utf-8的代码，在windows中将显示乱码
执行代码：
python2环境运行乱码了，python3环境运行代码正常显示。
如何在windows上显示正常呢？
　　1、字符串以gbk格式显示
　　2、字符串以unicode编码
既然python2不会自动把文件编码转成unicode存在内存里，那么python3里自动转肯定是调用了什么方法，那么在python2里我们就手动使用这个方法：
UTF-8 -- &decode解码 --& Unicode
Unicode -- & encode编码 -- & GBK / UTF-8
decode示例：
encode示例：
　　文件编码默认 ：utf-8
　　字符串编码：unicode
　　文件编码默认：ascii
　　字符串编码默认：ascii
　　如果文件头声明了utf-8，那字符串的编码是utf-8
　　unicode是一个单独的类型
如何验证编码转对了呢？
看上节decode示例
utf-8 编码显示"路飞学城" 为12个字节，3个字节为一个中文。
unicode编码显示"路飞学城"为4个字节，
“路飞学城”的utf-8编码对应映射位置是“\xe8\xb7\xaf\xe9\xa3\x9e\xe5\xad\xa6\xe5\x9f\x8e”，\xe8\xb7\xaf代表路
“路飞学城”的unicode编码对应映射位置是“\u8def\u98de\u5b66\u57ce”，\u8def代表路
接下来我们在unicode对应的映射表里查找：
接下来我们在gbk对应的映射表里查找：
“路飞学城”的gbk编码对应映射位置是“\xc2\xb7\xb7\xc9\xd1\xa7\xb3\xc7”，\xc2\xb7代表路。
根据上图16进制计算映射表对应的值：
去掉第一行 128所在的高字节，这个是python的unicode在映射表上表达忽略了高字节，真正映射的时候还是需要高字节对的；
然后分别算出 每一个16进制对应的十进制的和；
最后将4个数组合就是unicode映射表。
python bytes类型
二进制的组合转换成16进制来表示就称之为bytes类型，即字节类型，它把8个二进制组成一个bytes，用16进制来表示。
在python2里，bytes类型和字符串是本质上时没有区分的。
　　str = bytes
　　python2 以utf-8编码的字符串，在windows上不能显示，乱码。
　　如何在python2下实现一种，写一个软件，在全球各国电脑上 可以直接看？
　　　　以unicode编码写软件。
　　　　s = you_str.decode("utf-8")
　　　　s2 = u"路飞"
　　unicode类型 也算字符串
python2：以utf-8 or gbk 编码的代码，代码内容加载到内存，并不会被转成unicode，编码依然是utf-8 or gbk。。。
python3：以utf-8 or gbk编码的代码，代码内容加到在内存，会被自动转成unicode。
在python3里，bytes类型主要来存储图片、视频等二进制格式的数据
　　str = unicode
　　默认就支持了全球的语言编码
为什么 python2里
默认不支持中文，初期 格局不够，python2的开发者没有想到python会发展这么快，发展这么强大。python2越来越臃肿、不简洁，终于python3解决了这些问题。
最后总结，python里只要出现各种编码问题，无非是哪里的编码设置出错了
常见编码错误的原因有：
　　1、python解释器的默认编码
　　2、python源文件文件编码
　　3、终端使用的编码（windows/linux/os）
　　4、操作系统的语言设置
本章练习题
#<span style="color: #、请用代码实现：利用下划线将列表的每一个元素拼接成字符串，li=["alex","eric","rain"]
li=["alex","eric","rain"]
s1 = "_".join(li)
#输出alex_eric_rain
#<span style="color: #、查找列表中元素，移除每个元素的空格，并查找以a或A开头并且以c结尾的所有元素。
li = ["alex","aric","Alex","Tony","rain"]
tu = ("alex","aric","Alex","Tony","rain")
dic = {"k1":"alex","k2":"aric","k3":"Alex","k4":"Tony"}
list1 = []
for i in li:
i = i.strip()
if i.startswith("a") | i.startswith("A") and i.endswith("c") :
list1.append(i)
print(list1)
list2 = []
for i in tu:
i = i.strip()
if i.startswith("a") | i.startswith("A") and i.endswith("c") :
list2.append(i)
print(list2)
list3 = []
for i in dic:
i = dic[i].strip()
if i.startswith("a") | i.startswith("A") and i.endswith("c") :
list3.append(i)
print(list3)
#<span style="color: #、写代码，有如下列表，按照要求实现每一个功能
li = ["alex","eric","rain"]
#计算列表长度并输出
print(len(li))
#列表中追加元素“seven”，并输出添加后的列表
li.append("seven")
#输出：['alex', 'eric', 'rain', 'seven']
#请在列表的第一个位置插入元素“Tony”，并输出添加后的列表
li.insert(0,"Tony")
#输出：['Tony', 'alex', 'eric', 'rain', 'seven']
#请修改列表第2个位置的元素为“Kelly”，并输出修改后的列表
li[1] = "Kelly"
#输出：['Tony', 'Kelly', 'eric', 'rain', 'seven']
#请删除列表中的元素“eric”，并输出修改后的列表
li.remove("eric")
#请删除列表中的第二个元素，并输出删除的元素的值和删除元素后的列表
print(li.pop(1))
#输出：['Tony', 'rain', 'seven']
#请删除列表中的第2至4个元素，并输出删除元素后的列表
# li.pop(2,5)
#此处已经只有3个元素了，无法删除第4个元素
# print(li)
#请将列表所有的元素反转，并输出反转后的列表
li.reverse()
#输出：['seven', 'rain', 'Tony']
#请使用for、len、range输出列表的索引
for i in range(len(li)):
#请使用enumrate输出列表元素和序号（序号从100开始）
for index,i in enumerate(li):
print(index+100,i)
#请使用for循环输出列表的所有元素
for i in li:
#<span style="color: #、写代码，有如下列表，请按照功能要求实现每一个功能
li = ["hello","seven",["mon",["h","kelly"],"all"],123,446]
#请根据索引输出“kelly”
print(li[2][1][1])
#请使用索引找到“all”元素并将其修改为“ALL”，如li[0][9]...
li[2][2] = "ALL"
#输出：['hello', 'seven', ['mon', ['h', 'kelly'], 'ALL'], 123, 446]
#<span style="color: #、写代码，有如下元组，按照要求实现每一个功能
tu = ("alex","eric","rain")
#计算元素长度并输出
print(len(tu))
#获取元素的第二个元素，并输出
print(tu[1])
#输出：eric
#获取元组的第1-2个元素，并输出
print(tu[0:2])
#输出：('alex', 'eric')
#请使用for输出元组的元素
for i in tu:
#请使用for，len，range输出元组的索引：
for i in range(len(tu)):
#请使用enumrate输出元组元素和序号（序号从10开始）
for index,i in enumerate(tu):
print(index+10,i)
#<span style="color: #、有如下变量，请事先要求的功能
tu = ("alex",[11,22,{"k1":"v1","k2":["age","name"],"k3":(11,22,33)},"<span style="color: #"])
#讲述元组的特性
元组的特点：有序的，不可变的
#请问tu变量中的“k2”对应的值是什么类型？是否可以被修改?如果可以，请在其中添加一个元素“Seven”
#“k2”对应的值是：列表，可以被修改
tu[1][2]["k2"].append("Seven")
#输出：('alex', [11, 22, {'k1': 'v1', 'k2': ['age', 'name', 'Seven'], 'k3': (11, 22, 33)}, '44'])
#请问tu变量中的“k3”对应的值是什么类型？是否可以被修改？如果可以，请在其中添加一个元素“Seven”
#“k3”对应的值是元组，元组的元素不可以修改。
#<span style="color: #、字典
dic = {"k1":"v1","k2":"v2","k3":[11,22,33]}
#请循环输出所有的key
for k in dic:
#请循环输出所有的value
for k in dic:
print(dic[k])
#请循环输出所有的key和value
for k in dic:
print(k,dic[k])
k3 [11, 22, 33]
#请在字典中添加一个键值对，“k4”：“v4”，输出添加后的字典
dic["k4"] = "v4"
print(dic)
#输出：{'k1': 'v1', 'k2': 'v2', 'k3': [11, 22, 33], 'k4': 'v4'}
#请在修改字典中“k1”对应的值为“alex”，输出修改后的字典
dic["k1"] = "alex"
print(dic)
#输出：{'k1': 'alex', 'k2': 'v2', 'k3': [11, 22, 33], 'k4': 'v4'}
#请在k3对应额值中追加一个元素44，输出修改后的字典
dic["k3"].append(44)
print(dic)
#输出：{'k1': 'alex', 'k2': 'v2', 'k3': [11, 22, 33, 44], 'k4': 'v4'}
#请在k3对应的值的第1个位置插入一个元素18，输出修改后的字典
dic["k3"].insert(0,18)
print(dic)
#输出：{'k1': 'alex', 'k2': 'v2', 'k3': [18, 11, 22, 33, 44], 'k4': 'v4'}
#<span style="color: #、转换
#将字符串s = "alex" 转换成列表
s = list("alex")
#输出：['a', 'l', 'e', 'x']
#将字符串s = "alex" 转换成元组
s = tuple("alex")
#输出：('a', 'l', 'e', 'x')
#将列表li = ["alex","seven"] 转换成元组
li = tuple(["alex","seven"])
#输出：('alex', 'seven')
#将元组tu = ("Alex","seven")转换成列表
tu = list(("Alex","seven"))
#输出：['Alex', 'seven']
#将列表li = ["alex","seven"]转换成字典且字典的key按照10开始向后递增
li = ["alex","seven"]
count = 10
for v in li:
dic[count] = v
print(dic)
#输出：{10: 'alex', 11: 'seven'}
#<span style="color: #、元素分类
#有如下值集合[11,22,33,44,55,66,77,88,99,90],将所有大于66的值保存至字典的第一个key中，
#将小于66的值保存至第二个key的值中。
#即：{"k1":大于66的所有制,"k2":小于66的所有制}
dic = {"k1": [],"k2":[]}
for i in [11,22,33,44,55,66,77,88,99,90]:
if i & 66:
dic["k1"].append(i)
elif i & 66:
dic["k2"].append(i)
print(dic)
#输出：{'k1': [77, 88, 99, 90], 'k2': [11, 22, 33, 44, 55]}
#<span style="color: #、输出商品列表，用户输入序号，显示用户选中的商品
#商品li = ["手机","电脑","鼠标垫","游艇"]
#允许用户添加商品
#用户输入序号显示内容
li = ["手机","电脑","鼠标垫","游艇"]
while True:
print("---------商品列表----------")
for index,i in enumerate(li):
print(index,i)
"\033[32m添加商品用请输入:&add&\033[0m")
user_input = input("请输入商品序号：")
if user_input.isdigit():
user_input = int(user_input)
if user_input & len(li)-1:
print("商品不存在")
print("您已选中商品：[%s]"% li[user_input])
elif user_input == "add":
goods_input = input("请输入你要添加的商品：")
li.append(goods_input)
print("输入格式不正确，请输入商品序号！！")
#<span style="color: #、用户交互显示类似省市县N级联动的选择
#允许用户增加内容
#允许用户选择查看某一个级别内容
#看后续作业增加需求; 4
#<span style="color: #、列举布尔值是False的所有值
print(2&3)
print("abc".isdigit())
print(len(["<span style="color: #","<span style="color: #"]) & 5)
#<span style="color: #、有两个列表
l1 = [11,22,33]
l2 = [22,33,44]
l1 = set(l1)
l2 = set(l2)
#获取内容相同的元素列表
print(l1.intersection(l2))
#获取l1中有，l2中没有的元素列表
print(l1.difference(l2))
#获取l2中有，l3中没有的元素列表
print(l2.difference(l3))
#获取l1和l2中内容都不同的元素
print(l1.symmetric_difference(l2))
#<span style="color: #、利用for循环和range输出
#for循环从小到大输出1 - 100
# for i in range(1,101):
#for循环从大到小输出100 - 1
# for i in range(100,0,-1):
#while循环从大到小输出100 - 1
# count = 100
# while True:
print(count)
if count == 1:
count -= 1
#while循环从小到大输出1 - 100
# count = 1
# while True:
print(count)
if count == 100:
count += 1
#<span style="color: #、利用for循环和range输出9*9乘法表
for y in range(1,10):
for x in range(1,y+1):
print("%d*%d=%d" % (x, y, x*y),end="|") #end=" " 表示不换行打印，双引号中间是不换行的隔离符号
#换行，这里是空格代表换行，
#python2.x 不换行符是在print之后加逗号就行，如：
print (XXX),
# 输出结果：
# 1*2=2|2*2=4|
# 1*3=3|2*3=6|3*3=9|
# 1*4=4|2*4=8|3*4=12|4*4=16|
# 1*5=5|2*5=10|3*5=15|4*5=20|5*5=25|
# 1*6=6|2*6=12|3*6=18|4*6=24|5*6=30|6*6=36|
# 1*7=7|2*7=14|3*7=21|4*7=28|5*7=35|6*7=42|7*7=49|
# 1*8=8|2*8=16|3*8=24|4*8=32|5*8=40|6*8=48|7*8=56|8*8=64|
# 1*9=9|2*9=18|3*9=27|4*9=36|5*9=45|6*9=54|7*9=63|8*9=72|9*9=81|
#简写的方法
print('\n'.join([ ' '.join([ "%d*%d=%1s" %(y,x,x*y) for y in range(1,x+1)]) for x in range(1,10)]))
1、三级菜单
现有省、市、县3级结构，要求程序启动后，允许用户依次选择进入各子菜单
可在任意一级菜单返回上一级
可以在任意一级菜单退出程序
所需知识：列表字典
数据结构：
'五道口':{
'soho':{},
'网易':{},
'google':{}
'中关村':{
'爱奇艺':{},
'汽车之家':{},
'youku':{},
2、写程序：购物车程序
功能需求：
1、启动程序后，输入用户名密码后，让用户输入工资，然后打印商品列表
2、允许用户根据商品编号购买商品
3、用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒
4、用户可随时退出，退出时，打印已购买商品和余额
5、在用户使用过程中，关键输出，如余额，商品已加入购物车等信息，需高亮显示
扩展需求：
1、用户下一次登录后，输入用户名密码，直接回到上次的状态，即上次消费的余额等的信息，再次登录可继续该买
2、允许查询之前的消费记录
数据结构：
{"name":"电脑","price": 1999},
{"name":"鼠标","price": 10},
{"name":"游艇","price": 200},
{"name":"ipad","price": 888},
阅读(...) 评论()