python学习第四篇 字典 集合

字典

一.定义：

1. 字典是一种可变的容器，可以存储任意类型的数据
2. 字典中的每个数据都是用‘键（key）’进行索引的，而不像序列（str,list,tuple）可以用整数进行索引
3. 字典的存储是无序的
4. 字典中的数据以键（key）-值（value）对形式进行存储
5. 字典的键不能重复，且只能用不可变类型做为字典的键

二.创建字典的字面值方式

       字典的表示方式以{}括起来，以冒号（：）分隔键值对，各个键值对之间使用逗号分隔开

1. 创建空的字典

d = {}

1. 创建字典的构造函数dict

dict()       #生成一个空的字典等同于{}

dict(iterable)          #通过可迭代对象创建一个字典

dict(**kwargs)        #关键字传参的形式生成一个字典

注：字典的键必须为不可变类型的值

可变的类型：list（列表）,dict（字典）,set(集合)

 三.字典的基本操作

              1.字典的键索引

                     语法：

                            字典[键]

                     作用：

                            用来获取字典键所对应的值

2.字典添加和修改字典的元素

语法：

        字典[键]=值

说明：

        键不存在时，创建键，并让键绑定对应的值

        键存在时，修改键绑定的值

3.删除字典的元素

del 语句

语法：

        del    字典[键]

4.字典的键判断in,not in 运算符

可以用in 运算符判断一个键是否存在于字典中，如果存在返回True, 如果不存在返回False   not in与之相反

练习：

       写程序实现以下需求：

1. 键如下数据形成一个字典seasons

键                   值

1 ========>‘春季有1,2,3月’

2 ========>‘夏季有4,5,6月’

3 ========>‘秋季有7,8,9月’

4 ========>‘冬季有10,11,12月’

1. 让用户输入一个整数代表这个季节，打印这个季节对应的信息，如果用户输入的信息不存在于字典内，则提示用户信息不存在

d={1:'春季有1,2,3月',
   2:'夏季有4,5,6月',
   3:'秋季有7,8,9月',
   4:'冬季有10,11,12月'}
print(d)
n=int(input("请输入一个整数"))
if n in d:
    print(d[n])
else:
    print("用户信息不存在")

四.字典的迭代访问

l=input('请输入一段字符串')
d={}
for n in l:
    if n not in d:
        d[n]=1
    else:
        d[n]+=1
for k in d:
    print(k,':',d[k],'次')

 

练习：

       输入一段字符串，打印出这个字符串中出过的字符以及出现过的次数

       如：

              输入：abcdabcdaba

              打印如下：

                     a：4次

                     b：3次

                     c：2次

                     d：2次

              注：不强调打印顺序

l=input('请输入一段字符串')
d={}
for n in l:
    if n not in d:
        d[n]=1
    else:
        d[n]+=1
for k in d:
    print(k,':',d[k],'次')

五.可以用于字典的函数

              Len(x)    max(x)    min(x)    any(x)

六.字典的内置方法

　1.dict.clear()

                     删除字典中所有的元素

                     这个方法没有参数没有返回值

　2.dict.fromkeys(seq[,value])

创建一个新的字典，以序列seq中的元素作为字典的键，value为字典所有键对应的初始值

参数：

       seq – 字典键值列表

       value – 可选参数，社会键序列（seq）的值

返回值：

       该方法返回一个新的字典

　3.dict.get(key,default = None)

返回指定键的值，如果值不在字典中返回默认值None

       参数:

              Key-字典中要查找的键

                     Default-如果指定键的值不存在时，返回该默认值返回值

       返回值:

                     返回指定键的值，如果值本在字典中返回默认值None

　4.dict.items()

以列表返回可迭代的（键，值）元组

