学习Python的第二天

1、算数运算符

   也称为数学运算符,用来进行数学运算，如加减乘除等。算术运算符的相关解释如下表所示:

a=2
b=11
print(a + b) # a 与b相加
print(a- b) # a与b相减
print(a* b) # a与b相乘
print(a / b) # a与b相除
print(a// b) # a与b整除运算
print(a % b) # a返回除法的余数
print(a** b) # a 的b次方
1
2
3
4
5
6
7
8
9

运行结果：
13
-9
22
0.18181818181818182
0
2
2048

2、比较运算符

  也称关系运算符，用于对常量、变量或表达式的结果进行大小比较，如果比较成立，则返回True(真)，反之则返回False(假)。

a=2b=11
print(a ==b)
print(a != b)
print(a >b)
print(a<b)
print(a >=b)
print(a <=b)
1
2
3
4
5
6
7

运行结果：
False
True
False
True
False
True

3、赋值运算符

  将右侧的值赋给左侧的变量或者常量，主要包括有=、+=、-=、*=、/=、%=、//=、**一。

赋值运算符的相关解释如下:

x=2
x*=x+1
print(x)  #结果为6

a=2
a+=a+1
print(a) #结果为5

b=2
b-=b+1
print(b) #结果为-1

c=2
c/=c+1
print(c)  #结果为0.6666666666666666

d=2
d%=d+1
print(d)  #结果为2

i=2
i**=i+1
print(i)  #结果为8

m=2
m//=m+1
print(m)  #结果为0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

4、位运算符

  在Python中，包括按位与(&)、按位或(|)、按位求(~)、按位异或(^)、左移位(<<)和右移位(>>)。

位运算符的相关解释如下:

5、逻辑运算符

  在Python中，逻辑运算符的符号有and、or和not ,and是逻辑与运算，or是逻辑或运算，not是取非运算。

逻辑运算符的相关解释如下：

or ：找真值：
如果有一个值为真，or 立刻返回第一个真值；
如果所有值都为假，or 返回最后一个假值。

and ：找假值：
如果有一个值为假，and 立刻返回第一个假值；
如果所有值都为真，and 返回最后一个真值。

print(True and False)
print(True and True)
print(True or False)
print(1 or True)
print(False or 1)  
print(not False)
1
2
3
4
5
6

运行结果如下：
False
True
True
1
1
True

6、成员运算符

  用于该值是否是序列中的成员，如果是，返回True ,否则返回False。

成员运算符有两个:in、not in
成员运算符的相关解释如下:

以hello这个字符串为例,，查看h、a、c、o是否存在。

str ='hello'
print('h' in str)
print('a' in str)
print('c' not in str)
print('o' not in str)
1
2
3
4
5

运算结果：
True
False
True
False

7、身份运算符

  Python中，身份运算符是用来比较内存地址是否相同,包括两个:is、not is。

身份运算符的相关解释如下:

a=1
b=1
c=1.0
# id()函数返回对象的唯一标识符
print(id(a),id(b),id(c))
# ==比较的是值是否相同
print('a==b:',a==b,'a==c',a==c)
print('a is b:',a is b)
print('a is c:',a is c)
print('a is not b:',a is not b)
print('a is not c:',a is not c)
1
2
3
4
5
6
7
8
9
10
11

运行结果：

8、运算符优先级

运算规则:
  先执行优先级高的运算符,后执行优先级低的,同一优先级的操作，按照从左到右的顺序进行。

从最高优先级到最低优先级的所有运算符:

9、列表

列表定义:
  列表(List)是一种有序的集合，是Python中最基本的数据结构，和Java等其他语言中的数组类似，但是功能比数组更强大。
  列表可以存放整型数字，浮点型,字符串以及对象等数据。

9.1、列表的创建

1、使用 [ ] 直接创建列表格式
列表名=[列表选项1,列表选项2..,列表选项n]

list1 =[1, "hello",2,"C语言"]
print(list1)
print(type(list1))
#创建一个空列表
list2=[]
print(list2)
1
2
3
4
5
6

运行效果:
[1,‘hello’ ,2,‘C语言’]

[]


2、使用list()函数创建列表格式
列表名=list(列表选项1,列表选项2...列表选项n)
该方式使用list()函数将其它数据类型转换为列表类型。

#将字符串转换成列表
list1 = list("hello")
print(list1)
#创建空列表
print(list())
1
2
3
4
5

运行结果：
[‘h’, ‘e’, ‘l’, ‘l’, ‘o’]
[ ]

list([iterable])函数返回一个列表
list()函数将可迭代对象的元素重新返回为列表。

9.2、访问列表中的元素

1.使用索引(Index)访问列表中的某个元素。
2.使用切片(slice)访问列表中的一组元素。

• 列表中每个元素都有属于自己的编号（(索引)。
• 从起始元素开始,索引值从0开始递增。

  Python支持索引值是负数，此类索引是从右向左计数，即从最后一个元素开始计数，从索引值-1开始。

使用索引访问元素格式:列表名[索引]

#使用索引访问列表中的某个元素
list1=['积'，'极','向','上']
#使用正数索引
print(list1[2])
#使用负数索引
print(list1[-3])  #倒数第一个元素的索引值为 -1
1
2
3
4
5
6

运行效果如下:
向
极


使用切片访问元素的格式:列表名[起始索引:结束索引:步长]

list1=['a','s','d','f','g','h']
#使用正数切片,散取索引为2，3，4的元素，默认步长为1
print(list1[2:5])
print(list1[:3) #散取索引为0-2的元素，起始索引默认为0
#散取索引为3-5的元素,结束索引默认为最后一个元素
print(list1[3:])
#使用正数切片,裁取索引为1-5的元素，步长为2
print(Iist1[1:6:2])  #步长是从索引0开始的 走2个步长取一个数字 不是隔两个
print(list1[-3:-1]) #使用负数切片
#步长如果是负数，即从右向左提取元素
print(list1[::-1])#步长·为·负，从右往左获取
print(list1[::-2])  #当步长为负数时，不论步长负多少，都会把第一个取了，再去走步长

#从刚开始那个数开始往后数，按照那个步长开始数到结束位置，中间如果没有其他数的话，那肯定就没了，不能超过那个结束位置。
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行结果：

python的索引值“左闭右开”的形式

例如:[2:5]
得到索引值为2、3、4的元素,不包含索引值为5的元素

9.3、遍历列表

可以完成查询、处理等功能。
在Python中，遍历列表的方法通过for循环实现。

语法格式如下:

for item in listname:
#输出item
1
2

  其中item用于保存获取的元素值,listname为列表名称

list1 =['Python',' Java','C']
#使用for循环遍历列表
for item in list1:
	print(item)
1
2
3
4

运行效果如下:
Python
Java
C

9.4、修改元素

修改列表中的单个元素直接通过赋值符号=进行。
代码如下：

list2=[10,56,34,2,56,44,7]
list2[2]=100
print(list2)
1
2
3

运行效果如下:
[10, 56, 100, 2, 56, 44, 7]

修改多个元素时,可以通过切片方式进行
语法格式：列表名[开始索引:结束索引:步长]

代码如下:

list3=[10,56,34,2,56,44,7]
# 修改第1~4个元素的值（不包括第4个元素）
list3[1:4:1]=[45,-56,98]
print(list3)
1
2
3
4

运行效果如下:
[10, 45, -56, 98, 56, 44, 7]

9.5、添加元素

向Python列表里面添加元素主要有三种方法:append()、extend( )、insert()

1.append()
用于在列表的末尾追加元素。
语法格式:列表名.append(添加到列表末尾的数据),
添加的数据可以是单个元素，也可以是列表，字典，元组，集合,字符串等, append()方法将列表和元祖组视为一个整体，作为一个元素添加到列表中,从而形成包含列表和元组的新列表。

代码如下：

# 列表添加元素
list1=['a','b','c']
list1.append('d')
print(list1)
#列表添加列表
list1.append(['e','f'])
print(list1)
1
2
3
4
5
6
7

运行效果如下：
[‘a’, ‘b’, ‘c’, ‘d’]
[‘a’, ‘b’, ‘c’, ‘d’, [‘e’, ‘f’]]

2.extend()
在列表的末尾一次添加多个元素,当添加的是元组或者列表时,把包含的元素逐个添加到列表中。

代码如下：

# 列表添加元素
list1=['a','b','c']
list1.extend('d')
print(list1)
# 列表添加列表
list2=['h','e','l','l','o']
list2.extend(['w','o','r','l','d'])
print(list2)
1
2
3
4
5
6
7
8

运行效果如下：
[‘a’, ‘b’, ‘c’, ‘d’]
[‘h’, ‘e’, ‘l’, ‘l’, ‘o’, ‘w’, ‘o’, ‘r’, ‘l’, ‘d’]

3.insert()
主要是在列表的特定位置添加想要添加的特定元素。
语法格式:列表名.insert((index , obj)
  index表示指定位置的索引值。
  insert()会将obj插入到 listname列表第index个元素的位置。

代码如下：

list1=['python','C','Java']
# 插入元素，在索引为1处插入C++
list1.insert(1,'C++')
print(list1)
1
2
3
4

运行效果如下：
[‘python’, ‘C++’, ‘C’, ‘Java’]

4.列表相加，可以使用加号"+"将多个列表拼接

9.6、删除元素

主要有:remove(). del,pop()。

1.remove()
移除掉列表里面的特定元素，但只会删除第一个和指定值相同的元素,而且必须保证该元素是存在的,否则会引发ValueError错误。
语法格式:列表名.remove(删除的值)

代码如下：

list1=['a','b','c']
# 删除列表中第一个值为a的元素
list1.remove('a')
print(list1)
# 引发ValueError错误
list1.remove('d')
print(list1)
1
2
3
4
5
6
7

运行效果如下：
[‘b’, ‘c’]
Traceback (most recent call last):
list1.remove(‘d’)
ValueError: list.remove(x): x not in list

2.pop()
用来删除列表中指定索引处的元素。
语法格式:列名.pop(index)
若没有具体的索引值，默认会删除列表中的最后一个元素。

代码如下：

nums=[10,56,34,2,56,44,7]
# 删除索引为3的元素
nums.pop(3)
print(nums)
# 删除最后一个元素
nums.pop()
print(nums)
1
2
3
4
5
6
7

运行效果如下：
[10, 56, 34, 56, 44, 7]
[10, 56, 34, 56, 44]

3.del
（1）用来删除列表中单个元素或者一段连续的元素。
（2）删除单个元素语法格式:del列表名[索引引]。
（3）删除一段连续的元素语法格式:del列表名[开始索引:结束索引]
（4）删除从开始索引到结束索引之间的元素,不包括结束索引的元
素。

代码如下：

list1=['a','b','c','a']
del list1[1]
# 删除索引为1的元素
print(list1)

list2=[10,56,34,2,56,44,7]
del list2[1:4]
# 删除索引为1-3的元素
print(list2)
1
2
3
4
5
6
7
8
9

运行效果如下：
[‘a’, ‘c’, ‘a’]
[10, 56, 44, 7]

4.clear
用于删除全部的元素

代码如下：

list1=['a','b','c','a']
# 清空列表
list1.clear()
print(list1)
1
2
3
4

运行效果如下：
[ ]

9.7 查找元素

1.index( )
查找列表中第一次出现元素value的位置。
index()语法格式为:
列表名.index[要查找的元素,索引起始位置,索引结束位置]

代码如下：

list1=[1,'a',3,'b',3,4,'b',4]
# 返回到列表list1中'b'第一次出现的位置
print(list1.index('b'))
# 索引的起始位置为下标为4的元素，索引范围为3,4,'b',4
print(list1.index('b',4))
# 索引的位置为下标为4的元素，结束位置为下标为7的元素。
# 索引范围3,4,'b',4
print(list1.index('b',4,7))
print(list1.index(3))
# 列表list1无0，报错
print(list1.index(0))
1
2
3
4
5
6
7
8
9
10
11

运行效果如下：
3
6
6
2
Traceback (most recent call last):
print(list1.index(0))
ValueError: 0 is not in list

2.count()
用来统计某个元素在列表中出现的次数。
语法格式：
列表名.count(统计的value元素)

代码如下：

list2=[10,22,3,5,4,51,5,53,5,'python']
print(list2.count(5))  #统计列表list2中5出现的次数
print(list2.count(0)) #列表list2中无0元素
print(list2.count('python')) #统计列表'python'出现的次数
1
2
3
4

运行效果如下：
3
0
1

9.8 元素排序

1.sort(）函数
用于对原列表进行排序，如果指定参数，则使用指定的比较函数。
语法格式为:ls.sort(key=None, reverse=False)
参数说明:
key–接受一个函数，且该函数只有一个返回值
reverse–排序规则，即排序是否反转。默认为False不反转(升序)，True则反转(降序)

代码如下：

ls1=['1','3','44','23','99','88','56']
ls2=[1,3,44,23,99,88,56]
# 升序排列
ls1.sort()
print(ls1)
ls2.sort()
print(ls2)
# 降序排列
ls1.sort(reverse=True)
print(ls1)
ls2.sort(reverse=True)
print(ls2)
1
2
3
4
5
6
7
8
9
10
11
12

运行效果如下：
[‘1’, ‘23’, ‘3’, ‘44’, ‘56’, ‘88’, ‘99’]
[1, 3, 23, 44, 56, 88, 99]
[‘99’, ‘88’, ‘56’, ‘44’, ‘3’, ‘23’, ‘1’]
[99, 88, 56, 44, 23, 3, 1]

9.9 遍历元素

挨个操作列表中的元素，比如挨个打印输出，必须要使用循环
例如：
for i in list:
print(i)

代码如下：

# 遍历就是使用循环挨个操作列表中的元素
nums=[100,23,4,39,135,91]
for i in nums:
    print(i)
1
2
3
4

运行效果如下：
100
23
4
39
135
91

9.10 内置函数len、max、min、cmp、sort

(1)len()：获取列表的长度，len(list)
(2)max()：最大值,max(list)
(3)min()：最小值，min(list)
(4)sort()：排序，默认从小到大进行排序，

num4=[120,23,4,39,135,91]
print("num4的长度为：",len(num4))
print("最大值为：",max(num4))
print("最小值为：",min(num4))
num4.sort()
print(num4)
num4.sort(reverse=True)  #从大到小进行排序
print(num4)
1
2
3
4
5
6
7
8

运行效果如下：
num4的长度为： 6
最大值为： 135
最小值为： 4
[4, 23, 39, 91, 120, 135]
[135, 120, 91, 39, 23, 4]

案例练习:联系人列表管理

1.创建两个空列表，用于存储姓名和电话。

2.向列表中添加两名联系人信息。

3.输出两名联系人的信息。

修改联系人信息。

5.使用clear（） 清空通信录。

nameList=[] #姓名
phoneList=[] #电话号码
name1=input("请输入第一名联系人的姓名：")
phone1=input("请输入第一名联系人的电话号码：")
# 使用列表的添加把它加入到列表当中
nameList.append(name1) #将联系人的姓名添加到列表
phoneList.append(phone1)
name2=input("请输入第二名联系人的姓名：")
phone2=input("请输入第二名联系人的电话号码：")
nameList.append(name2) #将联系人的姓名添加到列表
phoneList.append(phone2)
# 打印输出两名联系人的信息
print(nameList)
print(phoneList)
# 修改联系人信息  修改列表的内容通过索引
index=int(input("请输入您要修改的联系人序号："))-1  #将用户输入的序号转换成列表的索引号
#（因为用户输入的序号是从1开始的，而我们的索引是从0开始）
nameList[index]=input("请输入修改后的联系人的姓名：")
phoneList[index]=input("请输入修改后联系人的电话号码：")
# 打印输出修改之后的联系人的信息
print(nameList)
print(phoneList)
nameList.clear() #清空列表
phoneList.clear()
# 打印输出清空之后的联系人的信息
print(nameList)
print(phoneList)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

效果如下：
请输入第一名联系人的姓名：张三
请输入第一名联系人的电话号码：13888889999
请输入第二名联系人的姓名：李四
请输入第二名联系人的电话号码：13556789876
['张三', '李四']
['13888889999', '13556789876']
请输入您要修改的联系人序号：1
请输入修改后的联系人的姓名：Mark
请输入修改后联系人的电话号码：13333333333
['Mark', '李四']
['13333333333', '13556789876']
[ ]
[ ]
1
2
3
4
5
6
7
8
9
10
11
12
13
14

10、元组

10.1、元组概念与创建

1.元组(tuple)类型是Python中另一种重要的序列结构。
2.元组由一系列按特定顺序排序的元素组成。
3.元组是不可变的，一旦初始化就不可修改。
4.本质是一种有序的组合。

元组的创建使用小括号()，创建元组语法格式:
元组名=(元组元素1,元组元素2....,元组元素n)
  当创建的元组中只有一个元素时，该元素后面必须要加一个“，”，否则Python解释器会视为字符串。

元组和列表最大的区别：元组是不可变的 列表是可变的

  可以对列表进行新增、删除、修改元素的操作，在元组里都不可以。元组中的单个元素值不允许修改。

1.使用小括号来创建元组

元组创建示例：

方法1：
tuple1=()#创建空元组
print(tuple1)
# 创建带有元素的元组，可以有元素类型
tuple2=(1,"a",3,"hello")
print(tuple2)
tuple3=(1,) #元组创建只包含一个元素的元组时，必须在元素后面加一个逗号
print(tuple3)
1
2
3
4
5
6
7
8

运行效果如下：
()
(1, ‘a’, 3, ‘hello’)
(1,)


2.使用tuple()函数创建元组

  使用tuple()函数创建元组，主要是用来将其它数据类型转换为元组类型。
语法格式:tuple(数据)

代码如下：

tuple1=tuple("hello,world") #将字符串转换为元组
print(tuple1)
# 将列表转换成元组
list1=['python','Java','C++','C']
tuple2=tuple(list1)
print(tuple2)
1
2
3
4
5
6

运行效果如下：
(‘h’, ‘e’, ‘l’, ‘l’, ‘o’, ‘,’, ‘w’, ‘o’, ‘r’, ‘l’, ‘d’)
(‘python’, ‘Java’, ‘C++’, ‘C’)

10.2、访问元素元组

  元组中访问元素的方式和列表一样，通过索引进行访问。  具体格式为:元组名[索引]
  索引可以为正数，也可以是负数，正数时索引从0开始,负数时倒数从-1开始。
  同时还使用切片访问元组中的一组元素。
  语法格式:元组名[开始索引:结束索引:步长]

代码示例如下：

tuple1=('h','e','l','l','o')
# 使用索引访问元组中的某个元素
# 使用正数索引，从0开始
print(tuple1[1])
print(tuple1[-1])
# 使用负数索引，倒序从-1开始
# 使用切片访问元组中的一组元素
print(tuple1[1:4]) #使用正数切片
print(tuple1[1:4:2]) #指定步长
print(tuple1[-5:-1]) #使用负数切片
1
2
3
4
5
6
7
8
9
10

运行效果如下：
e
o
(‘e’, ‘l’, ‘l’)
(‘e’, ‘l’)
(‘h’, ‘e’, ‘l’, ‘l’)

10.3、访问元素元组

元组是不可变的,所以元组中的单个元素值不允许修改。
需要对元组进行连接组合,注意连接的内容必须都是元组。

代码如下：

tuple1=[12,34,56]
tuple2=('abc','mn')
# 修改元组元素操作是非法的
tuple1[0]=100
tuple3=tuple1+tuple2 #创建一个新的元组
print(tuple3)
1
2
3
4
5
6

运行效果如下：
Traceback (most recent call last):
tuple3=tuple1+tuple2 #创建一个新的元组
TypeError: can only concatenate list (not “tuple”) to list

10.4、删除元组

  元组中元素一旦创建就不可更改，但可以通过del关键字删除整个元组。
语法格式: del元组名

代码如下:

tuple1=(1,2,3,[4,5,6])
print(tuple1)
del tuple1
# 删除元组
print(tuple1)
1
2
3
4
5

运行效果如下:
(1, 2, 3, [4, 5, 6])
Traceback (most recent call last):
print(tuple1)
NameError: name ‘tuple1’ is not defined.

tuple1中没有定义，说明删除元组已经实现

10.5、元组的内置函数

Python元组包含了以下内置函数：

元组和列表（list)的不同之处

  列表的元素是可以更改的，包括修改元素值,删除和插入元素,所以列表是可变序列。
  元组一旦被创建,元素不可更改,
所以元组是不可变序列。
  元组中元素不可以修改，但是元组中嵌套了列表，列表元素可以修改。

案例：用元组实现联系人信息管理

#1.使用input()方法输入联系人·姓名、电话、邮件、地址。
# 2.定义元组tuplr1存储上述信息。
# 3.输出tuple1，查看联系人信息。
name=input("请输入联系人的姓名：")
tel=input("请输入联系人的电话：")
email=input("请输入联系人的邮箱：")
address=input("请输入联系人的地址：")
tupleInfo=("姓名：",name,"电话：",tel,"邮箱：",email,"地址：",address)
print(tupleInfo)
1
2
3
4
5
6
7
8
9

运行效果如下：

11、字典

字典的定义
  字典(dict)是一种无序的、可变的序列（容器），可存储任意类型对象，通过名字来引用值的数据结构，并把这种数据结构称为映射。
  字典类型是 Python中唯一的映射类型，字典中的值没有特殊的顺序，都存储在一个特定的键下，键可以是数字、字符串甚至元组。
  字典由多个键和其对应的值构成的键——值对组成，键为各元素对应的索引，值为各个键对应的元素，键及其关联的值称为“键值对”，具有极快的查找速度。
  在字典中键是唯一的，不可重复的，若同一个键出现多次，则只会保留最后一个键值对。但值不一定是唯一的。
  字典中的key必须是不可变的对象，只能是数字、字符串或者元组，因列表可变，不可作为key。
  例如保存多名学生的姓名和期末成绩，可使用字典,其中姓名为key，期末成绩为value。

11.1、字典的创建

创建字典的方式主要有通过{ }创建和通过dict()函数创建。

1.使用{ }创建字典
语法格式:

字典名={'key1':'value1' , 'key2':'value2',...,'keyn':valuen}

# key1......keyn为键名，必须唯一且不可变，键名可以是字符串、数字或者元组 不能是列表，列表是可变序列
dict3={[1,2,3]:“uestc”} 是错误的


# value1......valuen表示元素的值，可以是任何数据类型，不一定唯一
1
2
3
4
5
6
7

  在创建字典时，键和值之间使用" : "分隔，相邻元素之间使用“ , ”分隔，所有元素放在“{ }”中。

代码如下：

# 使用字符串作为key
dict1={'数学':95,'英语':92,'语文':84}
print(dict1)
# 使用元组和数字作为key
dict2={(20,30):'great',30:[1,2,3]}
print(dict2)
dict3={}# 创建空字典
print(dict3)
1
2
3
4
5
6
7
8

运行效果如下：
{‘数学’: 95, ‘英语’: 92, ‘语文’: 84}
{(20, 30): ‘great’, 30: [1, 2, 3]}
{ }

2.dict方法
格式：

字典名=dict(str1=value1,str2=value2,str3=value3)
1

  str表示字符串类型的键,value表示键对应的值。
  使用此方式创建字典时，字符串不能带引号。
代码如下：

dict4=dict(数学=95,英语=92,语文=84)
print(dict4)
1
2

运行效果如下：
{‘数学’: 95, ‘英语’: 92, ‘语文’: 84}

11.2、字典元素的访问

在Python中，字典元素通过关键字来访问对应的值。
语法格式:字典名[key]

代码如下:

dict4=dict(数学=95,英语=92,语文=84)
print(dict4['数学']) #键存在
print(dict4['python']) #键不存在 会报错
1
2
3

运行效果如下：

95
Traceback (most recent call last):
print(dict4[‘python’]) #键不存在
KeyError: ‘python’

使用get()方法来获取指定键对应的值。
语法格式:字典名.get(key[default])
  default用于指定要查询的键不存在时，此方法返回的默认值，如果不手动指定，会返回None。

代码如下：

dict1={'数学':95,'英语':92,'语文':84}
print(dict1.get('英语')) #键存在
print(dict1.get('ptyhon')) #键不存在，返回None
print(dict1.get('python','该键不存在')) #键不存在
1
2
3
4

运行效果如下：
92
None
该键不存在

11.3、字典添加键值对

语法格式:字典名称[新键]=值
代码如下:

dict1={'数学':95,'英语':92,'语文':84,'Python': 99}
dict1['语文']=100
dict1['C']=98
print(dict1)
1
2
3
4

效果如下：
{‘数学’: 95, ‘英语’: 92, ‘语文’: 100, ‘Python’: 99, ‘C’: 98}

  字典中各元素的键是唯一的，不可更改，只可更改键对应的值。如果新添加元素的键与已存在元素的键相同，对应值会被修改。

11.4、字典删除键值对

使用关键字del或使用pop()方法删除特定的键值对。
格式：dict.pop(key) 该方法会返回被删除键值对的值

代码如下:

dict1 ={'数学':95,'英语':92,'语文':84,'Python': 99}
del dict1['语文']
print(dict1)
dict1.pop('数学')
print(dict1)
1
2
3
4
5

运行效果如下:
{‘数学’: 95, ‘英语’: 92, ‘Python’: 99}
{‘英语’: 92, ‘Python’: 99}

11.5、拓展

  在使用dict()方法时,可以传入列表和元组。

  具体格式为:
dict1 = dict([('two',2),('one',1),('three' ,3)])

案例：用字典实现联系人信息关联

# 1．创建空的联系人字典,命名为contacts _ dict。
# 2．通过键盘录入一名联系人信息,信息包括姓名，电话号码,邮件,地址信息。
# 3．使用 print()方法查看联系人信息。
# 4.输入姓名搜索通信录。
contacts_dict={}
name=input("请输入联系人姓名：")
tel=input("请输入联系人电话：")
email=input("请输入联系人邮箱：")
address=input("请输入联系人地址：")
info={"电话":tel,"邮箱":email,"地址":address}
contacts_dict[name]=info
print("您所录入的联系人信息如下：",contacts_dict) #打印输出添加的联系人信息
name1=input("请输入你要查找的联系人姓名：")
# 字典中取值赋值给info1
info1=contacts_dict[name1]
print("您要查找的联系人为：","其信息如下所示：",info1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

运行效果如下：

列表和字典的异同

不同点

1. 列表外面是 [ ] 中括号，字典外面是 { } 大括号。
2. 列表中每个元素只有一部分，只有值，每个值有一个对应的小标。
3. 字典中每个元素都是【键：值】的形式存在的， 每个值都有一个对应的键。

相同点

1. 列表与字典中的元素都是用逗号隔开。
2. 删除的方法 del 相同。