Python 的安装和使用

一、Linux环境安装Python

• 官方地址：http://www.python.org

1.1、设置Yum仓库

# 准备Base源
[root@python3 ~]#  curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo


# 准备扩展源EPEL
[root@python3 ~]# yum -y install epel-release.noarch

1.2、安装依赖包

# 安装源码编译需要的编译环境
[root@python3 ~]# yum -y install gcc zlib zlib-devel libffi libffi-devel


# 解决后期出现的方向键、删除键乱码问题，这里提前避免
[root@python3 ~]# yum -y install readline-devel openssl-devel openssl11 openssl11-devel


# 设置编译FLAG，以便使用最新的openssl库
[root@python3 ~]# export CFLAGS=$(pkg-config --cflags openssl11)
[root@python3 ~]# export LDFLAGS=$(pkg-config --libs openssl11)

1.3、编译Python

1.3.1、解压Python压缩包

[root@python3 ~]# tar xvf Python-3.11.6.tar.xz

1.3.2、配置Python

[root@python3 ~]# cd Python-3.11.6/
[root@python3 Python-3.11.6]# ./configure --prefix=/usr/local/python3


# 此处有可选配置项，含义如下:
--enable-optimizations：用PROFILE_TASK启用以配置文件主导的优化（PGO）
--with-lto：在编译过程中启用链接时间优化（LTO）
--enable-shared：启用共享Python库libpython的编译
--with-ssl：编译安装ssl模块到Python3中（默认）

1.3.3、编译及安装

[root@python3 Python-3.11.6]# make && make install


# 如果主机上已经安装有其他版本的Python3，注意是3的版本，要使用altinstall而不是install。二则的一个重要区别在于，后者会创建链接符号，将Python3等命令链接到正在安装的新版本Python3上，这可能会破坏系统。如果是Python2的版本，不会有此影响

1.3.4、链接软连接

[root@python3 Python-3.11.6]# ln -s /usr/local/python3/bin/python3 /usr/bin/python3
[root@python3 Python-3.11.6]# ln -s /usr/local/python3/bin/pip3 /usr/bin/pip3

1.4、测试Python3运行

• 安装设置完毕，测试Python3的运行情况，命令如下：