没有参数

        返回值:

            返回可遍历的(键，值）元组数据

    5.dict. keys  () 

        以列表返回一个字典所有的键

        没有参数返回值:

            返回一个字典的键

    6、dict. update (dict2)

        把字典dict2的键/值对更新到dict里

        参数:

            dict2  添加到指定字典dict里的字典

        返回值:

            该方法没有任何返回值

    7.dict. values ()

        以列表返回字典中的所有的值

        没有参数

        返回值:

            返回字典中所有的值。

    8.pop (key. [, default])

删除字典给定键key所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值

        参数:

            key:要删除的键值

            default:如果没有key,返回default值。

        返回值:

            返回值被删除的值。

 

    9、popitem()

        随机返回并删除宇典中的对键和值

            没有参数

        返回值:

            返回一个键值对(key, value)形式

七.字典与列表比较

1. 都是可变的容器
2. 索引方式不同，列表用整数索引，字典用键索引
3. 列表的存储是有序的，字典的存储是无序的
4. 字典的插入，删除，修改的速度快于列表（重点）

练习：

       任意输入很多学生的姓名，年龄，成绩，每个学生的信息存入到字典中，然后再放在列表内每个学生的信息需要手动输入：

       如：

              请输入姓名：tarena

              请输入年龄：15

              请输入成绩：99

请输入姓名：china

              请输入年龄：70

              请输入成绩：98

              请输入姓名：<回车>#结束输入

       内部存储格式如下：

       Infors = [{“name”:”tarena”,”age”:15,”score”:99},{name”:”china”,”age”:70,”score”:98}]

1. 打印以上的列表
2. 按如下表格打印学生信息

姓名	年龄	成绩
Tarena	15	99
China	70	98

 

infors=[]
while True:
    d = {}
    na=input("请输入姓名：")
    if not na:
        break
    d["name"]=na
    ag=input("请输入年龄：")
    d["age"]=ag
    sc=input("请输入成绩：")
    # d = dict.fromkeys(na,sc)
    d["score"]=sc
    infors.append(d)
j=1
k=0
while j<=len(infors)+3:
    if j==1:
        print("+-------+-------+-------+")
    elif j==2:
        print("|  姓名 |  年龄 |  成绩 |")
    elif j<len(infors)+3 :
        dl=infors[k]
        print("|",dl['name'].center(5),"|",str(dl['age']).center(5),"|",str(dl['score']).center(5),"|")
        k+=1
    elif j==len(infors)+3:
        print("+-------+-------+-------+")
    j+=1
# print(infors)
# print("+---------------+----------+----------+")
# print("|     姓名      |   年龄   |   成绩   |")
# print("+---------------+----------+----------+")
# for d in infors:
#     n = d['name'].center(15)
#     a = str(d['age']).center(10)
#     s = str(d['score']).center(10)
#     print("|%s|%s|%s|" % (n, a, s))
# print("+---------------+----------+----------+")

打印名片管理系统：

要求：

1. 添加一个新的名片
2. 删除一个名片
3. 修改一个名片
4. 查询一个名片
5. 显示所有名片
6. 退出系统

提示：card_infors = [{‘name’:’xx’,’qq’:xxx,’weixin’:xxx,’addr’:’xxx’},

                               {‘name’:’xx’,’qq’:xxx,’weixin’:xxx,’addr’:’xxx’}

]

print("		打印名片系统")
l=[]
hd="+---------------+----------+----------+----------+"
zh="|     姓名      |    QQ    |   微信   |   地址   |"
a=0
tt="jkl"
while a<=6:
    k = 0
    d = {}
    a = int(input("1.添加 2.删除 3.修改 4.查询 5.显示所有 6.保存信息 7.退出"))
    if a == 1:
        na=input("名字:")
        qq=input("QQ:")
        wx=input("weixin")
        ad=input("addr:")
        d['name']=na
        d['qq']=qq
        d['weixin']=wx
        d['addr']=ad
        l.append(d)
    elif a==2:
        while k==0:
            i = 0
            an = input("请输入要删除的名字（可输入jkl返回）")
            if an==tt:
                k=1
            else:
                for dl in l:
                    if an == dl['name']:
                        l.pop(i)
                        print("删除成功")
                        k = 1
                    else:
                        i += 1
                if k == 0:
                    print("输入错误名字")
    elif a==3:
        while k==0:
            i = 0
            d = {}
            an = input("请输入要修改的名字（可输入jkl返回）")
            if an==tt:
                k=1
            else:
                for dl in l:
                    if an == dl['name']:
                        na = input("修改后名字:")
                        qq = input("修改后QQ:")
                        wx = input("修改后weixin")
                        ad = input("修改后addr:")
                        d['name'] = na
                        d['qq'] = qq
                        d['weixin'] = wx
                        d['addr'] = ad
                        l[i] = d
                        print(hd)
                        print(zh)
                        print(hd)
                        an = l[i]['name'].center(15)
                        pp = l[i]['qq'].center(10)
                        xw = l[i]['weixin'].center(10)
                        da = l[i]['addr'].center(10)
                        print("|%s|%s|%s|%s|" % (an, pp, xw, da))
                        print(hd)
                        k = 1
                    else:
                        i += 1
                if k == 0:
                    print("输入错误名字")
    elif a==4:
        while k==0:
            i = 0
            a = int(input("请输入要查询的序号(可输入-1退出)"))
            if a==-1:
                k=1
            else:
                if a <= len(l) + 1:
                    print(hd)
                    print(zh)
                    print(hd)
                    dl = l[a - 1]
                    an = dl['name'].center(15)
                    pp = dl['qq'].center(10)
                    xw = dl['weixin'].center(10)
                    da = dl['addr'].center(10)
                    print("|%s|%s|%s|%s|" % (an, pp, xw, da))
                    print(hd)
                    k = 1
                else:
                    print("请输入小于%d的正整数序号", len(l) + 1)
    elif a==5:
        print(hd)
        print(zh)
        print(hd)
        for dl in l:
            an = dl['name'].center(15)
            pp = dl['qq'].center(10)
            xw = dl['weixin'].center(10)
            da = dl['addr'].center(10)
            print("|%s|%s|%s|%s|" % (an, pp, xw, da))
        print(hd)
        # print(l)
    elif a==6:
        f = open('./mingpian.txt', 'w', encoding='utf-8')
        for dl in l:
            an = dl['name'].center(15)
            pp = dl['qq'].center(10)
            xw = dl['weixin'].center(10)
            da = dl['addr'].center(10)
            x=an+pp+xw+da
            print(x)
            f.write(x)
        f.close()
    elif a==7:
        break
    else:
        print("输入错误，退出")
        break

 

集合

       集合是可变的序列容器

       集合内的数据对象都是唯一的（不能重复多次的）

       集合是无序的存储结构，集合中的数据没有先后顺序关系

       集合内的元素必须是不可变对象

       集合是可迭代对象

       集合是相当于只有键没有值的字典

1. 创建集合的构造函数

Set() 创建一个空集合对象（不能用{}来创建空集合）

Set(iterable)   用可迭代对象来创建新的集合对象

注：

        非空集合用{}括起来，内部的各个元素用（，）分隔开

创建非空集合

集合的添加与删除操作

       添加：

1. add方法：把要传入的元素做为一个整个添加到集合中
2. updata方法：是把要传入的元素拆分，作为个体传入到集合中删除

 

remove 删除集合中要删除的元素

集合中的查看

       集合也是可迭代对象可以用for循环遍历查看其中的元素

 

集合的运算：

       交集&            生成两个集合的交集   

       并集|             生成两个集合的并集

       补集-             生成两个集合的补集   

       对称补集^      生成两个集合的对称补集

       子集<            判断一个集合是另一个集合的子集

       超集>            判断一个集合是另一个集合的超集