Python之路(第四篇)：Python基本数据类型列表、元组、字典

一、列表

1、列表

list ,是一个类，
li = [1,2,"nicholas"]
li是通过list类创建的对象。

2、list特点：

用中括号括起来，用逗号分割每个元素，列表中的元素可以是数字，可以是字符串，也可以是一个列表，甚至作为元素的列表也可以存在列表,布尔值也可以作为元素。
列表是有序的，元素可以被修改。
列表是一个可迭代对象。
列表相当于一个集合，内部可以放置任何东西。

如：

li = [1, 12, 9, "age", ["尼古拉斯", ["19", 10], "庞麦郎"], "alex", True]

　　

3、可以通过索引、切片取值

例子

li = [1, 12, 9, "age", ["尼古拉斯", ["19", 10], "庞麦郎"], "alex", True]
print(li[2])
print(li[1:3])

　　

输出结果

9
[12, 9]

　　

4、可以用for循环、while循环

for循环：

li = [1, 12, 9, "age", ["尼古拉斯", ["19", 10], "庞麦郎"], "alex", True]
for i in li :
    print(i)

　　

输出结果

1
12
9
age
['尼古拉斯', ['19', 10], '庞麦郎']
alex
True

　　

while循环

li = [1, 12, 9, "age", ["尼古拉斯", ["19", 10], "庞麦郎"], "alex", True]
count = len(li)
i = 0
while i < count:
    v = li[i]
    print(v)
    i = i + 1

　　

输出结果

1
12
9
age
['尼古拉斯', ['19', 10], '庞麦郎']
alex
True

　　

5、列表的元素可以被修改

a、通过索引删除修改
例子

li = [1, 12, 9, "age", ["尼古拉斯", ["19", 10], "庞麦郎"], "alex", True]
li[1] = 8 #通过索引直接赋值给某个元素
print(li)

　　

输出结果

[1, 8, 9, 'age', ['尼古拉斯', ['19', 10], '庞麦郎'], 'alex', True]

　　

del 删除

例子

li = [1, 12, 9, "age", ["尼古拉斯", ["19", 10], "庞麦郎"], "alex", True]
del li[1] #通过del加索引直接删除某个元素
print(li)

　　

输出结果

[1, 9, 'age', ['尼古拉斯', ['19', 10], '庞麦郎'], 'alex', True]

　　

b、通过切片删除修改
例子

li = [1, 12, 9, "age", ["尼古拉斯", ["19", 10], "庞麦郎"], "alex", True]
li[1:3] = [8,18]
#通过切片的方式直接赋值修改元素，注意要加中括号，组成一个列表
print(li)

　　

输出结果

[1, 8, 18, 'age', ['尼古拉斯', ['19', 10], '庞麦郎'], 'alex', True]

　　

例子

li = [1, 12, 9, "age", ["尼古拉斯", ["19", 10], "庞麦郎"], "alex", True]
del li[1:3]
#通过切片的方式直接删除元素
print(li)

　　

输出结果

[1, 'age', ['尼古拉斯', ['19', 10], '庞麦郎'], 'alex', True]

　　

6、列表也支持in操作

列表中的元素以逗号进行分割，各个作为一个整体。

li = [1, 12, 9, "age", ["尼古拉斯", ["19", 10], "庞麦郎"], "alex", True]
v = "age" in li
print(v)

　　

输出结果

True

　　

分析：这里的判断是不是在列表里是用完整的元素，即"age",
而"ag" in li则会输出False,同理，这个例子中"尼古拉斯"in li也会输出False.

7、列表多层索引的操作

可以使用下标索引来访问列表中的值
举个例子
我想获取"19"

li = [1, 12, 9, "age", ["尼古拉斯", ["19", 10], "庞麦郎"], "alex", True]
v =li[4][1][0]
print(v)

　　

输出结果

19

　　

分析：这里是一层一层的索引的
"19"所在的元素在第一层索引位置是4
v=li[4] ，这里的li[4]就是["尼古拉斯", ["19", 10], "庞麦郎"]这个整体，
同样的li[4][1]实际是["19", 10]，继续根据位置进行索引获取"19"即可。

8、字符串转换为列表，列表转为字符串

a、字符串转换为列表

str1 = "nicholas"
v =list(str1)
print(v)

　　

输出结果

['n', 'i', 'c', 'h', 'o', 'l', 'a', 's']

　　

字符串转列表可以直接用list，这里list会把字符串的每个字符循环一遍，输出以每个字符为元素的列表。
或者直接
v = list("nicholas")

