一、字典
字典的每个键值(key=>value)对用冒号(:)分割,每个对之间用逗号(,)分割,整个字典包括在花括号({})中 ,格式如下所示:
d = {key1 : value1, key2 : value2 }
2.1.字典声明
可以通过以下几种方式声明
x = dict()
y = dict(a=1,b=2)
z = {"name":"test"}
m = dict([("name","test"),("age",23)]) #此种方式用的不多
2.2.字典方法
2.2.1.get()方法
get() 函数返回指定键的值,如果值不在字典中返回默认值
语法
dict.get(key, default=None)
参数
key -- 字典中要查找的键。
default -- 如果指定键的值不存在时,返回该默认值值。
返回值
返回指定键的值,如果值不在字典中返回默认值 None
示例
d = {"name":"abel","age":23,"address":"江苏"} print("my name is : {0}".format(d.get("name"))) print("my age is : {0}".format(d.get("age"))) print("the address is : {0}".format(d.get("address")))
结果
my name is : abel
my age is : 23the address is : 江苏
2.2.2.pop()方法
pop() 方法删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值
语法
pop(key[,default])
参数
key: 要删除的键值
default: 如果没有 key,返回 default 值
返回值
返回被删除的值
示例
d = {"name":"abel","age":23,"address":"江苏"} m = d.copy() print("删除指定的值:{0}".format(d.pop("age"))) print("删除默认值:{0}".format(m.pop("mail","no info")))
结果
删除指定的值:23
删除默认值:no info
2.2.3.clear()方法
clear() 函数用于删除字典内所有元素语法
dict.clear()
返回值
无返回值
示例
d = {"name":"abel","age":23,"address":"江苏"} print("删除前的dict:{0}".format(d)) print("删除后的dict:{0}".format(d.clear()))
结果
删除前的dict:{'name': 'abel', 'age': 23, 'address': '江苏'}
删除后的dict:None
2.2.4.keys()方法
keys() 方法以列表返回一个字典所有的键(key)语法
dict.keys()
返回值
返回一个字典所有的键
示例
d = {"name":"abel","age":23,"address":"江苏"} print("字典中所有的键key:{0}".format(d.keys()))
结果
字典中所有的键值:dict_keys(['name', 'age', 'address'])
2.2.5.values()方法
values() 方法以列表返回字典中的所有值(value)语法
dict.values()
返回值
返回一个字典所有的值
示例d = {"name":"abel","age":23,"address":"江苏"} print("字典中所有的值value:{0}".format(d.values()))
结果
字典中所有的值value:dict_values(['abel', 23, '江苏'])
2.2.6.items()方法
items() 方法以列表返回可遍历的(键, 值) 元组数组,相当于python2中的iteriterms
语法
dict.items()
返回值
返回可遍历的(键, 值) 元组数组
示例
d = {"name":"abel","age":23,"address":"江苏"} for x in d.items(): print("key is {0}".format(x[0])) print("value is {0}".format(x[1]))
结果
key is name
value is abel
key is age
value is 23
key is address
value is 江苏
2.2.7.copy()方法
copy() 函数返回一个字典的浅复制
语法
dict.copy()
返回值
返回一个字典的浅复制
示例
d1 = {"name":"abel","job":["job1","job2","job3"]} d2 = d1 # 浅拷贝: 引用对象 d3 = d1.copy() # 浅拷贝:深拷贝父对象(一级目录),子对象(二级目录)不拷贝,还是引用 #修改dict1数据,看d2和d3结果 d1["name"]="test" d1["job"].remove("job1") print("d1 数据为: {0}".format(d1)) print("d2 数据为: {0}".format(d2)) print("d3 数据为: {0}".format(d3))
结果
d1 数据为: {'name': 'test', 'job': ['job2', 'job3']}
d2 数据为: {'name': 'test', 'job': ['job2', 'job3']}
d3 数据为: {'name': 'abel', 'job': ['job2', 'job3']}
实例中 d2 其实是 d1的引用(别名),所以输出结果都是一致的,d3父对象进行了深拷贝,不会随d1 修改而修改,子对象是浅拷贝所以随 d1的修改而修改。
2.2.8.update()方法
update() 函数把字典dict2的键/值对更新到dict里,相当于两个字典表相加
语法
dict.update(dict2)
参数
dict2 -- 添加到指定字典dict里的字典
返回值
该方法没有任何返回值
示例
d1 = {"name": "abel", "age":23} d2 = dict(a=1, b=2, c=3, d=4) d1.update(d2) print("使用update方法生成的字典:{0}".format(d1))
结果
使用update方法生成的字典:{'name': 'abel', 'age': 23, 'a': 1, 'b': 2, 'c': 3, 'd': 4}
2.2.9.fromkeys()方法
fromkeys() 函数用于创建一个新字典,以序列seq中元素做字典的键,value为字典所有键对应的初始值语法
dict.fromkeys(seq[, value]))
参数
seq -- 字典键值列表。
value -- 可选参数, 设置键序列(seq)的值。
返回值
该方法返回列表
示例
m = dict() x = [1, 2, 3, 4, 5] print(m.fromkeys(x,"ko"))
结果
{1: 'ko', 2: 'ko', 3: 'ko', 4: 'ko', 5: 'ko'}
2.2.10.setdefault()方法
setdefault() 方法和get()方法类似, 如果键不已经存在于字典中,将会添加键并将值设为默认值。语法
dict.setdefault(key, default=None)
参数
key -- 查找的键值。
default -- 键不存在时,设置的默认键值。
返回值
如果 key 在 字典中,返回对应的值。如果不在字典中,则插入 key 及设置的默认值 default,并返回 default ,default 默认值为 None。
示例
dt={"name":"test","age":7}
print("Age数值为:{0}".format(dt.setdefault("age",None)))
print("Sex数值为:{0}".format(dt.setdefault("sex",None)))
print("新字典为:{0}".format(dt))
结果
Age数值为:7
Sex数值为:None
新字典为:{'name': 'test', 'age': 7, 'sex': None}
2.3.赋值
a,b=("1","2") print("a 的值为:{0}".format(a)) print("b 的值为:{0}".format(b))
结果
a 的值为:1
b 的值为:2
2.4.高阶函数zip
zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个元组,然后返回由这些元组组成的列表
l1 = ["a","b","c","d"]
l2=[1,2,3,4]
print(dict(zip(l2,l1)))
结果
{1: 'a', 2: 'b', 3: 'c', 4: 'd'}
2.5.帮助函数
2.5.1.type()函数
type() 函数如果你只有第一个参数则返回对象的类型,三个参数返回新的类型对象
type(obj)
示例
print(type(1)) print(type("hello")) print(type(["hello","world"])) print(type(("hello","world"))) print(type({"hello":"world"}))
结果
<class 'int'>
<class 'str'>
<class 'list'>
<class 'tuple'>
<class 'dict'>
2.5.2.isinstance()函数
sinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()isinstance() 与 type() 区别:
type() 不会认为子类是一种父类类型,不考虑继承关系。
isinstance() 会认为子类是一种父类类型,考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()
语法
isinstance(object, classinfo)
参数
object -- 实例对象。
classinfo -- 可以是直接或间接类名、基本类型或者有它们组成的元组。
返回值
如果对象的类型与参数二的类型(classinfo)相同则返回 True,否则返回 False
示例
dict1 = {"name": "abel", "age":23} print("判断dict1是否是dict类型:{0}".format(isinstance(dict1,dict)))
结果
判断dict1是否是dict类型:True
2.5.3.hasattr()函数
语法
hasattr(object, name)
参数
object -- 对象。
name -- 字符串,属性名。
返回值
如果对象有该属性返回 True,否则返回 False
示例
print("判断dict是否是append方法:{0}".format(hasattr(list,"append")))结果
判断dict是否是append方法:True
2.5.4.help()函数
语法
help([object])
参数
object -- 对象。
返回值
返回对象帮助信息
示例
help(list)结果
Help on class list in module builtins:
class list(object)
| list() -> new empty list
| list(iterable) -> new list initialized from iterable's items
|
| Methods defined here:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return key in self.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __gt__(self, value, /)
| Return self>value.
|
| __iadd__(self, value, /)
| Implement self+=value.
|
| __imul__(self, value, /)
| Implement self*=value.
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.n
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __repr__(self, /)
| Return repr(self).
|
| __reversed__(...)
| L.__reversed__() -- return a reverse iterator over the list
|
| __rmul__(self, value, /)
| Return self*value.
|
| __setitem__(self, key, value, /)
| Set self[key] to value.
|
| __sizeof__(...)
| L.__sizeof__() -- size of L in memory, in bytes
|
| append(...)
| L.append(object) -> None -- append object to end
|
| clear(...)
| L.clear() -> None -- remove all items from L
|
| copy(...)
| L.copy() -> list -- a shallow copy of L
|
| count(...)
| L.count(value) -> integer -- return number of occurrences of value
|
| extend(...)
| L.extend(iterable) -> None -- extend list by appending elements from the iterable
|
| index(...)
| L.index(value, [start, [stop]]) -> integer -- return first index of value.
| Raises ValueError if the value is not present.
|
| insert(...)
| L.insert(index, object) -- insert object before index
|
| pop(...)
| L.pop([index]) -> item -- remove and return item at index (default last).
| Raises IndexError if list is empty or index is out of range.
|
| remove(...)
| L.remove(value) -> None -- remove first occurrence of value.
| Raises ValueError if the value is not present.
|
| reverse(...)
| L.reverse() -- reverse *IN PLACE*
|
| sort(...)
| L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
2.5.5.dir()函数
dir() 函数不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。如果参数包含方法__dir__(),该方法将被调用。如果参数不包含__dir__(),该方法将最大限度地收集参数信息。l1=dict(a=1)
print (dir(l1))
结果
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
2.6.强制转换类型
int()
list()
str()
float()
tuple()
dict()