7 判断语句

7.1 if语句

• if语句是用来进行判断的，其使用格式如下：

    if 要判断的条件:
        条件成立时，要做的事情

例1:

age = 30
print("------if判断开始------")
if age >= 18:
    print ("我已经成年了,我可以约妹子了！！！")
print ("------if判断结束------")

运行结果:

------if判断开始------
我已经成年了,我可以约妹子了！！！
------if判断结束------

例2:

age = 16
print("------if判断开始------")
if age >= 18:
    print ("我已经成年了,我可以约妹子了！！！")
print ("------if判断结束------")

运行结果:

    ------if判断开始------
    ------if判断结束------

**总结：**以上2个例子仅仅是age变量的值不一样，结果却不同；能够看得出if判断语句的作用：就是当满足一定条件时才会执行那块代码，否则就不执行那块代码

7.2 if-else语句

    if 条件:
        满足条件时要做的事情1
        满足条件时要做的事情2
        满足条件时要做的事情3
        ......
    else:
        不满足条件时要做的事情1
        不满足条件时要做的事情2
        不满足条件时要做的事情3
        ......

例：

age = 30
print("------if判断开始------")
if age >= 18:
    print ("我已经成年了,我可以约妹子了！！！")
else:
    print("还没有成年，不能约妹子！！！")
print ("------if判断结束------")

结果1：年龄大于18

------if判断开始------
我已经成年了,我可以约妹子了！！！
------if判断结束------

结果2：年龄小于18

------if判断开始------
还没有成年，不能约妹子！！！
------if判断结束------

7.3 elif

elif的使用格式如下:

    if xxx1:
        事情1
    elif xxx2:
        事情2
    elif xxx3:
        事情3

说明:

• 当xxx1满足时，执行事情1，然后整个if结束
• 当xxx1不满足时，那么判断xxx2，如果xxx2满足，则执行事情2，然后整个if结束
• 当xxx1不满足时，xxx2也不满足，如果xxx3满足，则执行事情3，然后整个if结束

例:

score = 66
if 90 <= score <= 100:
    print('本次考试，等级为A')
elif 80 <= score < 90:
    print('本次考试，等级为B')
elif 70 <= score < 80:
    print('本次考试，等级为C')
elif 60 <= score < 70:
    print('本次考试，等级为D')
elif 0 <= score < 60:
    print('本次考试，等级为E')

可以和else一起使用

   if 性别为男性:
       输出男性的特征
       ...
   elif 性别为女性:
       输出女性的特征
       ...
   else:
       第三种性别的特征
       ...

说明:

• 当 “性别为男性” 满足时，执行 “输出男性的特征”的相关代码

• 当 “性别为男性” 不满足时，如果 “性别为女性”满足，则执行 “输出女性的特征”的相关代码

• 当 “性别为男性” 不满足，“性别为女性”也不满足，那么久默认执行else后面的代码，即 “第三种性别的特征”相关代码

• elif必须和if一起使用，否则出错

7.4 if嵌套

if嵌套的格式

    if 条件1:

        满足条件1 做的事情1
        满足条件1 做的事情2
        ......

        if 条件2:
            满足条件2 做的事情1
            满足条件2 做的事情2
            ......

• 说明
  • 外层的if判断，也可以是if-else
  • 内层的if判断，也可以是if-else
  • 根据实际开发的情况，进行选择

if嵌套的应用举例：

age = 16
girl = False
if age >= 18:
    print("我已经成年了,我可以约妹子了！！！")
    if girl:
        print("有女朋友,去约会！！")
    else:
        print("没有女朋友,约个屁啊！！")
else:
    print("还没有成年，不能约妹子！！！")
    if girl:
        print("还没有成年,这是早恋啊！！")
    else:
        print("听话的好孩子！！！")

结果1：age= 30;girl= True

我已经成年了,我可以约妹子了！！！
有女朋友,去约会！！

结果2：age= 30;girl= False

我已经成年了,我可以约妹子了！！！
没有女朋友,约个屁啊！！

结果3：age= 16;girl= False

还没有成年，不能约妹子！！！
听话的好孩子！！！

结果4：age= 16;girl= True

还没有成年，不能约妹子！！！
还没有成年,这是早恋啊！！

8 循环、break和continue

