python字典为空

① python中字典为什么传递了不显示

因为字典对象是可变的，它是一个容器类型。
代码如下uhash的值是从网址中截取的然后传递给一个php页面，应该返回一个文件流，但返回的不是文件流。但是把uhash值用字面值赋值，就可以返回文件流。
字典是一个无序、可变和有索引的集合。在Python中，字典用花括号编写，拥有键和值。Python中的字典是python的一种数据结构，它的本质是key和value以及其对应关系的一种集合，一个key可以对应一个多个value。合理的使用字典能给我们编程带来很大的方便。

② 我的python为什么dict没有isnull方法

get()如果返回none就是没有找到key，
或者用in来判断是否在里面
和你要的isnull效果一样

③ Python字典遇到的value中遇到None跳出问题

#没有什么特别的算法，循环加上判断就可以了。。。
hosts={"a":"111","b":None,"c":"333"}
hname=""
for(k,v)inhosts.items():
ifv==None:
print"key:%s,value="%(k)
else:
print"key:%s,value=%s"%(k,v)
#key:a,value=111
#key:c,value=333
#key:b,value=

④ python3 defaultdict 和 dict的区别

yangyzh
Python中dict详解

python3.0以上，print函数应为print（），不存在dict.iteritems()这个函数。

在python中写中文注释会报错，这时只要在头部加上# coding=gbk即可

#字典的添加、删除、修改操作
dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}
dict["w"] = "watermelon"
del(dict["a"])
dict["g"] = "grapefruit"
print dict.pop("b")
print dict
dict.clear()
print dict
#字典的遍历
dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}
for k in dict:
print "dict[%s] =" % k,dict[k]
#字典items()的使用
dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
#每个元素是一个key和value组成的元组，以列表的方式输出
print dict.items()
#调用items()实现字典的遍历
dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}
for (k, v) in dict.items():
print "dict[%s] =" % k, v
#调用iteritems()实现字典的遍历
dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
print dict.iteritems()
for k, v in dict.iteritems():
print "dict[%s] =" % k, v
for (k, v) in zip(dict.iterkeys(), dict.itervalues()):
print "dict[%s] =" % k, v

#使用列表、字典作为字典的值
dict = {"a" : ("apple",), "bo" : {"b" : "banana", "o" : "orange"}, "g" : ["grape","grapefruit"]}
print dict["a"]
print dict["a"][0]
print dict["bo"]
print dict["bo"]["o"]
print dict["g"]
print dict["g"][1]

dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
#输出key的列表
print dict.keys()
#输出value的列表
print dict.values()
#每个元素是一个key和value组成的元组，以列表的方式输出
print dict.items()
dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
it = dict.iteritems()
print it
#字典中元素的获取方法
dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
print dict
print dict.get("c", "apple")
print dict.get("e", "apple")
#get()的等价语句
D = {"key1" : "value1", "key2" : "value2"}
if "key1" in D:
print D["key1"]
else:
print "None"
#字典的更新
dict = {"a" : "apple", "b" : "banana"}
print dict
dict2 = {"c" : "grape", "d" : "orange"}
dict.update(dict2)
print dict
#udpate()的等价语句
D = {"key1" : "value1", "key2" : "value2"}
E = {"key3" : "value3", "key4" : "value4"}
for k in E:
D[k] = E[k]
print D
#字典E中含有字典D中的key
D = {"key1" : "value1", "key2" : "value2"}
E = {"key2" : "value3", "key4" : "value4"}
for k in E:
D[k] = E[k]
print D
#设置默认值
dict = {}
dict.setdefault("a")
print dict
dict["a"] = "apple"
dict.setdefault("a","default")
print dict
#调用sorted()排序
dict = {"a" : "apple", "b" : "grape", "c" : "orange", "d" : "banana"}
print dict
#按照key排序
print sorted(dict.items(), key=lambda d: d[0])
#按照value排序
print sorted(dict.items(), key=lambda d: d[1])
#字典的浅拷贝
dict = {"a" : "apple", "b" : "grape"}
dict2 = {"c" : "orange", "d" : "banana"}
dict2 = dict.()
print dict2

#字典的深拷贝
import
dict = {"a" : "apple", "b" : {"g" : "grape","o" : "orange"}}
dict2 = .deep(dict)
dict3 = .(dict)
dict2["b"]["g"] = "orange"
print dict
dict3["b"]["g"] = "orange"
print dict

补充：
1 初始化
>>> d = dict(name='visaya', age=20)
>>> d = dict(zip(['name', 'age'], ['visaya', 20]))

