Python自学笔记之核心语法3

字典

Python是一种解释型语言，因此它会提供很多人性化的工具给我们使用。

一个新的数据类型——字典。

与列表和元组不同，字典中存储的是一组数据。字典中的每个数据都包含了两个部分，可以这么理解，字典中存放了一些学生名字，每个学生的名字前面都对应了一个学号，我们可以把学号理解为‘键’，姓名理解为‘值’。

字典的特性：

        1) 字典是没有顺序的，是任意对象的无序集合。

        2) 字典的键是唯一的，不能多次出现，多次出现时取最后一个值。

        3) 键是不可变的。

        4) 字典中的元素可增删。

        5) 因为没有顺序，所以不存在索引。

字典的形式及创建

字典每个元素包含2个部分，他们分别是‘键’和‘值’，键和值之间用‘：’隔开，两个元素之间用‘，’隔开。它的语法形式为：

my_dict = {‘key’ : ‘value’,’key1’ = ‘value1’....}

其中my_dict 为我们要创建的字典，key为键，value为键对应的值，他们可以是任何数类型。

        创建空字典的方式为：

>>> my_dict = {}#直接进行创建
>>> my_dict
{}
>>> type(my_dict)#看一下它的类型
<class 'dict'>

我们来创建一个字典，字典里有5个学号分别为1001,1002,1003,1004,1005，每个学号对应的名字为‘李华’，‘张三’，‘小雪’，‘小张’，‘小明’。

>>> my_dict = {1001:'李华',1002:'张三',1003:'小雪',1004:'小张',1005:'小明'}
>>> my_dict#交互模式下输人名字是直接访问输出
{1001: '李华', 1002: '张三', 1003: '小雪', 1004: '小张', 1005: '小明'}

键是不可以修改的，而值是可以变的，因此键要取不可变类型的数据。

字典元素的访问

字典中访问元素一般是通过访问其键的形式来获取它对应的值。

>>> my_dict = {1001:'李华',1002:'张三',1003:'小雪',1004:'小张',1005:'小明'}
>>> my_dict[1001]#访问键为1001的值
'李华'
>>> my_dict[1005]#访问键为1005的值
'小明'
>>> my_dict[1006]#访问键为1006的值，此时字典里没有1006，故报错。
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 1006

判断字典中的值是否存在

访问一个不存在的键的时候会出现错误，我们可以采用一种判断来判别字典中是否存在对应的键。

        判断是否存再我们使用的是in和not in。

使用in

>>> my_dict = {1001:'李华',1002:'张三',1003:'小雪',1004:'小张',1005:'小明'}
>>> if 1001 in my_dict:#如果my_dict中存在1001这个键就执行下面语句
       print(my_dict[1001])
>>> 李华

使用not in

>>> my_dict = {1001:'李华',1002:'张三',1003:'小雪',1004:'小张',1005:'小明'}
>>> if 1006 not in my_dict:#如果my_dict中吧存在1006这个键就执行下语句
       print('不存在1006这个键')
>>> 不存在1006这个键

 简单的使用in和not in 可以确保我们在访问的时候减少错误的发生，需要注意在in和not in操作的时候，字符串的比较需要区分大小写。

删除元素

除元素我们还是通过del语句进行删除，删除的是一整对元素，即包括键和值。

>>> my_dict{1001: '李华', 1002: '张三', 1003: '小雪', 1004: '小张', 1005: '小明', 1006
: '小李'}
>>> del my_dict[1001]#删除键为1001的一组元素
>>> del my_dict[1002]#删除键为1002的一组元素
>>> my_dict{1003: '小雪', 1004: '小张', 1005: '小明', 1006: '小李'}

修改元素

修改元素就等于是直接覆盖了现有元素，它的形式和添加元素的格式类似。

>>> my_dict
{1003: '小雪', 1004: '小张', 1005: '小明', 1006: '小李'}
>>> my_dict[1003] = '小天'#把键1003的值修改为‘小天’
>>> my_dict
{1003: '小天', 1004: '小张', 1005: '小明', 1006: '小李'}

字典中的常用函数

clear	清空字典内容
get	获取指定键对应值
items	返回包含对象中所有变量及其值的2元组的列表
keys	返回对象中所有键的元组形式
values	返回对象中所有值的元组形式
pop	如果键在字典中，则移除它并返回其值，否则返回默认值。如果未给定默认值且键不在字典中，则会引发键错误。

clear()方法

        使用clear（）方法会清空字典中的所有元素。

        使用方法为：