b、列表转为字符串
如果用str直接将列表转为字符串

li = ["nicholas","niu","bi"]
v =str(li)
print(v)

　　

输出结果

['nicholas', 'niu', 'bi']

　　

分析：这里确实可以将li转为字符串，但是这里只是将li这个列表整体作为一个字符串即"['nicholas', 'niu', 'bi']",要想实现列表里元素的合并，并拼接成字符串需要for循环或者用join（）。

for循环转字符串
例子
如果列表里元素都是字符串

li = ["nicholas","niu","bi"]
s = ""
for i in li:
    s = s + i
    print(s)

　　

输出结果

nicholasniubi

　　

在列表里元素都是字符串的情况下可以用
join()可以比较简单实现

li = ["nicholas","niu","bi"]
s = "".join(li)
print(s)

　　

输出结果

nicholasniubi

　　

但是如果列表里元素包含数字或者其他的类型，只能用for循环实现对列表元素拼接转为字符串

li = ["nicholas","niu","bi",8,18,True]
s = ""
for i in li:
    s = s + str(i)
#注意这里要把i转换为字符串类型，否则会报错
print(s)

　　

输出结果

nicholasniubi818True

　　

二、列表方法

1、append()

在列表末尾追加新的对象

li = ["nicholas","niu","bi",8,18,True]
li.append(99)
print(li)

　　

输出结果

['nicholas', 'niu', 'bi', 8, 18, True, 99]

　　

再举个例子

li = ["nicholas","niu","bi",8,18,True]
li.append(168)
li.append("99")
li.append("nick")
print(li)

　　

输出结果

['nicholas', 'niu', 'bi', 8, 18, True, 168, '99', 'nick']

　　

分析：注意这里是直接在列表里进行修改的，并不需要重新对li.append()进行变量的重命名。

2、clear()

清空列表

li = ["nicholas","niu","bi",8,18,True]
li.clear()
print(li)

　　

输出结果

[]

　　

结合append举个例子

li = ["nicholas","niu","bi",8,18,True]
li.clear()
li.append(99)
print(li)

　　

输出结果

[99]

　　

分析：在这里我们可以看到，clear、append都是直接对列表进行操作的。

3、copy()

举个例子

li = ["nicholas","niu","bi",8,18,True]
v = li.copy()
#这里由于是复制，所以需要一个新的变量以满足赋值需要
print(v)

　　

输出结果

['nicholas', 'niu', 'bi', 8, 18, True]

　　

这里的复制是浅拷贝。

4、count()

统计某个元素在列表中出现的次数

li = ["nicholas","niu","bi",8,18,True]
v = li.count(8)
#count这里必须包含一个参数，不能为空，为空则报错。
print(v)

　　

输出结果

1

　　

5、extend()

在列表末尾一次性追加另一个序列中的多个值
举个例子

li1 = ["nicholas","niu","bi",8,18,True]
li2 = ["nicholas","niu","bi",8,18,True]
li1.append([16,"nick"])
li2.extend([16,"nick"])
print(li1)
print(li2)

　　

输出结果

['nicholas', 'niu', 'bi', 8, 18, True, [16, 'nick']]
['nicholas', 'niu', 'bi', 8, 18, True, 16, 'nick']

　　

分析：这里append的追加是把后面的参数作为一个整体，追加到原列表成为最后一个元素。extend这里的追加是把参数做了一个循环依次添加到原列表中，相当于内部执行for循环。

6、index（）

从列表中找出某个值第一个匹配项的索引位置,根据index的参数获取其当前列表的索引位置，从左边开始。

li = ["nicholas","niu","bi",8,18,True,8]
v = li.index("niu")
print(v)

　　

输出结果

1

　　

再举个例子

li = ["nicholas","niu","bi",8,18,True,8]
v = li.index(8)
print(v)

　　

输出结果

3

　　

这里列表中有2个8，但是index只会输出从左向右遇到的第一个的位置。

例子

li = ["nicholas","niu","bi",8,18,True,8,9]
v = li.index(8,4,8)
#这里的index(8,4,8),其中第一个8是表示要寻找的对象，“4,8”表示从列表的索引第4个位置开始寻找到第8个位置结束
print(v)

　　

输出结果

6

　　

分析：这里我们可以看到index寻找列表内容也可以规定寻找位置。

7、insert()

将对象插入列表