#dict.fromkeys(listkeys, default=0) 把listkeys中的元素作为key均赋值为value，默认为0
>>> d = dict.fromkeys(['a', 'b'], 1)
>>> d
{'a': 1, 'b': 1}
2 字典视图和几何
dict.keys()类似信使可以进行交集和并集等集合操作（类似集合，因为不存在重复的项），但dict.values()不可以进行如上操作。

>>> k = d.keys()
>>> k
dict_keys(['a', 'b'])
>>> list(k)
['a', 'b']
>>> k | {'x': 3}
{'a', 'x', 'b'}
>>> k | {'x'}
{'a', 'x', 'b'}
>>> k | {'x', 'y'}
{'a', 'y', 'b', 'x'}
>>> k & {'x'}
set()
>>> v = d.values()
>>> v
dict_values([1, 2])
>>> v | {'x'}
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: unsupported operand type(s) for |: 'dict_values' and 'set'
3 排序字典键
两种方法:
3.1 sort:
>>> Ks = list(d.keys())
>>> Ks.sort()
>>> for k in Ks:
... print(k, d[k])
...
a 1
b 2
3.2 sorted:
>>> for k in sorted(d.keys()):
... print(k, d[k])
...
a 1
b 2

3.3 注意
>>> for k in list(d.keys()).sort():
... print(k, d[k])
...
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: 'NoneType' object is not iterable

出错原因：
list.sort() list.append()函数都是对自身的操作，没有返回值，故需先将list(d.keys())的结果保存下来，在结果上进行sort()
4 常用函数
4.1 get()
D.get(k[, d]) => D[k] if k in D else d. d defaults to none.
4.2 pop()
D.pop(value[, d]) => Remove specified key and return the corresponding value. If key is not found, d is returned if given, otherwise KeyError is raised.
4.3 udpate()
D.update(E, **F) -> None. Update D from dict/iterable E and F.
If E has a .keys() method, does: for k in E: D[k] = E[k]
If E lacks .keys() method, does: for (k, v) in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]

>>> d = dict(name='visaya', age=21)
>>> d1= {'age': 20, 'sex': 'male'}
>>> d2 = zip(['a', 'b'], [1, 2])

>>> d.update(d1)
>>> d
{'age': 20, 'name': 'visaya', 'sex': 'male'}
#for k in d1: d[k] = d1[k]

>>> d.update(d2)
>>> d
{'age': 20, 'name': 'visaya', 'sex': 'male'}
#for (k, v) in d2: d[k] = v
4.4 del()
del D[key]
4.5 clear()
4.6 ()
Python中的dict
初始化
构造方法创建
Python代码
d = dict()
d = dict(name="nico", age=23)
d = dict((['name', "nico"], ['age', 23]))
当然还有更方便，简单的
Python代码
d = {}
d = {"name":"nico", "age":23}

遍历
通过对key的遍历，遍历整个dict

Python代码
d = {"name":"nico", "age":23}
for key in d:
print "key=%s, value=%s" % (key, d[key])

for key in d.iterkeys():
print "key=%s, value=%s" % (key, d[key])

for key in d.keys():
print "key=%s, value=%s" % (key, d[key])

for key in iter(d):
print "key=%s, value=%s" % (key, d[key])

for key,item in d.items():
print "key=%s, value=%s" % (key, item)

当然也可以直接遍历value

Python代码
d = {"name":"nico", "age":23}
for value in d.values():
print value

for key,value in d.viewitems():
print "key=%s, value=%s" % (key, value)

for value in d.viewvalues():
print "value=%s" % (value)
这里values和viewvalues的区别

后者返回的是该字典的一个view对象，类似数据库中的view，当dict改变时，该view对象也跟着改变

常用方法

Python代码
d = {"name":"nico", "age":23}
d["name"] = "aaaa"
d["address"] = "abcdefg...."
print d #{'age': 23, 'name': 'aaaa', 'address': 'abcdefg....'}

获取dict值
Python代码
print d["name"] #nico
print d.get("name") #nico

如果key不在dict中，返回default，没有为None
Python代码
print d.get("namex", "aaa") #aaa
print d.get("namex") #None

排序sorted()
Python代码
d = {"name":"nico", "age":23}
for key in sorted(d):
print "key=%s, value=%s" % (key, d[key])
#key=age, value=23
#key=name, value=nico

删除del
Python代码
d = {"name":"nico", "age":23}
Python代码
del d["name"]
#如果key不在dict中，抛出KeyError
del d["names"]
Python代码
Traceback (most recent call last):
File "F:\workspace\project\pydev\src\ddd\ddddd.py", line 64, in <mole>
del d["names"]
KeyError: 'names'