8.1 while循环

    while 条件:
        条件满足时，做的事情1
        条件满足时，做的事情2
        条件满足时，做的事情3
        ...(省略)...

例：

i = 0
while i < 5:
    print("当前是第%d次执行循环" % (i + 1))
    print("i=%d" % i)
    i += 1

结果:

    当前是第1次执行循环
    i=0
    当前是第2次执行循环
    i=1
    当前是第3次执行循环
    i=2
    当前是第4次执行循环
    i=3
    当前是第5次执行循环
    i=4

案例1. 计算1~100的累积和（包含1和100）

参考代码如下:

# encoding=utf-8
i = 1
sum = 0
while i <= 100:
    sum = sum + i
    i += 1
print("1~100的累积和为:%d" % sum)

运行结果：1~100的累积和为:5050

案例2. 计算1~100之间偶数的累积和（包含1和100）

# encoding=utf-8
i = 1
sum = 0
while i <= 100:
    if i % 2 == 0:
        sum = sum + i
    i += 1

print("1~100的偶数累积和为:%d" % sum)

运行结果：1~100的偶数累积和为:2550

8.2 while循环嵌套

类似if的嵌套，while嵌套就是：while里面还有while

格式如下

    while 条件1:

        条件1满足时，做的事情1
        条件1满足时，做的事情2   
        ......
        while 条件2:
            条件2满足时，做的事情1
            条件2满足时，做的事情2
            条件2满足时，做的事情3
            ...(省略)...

案例1 要求：打印如下图形：

    *
    * *
    * * *
    * * * *
    * * * * *

参考代码：

    i = 1
    while i<=5:
        j = 1
        while j<=i:
            print("* ",end='')
            j+=1
        print("\n")
        i+=1

案例2 ：九九乘法表

    i = 1
    while i<=9:
        j=1
        while j<=i:
            print("%d*%d=%-2d "%(j,i,i*j),end='')
            j+=1
        print('\n')
        i+=1

运行结果：

1*1=1  

1*2=2  2*2=4  

1*3=3  2*3=6  3*3=9  

1*4=4  2*4=8  3*4=12 4*4=16 

1*5=5  2*5=10 3*5=15 4*5=20 5*5=25 

1*6=6  2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 

1*7=7  2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 

1*8=8  2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 

1*9=9  2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 

8.3 for循环

像while循环一样，for可以完成循环的功能。

在Python中 for循环可以遍历任何序列的项目，如一个列表或者一个字符串等。

格式如下：

    for 临时变量 in 列表或者字符串等:
        循环满足条件时执行的代码
    else:
        循环不满足条件时执行的代码

例1：

name = 'AIHao'
for x in name:
    print(x)

运行结果如下:

A
I
H
a
o

案例2：

name = ''
for x in name:
    print(x)
else:
    print("没有数据")

运行结果如下:

没有数据

8.5 break

1） for循环

  name = 'AIHao'
  for x in name:
      print('----')
      if x == 'a': 
          break
      print(x)

运行结果:

----
A
----
I
----
H
----

2）while循环

  i = 0
  while i<10:
      i = i+1
      print('----')
      if i==5:
          break
      print(i)

运行结果:

----
1
----
2
----
3
----
4
----

**总结:**break的作用：用来结束整个循环

8.6 continue

1） for循环

  name = 'AIHao'
  for x in name:
      print('----')
      if x == 'a': 
          continue
      print(x)

运行结果:

----
A
----
I
----
H
----
----
o

2） while循环

  i = 0
  while i<10:
      i = i+1
      print('----')
      if i==5:
          continue
      print(i)

运行结果:

----
1
----
2
----
3
----
4
----
----
6
----
7
----
8
----
9
----
10

**总结:**continue的作用：用来结束本次循环，紧接着执行下一次的循环

注：

• break/continue只能用在循环中，除此以外不能单独使用
• break/continue在嵌套循环中，只对最近的一层循环起作用

9 字符串、列表、元组、字典

9.1 字符串

1）使用单引号或双引号定义的数据就是字符串，例：

a='hello'
或者
a="hello"

2）字符串的输出使用print（）

name = 'AI浩'
position = '算法工程师'
address = '北京石景山'
print('--------------------------------------------------')
print("姓名：%s" % name)
print("职位：%s" % position)
print("公司地址：%s" % address)
print('--------------------------------------------------')