li = ["nicholas","niu","bi",8,18,True,8,9]
li.insert(7,4)
print(li)

　　

输出结果

['nicholas', 'niu', 'bi', 8, 18, True, 8, 4, 9]

　　

分析：insert的第一个参数规定了要插入的指定位置，第二个参数是插入的内容。

8、pop()

删除某个值，并可以获取当前删除的值
没有指定索引，默认删除最后一个元素

，这里只能是索引，或者没有参数，不能指定具体元素

li = ["nicholas","niu","bi",8,18,True,8,9]
v = li.pop(7)
# li.pop(7),如果不需要获取被删除的值可以直接这样写
print(li)
print(v)

　　

输出结果

['nicholas', 'niu', 'bi', 8, 18, True, 8]
9

　　

9、remove()

移除列表中某个值的第一个匹配项，这里可以指定元素

li = ["nicholas","niu","bi",8,18,True,8,9]
li.remove(8)
print(li)

　　

输出结果

['nicholas', 'niu', 'bi', 18, True, 8, 9]

　　

例子2

li = ["nicholas","niu","bi",8,18,True,8,9]
li.remove("niu")
print(li)

　　输出结果

['nicholas', 'bi', 8, 18, True, 8, 9]

　　

分析：这里remove（）参数是要删除的对象，会删除从左到右遇到的第一个匹配的对象。

10、reverse()

将当前列表进行反转

li = ["nicholas","niu","bi",8,18,True,8,9]
li.reverse()
print(li)

　　

输出结果

[9, 8, True, 18, 8, 'bi', 'niu', 'nicholas']

　　

11、sort（）

对原列表进行排序

li1 = ["nicho","las","ciu","bi"]
li2 = [1,3,490,23,50]
li1.sort()
li2.sort()
print(li1)
print(li2)

　　

输出结果

['bi', 'ciu', 'las', 'nicho']
[1, 3, 23, 50, 490]

　　

分析：这里的排序要求列表是全部是字符串或者数字，根据英文首字母顺序或者数字的从小到大进行排序。如果列表既包含字符串又包含数字则会进行报错。

这里是根据ascii码表确定的顺序进行排序的。

例子

li = [1,3,490,23,50]
li.sort(reverse = True)
print(li)

　　

输出结果

[490, 50, 23, 3, 1]

　　

分析：这里的sort()加上参数reverse =True 会进行反向的排序。

三、元组

1、元组

tuple,
tu = (111,22,33,44)

2、元组的特点

元组的元素不可被修改，不能被增加或者删除
元组的元素可以是字符串、数字、布尔值、列表。
推荐一般写元组在小括号的最后加一个逗号。
tu = (111,"nicholas",[1,2,"18"],true,)
元组也是一个可迭代对象。

3、元组的索引、切片

tu = (2,3,"nicholas",["你好","hello",12,],True，)
v1 = tu[3]
v2 = tu[2:4]
print(v1)
print(v2)

　　

输出结果

['你好', 'hello', 12]
('nicholas', ['你好', 'hello', 12])

　　

4、 元组可以被for循环

tu = (2,3,"nicholas",["你好","hello",12,],True)
for i in tu :
    print(i)

　　

输出结果

2
3
nicholas
['你好', 'hello', 12]
True

　　

5、字符串、列表、元组的相互转换

字符串转元组

s1 = "nicholas"
s2 = "168"
v1 = tuple(s1)
v2 = tuple(s2)
print(v1)
print(v2)

　　

输出结果

('n', 'i', 'c', 'h', 'o', 'l', 'a', 's')
('1', '6', '8')

　　

分析：这里tuple相当于内部执行了一个for循环。

列表转元组

li1= [1,2,"nicholas",True]
v = tuple(li1)
print(v)

　　

输出结果

(1, 2, 'nicholas', True)

　　

分析：这里tuple相当于内部执行了一个for循环。

元组转字符串

对于列表里只有字符串也可以用join来合成一个整体元素。当然这里也可以用for循环。
如：

tu1= ["nicholas","niu","bi"]
v = "".join(tu1)
print(v)

　　

输出结果

nicholasniubi

　　

6、元组也是有序的，可以通过多层索引取值

例子

tu = ("nicholas",1,3,"niu",[2,"nick",[22,"hello"]],"bi")
v = tu[4][2][0]
print(v)

　　

输出结果

22

　　

这里的多层索引取值与列表类似。

7、元组的第一个元素整体不能被修改，但是第二层的如列表是可以被修改的，如删除、增加。

