python中字典中数据类型不一致

python其他知识目录

 

1、一道题，选择商品的序号。程序员和用户各自面对的序号起始值

如有变量 googs = ['汽车','飞机','火箭'] 提示用户可供选择的商品：

0,汽车
1,飞机
2,火箭
用户输入索引后，将指定商品的内容拼接打印，如：用户输入0，则打印 您选择的商品是汽车。

goods=["汽车","飞机","大炮"]
for i in range(0,len(goods)):
    print(i,goods[i])
num=input("请输入要选择的商品序号：")
num=int(num)
text="您选择的产品是：%s"%(goods[num])
print(text)
-------------结果：
0 汽车
1 飞机
2 大炮
请输入要选择的商品序号：0
您选择的产品是：汽车

变形：
1,汽车
2,飞机
3,火箭
用户输入索引后，将指定商品的内容拼接打印，如：用户输入1，则打印 您选择的商品是汽车

goods=["汽车","飞机","大炮"]
for i in range(0,len(goods)):            #索引是从0开始
    print(i+1,goods[i])                  #用户看的数字，索引+1显示
num=input("请输入要选择的商品序号：")    #用户输入的是看的数字，做索引要-1
num=int(num)-1
text="您选择的产品是：%s"%(goods[num])
print(text)
------------结果：
1 汽车
2 飞机
3 大炮
请输入要选择的商品序号：1
您选择的产品是：汽车

不改变原代码，插入一个数字实现的思想

goods=["汽车","飞机","大炮"]
goods.insert(0,"0")               #列表前面插入一个字符
for i in range(1,len(goods)):      #索引从1开始
    print(i,goods[i])
num=input("请输入要选择的商品序号：")
num=int(num)
text="您选择的产品是：%s"%(goods[num])
print(text)
----------------结果：
1 汽车
2 飞机
3 大炮
请输入要选择的商品序号：1
您选择的产品是：汽车

2、#1,(1)(1,)()之间类型的区别

v1=1
v2=(1)
v3=(1,)
v4=()
print(type(v1),type(2),type(v3),type(v4))
------------结果：
<class 'int'> <class 'int'> <class 'tuple'> <class 'tuple'>
# 元组记得加逗号。小括号是元组，小括号只有一个数是数字，小括号一个数字加个逗号才是元组。 
[(1),(2),(3)]等价于[1,2,3]，

 3、数据类型总结：

int
 py2/py3
 除法
 强制转换：
  int('字符串') 【重要】
  int(布尔值)
bool
 强制转换：
  bool(整数) -> bool(1)/.. -> bool(0)
  bool(字符串) -> bool('xx') --> bool("")
  bool(列表) -> bool([]) --> bool([])
  bool(元组) -> bool(()) --> bool(空元组)
   v1 = bool(0)
   v2 = bool("")
   v3 = bool([])
   v4 = bool(())
   print(v1,v2,v3,v4) # False
str
 独有功能：upper/lower/split/strip/replace/isdigit/startswith/endswith/format/join/encode
 公共公共：
  len
  索引
  切片
  步长
  for循环
  删除【无】
  更新【无】
 强制转换：
  str(999) # "999"
  str(True) # "True"
  str(["唐开发",'李忠伟']) # "["唐开发",'李忠伟']" --> v2 = "".join(["唐开发",'李忠伟'])
  str(["唐开发",'李忠伟'])
list
 独有功能：append/insert/pop/remove/clear/ extend
 公共功能：
  len
  索引
  切片
  步长
  for循环
  删除
  更新
 强制转换：
  list("asdfadfasfdadfasfd")
   v1 = list("asdfadfasfdadfasfd")
   print(v1)
  list( (11,22,33,44,) )
   v1 = list( (11,22,33,44,) )
   print(v1)
tuple
 独有功能【无】
 公共功能：
  len
  索引
  切片
  步长
  for循环
  删除【无】
  更新【无】
 强制转换：
  tuple('adfadfasdfasdfasdfafd')
   tuple([11,22,33,44])
   v1 = list("asdfadfasfdadfasfd")
  print(v1)
  v1 = list( (11,22,33,44,) )
  print(v1)
  v1 = tuple('adfadfasdfasdfasdfafd')
  print(v1)