运行结果：

--------------------------------------------------
姓名：AI浩
职位：算法工程师
公司地址：北京石景山
--------------------------------------------------

3）字符串输入

userName = input('请输入用户名:')
print("用户名为：%s" % userName)
password = input('请输入密码:')
print("密码为：%s" % password)

结果：（根据输入的不同结果也不同）

请输入用户名:dfsdfsd
用户名为：dfsdfsd
请输入密码:qqq
密码为：qqq

4）下标和切片

下标的使用

name = 'abcdef'
print(name[0])
print(name[1])
print(name[2])

运行结果：

a
b
c

切片：

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

切片的语法：[起始:结束:步长]

注意：选取的区间属于左闭右开型，即从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)。

name = 'abcdef'
print(name[0:3])  # 取 下标0~2 的字符

运行结果：

abc

9.2 字符串常见操作

如有字符串mystr = 'hello world AIHao and CSDN'，以下是常见的操作

9.2.1 find

检测 str 是否包含在 mystr中，如果是返回开始的索引值，否则返回-1，语法：

mystr.find(str, start=0, end=len(mystr))

例：

mystr = 'hello world AIHao and CSDN'
print(mystr.find("AIHao", 0, len(mystr)))

运行结果：

12

9.2.2 index

跟find()方法一样，只不过如果str不在 mystr中会报一个异常，语法：

mystr.index(str, start=0, end=len(mystr)) 

例：

mystr = 'hello world AIHao and CSDN'
print(mystr.index("Hao", 0, len(mystr)))

运行结果：

14

9.2.3 count

返回 str在start和end之间 在 mystr里面出现的次数，语法：

mystr.count(str, start=0, end=len(mystr))

例：

mystr = 'hello world AIHao and CSDN'
print(mystr.count("a", 0, len(mystr)))

运行结果：2

9.2.4 replace

把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次，语法：

mystr.replace(str1, str2,  mystr.count(str1))

例：

mystr = 'hello world AIHao and CSDN'
newStr=mystr.replace("a","ee",mystr.count("a"))
print(newStr)

运行结果：

hello world AIHeeo eend CSDN

9.2.5 split

以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串,语法：

mystr.split(str=" ", 2)    

例：

mystr = 'hello world AIHao and CSDN'
newStr=mystr.split(" ",2)
print(newStr)

运行结果：

['hello', 'world', 'AIHao and CSDN']

mystr = 'hello world AIHao and CSDN'
newStr=mystr.split(" ")
print(newStr)

运行结果：

['hello', 'world', 'AIHao', 'and', 'CSDN']

9.2.6 capitalize

把字符串的第一个字符大写，其他的变成小写，语法：

mystr.capitalize()

例：

mystr = 'hello world AIHao and CSDN'
print(mystr.capitalize())

运行结果：

Hello world aihao and csdn

9.2.7 title

把字符串的每个单词首字母大写，其他的改成小写，例：

mystr = 'hello world AIHao and CSDN'
print(mystr.title())

运行结果：

Hello World Aihao And Csdn

9.2.8 startswith

检查字符串是否是以 obj 开头, 是则返回 True，否则返回 False

mystr.startswith(obj)

例：

mystr = 'hello world AIHao and CSDN'
ss='hello'
print(mystr.startswith(ss))

运行结果：True

9.2.9 endswith

检查字符串是否以obj结束，如果是返回True,否则返回 False，用法同上

mystr.endswith(obj)

9.2.10 lower

转换 mystr 中所有大写字符为小写

mystr.lower()        

例：

mystr = 'hello world AIHao and CSDN'
print(mystr.lower())

运行结果：

hello world aihao and csdn

9.2.11 upper

转换 mystr 中的小写字母为大写，用法同上。

mystr.upper()    

9.2.12 ljust

返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串

mystr.ljust(width) 

例：

mystr = "hello world AIHao and CSDN"
print(mystr.ljust(50))

运行结果：

hello world AIHao and CSDN    

9.2.13 rjust

返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串

mystr.rjust(width)    

例：

mystr = "hello world AIHao and CSDN"
print(mystr.rjust(30))

运行结果：

    hello world AIHao and CSDN

9.2.14 center