例子

tu = ("nicholas",1,3,"niu",[2,"nick",[22,"hello"]],"bi")
tu[4][2] = 8
print(tu)

　　

输出结果

('nicholas', 1, 3, 'niu', [2, 'nick', 8], 'bi')

　　

四、元组的方法

1、count()

获取指定元素在元组中出现的次数

tu = ("nicholas",1,3,"niu",[2,"nick"],"bi",8,1)
v = tu.count(1)
print(v)

　　

输出结果

2

　　

2、index（）

获取某一个值的索引位置
例子

tu = ("nicholas",1,3,"niu",[2,"nick"],"bi",8,"niu")
v = tu.index("niu")
print(v)

　　

输出结果

3

　　

分析：这里与列表类似，index只会输出从左向右遇到的第一个的位置。

五、字典

1、dict ｛key:value｝

key：value 是一个键值对

2、字典的value可以是任何值（字符串、数字、列表、元组、布尔值），同时可以进行嵌套。

3、字典的key不能是列表、字典 注意true、false可能和1和0重复。

布尔值true\false在内存中就存储为1\0.
如果两个key是相同的，只能显示一个

4、字典是无序的，多层索引取值

例子1

 dic = {
            "k1": 18,
            "k2": True,
            "k3": [
                11,
                [],
                (),
                22,
                33,
                {
                    'kk1': 'vv1',
                    'kk2': 'vv2',
                    'kk3': (11,22),
                }
            ],
            "k4": (11,22,33,44)
        }
print(dic)

　　

　　

输出结果

{'k1': 18, 'k2': True, 'k3': [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}], 'k4': (11, 22, 33, 44)}

　　

例子2
如何找到上面例子中的第三个键值对中的value中的'kk3': (11,22)中的11呢?

dic = {
        "k1": 18,
        "k2": True,
        "k3": [
            11,
            [],
            (),
            22,
            33,
            {
                'kk1': 'vv1',
                'kk2': 'vv2',
                'kk3': (11,22),
            }
        ],
        "k4": (11,22,33,44)
    }
v = dic["k3"][5]["kk3"][0]
print(v)

　　

　　

输出结果

11

　　

　　

分析：由于字典的键值对是成对出现的，而且是无序的，这里只能先指定key,这里的

dic["k3"]=[11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}]
同样的
dic["k3"][5]=
{'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}

dic["k3"][5]["kk3"] =(11, 22)
最终用

dic["k3"][5]["kk3"][0]获取了值11.

字典由于是无序的，无法进行切片

（注：从python3.6开始，字典是有序的，即你每次打印字典内容都是一样的。但是这只是现在版本的一个功能，目前并未作为一个语法，所以现在仍然可以认为python3中字典是无序的。时间20180316。来源：超链接）

5、字典的删除

字典的删除用del，具体方式与字典的多层索引类似
如需要删除'kk1': 'vv1',
则可以这样写

dic = {
        "k1": 18,
        "k2": True,
        "k3": [
            11,
            [],
            (),
            22,
            33,
            {
                'kk1': 'vv1',
                'kk2': 'vv2',
                'kk3': (11,22),
            }
        ],
        "k4": (11,22,33,44)
    }
del dic["k3"][5]["kk1"]
print(dic)

　　

输出结果

{'k1': 18, 'k2': True, 'k3': [11, [], (), 22, 33, {'kk2': 'vv2', 'kk3': (11, 22)}], 'k4': (11, 22, 33, 44)}

　　

如需删除"k1": 18
则可以这样写

    dic = {
        "k1": 18,
        "k2": True,
        "k3": [
            11,
            [],
            (),
            22,
            33,
            {
                'kk1': 'vv1',
                'kk2': 'vv2',
                'kk3': (11,22),
            }
        ],
        "k4": (11,22,33,44)
    }
    del dic["k1"]
    print(dic)

　　

输出结果

{'k2': True, 'k3': [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}], 'k4': (11, 22, 33, 44)}

　　

6、字典的for循环

在字典的for循环中，默认只会输出字典的keys

如：

dic = {
        "k1": 18,
        "k2": True,
        "k3": [
            11,
            [],
            (),
            22,
            33,
            {
                'kk1': 'vv1',
                'kk2': 'vv2',
                'kk3': (11,22),
            }
        ],
        "k4": (11,22,33,44)
    }
for item in dic:
    print(item)

　　

输出结果

k1
k2
k3
k4

　　

如果想要输出values可以这样写

