python学习-第3课

一、字典

字典的每个键值(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 : 23
the 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()