[root@python3 ~]# python3
Python 3.11.6 (main, Aug 12 2024, 08:28:21) [GCC 4.8.5 20150623 (Red Hat 4.8.5-44)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print('hello world')  # 打印一句话，每个程序员的第一个语句
hello world

# exit()或Ctrl+D可以退出Python命令终端
>>> exit()

1.5、设置国内pip更新源

• pip是Python的一个包管理工具，主要用于 安装和管理Python包。它提供了一个简单的命令行接口，可以从Python Package index等源下载和安装软件包。

# 本次使用阿里云的更新源
[root@python3 ~]# mkdir -p /root/.config/pip/
[root@python3 ~]# cat <<EOF> /root/.config/pip/pip.conf 
[global]
index-url = https://mirrors.aliyun.com/pypi/simple/

[install]
trusted-host=mirrors.aliyun.com
EOF

# 使用以下命令也可以设置pip更新源
pip3 config set global.index-url https://mirrors.aliyun.com/pypi/simple 
pip3 config set install.trusted-host mirrors.aliyun.com

1.6、更新pip版本（必须更新）

[root@python3 ~]# pip3 install --upgrade pip

1.7、测试更新源

• 安装一个获取日区间数据的pandas模块

[root@python3 ~]# pip3 install pandas

二、Python的语法基础

2.1、标识符

• 所谓的标识符就是对变量、常量、函数、类等对象起的名字。
• 首先必须说明的是，Python语言在任何场景都严格区分大小写！也就是说A和a代表的意义完全不一样，Python对于表示标识符的命名如下规定：
  • 标识符的长度不受限制，但其中的字符必须是字符、数字、或者下划线(_)，而不能使用空格、连字符、标点符号、引号或其他字符。
  • 标识符的第一个字符不能是数字，而必须是字母或者下划线。
  • Python严格区分大小写。
  • 不能将Python内置的关键字作为标识符。
• 例如：a、abc、_id等都可以的。但是例如$a（以$$开头的是PHP的变量语法），~abc，123a都是不可以的。这一点一定要注意。可能有人会问，中文可以作为标识符吗？答案是可以的。

2.2、Python保留字

• Python保留字，也叫关键字，是Python语言官方确定的用作语法功能的专用标识符，不能把它们用作任何自定义标识符名称。关键字只包含小写字母。可以通过Python提供的库输出这些关键字：
• Python的标准库提供了一个keyword模块，可以输出当前版本的所有关键字。如下所示：

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

2.3、注释

• 我们写的程序里，不光有代码，还要有很多注释。注释有说明性质、帮助性质的，它们在代码执行过程中相当于不存在，透明的。

2.3.1、单行注释

• Python，以符号“#”为当行注释的开始，从它往后的本行的末尾，都是注释的内容。语法如下

>>> # 单行注释

2.3.2、多行注释

• Python没有真正意义上的多行注释（块注释），语法如下

>>> # 第一行注释
>>> # 第二行注释
>>> # 第三行注释

2.4、语句与缩进

2.4.1、语句

• 在代码中，能够完整表达某个意思、操作或者逻辑的最短代码，被称为语句。这里强调一下，Python的标准语言不需要使用分号。简单的换行就是表示语句已经结束。

>>> a = 123
>>> b = 456
>>> print("hello world")

2.4.2、代码块

• 为完成某一特定功能而联系在一起的一组语句构成了一个代码块。有判断、循环、函数、类等各种代码块。代码块的首行通常以关键字开始，以冒号（:）结束。比如：

a = 10
if a > 5:
    print("1大于5")
else:
    print("a小于5")
    
    
# Python最具特色的语法就是使用缩进来表示代码块，不需要使用大括号像PHP、JAVA等语法都是使用({})来表示代码块。Python一般用四个空格来缩进。在Pycharm或vscode中tab自动回转成4个空格。在Linux环境中，如vim编辑器，建议使用空格。

2.4.3、多行语句

• 前面的例子中都是多条语句在同一行，但如果一条语句实在太长，也可是可以占用多行的，可以使用反斜杠()来实现多行语句。

>>> print ("你好 \
... 我是 kgc \
... 很高兴认识你")


# 执行结果
你好 我是 kgc 很高兴认识你

2.5、pass语句

• pass语句是占位语句，它什么都不做，只是为了保证语法的正确性而写。以下场景中，可以使用pass语句把或的输出语句换成pass
  • 当你不知道后面的代码怎么写的时候
  • 当你不需要代码细节的时候
  • 当语句必须，又没有实际内容可写的时候
  • 其它的一些你觉得需要的场景

a = 10
if a > 5:
    print("a大于5")
else:
    pass

三、Python常用的数据类型

• Python内置的数据类型有数字、字符串、元组、列表和字典。

3.1、数字

• 数字类型包括整型、浮点型、布尔型，声明时由Python内置的数据类型管理变量，在程序的后台实现数值与类型的关联，以及转换等操作。根据变量的值自动判断变量的类型，程序员不需要关心变量空间是什么类型，只需要知道创建的变量中才存放了一个数，通过编码对这个数值进行操作即可。

3.1.1、整型和浮点型

• 整数使用整型表示，有小数位是哦那个浮点型表示

# 示例1：为变量赋予整型和浮点型的数值
>>> x = 123
>>> print (x)
123

>>> x = 1.98
>>> print (x)
1.98


# 示例1的代码中，首先定了变量x=123.此时的x的值是整数，x即是整型变量。当执行语句x=1.98时，x又变成了浮点型变量，由此可以看出，变量的类型是能改变的，与Java、C#语言等都是由区别的。这是因为当Python给已经存在的变量再次赋值时，实际上是创建了一个新的变量，即使变量名相同，但标识并不相同，变量的标识可以使用id函数输出。

3.1.2、布尔型

• 布尔型适用于逻辑运算，有2个值True、False，表示真和假。

# 示例2：为变量赋值布尔型的数值
>>> f = True
>>> print(f)
True
>>> if(f):
...  print(1)
...
1  # 执行结果


# 代码定义了变量f=True。if是判断语句，为真则执行print语句，最后输出的是1，说明语句执行成功。

# 使用比较运行符返回的结果是布尔值
# 示例3：获取比较运算符结果示例代码如下
>>> 3>4
False  # 假
>>> 4.15>2
True   # 真

3.1.3、Python运算符

• Python中使用的算术运算符和数学运算中的符号基本相同，又+、-、*、/（加、减、乘、除）和小括号组成，运算顺序也是先乘除后加减、小括号优先。下面演示几个示例说明它们的使用方法。

# 示例4：四则运算代码如下
# 同时给两个变量赋值
>>> x,y = 10,2
>>> print (x+y,x*y,x/y)
12 20 5.0

>>> print (5 + 8 * 3)
29

>>> print ((5+8)*3)
39

>>> print (5 + 8 * 3 /4)
11.0

• Python还有两个算术运算符是%和**，分别实现求模和求幂运算。
• 求模运算取余数，求幂是计算累乘的结果。

# 示例5：求模和求幂示例代码如下
>>> 8%5
>>> 8%4

>>> 2**2
>>> 2**4

3.2、字符串

• Python中的字符串类型是一组包含数字】字母和符号的集合，作为一个整体使用。

3.2.1、字符串的使用

• 在Python中有3中表示字符串的方式，单引号、双引号、三引号

# 示例6：Python字符串的3中表现方式
>>> name = '课工场'
>>> address = "文博西路"
>>> content = '''每时每课，给你好机会'''


>>> print (name)
>>> print (address)
>>> print (content)


# 在示例6中，变量name使用单引号，变量address使用双引号，变量content使用三引号，它们都是合法的Python字符串类型。需要注意的是，单引号和双引号作用是一样的，可以根据习惯使用。但是定义多行文字时，必须使用三引号。

3.2.2、使用字符串注意事项

• 字符串的定义方式单引号、双引号、三引号大部分情况下作用是相同，但是特俗情况中使用也有所区别，下面列出需要注意的地方。

# 注意1：
# 单引号、双引号、三引号都是成对出现的。如果以单引号开头就要以单引号结尾，不能混合使用表示字符串。如下代码就会报错
>>> name = "课工场'
  File "<stdin>", line 1
    name = "课工场'
           ^
SyntaxError: unterminated string literal (detected at line 1)


>>> name = "课工场'''
  File "<stdin>", line 1
    name = "课工场'''
           ^
SyntaxError: unterminated string literal (detected at line 1)

# 注意2：
# 如果字符串中单独出现单引号或双引号，可以使用另一种引号定义。
>>> title1 = "Let' Go!"  # 双引号定义
>>> print (title1)
Let' Go!

>>> title2 = 'Let" Go!'
>>> print (title2)
Let" Go!

>>> title3 = '''Let' Go! Let" Go!'''  # 三引号定义
>>> print (title3)
Let' Go! Let" Go!

• 字符串变量tiele1中出现了单引号，就需要使用双引号定义，字符串变量title2中出现了双引号，就需要使用单引号定义。当字符串中同时单引号和双引号，就需要使用三引号进行定义。

# 注意3：
# 当字符串中出现单引号、双引号等特俗字符时，还可以使用转义字符定义。Python中的转义字符是“\”，只要在特俗字符前面加上“\”，就可以输出原本的字符，而不需要关注定义字符除按使用的是单引号还是双引号。

# 示例8：使用转义字符为字符串赋值代码示例如下
>>> title = 'Let\' Go!'
>>> print (title)
Let' Go!



# 备注
\(在行尾时)续行符
\\ 反斜杠符号
\' 单引号
\" 双引号
\n 换行
\v 纵向制表符
\t 横向制表符
\r 回车

3.3.3、字符串的其他用法

• Python的字符串可以进行乘法（*）的操作，使用一个整型数字和字符串相乘。

# 例如用数字3乘字符串“a”，结果是字符串“aaa”，等同于将字符串“a”连接了3遍
>>> print (3 * 'a')
aaa

四、列表

• 列表（list）是Python中非常重要的数据类型，通常作为函数的返回类型。有一组元素组成，列表可以实现添加、删除和查找操作，元素值可以被修改。

4.1、列表的定义

• 列表是Python内置的一种数据结构，由中括号"[]"定义，元素以逗号开发

• 语法格式：列表名 = [元素1,元素2,…]

4.2、列表的取值

4.2.1、取指定位置的值

• 列表中的数据是有序的，按定义时的顺序排好，可以单独取出某一位置元素的数值。
• 语法格式：列表名[索引位置]

# 示例9：使用列表保存元素的数值，并输出示例代码如下
>>> num = ['001','002','003']

>>> print (num)
>>> print (num[0])
>>> print (num[1])
>>> print (num[2])


# 示例9代码中，定义的列表num中，存储有三个字符串，其顺序是“001”、“002”、“003”，取值时用列表名num加上中括号，数字表示索引位置。需要注意：列表中元素的值是由0开始，以1为单位依次递增

4.2.2、取指定范围的值

• 语法格式：列表名[起始位置:终止位置]

• 可以输出起始位置到终止位置前的元素，不包括终止位置的元素

# 示例10：输出列表中指定位置的元素
>>> num = ['001','002','003']
>>> print (num[0:1])
['001']

>>> print (num[0:2])
['001', '002']

>>> print (num[0:3])
['001', '002', '003']

>>> print (num[1:2])
['002']

>>> print (num[1:3])
['002', '003']


# 示例10中，num列表后的[0:1]表示获取由索引0开始至索引位置1之前的元素，所有只能取到1个元素；而[0:2]则可以取到索引2之前的元素，其他的与此相同。

4.2.3、修改列表元数值

• 可以修改指定位置的列表元数值
• 语法格式：列表名[索引位置] = 值

# 示例11：修改列表中指定位置的元素值
>>> num = ['001','002','003']
>>> num[0] = '004'  # 修改
>>> print (num)
['004', '002', '003']


# 定义列表num时，索引位置0的元素是“001”，修改它的值为“004”后，索引位置的值变为“004”

4.3、添加列表元素

• 可以采用两种方式，添加向列表中添加元素

4.3.1、在列表最后添加元素

• 可以把一个元素添加到列表的最后
• 语法格式：append(元素值)

# 示例12：将元素添加到列表最后位置
>>> num = ['001','002','003']
>>> print (num)
['001', '002', '003']

>>> num.append('004')  # 末尾添加新元素
>>> print (num)
['001', '002', '003', '004']


# 示例12的代码执行语句num.append('004')之后，字符串”004“被添加到列表的末尾

4.3.2、在列表前添加元素

• 在列表指定位置前插入新的元素
• 语法格式：列表名.insert(索引位置,元素值)

>>> num = ['001','002','003']
>>> num.insert(1,'004')
>>> print (num)
['001', '004', '002', '003']


# 示例13中，语句num.insert(1,'004')的作用是在列表num的索引位置1之前插入字符串'004'。初始时，num有3个元素，索引位置1的当前元素是'002'，执行示例13的代码后，字符串'004'插入到'002'的前面

4.4、删除列表元素

• 可以删除列表指定索引位置的元素
• 语法格式：del 列表名[索引位置]

# 示例14：删除列表中第2个元素
>>> num = ['001','002','003']
>>> del num[1]
>>> print (num)
['001', '003']


# 示例14中，首先，执行语句del num[1]，使用del删除索引1的元素'002'。然后输出列表num中所有元素时，列表中已经不存在'002'元素

4.5、查找列表元素

• 使用in关键字可以查找列表中是否存在指定的数值

• 语法格式：元素值 in 列表名

• 返回布尔类型True或False。如果查找到，返回True，否者返回False

# 示例15：使用关键字in查找列表中是否存在指定的数值
>>> num = ['001','002','003']
>>> num = ['001','002','003']
>>> '001' in num  
True  # 001存在
>>> '004' in num
False # 002不存在

4.6、合并列表

• 多个列表可以使用加号（+）进行合并，加号后面的列表元素会追加到前面的列表的后面

# 示例16：使用+合并两个列表
>>> num1 = ['001','002']
>>> num2 = ['003','004']


>>> numAll = num1 + num2
>>> print (numAll)
['001', '002', '003', '004']


>>> numAll = num2 + num1
>>> print (numAll)
['003', '004', '001', '002']


# 示例16：定义了两个列表num1和num2。是哦那个加号进行合并操作时，加号后面的列表元素会追加到前面列表的后面

4.7、重复列表

• 使用星号（*）可以对列表进行重复操作，与单独字符串乘法操作类似

# 示例17：使用*重复输出列表的元素值
>>> num1 = ['001','002']
>>> num = num1 * 5
>>> print (num)
['001', '002', '001', '002', '001', '002', '001', '002', '001', '002']


# 示例17中，语句num = num1*5表示为num赋值时，将num1的元素重复出现了5遍

4.8、列表常见问题

• Python中，使用列表实现各种操作时，可能会得到意外的结果。其中最常见的问题是索引越界。索引越界是使用列表时经常犯的一个错误。如列表中有3个元素，因为索引位置是从0开始计算，所以最大的索引值是2。如果索引值大于2，表示索引是越界的，程序无法执行。

4.8.1、索引越界

>>> num1 = ['001','002','003']
>>> print (num1[5])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

4.8.2、负值索引

• 索引值为5时，大于最大的索引值2，程序报索引越界错误。那么，当使用小于0的负数索引时会不会出错呢？答案是不会的，因为Python列表的负数索引表示的是由列表的末尾进行反向取值，也就是最后一个元素的位置也可以是哦那个所以-1取值，倒数第二个索引是-2，向前依次递减

>>> num1 = ['001','002','003']
>>> num1 = ['001','002','003']
>>> print (num1[-1])
003
>>> print (num1[-2])
002
>>> print (num1[-3])
001

4.8.3、获取不存在的索引问题

• 当获取列表指定范围的一组元素时，不存在的列表索引越界的问题

>>> num = ['001','002','003']
>>> num1 = num[1:5]
>>> print (num1)
['002', '003']
>>> print (num)
['001', '002', '003']


# 列表num中有3个元素，获取列表范围时指定了最大位置是5，超出了最大索引值，程序可以正常执行，并没有报错

4.8.4、获取列表之地那个范围同时指定正数和负数索引

>>> num = ['001','002','003']
>>> print (num[0:-1])
['001', '002']


# 表示获取由索引位置0元素开始，到-1元素之前的所有元素

4.8.5、列表也可以是列表

>>> num = [['001','002','003'],['101','102','103'],['201','102','203']]
>>> print (num[0])
['001', '002', '003']

>>> print (num[0][0])
001

>>> print (num[2][1])
102


# 上述案例定了列表num，它里面的每一个元素也是一个列表，使用num[0]表示取到的是第一个元素值，对应的第一个列表。使用num[0][0]表示取到第一个元素列表的第一个值，使用print (num[2][1])表示取到第三个列表的第二个值

五、元组

• 元组（tuple）和列表类似，也是Python的一种数据结构，由不同的元素组成，每个元素可以存储不同类型的数据，如字符串、数字、甚至元组。但元组是不可被修改的，即元组创建后不能做任何的修改操作。元组通常表示一行数据，而元组中的元素表示不同的数据项。

5.1、元组的创建

• 元组由关键字和小括号定义，一旦创建后就不能修改元组的内容
• 语法格式：元组名 = (元素1,元素2,…)
• 与列表最大的不同是：元组是写保护的，元组一旦创建就不能做任何修改。下面定义一个元组，尝试对它修改

>>> num = ('001','002','003')
>>> del num[0]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion


# 定义元组num后，尝试对索引位置0的元素值进行修改，程序直接报错。元组与列表的区别如下表所示

	列表	元组
元素	方括号	圆括号
可变性	可变	不可变
操作	添加、修改、删除、搜索	搜索

• 在使用元组与列表去呗并不大，那么为什么要使用元组呢？主要使用元组是不可变的，操作速度比列表快，而且因为它不可以被修改，数据更加安全，所以要根据实际情况决定是使用元组还是列表，使程序更加高效合理

5.2、元组的操作

5.2.1、元组的取值

# 元组具有不可变性，所以相比列表的操作要少，其中取值操作与列表完全相同
>>> num = ('001','002','003')
>>> print (num[0])
001
>>> print (num[2])
003


# 与列表的取值操作完全相同，都是使用方括号、索引获取指定的位置的数值

5.2.2、删除整个元组

• 元组不允许删除元组中的元素值，但是可以删除整个元组

• 语法格式：del 元组名

# 示例18：元组删除报错代码如下
>>> num = ('001','002','003')
>>> del num[0]  # 删除元素，报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion

# 删除整个元组
>>> print (num)
('001', '002', '003')

>>> del num  # 删除元组后元组不存在，报错
>>> print (num)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'num' is not defined. Did you mean: 'num1'?


# 定义元组num后，删除其中的某一个元素程序报错。删除整个元素后，再想使用元组，报未定义便令的错误

5.2.3、元组列表互相转换操作

• 语法格式：list (列表名) 元组转换列表

# 示例19：元组转换为列表代码如下
>>> num = ('001','002','003')  # 元组
>>> listNum = list(num)  # 转换为列表
>>> print (listNum)
['001', '002', '003']

>>> listNum[0]='004'  # 修改列表
>>> print (listNum)
['004', '002', '003']

>>> print (type(num))  # 输出元组类型
<class 'tuple'>

>>> print (type(listNum))  # 输出列表类型
<class 'list'>


# 这段代码首先定义了元组num，然后把它转换为列表listNum，对列表listNum可以做修改元素的操作，使用type()函数输出了元组的列表的类型

• 语法格式：tuple(列表名) 将列表转换为元组

# 示例25：列表转换为元组
>>> num = ['001','002','003']
>>> tupleNum = tuple(num)
>>> print (type(num))
<class 'list'>
>>> print (type(tupleNum))
<class 'tuple'>


# 可以看到转换是成功的，输出的类型正确

六、字典

• 字典（dict）是Python中重要的数据类型，字典是由”键-值“对组成的集合，字典中的值通过键来引用。

6.1、字典的创建

• 字典的每个元素都是键值对（key-value）组成，键值之间使用冒号分隔，”键值对“之间用逗号隔开，并且被包含在一对花括号中，键是唯一的，不能存在多个相同的值，且它们的值是无序的，键可以是数字、字符串、元组、一般用字符串作为键。
• 语法格式：字典名 = {键1:值1,键2:值2,…}

# 示例代码如下
>>> mobile = {'Tom':'199111','Alice':'199222','Bob':'199333'}
>>> print (mobile)
{'Tom': '199111', 'Alice': '199222', 'Bob': '199333'}

>>> print (type(mobile))
<class 'dict'>


# 定义了一个字典mobile，存储的键的姓名、值是电话号码，由此，姓名和电话号码就构成了对应的关系，可以使用type()函数来查看它们的类型是”dict“

6.2、字典的取值操作

• 字典的取值与元组和列表有所不同，元组和列表都是通过数字索引获取对应位置的值，而字典是通过键来获取对应的值。

# 示例代码如下
>>> mobile = {'Tom':'199111','Alice':'199222','Bob':'199333'}
>>> print (mobile['Tom'])
199111

>>> print (mobile['Bob'])
199333

6.3、字典的添加、修改、删除操作

6.3.1、字典添加新元素

• 字典添加新元素只需要对新键进行赋值即可，字典中不存在的键，会自动进行添加

>>> mobile = {'Tom':'199111','Alice':'199222','Bob':'199333'}
>>> mobile['wzh']='199444'

>>> print (mobile)
{'Tom': '199111', 'Alice': '199222', 'Bob': '199333', 'wzh': '199444'}

• 字典键值对的键名是区分大小写的，同一个单词，如果大小写不同，则被视为不同的键。

>>> mobile = {'Tom':'199111','tom':'199222'}
>>> print (mobile)
{'Tom': '199111', 'tom': '199222'}

6.3.2、修改字典元素

• 修改字典中的元素，直接使用存在的键赋值即可

>>> mobile = {'Tom':'199111','Alice':'199222'}
>>> mobile['Tom'] = '199333'
>>> print (mobile)
{'Tom': '199333', 'Alice': '199222'}

6.3.3、删除字典中的元素

• 删除字典中的元素，使用del函数

>>> mobile = {'Tom':'199111','Alice':'199222'}
>>> del mobile['Tom']
>>> print (mobile)
{'Alice': '199222'}


# 使用del函数删除键”Tom“，字典中的对应的键就不存在了

6.3.4、字典中常见问题

• 字典不能使用”+“运算符执行连接操作

>>> mobile1 = {'Tom':'19911','Alice':'199222'}
>>> mobile2 = {'Tom2':'19911','Alice2':'199222'}
>>> print (mobile1 + mobile2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'dict' and 'dict'

# 上从面代码的运行结果可以得到结论：使用”+“运算符直接报错