>>> my_dict{1003: '小天', 1004: '小张', 1005: '小明', 1006: '小李'}
>>> my_dict.clear()#使用clear()方法进行清空操作
>>> my_dict{}

get()方法

        我们在获取键对应的值的时候，使用get()方法可以避免因未找到相应目标而引发异常的情况。使用方法：

my.dict.get(key,default)

  Key为我们要查询的键，default为未找到时的默认返回值，我们可以进行自定义。

>>> my_dict = {1001:'小张',1002:'小华'}
>>> my_dict.get(1001)#找到key1001对应值
'小张'
>>> my_dict.get(1002)#找到key1002对应值
'小华'
>>> my_dict.get(1003,'not found')#找到key1003对应值,如果找不到就输出'not found'
'not found'

 items()方法

        items方法返回字典中成对的键和值，返回的是一种名叫字典视图的特殊序列，其中每个元素都是一个元组。

 使用方法：

my_dict.items()

  具体使用：

>>> my_dict
{1001: '小张', 1002: '小华'}
>>> my_dict.items()
dict_items([(1001, '小张'), (1002, '小华')])

items方法访问的是整组整组的元素。再循环操作时会用到。

keys（）方法

        它的使用方式和items使用方法类似，keys返回字典中的键。

>>> my_dict
{1001: '小张', 1002: '小华'}
>>> my_dict.keys()
dict_keys([1001, 1002])

pop（）方法

        pop（）方法会删除指定的键，并返回其值，如果没有找到相应键可输出默认值。

        使用方法：

1	my_dict.pop(key,default)

Key为我们要删除的键，当没有找到该键的时候会输出default，default可自定义，当没有default时返回的是None。

>>> my_dict = {1001:'小华',1002:'小张',1003:'小美'}
>>> my_dict.pop(1001)#删除键为1001的这一项
'小华'
>>> my_dict#此时字典里已经没有键为1001这一项
{1002: '小张', 1003: '小美'}
>>> my_dict.pop(1004,'no found')#删除键为1004这一项，如果找不到返回'no found'
'no found'

values（）方法

        vlaues（）返回字典中的所有值。

>>> my_dict
{1001: '小张', 1002: '小华'}
>>> my_dict.values()
dict_values(['小张', '小华'])

混合字典

混合字典，即字典中存储的数据是各种类型混合在一起的，键需要取不可变的数据类型，但是值是可以取任意类型的对象。

例如：

my_dcit = {'小明':['身高：170cm','体重：65kg'],'小李':'爱学习,爱运动','小华':('居住地:苏州','出生地:上海')}

可通过之前所学方式进行访问。

my_dcit = {'小明':['身高：170cm','体重：65kg'],'小李':'爱学习,爱运动','小华':('居住地:苏州','出生地:上海')}
print('访问key=‘小明’->',my_dcit['小明'])
print('访问key=‘小华’->',my_dcit['小李'])
print('访问key=‘小华’->',my_dcit['小华'])
print('itmes()方法:',my_dcit.items())     #整体访问
print('keys()方法:',my_dcit.keys())      #只访问了所有key
print('values()方法:',my_dcit.values())    #只访问了value
print('get()方法:',my_dcit.get('小明'))    #get方法来访问指定键
my_dcit.pop('小明')              #此步骤为pop()方法，会删除键=‘小明’的成对元素
print('pop()方法后的my_dict：',my_dcit)       #查看一下删除后的字典

输出结果：

访问key=‘小明’-> ['身高：170cm', '体重：65kg']
访问key=‘小华’-> 爱学习,爱运动
访问key=‘小华’-> ('居住地:苏州', '出生地:上海')
itmes()方法: dict_items([('小明', ['身高：170cm', '体重：65kg']), ('小李', '爱学习,爱运动'), ('小华', 
('居住地:苏州', '出生地:上海'))])
keys()方法: dict_keys(['小明', '小李', '小华'])
values()方法: dict_values([['身高：170cm', '体重：65kg'], '爱学习,爱运动', ('居住地:苏州', '出生地:上海'
)])
get()方法: ['身高：170cm', '体重：65kg']
pop()方法后的my_dict： {'小李': '爱学习,爱运动', '小华': ('居住地:苏州', '出生地:上海')}

 遍历字典

使用字典的经常要进行字典的遍历，通常会使用for循环去遍历字典所有的键。

 一般情况下的遍历访问：