清空clear()
Python代码
d = {"name":"nico", "age":23}
d.clear()
print d #{}

()
Python代码
d1 = d.() #{'age': 23, 'name': 'nico'}
#使用返回view对象
d2 = d1.viewitems() #dict_items([('age', 23), ('name', 'nico')])
#修改字典d1，新增元素
d1["cc"] = "aaaaaa"
print d2
#dict_items([('cc', 'aaaaaa'), ('age', 23), ('name', 'nico')])

pop(key[, default])
如果key在dict中，返回，不在返回default
Python代码
#如果key在dict中，返回，不在返回default
print d.pop("name", "niccco") #nico
print d.pop("namezzz", "niccco") #niccco
#key不在dict中，且default值也没有，抛出KeyError
print d.pop("namezzz") #此处抛出KeyError

popitem()
删除并返回dict中任意的一个(key,value)队，如果字典为空会抛出KeyError
Python代码
d = {"name":"nico", "age":23}
print d.popitem() #('age', 23)
print d.popitem() #('name', 'nico')
#此时字典d已为空
print d.popitem() #此处会抛出KeyError

update([other])
将字典other中的元素加到dict中，key重复时将用other中的值覆盖
Python代码
d = {"name":"nico", "age":23}
d2 = {"name":"jack", "abcd":123}
d.update(d2)
print d #{'abcd': 123, 'age': 23, 'name': 'jack'}

⑤ PYTHON如何判断一个字典或者列表为空

if py_obj:
print '非空'
if py_obj is None:
print '空'
if not py_obj:
非空

⑥ python有办法表示变量为空吗

可以的

你可以这样赋值：
i = None
i = null
i = 0 (数值类型)
i = '' （两个单引号） 或 i = "" (这是字符串类型)
i = [] (列表类型)
i = {}（字典类型）
i = () （元祖类型）

⑦ python 字典列表值可能空如何建字典

data = dict()
data["a"] = 'v1'
data["b"] = 'v2'
如果没有c可以不赋值，也可以
data["c"] = ''
取值时可以data.get("c", None)意思是如果存在c就返回值，不存在就返回None

⑧ python如何判断字符串是否有空格

①判断一个字符串、列表、字典是否为空，可用bool(self)函数，空则返回0，非空返回1。bool函数可判断内置数据结构是否为空。
相关推荐：《Python入门教程》
② 判断一个字符串是否为空格，可用str.isspace()。

③判断一个字符串是否含有空格，之前自己做题时，用的是for循环，遍历一个字符串，判断每个字符是否等于' '（一个空格字符）。其实可用in方法，即 ' ' in str来判断，更简洁。

⑨ python常见数据类型

一,python整数类型所表示的数据。

1,一般用以表示一类数值:所有正整数,0和负整数;

2,整型作为最常用的,频繁参与计算的数据类型，在python3.5中解释器会自动在内存中创建-5-3000之间的（包含5，不包含3000）整型对象，也就是说在该范围内,相等都是同一个已经创建好的整型对象。范围之外的即使相等也表示不同对象，该特性随python版本而改变，不要过于依赖。

3,bool型继承了int型，他是int的子类。

4,Python2中有长整型long，数值范围更大，在python3中已取消，所有整型统一由int表示。

5,参与所有数值计算，数学运算，科学计算。这也是所有编程语言都有的数据类型，因为编程语言生而需要模拟人的思维，借助数学方式，自动计算、更好的解决大量重复性的事务，因此数值类型、整数类型在编程语言中不可或缺。

6,支持二进制(0b\0B开头),十进制,八进制(0o\0O),十六进制(0x\0X)

二，python整数和浮点型支持常规的数值运算

整数和浮点数都可参与的运算：+ - * / %（取余） //（整除） **（幂）

Python字符型：

python字符型表示的数据：
python3支持Unicode编码，由字母、数字和符号组成的形式就叫字符串，更接近或者相同与人们文字符号表示，因此在信息表示和传递时它也是最受认可的形式。在程序编写中也是非常常用，对应的可操作的方法也很多，很有意思。
字符串不可被修改，可以拼接等方法创建新字符串对象；
支持分片和下标操作；a[2:]
支持+拼接，*重复操作和成员关系in/not in；
表示形式：用单引号双引号包含起来的符号；a = str(‘sdfsdfsdf’) 或 r’\t\nabcd’ 原始字符，Bytes：b’abcd’；
6,字符串属于不可变数据类型，内部机制为了节省空间，相同的两个字符串表示相同的一个对象。a = ‘python’ b = ‘python’ a is b :True

二, 字符串支持的运算方法