总结
常见的类型转换
 # 字符串转数字
 # 数字转字符串
 # 列表转元组
 # 元组转列表
 # 其他转bool时，只有：0 “” [] ()

 

4、#字符串是数字且有空格，先去掉空格才能int()吗#

li=[" 8 ","  12  "]
mcw=li[0]+li[1]
mcw2=int(li[0])+int(li[1])
mcw3=int("  5  ")+int(" 11  ")
mcw4=int("      12       ")
print(mcw)
print(mcw2,mcw3,mcw4)
--------------结果：
 8   12  
20 16 12

结论：字符类型的数字带有空格时，使用int()函数转化为数字时无需提前去空格。由上可得，转化的过

程中应该是做了去空格的操作了。

5、字典：

http://www.runoob.com/python/python-dictionary.html

5.1字典简单理解

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：

dkey1value1, key2value2 }

键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

>>>dict'a': 1, 'b': 2, 'b': '3'} >>> dict['b']'3'dict'a': 1, 'b': '3'}

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

一个简单的字典实例：
 
 
dict'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
 
 
也可如此创建字典：
 
 
dict1'abc': 456dict2'abc': 123, 98.6: 37 }

 

5.4、#添加键值对以及定义空字典添加键值对，update (增)

dic={}
dic["name"]="mcw"
dic["age"]=18
print(dic)
------------结果：
{'name': 'mcw', 'age': 18}
 #原有字典.update(另一个字典)  不存在的键添加，存在的键覆盖

userinfo={"username":"mcw","password":123456}
userinfo.update({"age":18,"password":654321})
print(userinfo)
---------------结果：
{'username': 'mcw', 'password': 654321, 'age': 18}

 

5.5#字典删除元素pop/del（删）

dic={"name":"mcw","age":18,"hobby":"music"}      #pop删除"hobby")
print(dic)
-----------结果：
{'name': 'mcw', 'age': 18}
 #del删除

userinfo={"username":"mcw","password":123456}
del userinfo["password"]
print(userinfo)
------------------结果：
{'username': 'mcw'}

 

5.3字典的修改：（存在就修改/不存在就增加）（改）

---value 是1 "1"不一样的注意

userinfo={"username":"mcw","password":123456} userinfo["username"]="xiaoma" print(userinfo) -------------结果： {'username': 'xiaoma', 'password': 123456}
 #多个键值修改

userinfo={"username":"mcw","password":123456}
userinfo.update({"username":"xiaoma","password":654321})
print(userinfo)
--------------------结果：
{'username': 'xiaoma', 'password': 654321}

5.2、#取字典元素：（查），

userinfo={"username":"mcw","password":123456}
print(userinfo['username']) #获取字典中单个键的值
print(userinfo.keys()) #keys获取字典中所有的键
print(userinfo.values()) #valuses获取字典中所有的值
------结果：
mcw
dict_keys(['username', 'password'])
dict_values(['mcw', 123456])

print(type(userinfo.values()))
---------结果：
<class 'dict_values'>

userinfo={"username":"mcw","password":123456}   #打印整个字典
print(userinfo)
--------------结果：
{'username': 'mcw', 'password': 123456}

userinfo={"username":"mcw","password":123456}
for v1,v2 in userinfo.items(): #items获取所有的键值对
print(v1,v2)
--------------结果：
username mcw
password 123456

for循环默认只循环字典中的键
userinfo={"username":"mcw","password":123456}
for i in userinfo:
 print(i)
-------------结果：
username
password

报错：接收的多了
for item,v in userinfo:
 print(item,v)
--------结果：
for item,v in userinfo:
ValueError: too many values to unpack (expected 2)

#字典.get(键)
“字典名["键"]”来取没有的键会报错。“字典.get(键)”、“字典.get(键，键不存在时的返回值)”同样能获取字典的值，字典中没有这个键的时候指定返回的值默认为none（特殊的数据类型，占内存空间的，是空的地址转为bool为false）
建议：尽量用get取字典，这样可以对键是否存在先做个判断

