Python 数据类型（二）

Python 字典(dict)

dict是dictionary的缩写，其存储数据以key:value方式，类似java中的map，javascripts中的jason。字典可以存储任意对象，也可以是不同的数据类型。

字典的创建是每个key-value之间使用:(冒号)分隔，每个key:value对之间使用,(逗号)分隔，整个字典使用{ }(大括号)括起来；

格式为    d = {key1: value1, key2: value2 }。

字典中的key不能相同，value可以相同。字典中的key必须是不可变的。数字、字符串、元组都可以作为key，但是列表不可以作为key。

字典三种初始化的方法：

d1 = dict(a=1, b=2)
d2 = {"a":1, "b":2}
d3 = dict([("a", 1),("b", 2)])
print(d1,d2,d3)

结果输出：   {'a': 1, 'b': 2} {'a': 1, 'b': 2} {'a': 1, 'b': 2}

一个简单的字典实例：

dic = {'name':'hewj', 'age':'28', 'gender':'Man'}

也可如此创建字典：

dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };

访问字典里的值

访问字典中的值，直接将对应的key放入[ ]即可。

dict = {'Name': 'hewj', 'Age': 28, 'From': 'GZ'};
print(dict["Name"])print(dict["Age"])--------------------   //打印以下结果hewj    18

当访问的key不存在时，就会报错；

dict = {'Name': 'hewj', 'Age': 28, 'From': 'GZ'};
print(dict["abc"])
-------------------------------------- //打印以下结果

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'abc'

修改字典
既可以新增key:value键值对，也可以修改已有的内容。
新增键值对

dict = {'Name': 'hewj', 'Age': 28, 'From': 'GZ'};
dict["sorce"] = 100
print(dict)
-----------------------
{'Name': 'hewj', 'Age': 28, 'From': 'GZ', 'sorce': 100}

修改已有的内容

dict = {'Name': 'hewj', 'Age': 28, 'From': 'GZ'};
dict["Age"] = 3
print(dict)
-----------------------
{'Name': 'hewj', 'Age': 3, 'From': 'GZ'}

当对同一值进行多次修改时，前面的值将被覆盖。

删除字典
可以对字典的键值进行删除，也可以直接删除字典。

删除键值

dict = {'Name': 'hewj', 'Age': 28, 'From': 'GZ'};
del dict["Age"]
print(dict)
-----------------------
{'Name': 'hewj','From': 'GZ'}

删除字典