>>> my_dict ={1001:'小明',1002:'小华',1003:'小张'}
>>> for i in my_dict:
        print(i, my_dict[i])#输出key及key对应的值
1001 小明
1002 小华
1003 小张

使用items()方法来获取成对的元素。

>>> my_dict ={1001:'小明',1002:'小华',1003:'小张'}
>>> for i in my_dict.items():
        print(i)
(1001, '小明')
(1002, '小华')
(1003, '小张')

字典推导式

>>> my_dict = {i:'www' for i in range(1,5)}
>>> my_dict
{1: 'www', 2: 'www', 3: 'www', 4: 'www'}

第一部分等同于每一个i的值对象都用’www’来赋值，我们也可以先定义一个列表，把列表中的值赋予它。

>>> my_list = [10,20,30,40,50]
>>> my_dict = {i:my_list[i] for i in range(1,5)}
>>> my_dict
{1: 20, 2: 30, 3: 40, 4: 50}

例题：
输入总资产，例如： 3000，然后显示购物车列表，计算购物车商品总金额，如果商品总额大于总资产，提示账户余额不足，否则，购买成功。购物车列表如下：
carts=[{"name":"床","price":1999,”num”:1},{"name":"枕头","price":10, ” num”:2},{"name":"被子","price":20, ”num”:1}]。

carts=[
{"name":"床","price":1999,”num”:1},
{"name":"枕头","price":10, ”num”:2},
{"name":"被子","price":20, ”num”:1}
]。
m = int(input())
sum = 0
for i in range(len(carts)):
    sum = carts[i]['price'] * carts[i]['num'] + sum
if m >= sum:
    print('购买成功')
else:
    print('账户余额不足')

集合

        集合中元素有以下几个特性：

        1) 无序性，集合中保存的元素是没有顺序的。

        2) 多样性，集合中可以保存多种数据类型的元素。

        3) 唯一性，集合中的元素都是唯一存在的，不会重复出现。

创建集合

创建集合的时候有2种方式，一种是直接使用集合的特征符号‘{}’来创建，一种是使用set()函数强制类型转换来创建。

1) 直接创建

        首先我们要知道集合和字典的区别，集合是由‘{}’括起来的结构，每个元素之间用‘,’隔开，

        集合和字典都是用大括号括起来，但是集合之间不使用冒号。

结构为：my_set = {元素1,元素2,元素3}

   my_set为要创建的集合名，括号内的为集合中的元素。

>>> my_set = {1,2,3,4,5,6}
>>> my_set
{1, 2, 3, 4, 5, 6}

  2) 使用set()函数强制类型转换创建

        使用set()可以直接创建一个空集合，也可以将其他类型的结构直接转换为集合。

my_set = set(iteration)

  my_set为要创建的集合名，set()函数为强制类型转换，iteration是一个可迭代对象，它可以是元组、列表或range对象。

>>> m = set('12345')#强制转换字符串
>>> n = set([1,2,3,4,5])#强制转换列表
>>> k = set(range(1,6))#强制转换range()对象
>>> i = set((1,2,3,4,5))#强制转换元组
>>> m
{'4', '3', '5', '1', '2'}
>>> n
{1, 2, 3, 4, 5}
>>> k
{1, 2, 3, 4, 5}
>>> i
{1, 2, 3, 4, 5}

清空集合

       del()方法可以直接删除整个集合，语法格式为：del my_set

添加元素

        集合是可变序列，因此我们可以对其中的元素进行增删操作。

        添加元素使用add()方法，语法格式如下：my_set.add(x)

>>> my_set#插入前
{1, 2, 3, 4, 5, 6}
>>> my_set.add('插入一个新元素x')
>>> my_set#插入后
{1, 2, 3, 4, 5, 6, '插入一个新元素x'}

删除元素

        删除元素可以使用集合的pop()方法或者remove()方法去删除一个元素，也可以使用clear()方法去清空集合。

        需要注意的是remove()方法是移除指定元素，而pop()方法是直接删除集合中的第一个元素并输出，clear()方法直接清空了集合中的所有元素。

>>> my_set{1, 2, 3, 4, 5, 6, '插入一个新元素x'}
>>> my_set.pop()#会删除并输出第一个元素1
>>> my_set{2, 3, 4, 5, 6, '插入一个新元素x'}
>>> my_set.remove(6)#直接指定删除6
>>> my_set{2, 3, 4, 5, '插入一个新元素x'}
>>> my_set.clear()#清空集合
>>> my_set#打印结果显示为一个空集合
set()