userinfo={"username":"mcw","password":123456}
result1=userinfo.get("username")
result2=userinfo.get("age")
print(result1,result2)
---------------结果：
mcw None

使用形式：
result=userinfo.get("键")
if result==None：
   print("键不存在")

5.5、#字典多行美观显示，注意不要忘记逗号

userinfo={
    "username":"mcw",
    "password":123456
}
print(userinfo)
---------结果：
{'username': 'mcw', 'password': 123456}

5.6、#字典和列表嵌套构建用户登录的案例

user_list=[]
while True:
    u=input("请输入用户：")
    if u=="N":
        break
    p=input("请输入密码：")
    v={}
    v["user"]=u
    v["pwd"]=p
    user_list.append(v)
print(user_list)
rec_str1=input("请输入用户：")
rec_str2=input("请输入密码：")
flag=0
for i in user_list:
    if i["user"]==rec_str1 and i["pwd"]==rec_str2:
        flag=1
if flag==1:
    print("请进行登录")
else:
    print("登录失败!")


完善后：
user_list=[]
while True:
    u=input("请输入用户：")
    if u=="N":
        break
    p=input("请输入密码：")
    v={}
    v["user"]=u
    v["pwd"]=p
    user_list.append(v)
print(user_list)
rec_str1=input("请输入用户：")
rec_str2=input("请输入密码：")
message="登录失败！"
for i in user_list:
    if i["user"]==rec_str1 and i["pwd"]==rec_str2:
            message="登录成功！"
            break
print(message)
-----------------结果：
请输入用户：mcw
请输入密码：123
请输入用户：xiaoma
请输入密码：123
请输入用户：N
[{'user': 'mcw', 'pwd': '123'}, {'user': 'xiaoma', 'pwd': '123'}]
请输入用户：mcw
请输入密码：123
登录成功！

5.7、单变量和双变量接收字典items()返回值

单变量和双变量接收字典items()返回值，单变量是循环接收字典键值对形成的元组，双变量一个接收键
，一个接收值。

---
v="4+3"
a,b=v.split("+")
print(a,b)
------结果：
4 3

v="4+3"
a=v.split("+")
print(a[0],a[1])
------------结果：
4 3

userinfo={"username":"mcw","password":123456}
for i in userinfo.items():
 print(i,type(i))
-------结果：
('username', 'mcw') <class 'tuple'>
('password', 123456) <class 'tuple'>

userinfo={"username":"mcw","password":123456}
for k,v in userinfo.items():
 print(k,v,type(k),type(v))
------------结果:
username mcw <class 'str'> <class 'str'>
password 123456 <class 'str'> <class 'int'>

5.8生成列表中每个元素都是相同键的字典

两个列表元素，一个当字典的键，另一列表每个元素都是字典分隔开来的值。合并成列表中有多个字典元素的方法.

li1=["name","age","hobby"]
li2=["mcw,18,study","xiaoma,19,music","yh,10,eat"]
print([[li1[j]+":"+li2[i].split(",")[j] for j in range(0,len(li1))] for i in range(0,len(li2))])
mcw=[{li1[j]:li2[i].split(",")[j] for j in range(0,len(li1))} for i in range(0,len(li2))]
print(mcw)
print(type(mcw[0]))
----------------结果：
[['name:mcw', 'age:18', 'hobby:study'], ['name:xiaoma', 'age:19', 'hobby:music'], ['name:yh', 'age:10', 'hobby:eat']]
[{'name': 'mcw', 'age': '18', 'hobby': 'study'}, {'name': 'xiaoma', 'age': '19', 'hobby': 'music'}, {'name': 'yh', 'age': '10', 'hobby': 'eat'}]
<class 'dict'>

 

===
列表，元组嵌套。加一个字典，嵌套，意义何在呢
int/bool/str list/tuple/dict可以相互嵌套，

字典值：能放各种 所有都能当
字典键 ：可以有：元组，数字，布尔值，字符串
               不可以：字典，列表 可hash的可以当key，字典和列表是可变的，不可hash，所以不能当键。

#元组 列表有序，字典无序，Python3.6之后字典有序了。