返回一个原字符串居中,并使用空格填充至长度 width 的新字符串，用法同上。

mystr.center(width)   

9.2.15 lstrip

删除 mystr 左边的空白字符

mystr.lstrip()

9.2.16 rstrip

删除 mystr 字符串末尾的空白字符

mystr.rstrip()    

9.2.17 strip

删除mystr字符串两端的空白字符

>>> a = "\n\t itcast \t\n"
>>> a.strip()
'itcast'

9.2.18 rfind

类似于 find()函数，不过是从右边开始查找.

mystr.rfind(str, start=0,end=len(mystr) )

9.2.19 rindex

类似于 index()，不过是从右边开始.

mystr.rindex( str, start=0,end=len(mystr))

9.2.20 partition

把mystr以str分割成三部分,str前，str和str后

mystr.partition(str)

9.2.21 rpartition

类似于 partition()函数,不过是从右边开始.

mystr.rpartition(str)

9.2.22 splitlines

按照行分隔，返回一个包含各行作为元素的列表

mystr.splitlines()  

9.2.23 isalpha

如果 mystr 所有字符都是字母 则返回 True,否则返回 False

mystr.isalpha()  

9.2.24 isdigit

如果 mystr 只包含数字则返回 True 否则返回 False.

mystr.isdigit() 

9.2.25 isalnum

如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False

mystr.isalnum()  

9.2.26 isspace

如果 mystr 中只包含空格，则返回 True，否则返回 False.

mystr.isspace()   

9.2.27 join

将mystr 中每个字符后面插入str,构造出一个新的字符串

mystr.join(str)

例：

str_new=" ".join(_my)
print(str_new)
_new1='-'.join(_my)
print(_new1)

运行结果：

my name is AIhao
my-name-is-AIhao

9.3 列表List

列表list用[,…]表示，格式如下：

  namesList = ['xiaoWang','xiaoZhang','xiaoHua']

9.3.1 for循环遍历list

1）例：

namesList = ['xiaoWang', 'xiaoZhang', 'xiaoHua']
for name in namesList:
    print(name)

结果:

    xiaoWang
    xiaoZhang
    xiaoHua

列表推导式

1）普通方式

a = [x for x in range(4)]
print(a)
b = [x for x in range(3, 4)]
print(b)
c = [x for x in range(3, 19)]
print(c)
d = [x for x in range(3, 19, 2)]
print(d)

运行结果：

[0, 1, 2, 3]
[3]
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
[3, 5, 7, 9, 11, 13, 15, 17]

2）在循环的过程中加入if判断

a = [x for x in range(3, 15) if x % 2 == 0]
print(a)
b = [x for x in range(3, 15) if x % 2 != 0]
print(b)
b = [x for x in range(3, 15)]
print(b)

运行结果：

[4, 6, 8, 10, 12, 14]
[3, 5, 7, 9, 11, 13]
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

3）多个for循环

a = [(x, y) for x in range(3, 5) for y in range(3)]
print(a)
b = [(x, y, z) for x in range(3, 5) for y in range(3) for z in range(4, 6)]
print(b)

运行结果：

[(3, 0), (3, 1), (3, 2), (4, 0), (4, 1), (4, 2)]
[(3, 0, 4), (3, 0, 5), (3, 1, 4), (3, 1, 5), (3, 2, 4), (3, 2, 5), (4, 0, 4), (4, 0, 5), (4, 1, 4), (4, 1, 5), (4, 2, 4), (4, 2, 5)]

9.3.2 while循环遍历list

namesList = ['xiaoWang', 'xiaoZhang', 'xiaoHua']
length = len(namesList)
i = 0
while i < length:
    print(namesList[i])
    i += 1

运行结果：

xiaoWang
xiaoZhang
xiaoHua

9.4 列表的常用操作

列表中存放的数据是可以进行修改的，比如"增"、“删”、“改”"

9.4.1 添加元素("增"append, extend, insert)

append：通过append可以向列表添加元素

例:

    #定义变量A，默认有3个元素
    A = ['xiaoWang','xiaoZhang','xiaoHua']
    print("-----添加之前，列表A的数据-----")
    for tempName in A:
        print(tempName)
    #提示、并添加元素
    temp = input('请输入姓名:')
    A.append(temp)
    print("-----添加之后，列表A的数据-----")
    for tempName in A:
        print(tempName)