1,capitalize() :首字母大写后边的字母小写 a = ‘abcd’ b = a.capitalize() b:Abcd

2,casefold() lower():字母转换为全小写

3,center(width,fillchar) :居中，width填补的长度；fillchar添加的字符

a = a.center(10,’_’) //’____abcd____’ 默认无fillchar填充空格

4,count(sub,star,end) :字母计数：sub要查询的字符

5,encode(encoding=’utf-8’,errors=’strict’) 设置编码

Errors :设置错误类型

6,endswith(suffix,star,end) : 若以suffix结尾返回True

7，expandtabs(8) :设置字符串中tab按键符的空格长度：’\tabcde’

8,find(sub,star,end) : 返回指定范围内的字符串下标，未找到返回-1

9，index(sub,star,end) :返回指定范围字符串下标未找到抛出异常

10，isalnum() :判断字符串是否是字母或数字，或字母和数字组合

11，isalpha() :判断是否全是字母

12，isdecimal() :判断字符串是否是十进制数值

13，isdigit() :判断字符串是否是数字

14，isidentifier() :判断字符串中是否包含关键字

15，islower() :判断是否全小写

16，isnumeric() :判断全是数字

17，isspace() :判断是否是空格

18，isupper() 判断是否大写

19，istitle() :判断是否首字母大写

20，join(iterable) :把可迭代对象用字符串进行分割：a.join(‘123’)

21,ljust(width,fillchar);rjust() :左对齐右对齐

22, upper() :将字符串改为大写

23，split(sep=None,maxsplit=-1) :分割一个字符串，被选中字符在字符串中删除

‘ab1cd1efg’.split(‘1’) :[‘ab’,’cd’,’efg’]

三，字符串格式化：按照规格输出字符串

format(*args,**kwargs) :args位置参数，kwargs关键字参数

‘{0:.1f}’.format(123.468) :格式化参数，小数点后保留1位四舍五入

四，字符串操作符%

1，%s :格式化字符串 ‘abcd%sdef’%’dddd’

2，%d:格式化整数

3，%o格式化无符号八进制

4，%x格式化无符号十六进制

5，%f格式化定点数

6, %e: 科学计数法格式化定点数

7，%g 根据值大小自动选%f,%e

8, %G E X :大写形式

五，格式化辅助命令：

m.n :m最小总宽度，n小数点后位数：’%12.4f’%23456.789

六，转义字符：字符串前r避免转义：r’\nhello\thi’

\n:换行符

\t:横向制表符

\':'

\":"

\b:退格符

\r:回车

\v:纵向制表符

\f:换页符

\o,\x:八进制和十六进制

\0:空字符串

Python列表list

一，Python的列表list类型表示的数据：

Python列表在cpython中被解释为长度可变的数组，用其他对象组成的连续数组。

列表中元素可以是相同或不同的数据类型；
当列表元素增加或删除时，列表对象自动进行扩展或收缩内存，保证元素之间没有缝隙，总是连续的。
Python中的列表是一个序列，也是一个容器类型
创建列表：a = []; b = [1,’python’]; c = list(); d = list((1,3,4,5))
支持切片操作list[start,stop,step]
python列表常用方法
1,append添加单个元素：list.append(object); //a.append(‘python’)

2,extend添加可迭代对象: list.extend(iterable); //a.extend(‘abcde’/[1,2,3])

3,insert 插入元素：list.insert(index,object): 在index下标前插入元素//a.insert(2,’python’)

4,clear 清空所有元素：list.clear() //a.clear()

5,pop 删除并返回一个元素：list.pop(index) //默认删除默认一个元素

remove 删除指定元素：list.remove(v) ,v元素不存在报错 //a.remove(‘c’)
7，count 返回这个值在列表中数量：list.count(value)

8, 浅拷贝一个新列表：list.()

9,sort:排序list.sort(reverse=False/True) :默认升序

排序函数：sorted(list)

10，reverse: 原地翻转：list.reverse()

11，index(value,star,stop) :指定范围内该值下标：list.index(2,0,5)

列表元素访问：
下标访问：list[1]
For循环遍历
通过下标修改元素：list[2 ] = ‘hello’
列表常用运算符：
1,比较运算符：从第一个元素开始对比

2，+ 拼接一个新列表：l1+ l2

3, 重复操作符：* ,多个列表拼接

成员关系操作符：in/ not in
逻辑运算符：and not or
列表常用的排序方法：
冒泡排序；选择排序；快速排序；归并排序

Python元组tuple

一，Python元组tuple数据类型表示的数据：