dic = {
        "k1": 18,
        "k2": True,
        "k3": [
            11,
            [],
            (),
            22,
            33,
            {
                'kk1': 'vv1',
                'kk2': 'vv2',
                'kk3': (11,22),
            }
        ],
        "k4": (11,22,33,44)
    }
for item in dic.values():
    print(item)

　　

输出结果

18
True
[11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}]
(11, 22, 33, 44)

　　

想要输出keys也可以这样写

dic = {
        "k1": 18,
        "k2": True,
        "k3": [
            11,
            [],
            (),
            22,
            33,
            {
                'kk1': 'vv1',
                'kk2': 'vv2',
                'kk3': (11,22),
            }
        ],
        "k4": (11,22,33,44)
    }
for item in dic.keys():
    print(item)

　　

输出结果

k1
k2
k3
k4

　　

如果想同时输出keys、values
则可以这样写

dic = {
        "k1": 18,
        "k2": True,
        "k3": [
            11,
            [],
            (),
            22,
            33,
            {
                'kk1': 'vv1',
                'kk2': 'vv2',
                'kk3': (11,22),
            }
        ],
        "k4": (11,22,33,44)
    }
for k,v in dic.items():
    print(k,v)

　　

输出结果

k1 18
k2 True
k3 [11, [], (), 22, 33, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (11, 22)}]
k4 (11, 22, 33, 44)

　　

分析：这里用的是字典的items()方法

7、字典的in判断

例子

dic = {
        "k1": 18,
        "k2": True,
        "k3": [
            11,
            [],
            (),
            22,
            33,
            {
                'kk1': 'vv1',
                'kk2': 'vv2',
                'kk3': (11,22),
            }
        ],
        "k4": (11,22,33,44)
    }
v1= "k4"in dic
v2= "18"in dic
print(v1,v2)

　　

输出结果

True False

　　

分析：

分析：这里默认判断的是key,如果想判断value可以这样写

v1= "k4"in dic.values()

六、字典的方法

1、clear（）

和列表中的用法类似。

dic = {
        "k1": 18,
        "k2": True,
        "k3": [0,"ni"],
        "k4": (11,22,33,44)
    }
dic.clear()
print(dic)

　　

输出结果

{}

　　

2、copy（）

和列表中的用法类似。

dic = {
        "k1": 18,
        "k2": True,
        "k3": [0,"ni"],
        "k4": (11,22,33,44)
    }
v = dic.copy()
print(v)

　　

输出结果

{'k1': 18, 'k2': True, 'k3': [0, 'ni'], 'k4': (11, 22, 33, 44)}

　　

3、fromkeys()

用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。
语法：

dict.fromkeys(seq[, value]))
例子

dic = {
            "k1": 18,
            "k2": True,
            "k3": [0,"ni"],
            "k4": (11,22,33,44)
        }
v = dic.fromkeys([1,2,3])
print(v)

　　

输出结果

{1: None, 2: None, 3: None}

　　

分析：这里以fromkeys()第一个参数作为生成字典额keys,如果没有第二个参数则默认values为None

例子

dic = {
        "k1": 18,
        "k2": True,
        "k3": [0,"ni"],
        "k4": (11,22,33,44)
    }
v = dic.fromkeys([1,2,3],"nicholas")
print(v)

　　

输出结果

{1: 'nicholas', 2: 'nicholas', 3: 'nicholas'}

　　

分析：这里以fromkeys（）的第一个参数作为keys,第二个参数统一作为各个keys的值。

4、get()

根据key获取值，key不存在时，可以指定默认值
例子

 dic = {
        "k1": 18,
        "k2": True,
        "k3": [0,"ni"],
        "k4": (11,22,33,44)
    }
v = dic.get("k1","no")
print(v)

　　

输出结果

18

　　

分析：get()第一个参数是要取回的key,第二个参数是如果key不存在返回的内容。这时这里的"no"被忽略了。

例子

dic = {
        "k1": 18,
        "k2": True,
        "k3": [0,"ni"],
        "k4": (11,22,33,44)
    }
v = dic.get("k11","no")
print(v)

　　

输出结果

no

　　

分析：这里可以看到，当取回的值不存在时，get()返回了规定的内容。

5、items()

以列表返回可遍历的(键, 值) 元组数组。
例子

dic = {
        "k1": 18,
        "k2": True,
        "k3": [0,"ni"],
        "k4": (11,22,33,44)
    }
v= dic.items()
print(v)

　　

输出结果