结果:

-----添加之前，列表A的数据-----
xiaoWang
xiaoZhang
xiaoHua
请输入姓名:xiaohei
-----添加之后，列表A的数据-----
xiaoWang
xiaoZhang
xiaoHua
xiaohei

extend：通过extend可以将另一个集合中的元素逐一添加到列表中

a = [1, 2]
b = [3, 4]
a.append(b)
print(a)
a.extend(b)
print(a)

结果：

[1, 2, [3, 4]]
[1, 2, [3, 4], 3, 4]

insert ：insert(index, object) 在指定位置index前插入元素object

a = [0, 1, 2]
a.insert(1, 3)
print(a)

结果：

[0, 3, 1, 2]

9.4.2修改元素(“改”)

修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改，例:

    #定义变量A，默认有3个元素
    A = ['xiaoWang','xiaoZhang','xiaoHua']

    print("-----修改之前，列表A的数据-----")
    for tempName in A:
        print(tempName)
    #修改元素
    A[1] = 'xiaoLu'
    print("-----修改之后，列表A的数据-----")
    for tempName in A:
        print(tempName)

结果:

    -----修改之前，列表A的数据-----
    xiaoWang
    xiaoZhang
    xiaoHua
    -----修改之后，列表A的数据-----
    xiaoWang
    xiaoLu
    xiaoHua

9.4.3 查找元素("查"in, not in, index, count)

所谓的查找，就是看看指定的元素是否存在

in, not in

python中查找的常用方法为：

• in（存在）,如果存在那么结果为true，否则为false
• not in（不存在），如果不存在那么结果为true，否则false

demo

    #待查找的列表
    nameList = ['xiaoWang','xiaoZhang','xiaoHua']
    #获取用户要查找的名字
    findName = input('请输入要查找的姓名:')
    #查找是否存在
    if findName in nameList:
        print('在字典中找到了相同的名字')
    else:
        print('没有找到')

说明：

in的方法只要会用了，那么not in也是同样的用法，只不过not in判断的是不存在

index, count

index和count与字符串中的用法相同

a = ['a', 'b', 'c', 'a', 'b']
print(a.index('a', 1, 4))
print(a.count('b'))
print(a.count('d'))
print(a.index('a', 1, 3)) # 注意是左闭右开区间

运行结果：

Traceback (most recent call last):
  File "C:/Users/WH/Desktop/Python基础/第一个Python程序.py", line 5, in <module>
    print(a.index('a', 1, 3)) # 注意是左闭右开区间
ValueError: 'a' is not in list
3
2
0

9.4.4 删除元素("删"del, pop, remove)

类比现实生活中，如果某位同学调班了，那么就应该把这个条走后的学生的姓名删除掉；在开发中经常会用到删除这种功能。

列表元素的常用删除方法有：

• del：根据下标进行删除
• pop：删除最后一个元素
• remove：根据元素的值进行删除

demo:(del)

    movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']
    print('------删除之前------')
    for tempName in movieName:
        print(tempName)
    del movieName[2]
    print('------删除之后------')
    for tempName in movieName:
        print(tempName)

结果:

    ------删除之前------
    加勒比海盗
    骇客帝国
    第一滴血
    指环王
    霍比特人
    速度与激情
    ------删除之后------
    加勒比海盗
    骇客帝国
    指环王
    霍比特人
    速度与激情

例:(pop)

    movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']

    print('------删除之前------')
    for tempName in movieName:
        print(tempName)

    movieName.pop()

    print('------删除之后------')
    for tempName in movieName:
        print(tempName)

结果:

    ------删除之前------
    加勒比海盗
    骇客帝国
    第一滴血
    指环王
    霍比特人
    速度与激情
    ------删除之后------
    加勒比海盗
    骇客帝国
    第一滴血
    指环王
    霍比特人

demo:(remove)

    movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']

    print('------删除之前------')
    for tempName in movieName:
        print(tempName)

    movieName.remove('指环王')

    print('------删除之后------')
    for tempName in movieName:
        print(tempName)

结果:

    ------删除之前------
    加勒比海盗
    骇客帝国
    第一滴血
    指环王
    霍比特人
    速度与激情
    ------删除之后------
    加勒比海盗
    骇客帝国
    第一滴血
    霍比特人
    速度与激情