元组是受到限制的、不可改变的列表；
可以是同构也可以是异构；
元组是序列类型、是可迭代对象，是容器类型。
元组的创建: a = (1,2,3)或a=1,2,3; b = tuple(); c = tuple(iterable)
支持切片操作tuple[start,stop,step]

二，python元组常用方法

1,index(value,star,stop) :指定范围内该值下标：tuple.index(2,0,5)

2,count(value) ：值出现次数

三，支持运算：

1,比较运算符：从第一个元素开始对比

2，+ 拼接一个新元组：l1+ l2

3, 重复操作符：* ,多个元组拼接

4成员关系操作符：in/ not in

逻辑运算符：and not or
四，元组的访问

下标操作；
For循环遍历访问。

Python字典类型

一,Python字典dict表示的数据：{key:value}

可根据关键字：键快速索引到对应的值；
字典是映射类型，键值对一一对应关系，不是序列；
字典元素是无序的；
字典是可迭代对象，是容器类型；
字典的创建：k = {}; k1={‘keyword’:object}; k2 = dict();
K3 = dict(mapping); dict=(iterable)

二，字典的访问：

通过key：k[‘key’]

修改key对应的值：K[‘key’] = value

For循环遍历出来的是key；

For循环键值对：for I in d.items():

For 循环enumerate: for k,v in enumerate(k1):

In/not in 成员关系查询键不支持查值

三，字典常用方法

get(key,de):获取值：k.get(key,de) //若不存在则默认输出de
pop(k,de):删除一个键值对，不存在输出de，未设置报错；
keys() :返回字典所有key组成的序列：list(k.keys()) [1,2,3];
values():返回字典所有value组成的序列：list(k.values())
items():返回键值对组成的元组为元素的序列：（类set）list(k.items())
update(e):更新字典：e可是字典或两元素组成的单位元素序列：e=[(5,6),(7,8)];
k.update(e)

clear():清空字典；
popitem()删除某个键值对，若字典为空则报错
() :浅拷贝
10, fromkeys(iterable,value=None):从可迭代对象创建字典

{}.fromkeys([1,2,3]) -----{1:None,2:None,3:None}

11,setdefault(k,d=None) :若key不存在则生成一个键值对

k.setdefault(‘keyword’)

Python 集合set

集合表示的数据：
多个元素的无序组合，集合是无序的，集合元素是唯一的；
字典的键是由集合实现的；
集合是可迭代对象
集合创建：s = {1,2}; s1 = set(); s2 = set(iterable)
集合元素的访问：
For 循环将集合所有元素全部访问一遍，不重复

常用方法：
add(object):s.add(‘hi’) 向集合添加一个元素
pop() :弹栈，集合为空则报错：删除任意一个元素；
clear():清空集合，返回一个空集合对象；
remove(object):删除一个元素，不存在和报错：s.remove(‘hi’)
update(集合)：更新另一个集合，元素不存在则不更新；
() :浅拷贝
集合的运算：
交集：s1&s2;
差集,补集：s1-s2;
并集：s1|s2;
Issubset():判断是否是子集：s1.issubset(s2) s1是否s2的集合子集
Issuperset():判断是否是父集：s1.issuperset()
不可变集合：
Frozenset():返回一个空的不可变集合对象

Frozenset(iterable):

S = frozenset(iterable)

Python序列类型共同特性

一,序列类型共同特性

python序列类型有:str字符串,list列表,tuple元组
都支持下标索引，切片操作；
下标都是从0开始，都可通过下标进行访问；
拥有相同的操作符
二，支持的函数：

len(obj):返回对象长度；
list(iterable):将可迭代对象转为列表；
tuple(iterable):将可迭代对象转为元组；
str(ojb):将任何对象转为字符串形式；
max(iterable): python3中元素要是同类型，python2中元素可异构：max([‘a’,1])
min(iterable):和max类似；
sum(iterable,star=0),求可迭代对象和，默认star为0，元素不能为字符串
sorted(iterable,key=None,reverse=False)
s=[(‘a’,3),(‘b’,2),(‘c’,9)]

sorted(s,key=lambda s:s[1]) //按照数字排序

reversed(sequence):翻转序列，返回迭代器
enumerate(iterable):返回enumerate对象,其元素都是一个元组（下标，值）
zip（iter1,iter2）: zip([1,2],[3,4]) ----[(1,3),(2,4)]

序列类型的切片操作：

Slice:

L[index]; 访问某个元素；

L[1:4]; 区间

L[star:stop:step]; 设置步长取区间元素

⑩ python如何判断获取字典键值是None

以前有过类似的问题 可以参考下：

http://blog.csdn.net/hhtnan/article/details/77164198