dict_items([('k1', 18), ('k2', True), ('k3', [0, 'ni']), ('k4', (11, 22, 33, 44))])

　　

6、keys()

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

dic = {
        "k1": 18,
        "k2": True,
        "k3": [0,"ni"],
        "k4": (11,22,33,44)
    }
v= dic.keys()
print(v)

　　

输出结果

dict_keys(['k1', 'k2', 'k3', 'k4'])

　　

7、pop()

删除并获取被删除的值
删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。

dic = {
        "k1": 18,
        "k2": True,
        "k3": [0,"ni"],
        "k4": (11,22,33,44)
    }
dic.pop("k2")
print(dic)

　　

输出结果

{'k1': 18, 'k3': [0, 'ni'], 'k4': (11, 22, 33, 44)}

　　

例子

dic = {
        "k1": 18,
        "k2": True,
        "k3": [0,"ni"],
        "k4": (11,22,33,44)
    }
v = dic.pop("k2")
#这里获取删除的key的值
print(dic,v)

　　

#这里获取删除的key的值
print(dic,v)

输出结果

{'k1': 18, 'k3': [0, 'ni'], 'k4': (11, 22, 33, 44)} True

　　

8、popitem()

随机返回并删除字典中的一对键和值(一般删除末尾对)。
如果字典已经为空，却调用了此方法，就报出KeyError异常。

例子

dic = {
        "k1": 18,
        "k2": True,
        "k3": [0,"ni"],
        "k4": (11,22,33,44)
    }
 v = dic.popitem()
 print(dic,v)

　　

输出结果

{'k1': 18, 'k2': True, 'k3': [0, 'ni']} ('k4', (11, 22, 33, 44))

　　

这里也返回了被删除的键值位值
还可以这样写

dic = {
            "k1": 18,
            "k2": True,
            "k3": [0,"ni"],
        }
k,v = dic.popitem()
#这里把被删除的字典的key赋值给k,被删除的value赋值给v
print(dic,k,v)

　　

输出结果

{'k1': 18, 'k2': True} k3 [0, 'ni']

　　

9、setdefault()

setdefault()设置键和值，

如果key已存在，不设置，获取当前key对应的值
如果key不存在，设置，如果键不存在于字典中，将会添加键并将值设为默认值，返回新加入字典的键的值。
例子

dic = {
        "k1": 18,
        "k2": True,
    }
v = dic.setdefault("k1",123)
print(dic,v)

　　

输出结果

{'k1': 18, 'k2': True} 18

　　

分析：这里的键"k1"已经存在，获取原"k1"的值18

例子

dic = {
        "k1": 18,
        "k2": True,
    }
v = dic.setdefault("k12",123)
print(dic,v)

　　

输出结果

{'k1': 18, 'k2': True, 'k12': 123} 123

　　

分析：setdefault（）里的键位在原字典不存在，所以键值位值被添加进去，同时返回了值。

10、update()

更新字典，已经存在的直接覆盖掉，没有的直接加上去
例子

dic = {
        "k1": 18,
        "k2": True,
    }
dic.update({"k1":12,"k12":123})
print(dic)

　　

输出结果

{'k1': 12, 'k2': True, 'k12': 123}

　　

分析：这里可以看到,"k1"的值被直接修改了，原字典没有的"k12"直接被添加进去了。
update()还可以这样写

dic = {
        "k1": 18,
        "k2": True,
    }
print(dic)
dic.update(k1 = "1",k2 = "2",k5 = "5")
print(dic)

　　

输出结果

{'k1': 18, 'k2': True}
{'k1': '1', 'k2': '2', 'k5': '5'}

　　

分析：可以看到新的字典是update参数里等号左右两边生成的键值位值

11、values()

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

dic = {
        "k1": 18,
        "k2": True,
    }
v = dic.values()
print(dic)
print(v)

　　

输出结果

{'k1': 18, 'k2': True}
dict_values([18, True])

　　

七、重点知识

1、数字中的int()

2、字符串的方法

a、replace()
b、find()
c、join()
d、strip()
e、startswith()
f、split()
g、upper()
h、lower()
i、format()

3、列表的方法
append()、extend（）、insert()
索引、切片、循环

4、元组
索引、切片、循环
一级元素整体不能被修改

5、字典的方法
get()、update（）、keys()、values()
、items()

八、布尔值

true 、false
以下布尔值都为假
None 空
"" '' 空字符串
()空元组
[]空列表
{}空字典
0