9.4.5 排序(sort, reverse)

sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。

reverse方法是将list逆置。

>>> a = [1, 4, 2, 3]
>>> a
[1, 4, 2, 3]
>>> a.reverse()
>>> a
[3, 2, 4, 1]
>>> a.sort()
>>> a
[1, 2, 3, 4]
>>> a.sort(reverse=True)
>>> a
[4, 3, 2, 1]

9.4.6 列表的嵌套

类似while循环的嵌套，列表也是支持嵌套的

一个列表中的元素又是一个列表，那么这就是列表的嵌套

    schoolNames = [['北京大学','清华大学'],
                    ['南开大学','天津大学','天津师范大学'],
                    ['山东大学','中国海洋大学']]

案例：一个学校，有3个办公室，现在有8位老师等待工位的分配，请编写程序，完成随机的分配

#encoding=utf-8
import random
# 定义一个列表用来保存3个办公室
offices = [[],[],[]]
# 定义一个列表用来存储8位老师的名字
names = ['A','B','C','D','E','F','G','H']
i = 0
for name in names:
    index = random.randint(0,2)    
    offices[index].append(name)
i = 1
for tempNames in offices:
    print('办公室%d的人数为:%d'%(i,len(tempNames)))
    i+=1
    for name in tempNames:
        print("%s"%name,end='')
    print("\n")
    print("-"*20)

运行结果如下:

办公室1的人数为:3
BFG

--------------------
办公室2的人数为:5
ACDEH

--------------------
办公室3的人数为:0


--------------------

9.5 元组

Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号()，列表使用方括号[],例：

aTuple = ('et',77,99.9)
print(aTuple)

运行结果：(‘et’, 77, 99.9)

9.5.1 访问元组

aTuple = ('et',77,99.9)
print(aTuple[0])
print(aTuple[1])

运行结果：

et
77

9.5.2 修改元组

aTuple = ('et',77,99.9)
aTuple[0]=111

运行结果：

Traceback (most recent call last):
  File "C:/Users/WH/Desktop/Python基础/第一个Python程序.py", line 2, in <module>
    aTuple[0]=111
TypeError: 'tuple' object does not support item assignment

从上面的运行结果可以得出： python中不允许修改元组的数据，包括不能删除其中的元素。

9.5.3 元组的内置函数count, index

index和count与字符串和列表中的用法相同

>>> a = ('a', 'b', 'c', 'a', 'b')
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0

9.6 字典

字典是一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

例：

   info = {'name':'AI浩', 'id':100, 'sex':'f', 'address':'中国北京'}

9.6.1 根据键访问值

    info = {'name':'AI浩', 'id':100, 'sex':'f', 'address':'中国北京'}
    print(info['name'])
    print(info['address'])

结果:

    AI浩
    中国北京

若访问不存在的键，则会报错：

info = {'name': 'AI浩', 'id': 100, 'sex': 'f', 'address': '中国北京'}
print(info['age'])

运行结果：

Traceback (most recent call last):
  File "C:/Users/WH/Desktop/Python基础/第一个Python程序.py", line 2, in <module>
    print(info['age'])
KeyError: 'age'

在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值：

>>> age = info.get('age')
>>> age #'age'键不存在，所以age为None
>>> type(age)
<type 'NoneType'>
>>> age = info.get('age', 18) # 若info中不存在'age'这个键，就返回默认值18
>>> age
18

9.7 字典的常用操作

9.7.1 修改元素

字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改，例:

info = {'name': 'AI浩', 'id': 100, 'sex': 'f', 'address': '中国北京'}
info['id'] = 150
print('修改之后的id为:%d' % info['id'])

结果:修改之后的id为:150

9.7.2 添加元素

使用 变量名[‘键’] = 数据 时，这个“键”在字典中，不存在，那么就会新增这个元素，例：

info = {'name': 'AI浩',  'sex': 'f', 'address': '中国北京'}
newId = input('请输入新的ID')
info['id'] = int(newId)

print('添加之后的id为:%d' % info['id'])

结果:

请输入新的ID123
添加之后的id为:123

9.7.3 删除元素

对字典进行删除操作，有一下几种：

• del
• clear()

例1:del删除指定的元素