>>> d1 = {"name": "xiahh", "age": 18 }
>>> del d1
>>> print(d1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'd1' is not defined

dict常用的方法

get()

返回指定键的值，若值在字典中不存在则返回默认值(默认值为None，可自定义)。

>>> d1 = {"name": "xiahh", "age": 18 }
>>> print(d1.get("name"))
xiahh
>>> print(d1.get("address"))       #不存在则返回默认值None
None
>>> print(d1.get("address",-1))    #此处-1为自定义的默认值，当不存在时则返回-1
-1

setdefault()

若查找的键在字典中则返回对应值，若不存在则插入对应的键及默认值(默认值为None，可自定义)。

>>> d1 = {"name": "hewj", "age": 18 }
>>> print(d1.setdefault("name"))
'hewj'
>>> d1.setdefault("address")
>>> print(d1)
{'name': 'hewj', 'age': 18, 'address': None}
>>> d1.setdefault("num",168)
>>> print(d1)
{'name': 'hewj', 'age': 18, 'address': None, 'num': 168}

key()

以列表形式返回字典中key值。

>>> d1 = {"name": "xiahh", "age": 18 }
>>> print(d1.keys())

--------------------------下面输出key值
dict_keys(['name', 'age'])

values()

//以列表形式返回字典中value值。

>>> d1 = {"name": "xiahh", "age": 18 }
>>> print(d1.values())

------------------------下面输出value值
dict_values(['xiahh', 18])

update()

//将参数中的字典添加到原字典中，无返回值。

>>> d1 = {"name": "hewj", "age": 18 }
>>> d1.update({"address": "GZ"})
>>> print(d1)

{'name': 'hewj', 'age': 18, 'address': 'GZ'}

另一种方式：

a = dict(a=1, b=2) b = dict(x=10, y=20) a.update(b) print(a) —————————— {'a': 1, 'b': 2, 'x': 10, 'y': 20}

items()

以列表的形式返回可遍历的元组数据

>>> d1 = {"name": "hewj", "age": 18 }
>>> print(d1.items())
dict_items([('name', 'hewj'), ('age', 18)])
>>> for i,j in d1.items(): 

     >>>print(i,j)
...
name hewj
age 18

说明：

在python2中存在items()和iteritems()2种方法；

items()返回一个字典的拷贝列表，占用额外内存；iteritems()返回字典列表操作后的迭代，不占用额外内存。

在python3中使用items()方法替代iteritems()方法，可以采用for进行循环遍历。

pop()
删除字典中指定键对应的值，返回值为被删除的值；其中键必须给出，若指定的键不存在则返回默认值。

>>> d1 = {"name": "hewj", "age": 18 }
>>> a = d1.pop("name")    #给出的键存在则返回被删除的值
>>> print(a)

'hewj'
>>> print(d1)
{'age': 18}
>>> b = d1.pop("address")    #给出的键不存在且不指定默认值，报错

>>> print(b)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'address'
>>>c = d1.pop("address",-1)    #给出的键不存在，指定默认值，返回默认值
>>>print(c)

-1
>>> print(d1)
{'age': 18}

clear()
清空字典；无返回值。

>>> d1 = {"name": "xiahh", "age": 18 }
>>> d1.clear()
>>> print(d1)
{}

copy()
返回字典的一个浅拷贝。使用=进行的直接赋值和copy()进行的浅拷贝不一样，赋值只是对原对象的引用；浅拷贝则是对父对象进行拷贝，对象的子对象则是引用。

d1 = {"name": "hewj", "age": 18, "num": [1,2,3] }
>>> d2 = d1           #d2是赋值
>>> d3 = d1.copy()    #d3是浅拷贝，其中num对应的值为元组，对于字典属于子对象
>>> d1["name"]="superman"
>>> d1["num"].remove(2)
>>> print(d1)
{'name': 'superman', 'age': 18, 'num': [1, 3]}
>>> print(d2)
{'name': 'superman', 'age': 18, 'num': [1, 3]}
>>> print(d3)
{'name': 'hewj', 'age': 18, 'num': [1, 3]}

sorted()

对字典进行排序，按照key或value。

>>> d1 = {"name": "xiahh", "age": "18" }

>>> print(sorted(d1.items(),key=lambda d: d[0]))    #按照键进行排序
[('age', '18'), ('name', 'xiahh')]

>>> print(sorted(d1.items(),key=lambda d: d[1])) #按照值进行排序TypeError: '<' not supported between instances of 'int' and 'str'
注意：
排序只能针对同一类型；字符串或者数字，不能用于不同类型值。
当字典定义为d1 = {"name": "xiahh", "age": 18 }，只能使用键进行排序，不能使用值进行排序，否则报错。
TypeError: '<' not supported between instances of 'int' and 'str'

zip（）

将两个列表组成字典。

l1 = ["a", "b", "c", "d"] l2 = ["1", "2", "3", "4"] print(dict(zip(l1,l2))) ———————————— {'a': '1', 'b': '2', 'c': '3', 'd': '4'}

len()
返回对象的长度。

d1 = {"name": "hewj", "age": 18}
print(len(d1))
str2 = "1,2,3,4"
print(len(str2))

type()
返回对象类型。

>>> str = "I'm a superman!"
>>> print(type(str))
<class 'str'>
>>> d1 = {"name": "xiahh", "age": 18 }
>>> print(type(d1))
<class 'dict'>

isinstance() //判读对象是否有指定的类型；如果是返回True，否则返回False

l1 = ["a", "b", "c", "d"] print(isinstance(l1,list)) //判断是否有list列表类型 ———————————— True

8、.enumerate()

将一个可遍历的数据对象(如列表、元组或字符串)组合成一个索引序列，同时列出数据和数据下标。

x1 = ["a", "b", "c", "d", "e", "f"]
print(list(enumerate(x1)))

常用在for循环中

x1 = ["a", "b", "c", "d", "e", "f"] for i,j in enumerate(x1): print(i,j) //i为索引的下标，j为遍历的内容 0 a 1 b 2 c 3 d 4 e 5 f 或者 x1 = ["a", "b", "c", "d", "e", "f"] for x in enumerate(x1): //x为元组 print(x) —————————— (0, 'a') (1, 'b') (2, 'c') (3, 'd') (4, 'e') (5, 'f')

help( )

用于查看帮助信息

>>> d1 = {"name": "xiahh", "age": 18 }
>>> help(d1)

强制类型转换
int()    //整型
str()    //字符串
list()   //列表
tuple()  //元组
dict()   //字典