info = {'name': 'AI浩',  'sex': 'f', 'address': '中国北京'}
print('删除前,%s' % info['name'])
del info['name']
print('删除后,%s' % info['name'])

结果：

删除前,AI浩
Traceback (most recent call last):
  File "C:/Users/WH/Desktop/Python基础/第一个Python程序.py", line 4, in <module>
    print('删除后,%s' % info['name'])
KeyError: 'name'

例2:del删除整个字典

info = {'name': 'AI浩',  'sex': 'f', 'address': '中国北京'}
print('删除前,%s' % info)
del info
print('删除后,%s' % info)

运行结果：

Traceback (most recent call last):
  File "C:/Users/WH/Desktop/Python基础/第一个Python程序.py", line 4, in <module>
    print('删除后,%s' % info)
NameError: name 'info' is not defined
删除前,{'name': 'AI浩', 'sex': 'f', 'address': '中国北京'}

例3:clear清空整个字典

info = {'name': 'AI浩',  'sex': 'f', 'address': '中国北京'}
print('清空前,%s' % info)
info.clear()
print('清空后,%s' % info)

运行结果：

清空前,{'name': 'AI浩', 'sex': 'f', 'address': '中国北京'}
清空后,{}

9.7.4 字典的长度

使用len()方法，求字典的长度，例：

info = {'name': 'AI浩',  'sex': 'f', 'address': '中国北京'}
print('字典的长度:%d' % len(info))

运行结果：字典的长度:3

9.7.5 找出字典中的所有key

keys返回一个包含字典所有KEY的视图对象，例：

info = {'name': 'AI浩',  'sex': 'f', 'address': '中国北京'}
dicKeys=info.keys()
print(dicKeys)
print(dicKeys[0])

运行结果：

Traceback (most recent call last):
  File "C:/Users/WH/Desktop/Python基础/第一个Python程序.py", line 4, in <module>
    print(dicKeys[0])
TypeError: 'dict_keys' object is not subscriptable
dict_keys(['name', 'sex', 'address'])

注：返回的是个视图对象，不是list，很多资料说list是不对的，但是可以转为list，例：

info = {'name': 'AI浩',  'sex': 'f', 'address': '中国北京'}
dicKeys=list(info.keys())
print(dicKeys)
print(dicKeys[0])

运行结果：

['name', 'sex', 'address']
name

9.7.6 找出字典所有的value

属性values返回一个包含字典所有value的视图列表，用法同上，例：

info = {'name': 'AI浩',  'sex': 'f', 'address': '中国北京'}
dicvalues=list(info.values())
print(dicvalues)
print(dicvalues[0])

运行结果：

['AI浩', 'f', '中国北京']
AI浩

9.7.7 找出字典的（键，值）

属性items，返回一个包含所有（键，值）元祖的列表

info = {'name': 'AI浩',  'sex': 'f', 'address': '中国北京'}
dicItems=info.items()
print(dicItems)

运行结果：

dict_items([('name', 'AI浩'), ('sex', 'f'), ('address', '中国北京')])

9.7.8 判断key是否存在

“key in dict"如果键在字典dict里返回true，否则返回false，例：

info = {'name': 'AI浩',  'sex': 'f', 'address': '中国北京'}
ss='name' in info
print(ss)

运行结果：True

9.7.9 遍历字典的几种方式

1） 遍历字典的key（键）

info = {'name': 'AI浩',  'sex': 'f', 'address': '中国北京'}
for key in info.keys():
    print(key)

运行结果：

name
sex
address

2) 遍历字典的value（值）

info = {'name': 'AI浩',  'sex': 'f', 'address': '中国北京'}
for key in info.values():
    print(key)

运行结果：

AI浩
f
中国北京

3) 遍历字典的项（元素）

info = {'name': 'AI浩',  'sex': 'f', 'address': '中国北京'}
for item in info.items():
    print(item)

运行结果：

('name', 'AI浩')
('sex', 'f')
('address', '中国北京')

4) 遍历字典的key-value（键值对）

info = {'name': 'AI浩', 'sex': 'f', 'address': '中国北京'}
for key, value in info.items():
    print("key=%s,value=%s" % (key, value))

运行结果：

key=name,value=AI浩
key=sex,value=f
key=address,value=中国北京