数据治理 | 带你学Python之 环境搭建与基础数据类型介绍篇

我们将在数据治理板块中推出一系列原创推文，帮助读者搭建一个完整的社科研究数据治理软硬件体系。该板块将涉及以下几个模块：
1.计算机基础知识
(1) 社科研究软硬件体系搭建——虚拟化技术概述与实践
2.编程基础
(1)本期内容 数据治理 | 带你学Python之 环境搭建与基础数据类型介绍篇
3.数据采集
4.数据存储
(1)安装篇 数据治理 | 遇到海量数据stata卡死怎么办？这一数据处理利器要掌握
(2)管理篇 数据治理 | 多人协同处理数据担心不安全？学会这一招，轻松管理你的数据团队
(3)数据导入 数据治理 | “把大象装进冰箱的第二步”：海量微观数据如何“塞进”数据库？
5.数据清洗
6.数据实验室搭建

Part1前言

这里是 Python 编程基础系列内容，该系列共包含三部分内容（本文属第一部分内容），分别讲述了安装并使用Python 编程语言的相关知识。本文将会讲解如何在系统中搭建 Python 编程环境，以及Python 编程语法中最基本的内容和数据类型。该系列后续两部分内容将会以顺序结构基础讲解 Python 编程的语法和技术。

Part2引言

随着大数据时代的到来，我们个人的数据资料也越来越多样化，数据量越来越庞大。面对各种各样的数据清洗、处理的需求，人工分析或操作越来越捉襟见肘。此时，我们需要一个强大且好用的编程语言，而 Python 是数据处理方面的神兵利器。

Part3Python 简介

Python 是由荷兰人 Guido van Rossum 在 1989 年因圣诞节十分无聊，打发时间而创造，并在 1991 年正式发布了第一版。他曾参与开发 ABC 语言，但是因为 ABC 语言本身的缺陷且未开源，所以他便彻底改进了 ABC 语言，使之开源，并根据他喜欢的喜剧《Monty Python’s Flying Circus》将其命名为 Python。

Python 是一种广泛使用的解释型，高级和通用的编程语言，提供了高效的数据结构，并且能简单些有效的面向对象编程。相较于编程界热门的几大编程语言，如 Java，C，C++等，Python 代码的执行效率虽不及前者，但其风格优雅，易读，易维护，非常适合没有编程基础的人入手编程所学习的第一门编程语言。另外，Python 在数据处理方面游刃有余，对于需要处理数据的用户来说，Python 是入手编程和处理数据的不二之选！

Python 在 1991 年正式发布，2000 年，Python 2.0 发布，开启了 Python 2 的版本迭代之路，直到 2008 年 Python 3.0 的发布。这期间 Python 使用者一直在不停地发展壮大，Python 3 的发布使得 Python 更加完善，到 2010 年时，Python 2.7发布，从此之后，Python 2 彻底停止更新，Python 3 稳定了地位。虽然至今仍有用户在使用 Python 2 ，但是若没有特殊需求，更建议使用 Python 3。

近十几年来，Python 在国内爆火，其应用领域几乎遍及所有行业，究其原因，是这个数据爆发时增长的大数据时代，社会，科学等各个领域越来越清楚数据的重要性，无论是数据清洗、整合，还是在数据挖掘，深度学习等各个方面，Python 都已经成长为人与数据之间的强大媒介，并撑起了人工智能的半边天。

Part4Python 环境搭建

工欲善其事，必先利其器。一般的编程语言都有这样的特点——计算机无法直接识别编程语言，若想要计算机能够读懂并执行代码，就需要事先搭建好相应的编程环境。Python 也是一样的，想要进行编程执行 Python 代码，也需要提前搭建 Python 的相关环境。

1安装 Python 解释器

什么是Python 解释器？简单来说，Python 解释器就是计算机能够读懂并执行 Python 代码的工具。只有安装了 Python 解释器，我们的电脑才能执行 Python 代码。在 Windows 10 系统中安装 Python 解释器的步骤如下。

登录python官方网站[1]，找到Python3.8下载页面[2]。下载Windows版本的python解释器。

下载完毕后，双击启动。勾选下面的【Add Python 3.8 to PATH】后，再点击【Customize installaion】。

勾选所有选项，然后点击，【Next】。

勾选所有选项后，配置好安装目录【Customize install location】，最后点击【Install】。

稍等片刻后，Python3.8 解释器安装完毕。点击【Close】。

打开Windows中的【命令提示符】。

输入【python】，然后回车，如果出现Python 3.8.10等内容，说明安装成功。

到这里为止，Python 解释器就已经安装好了。在上面的命令提示符中输入【Python】后，出现了 Python 版本相关信息后，下面还会出现类似于三个大于号的符号【>>>】，在这个符号后面就可以输入并执行 Python 代码了。其实 Python 安装完成之后，会自带有 Python 的编程环境，在开始菜单栏中找到并打开它。

在出现的 【IDLE Shell 3.8.10】窗口中，输入print('hello')，交互式开发工具就会返回这行语句的结果。

2安装集成开发工具

以上两种编程环境都属于交互式编译环境。也就是说，安装好 Python 解释器之后，就已经可以在这两个地方进行编程了。不过使用 Python 的人们基本上不会使用以上的 Python 自带的编译环境，就像人们不会入住毛胚房一样。所以为了更好地使用 Python，接下来还需要安装集成开发环境，集成开发环境（IDE，Integrated Development Environment ）是用于提供程序开发环境的应用程序，一般包括代码编辑器、编译器、调试器和图形用户界面等工具。集成了代码编写功能、分析功能、编译功能、调试功能等一体化的开发软件服务套。如果把 Python 自带的运行环境比作是毛胚房，成熟的IDE 就相当于是精装房了。这里只推荐使用一种 IDE —— Jupyter Notebook。

Jupyter Notebook 是一款基于浏览器的python代码开发工具，它体积小，在输出上做了优化，并支持交互式的运行方式，更适合从事数据科学相关工作的读者。

安装 Jupyter Notebook 是一件非常容易的事，我们打开windows系统的【命令提示符】，输入：pip install jupyter notebook，然后回车运行。

稍等片刻后，jupyter notebook就会安装完毕。pip 是 Python 中的标准库管理器。它允许你安装和管理不属于 Python标准库 的其它软件包。例如：jupyter notebook就是一个第三方包，我们可以通过pip工具将其下载安装，然后python解释器就可以调用这个第三方包。

安装完毕后，我们打开一个文件夹（作为存放python代码的目录），在这个文件夹中，按住shift，然后点击鼠标右键，点击【在此处打开 Powershell 窗口】。

在弹窗中输入：jupyter notebook，稍等片刻后，浏览器会登录 jupyter notebook控制台，我们就可以使用了。

在jupyter notebook网页控制台中，点击【New】，选择【Python 3】。

出现一个浏览器的新标签。在指定位置输入python代码，然后使用快捷键，即可运行得到结果。

Part5Python 基础语法和相关知识

---

读者须知：在【安装 Python 解释器】中有讲过，Python 解释器安装完毕后，可以在电脑开始菜单找到 Python 自带的 IDLE 交互式环境。虽然在具体的编程中不会使用这个编程环境，但是这种环境能够清楚的区分代码和输出。所以本文中的代码均是在 IDLE 环境中编写并运行。

3缩进，注释与输入输出

缩进

Python 语言有着严格的书写格式，在Python 语言中用缩进体现语句之间的逻辑关系，这种设计有助于提高代码的可读性和可维护性。

缩进指的是每一行代码前的空白部分，用来表示代码之间的层次关系。不需要有逻辑关系的代码顶行编写即可，不需要缩进。当表示分支，判断，循环，函数，类等程序含义时，在 if，while，def，class 等保留字所在完整语句后通过英文冒号“ : ”结尾并在之后进行缩进，一层完整的缩进由四个空格组成，或者在键盘上按下一次【Tab】键。当Python 语句存在更深层次逻辑时，可使多层缩进表示层次关系。例如：

>>> for i in range(10):
       if i == 6:
           print('This number is good!')

一般一行代码不宜超过 80 个字符，若实际编程中一行代码的字符数量过多或层次不鲜明时，可以使用反斜杠 “\” 延续行。例如：

>>> s = 'Python is a very simple and easy-to-use programming language,\
    and once you learn it, you hold the key to a new world'
>>> print(len(s))
119

缩进表达了所属关系，单层缩进属于之前最相邻的一行无缩进代码，多层缩进根据缩进关系决定所属范围。在编写大量代码时，需要留意层级之间的缩进关系。

注释

代码中的辅助性文字被称为注释，在程序运行时注释会被编译器或者解释器忽略，一般用于程序编写者对代码的解释说明。Python 中采用 “#” 表示一行注释的开始，多行注释即每行注释开始之前使用 “#” 。

注释可以在一行中的任意位置开始，“#” 之后的内容会作为注释不被执行，之前的内容仍是 Python执行程序的一部分。

当有连续几行内容需要注释时，可以在需要注释部分的首尾分别使用连续三个英文单引号或者三个英文双引号进行注释。例如：

>>> def annotation():
        """
        这是一个函数
        功能是展示注释
        """
        '''
        三个单引号也可以注释内容
        这种注释格式适合书写连续多行注释
        '''
        # 开始编写函数(这也是一段注释)
        print('这就是注释')  # 函数编写完成

输入与输出

print() 函数是 Python 的打印(输出)方法，可以输出多种对象。print() 函数是 Python 中使用最频繁的方法之一，它是学习 Python 的人应该首要掌握的 Python 函数。

>>> infomation = 'this and that.'
>>> number_1 = 2
>>> number_2 = 3    # 以上三句分别定义三个变量
>>> print(infomation) # 使用 print 函数输出定义的变量 infomation
this and that.
>>> print(number_1 + number_2) # 输出 number_1 和 number_2 相加的结果
5
>>> print('Hello world!') # 输出一个字符串
Hello world!
>>> print(print)  # 输出 print 本身
<built-in function print>

input() 函数是 Python 的输入方法，Python 解释器执行到 input 语句时会暂停执行，等待从用户端获取一个对象，一般需要用户手动输入，随后将输入的信息赋值给 input 语句指向的变量。再继续执行 input 语句后面的语句。例如：

>>> price = input('请输入衬衫的价格：') # 需要执行才能体会这个过程
请输入衬衫的价格：9磅15便士
>>> print(price)
9磅15便士

另外，在 Python 的所有交互式环境中，可以不使用 print() 函数也可以将对象打印出来。使用这种方式时，系统只会打印代码段中的最后一行代码，且最后一行代码只能是打印对象的本身，不包含其他字符，同时打印多个变量时中间使用逗号分隔。例如：

>>> name = 'Tom'  # 把字符串'Tom'赋值给变量name
>>> age = 20   # 把数字20赋值给变量 age
>>> weight = '70kg'  # 把字符串'70kg'赋值给变量weight
>>> name  # 输出变量name的值
'Tom'
>>> age,name  # 输出变量age和name的值
(20, 'Tom')

4Python的基本数据类型

基本数据类型

数字类型

Python 中常用的数字类型有两种：整数（int），浮点数（float）。Python 中还有一种数字类型——复数，但这种数字类型的应用场景极少，本文将不会介绍复数。

(1) 整数

没有小数的数字就是整数，Python 的整数类型没有长度限制，支持任意大的整数，只受限于内存的大小。在 Python 中使用“int”表示整数类型，即int型就表示整数型。

(2) 浮点数

浮点数就是带有小数的数字。浮点数的精度要比整数高，在 Python 中，整数与浮点数运算会得到浮点数。在 Python 中使用“float”表示浮点数类型，即float型就表示小数型。

(3) 数字类型的转换

在实际的程序中，所获得数据可能需要转换才能变成我们想要的数据，这时需要用到一些函数将其类型进行转换。

函数	描述
int(x)	将 x 转化为一个整数，只保留 x 的整数部分
float(x)	将 x 转化为一个浮点数

字符串类型

字符串是 Python 最基本的数据类型之一，在 Python 中使用“str”表示字符串类型。(1) 字符串的组成字符串是由字符组成的序列，在 Python 中可以使用英文单引号或者双引号创建和表示字符串。例如：

>>> word_1 = 'How are you?'
>>> print(word)
How are you?
>>> type(word_1)
<class 'str'>

>>> word_2 = "How are you?"
>>> print(word)
How are you?

a = """ 123
123123 """
print(a)  # 可以补充三个引号也是可以作为字符串的，常用于换行操作

(2) 字符串中的转义符

在字符串的一些操作中，需要表示特殊的含义或保留字符原本的含义，此时就需要用反斜杠（\）来转义字符，以便于表示特殊字符。下表是常见的转义字符。

转义字符	含义
\n	换行
\t	横向制表符
\vn	纵向制表符
\rn	回车符
\0	空格
'	单引号
"	双引号
\	\

一些字符串中包含反斜杠（\）,表示特定的含义，当不需要转义字符生效时，需要在用 r 或者 R 加在字符串的前面。例如：

>>> path = 'D:\number'
>>> print(path)
D:
umber

>>> path = r'D:\number'
>>> print(path)
D:\number

字符串的基本操作

(1) 字符串的连接与复制

字符串与字符串之间使用 “+” 进行首尾相连，且连接后中间没有空格。例如:

>>> 'It' + 'is' + 'good'
'Itisgood'
>>> '1' + '1'
'11'

在 Python 中，“ * ”表示“乘”，“*” 在字符串复制的作用是将前面的字符串按照后面的次数重复若干次。例如：

>>> 'I love python' * 3
'I love pythonI love pythonI love python'
>>> '字符串' * 2
'字符串字符串'

(2) 字符串的切片

在 Python 中可以使用切片截取字符串中的一部分字符，通过“[ ]”来获取相应索引位置的字符。Python中有两种索引方式，一种是正序，一种是倒序。正序索引表示取 n 个字符时，从 0 开始到 n - 1 ；倒序索引表示取 n 个字符时，从 -1 开始到 -n。切片共有三个参数，在“[ ]”内使用冒号“ : ”分隔开。第一个参数表示切片开始位置（包含本身），第二个参数表示切片结束位置（不包含本身），第三个参数表示切片的步长（默认为 1），步长省略时，可以省略最后一个冒号。例如：

>>> s = 'How are you?'
>>> print(s[:])  # 切片开始位置省略表示从字符串的第一个位置开始
>>>             # 切片结束位置省略表示到字符串的最后一个位置结束
'How are you?'
>>> s[5:10]
're yo'
>>> s[4:]
'are you?'
>>> s[::2]
'Hwaeyu'

字符串是不可变对象，一经创建，字符串的值不会被改变。所以不可以对字符串切片赋值,例如：

>>> S = 'ABC'
>>> S[0]
A
>>> S[0] = 'D'
SyntaxError: invalid syntax

(3) 字符串的相关函数和方法

• len()

• 长度函数，可以确定字符串的字符数量。注意，在字符串中，空格和标点，符号等也表示独立的字符。例如：

>>> s = 'How are you?'
>>> len(s)
12

• title()

• 以首字母大写的方式显示每一个字符，即将所有单词的首字母由小写改为大写。例如：

>>> s = 'How are you?'
>>> s.title()
'How Are You?'

• upper() 和 lower()

将字符串中的字母全部大写或者小写。例如：

>>> s = 'How are you?'
>>> s.upper()
'HOW ARE YOU?'
>>> s.lower()
'how are you?'

• strip()去除字符串首尾两端的空白字符，当有参数时，去除字符串首尾两端的输入字符。例如：

>>> s = '   How are you?  '
>>> s.strip()
'How are you?'
>>> s = '##How are you?#'
>>> s.strip('#')
'How are you?'

• split()

以输入字符分割字符串，返回一个列表。例如：
>>> s = 'How are you?'
>>> s.split('o')
['H', 'w are y', 'u?']

• join()

将多个字符串以输入字符连接起来，形成一个大字符串。

>>> s = ['H', 'w are y', 'u?']
>>> 'o'.join(s)
'How are you?'
>>> '—'.join(['2022','01','01'])
'2022—01—01'

字符串格式化输出

Python 中字符串格式化输出一般使用三种方式，这里做简单介绍。

• % 格式化

>>> print('班长的名字叫%s' % '刘克')
我好兄弟的名字叫刘克
>>> print('%.2f一个两位小数'%3)
3.00一个两位小数
>>> print('%.3f一个两位小数'%3)
3.000一个两位小数
>>> print('%s有%d个糖果，每个%.1f元'%('刘克',15,1.5))  # %.1f 表示保留一位小数
刘克有15个糖果，每个1.5元

其中%后跟着不同字符代表不同类型的数据。“%s”代表输出字符串，“%d”代表输出整数，“%f”代表输出浮点数。

• format 格式化

这是一种自由度很高的字符串格式化输出方式，默认以正向(从左往右)顺序填充位置。也可以自定义顺序或使用关键字确定顺序。下面是它的简单介绍。

>>> # 默认顺序
>>> print('不{}的话可以{}。'.format('满意','退款'))
不满意的话可以退款。
>>> # 指定顺序
>>> print('不{1}的话可以{0}。'.format('退款','满意'))
不满意的话可以退款。
>>> # 使用关键字
>>> print('不{x}的话可以{y}。'.format(y='退款',x='满意'))
不满意的话可以退款。

• f-string 格式化

• f-string 的全称叫字面量格式化字符串，这是一种最为简单实用的字符串格式化输出方式，只需要在字符串前面加一个字母“f”，随后在待填充位置中放入数字，字符串或者变量即可。本书中多采用这种方式进行字符串格式化输出。

>>> name = '刘克'
>>> age = 20
>>> print(f'班长是{name},它{age}岁，它是一个{"男生"}')
班长是刘克,它20岁，它是一个男生

特殊数据类型

Python中有两种比较有特殊的数据类型，bool (布尔)类型，和 None。其实前面这句话是不太严谨的，因为 bool 是数据类型，而 None 是一个数据，它的类型是 NoneType。需要注意的是，这一部分知识会有一些超前，但本章后面的小节会补充这些超前的概念或者知识。读者可以先阅读后面的部分，也可以先尝试理解这里的知识。（超前部分：4.组合数据类型，5.程序控制结构）

(1) bool 类型

bool 类型只有两个值：True 和 False，分别代表真和假。在程序世界中，二进制是一种传奇的存在，二进制数字只由数字0和1组成，这是一种非常清晰的结构——非0即1。这种结构的原理其实就是bool型数据的原理。bool 值同样是非真即假，而且1，0 和 True，False 是高度呼应的，程序世界中，1 表示是True，而 0 则表示 False。不仅如此，在数字中，只要不是整数0和浮点数0，都可以判断为真，只有0会被判断为假。而判断字符串，和其他组合数据类型的时候会使用他们的长度判断真与假，长度不为0时，判断为真；长度为0时会被判断为假。

True 和 False多用于表示一种状态，常与判断结构一同使用；也可以表示一个数据占用一个数据应该占据的位置。也就是说，在做判断时，若列表中只有一个数据True，或只有一个数据False，也会被判断为真。

(2) None

前面说到，None其实并非是一种数据类型，None 是一个数据，它的含义就是，空、虚无、什么都没有。它的类型是 NoneType，即无类型，当真是编程界独一无二的存在。而且这种数据类型不能进行任何运算，它只是单纯的虚无。但 None 和 bool 类型的数据有一点类似，即 None 同样表示一个数据并占据一个数据的位置。也就是说，在做判断时，若列表中只有一个数据None，也会被判断为真。但若是单独判断 None 本身，会被判断为假。

浅谈进制和编码

在介绍数据类型之前先了解以下进制和字符编码。进制和编码的知识较为复杂，深入学习需要花费大量的时间和精力。而在现实生活中，很少使用深层的进制和编码知识。也正因此，这里将介绍这方面最基本的知识，将最常用和使用的知识摆在读者面前。

进制

计算机常用的进制有四种，二进制，八进制，十进制和十六进制。其中我们人类最常用的是十进制，十进制就是用十个数字0，1，2，3，4，5，6，7，8，9等来表示数字，其核心思想就是“逢十进一”。而二进制只使用 0，1 两个数字来表示数值，比如二进制数字 01 表示十进制数字 1 ，10 表示十进制数字 2，11 表示十进制数字 3，100 表示十进制数字 4……八进制使用 0，1，2，3，4，5，6，7 这八个数字来表示数值，而十六进制则使用 0，1，2，3，4，5，6，7，8，9，A，B，C，D，E，F这16个字符表示。为了防止这些不同的编码在计算机内部无法被准确地识别，在不同进制的数字前会加上其使用进制的特殊前缀。二进制，八进制，十六进制在计算机内部的前缀分别是 0b/0B，0o/0O，0x/0X，十进制则没有前缀。

	组成元素	特点	在计算机中的前缀
二进制	0，1	逢二进一	0b / 0B
十进制	0，1，2，3，4，5，6，7，8，9	逢十进一
八进制	0，1，2，3，4，5，6，7	逢八进一	0o / 0O
十六进制	0，1，2，3，4，5，6，7，8，9，A，B，C，D，E，F	逢十六进一	0x / 0X

无论是那种进制的数字或者字符，在计算机中最底层都会被转换为二进制信息。对于人们来说，十进制的数字是最常用，好理解和方便计算的数字表示形式。而对于计算机来说，二进制的运算要简单的多。因为在计算机中，机器处理指令的方式是双态的，使用电位的“高”和“低”来实现，这分别对应着 1 和 0。

编码

了解编码之前需要了解两个更为基础的概念：位(bit，也称比特)，字节(byte)。

位(bit)是计算机存储数据最基础的组成单元，1 个 bit 表示二进制的 0 或 1。字节 (byte)是一小组 bit ，一个字节由 8 位(bit)组成。在计算机中，一般一个英文字母占一个字节，一个汉字占用 2 个字节。编码常用于计算机内部处理各种字符。

• ASCII 编码其实计算机内部只能处理数字，无法直接处理字符等信息，所以要处理字符，就需要先将其转换为数字。计算机最早是由美国人发明的，他们把 127 个字符编码到计算机里，也就是大小写英文字母、数字和一些符号，这个编码表被称为 “ASCII”编码，比如大写字母A的编码是65，小写字母z的编码是122。采用 8 个比特作为 1 个字节，一个字符占用一个字节。

• Unicode 编码我们知道，相对于中文汉字，英文的基本元素是相对少很多的。在英语中，使用 26 个大写字母和 26 个小写字母以及数字和符号等就可以解决绝大部分的语言和数据。但是汉字的数量字母的数量多得多，一般只使用一个字节不足以表示汉所有的汉字，所以ASCII 编码不能很好的表示汉字和其他国家的语言字符，于是各国为了解决这个问题，分别制定了适合自己国家的编码格式。比方说中国制定了 GB2312 编码，并以此改进出了 GBK 编码，更好地来编码中文。同时这些编码格式也兼容了ASCII 编码，同样韩国就把韩文编到 Euc-kr 编码里。这样做就导致多语言本文中会不可避免地出现各种乱码，在这样的背景下，Unicode 编码应运而生。Unicode 编码由国际组织提出，它为世界上每一种语言的每一个字符定义了一个唯一的字符码。Unicode 编码最低使用 2 个字节编码一个字符，为了涵盖全球的文字元素，也会使用更多的字节数编码字符。

• UTF-8Unicode 编码作为一种编码规范，虽然涵盖了所有字符，但并非所有的字符都需要至少 2 个字节进行编码，这是对计算机空间的浪费。UTF-8 编码是针对 Unicode 优化的一种可变长度字符编码。它出现的初衷是为了解决 Unicode 空间浪费问题，尽可能少地使用 1~4 个字节来对字符进行编码，能用一个字节编码的字符绝不使用 2 个。同时它也可以用来表示 Unicode 标准中的任何字符，而且其编码中的第一个字节仍与 ASCII 相容，使得原来处理 ASCII 字符的软件无须或只进行少部份修改后，便可继续使用。现如今，这种编码已经成为我们日常使用文字的主要编码之一。

5变量与运算

变量

什么是变量

简单来说，其实就是计算机内存中的一块储存空间，用来存储CPU需要使用的数据。而这个储存空间需要一个名字，这个名字的统称就叫变量。在 Python 中没有专门的变量定义语句，第一次对变量进行赋值时就已经完成了对变量的定义。使用 del 命令可以删除一个对象（变量，函数等）并释放对象所占用的资源：

>>> x  # 尝试输出变量x,但x没有被定义
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    x
NameError: name 'x' is not defined
>>> x = 10  # 定义变量x,读作把数字10赋值给变量x
>>> x
10
>>> del x  # 从内存中删除变量x
>>> x
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    x
NameError: name 'x' is not defined

变量的命名规则

变量名的定义需要满足标识符命名规则。

Python 采用大写字母、小写字母、数字、下划线、汉字等字符及其组合对变量进行命名，但变量名首字母不能是数字，中间不能出现空格，不能与保留字同名；保留字是指被编程语言内部定义并保留使用的标识符。Python3.x 版本中共有 35 个保留字。如下表所示。

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

除此之外，变量的命名应当符合使用习惯，最好达到见名知意的效果。便于开发者的使用。比如，有一个列表变量，它是一个测试用的变量，此时可以将其命名为" list_test " 或 “ test_list ”，而不是把所有的变量命名为“ 变量1 ”，“ 变量2 ”…

基本运算

表达式

表达式与数学中的计算公式类似，运算后产生运算结果。按照运算符的种类，表达式可以分为算术表达式、关系表达式、逻辑表达式等。多种混合运算形式组成的表达式，按照运算符的优先级与结合性依次进行运算，出现括号时，优先计算括号内的。

在运算过程中要求两个操作数类型一致，当操作数类型不完全一致时，系统会以高类型为准进行运算。例如：

>>> x = 1
>>> y = 1.5
>>> x + y  # 整数和浮点数之间进行运算，会得到精度更高的浮点数
2.5

算术运算符

基本的算术运算符如表 5.1 所示。

表 5.1 基本的算术运算符

运算符	描述
x + y	两个数相加
x - y	两个数相减
x * y	两个数相乘
x / y	两个数相除，结果为浮点数
x % y	取余，两个数之商的余数
x // y	取整，两个数之商的整数部分
x ** y	幂运算，x 的 y 次幂

例如：

>>> 5 + 38
>>> 5 / 2
2.5
>>> 5 % 2
1
>>> 5 // 2
2
>>> 5 ** 2
25

比较运算符

比较运算符用来比较两个对象之间的关系，若比较成立，会返回布尔值 True，否则会返回布尔值 False。常用的比较运算符如下表所示。

运算符	描述
x == y	比较两个数是否相等，若是，返回 True，否则返回 False。下同
x != y	比较两个数是否不相同
x > y	返回 x 是否大于 y
x < y	返回 x 是否小于 y
x >= y	返回 x 是否大于等于 y
x <= y	返回 x 是否小于等于 y

例如：

>>> x = 6
>>> y = 6
>>> x == y
True
>>> x != y
False
>>> x > y
False
>>> x >= y
True

逻辑运算符

逻辑运算符如下表所示。

运算符	描述
and	布尔“与”；所有条件都为真就返回True，否则返回False
or	布尔“或”；所有条件有一个为真就返回True，否则返回False
not	布尔“非”；取反，为真返回False，为假则返回True

例如：

>>> # 重温：数字中，0表示False，所有非0的数字都表示True
>>> x = 3
>>> y = 6
>>> x and y
6
>>> x = 0
>>> y = 6
>>> x and y
0
>>> x or y
6
>>> not x
True
>>> not y
False
>>> 1 == 1 or 1 == 2
True

由例可知，当所有条件都为数字并执行“与”运算时，如果 x 为假，x and y 就返回假，否则就返回 y 的值；执行“或”运算时，如果 x 非 0，就返回 x 的值，否则返回 y 的值；执行“非” 运算时，如果 x 为真，就返回假，如果 x 为假，就返回真。若条件是表达式或者其他类型时，则只会返回布尔值 True 或 False。

赋值运算符

赋值运算符如下表所示。

运算符	描述
=	赋值运算，例如: x = 10 表示把 10 赋值给 x
+=	加法赋值运算，x += y 等价于 x = x + y。下同
-=	减法赋值运算，x -= y 等价于 x = x - y
*=	乘法赋值运算，x *= y 等价于 x = x * y
/=	除法赋值运算，x /= y 等价于 x = x / y
%=	取余赋值运算，x %= y 等价于 x = x % y
//=	取整赋值运算，x //= y 等价于 x = x // y
**=	幂赋值运算，x **= y 等价于 x = x ** y，即把x的y次幂重新赋值给x

例如：

>>> x = 10
>>> x
10
>>> x += 5
>>> x
15
>>> x = 10
>>> x *= 5
>>> x
50
>>> x = 10
>>> x **= 2
>>> x
100

运算符优先级

常见的运算符优先级如下表所示。注意，同数学中的运算优先级一样，有括号的需要优先计算括号内的内容。

优先级从上往下，由高到低（括号内运算符优先级相同）

索引 [ ]

幂运算 **

乘除，取余，取整（* , / , % , //）

加减 （+ , -）

（> , >= , < , <= , == , != , is , is not）

（= , += , -= , *= , = , %= , //= , **=）

and , or , not

6Python的组合数据类型

列表

什么是列表

列表（list）是 Python 的一种有序的组合数据类型，在列表中，值可以是任何的数据类型（包括列表），被称为“元素”或者“项”，Python 可以通过元素在列表中的所在位置的下标，即索引，来访问元素，进而实现对列表的各种操作。在 Python 中，所有支持索引的组合数据类型的索引都是从 0 开始。即第一个元素的索引为 0 ，第二个元素的索引是 1 ......，第 n 个元素的索引是 n-1。列表没有长度限制且元素的类型可以不同，所以不需要预先定义列表的长度。

列表用中括号 “[ ]” 表示，并用逗号分隔其中的元素，也可以通过 list() 函数将元组或者字符串转化成列表，直接使用该函数会返回一个空列表。

列表的基本操作

(1)列表的创建

使用中括号 “[ ]” 将一组数据包围起来，列表中的元素类型几乎可以是所有类型（包括列表类型）。各元素之间使用逗号分隔开，这样列表就创建成功了。例如：

>>> list_0 = ['Str',123,1.5]
>>> list_0
['Str',123,1.5]
>>> list_1 = [6,['s',123],[]]
>>> list_1
[6,['s',123],[]]

(2)向列表添加元素

使用 append 方法可在列表的末尾处添加元素。例如

>>> list_0 = [1,2,3]
>>> list_0.append(4)
>>> list_0
[1, 2, 3, 4]

若要在列表指定的位置添加元素，可以使用 insert() 方法，该方法有两个参数；第一个参数表示插入的位置，第二个参数表示插入的元素。例如，把数字 5 插入到列表索引为 2 的位置：

>>> list_1 = [1,2,3,4]
>>> list_1.insert(2,5)
>>> list_1
[1,2,5,3,4]

(3)从列表中获取元素

列表是有序数据集合，因此访问列表的元素时，只需要在列表名称后加上中括号，中括号内放入想要访问的元素的索引即可，例如：

>>> list_2 = ['a','b','c','d','e']
>>> list_2[0]
'a'
>>> list_2[1:4]
['b', 'c', 'd']

(4)从列表中删除元素

删除列表中的元素可以使用 remove() 方法，del 和 pop() 方法。

使用 remove() 方法只需要将需要删除的值传入其中，该方法就会删除列表中对应值的元素，并且没有返回值。若要删除的元素在列表中出现多次时，remove() 方法只会删除第一个。当列表中没有要删除的值时，使用 remove() 方法会报错。例如：

>>> list_3 = ['Tom','Bob','Siri','Siri']
>>> list_3.remove('Tom')
>>> list_3
['Bob', 'Siri', 'Siri']

>>> list_3 = ['Tom','Bob','Siri','Siri']
>>> list_3.remove('Siri')
>>> list_3
['Tom', 'Bob', 'Siri']

>>> list_3 = ['Tom','Bob','Siri','Siri']
>>> list_3.remove('David')
>>> list_3  # 报错
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    list_3.remove('David')
ValueError: list.remove(x): x not in list

使用 pop() 方法不传入参数时可以删除列表末尾的元素，若要传入参数，需要传入待删除元素的索引。使用 pop() 方法会返回被删除的元素。

>>> list_3 = ['Tom','Bob','Siri','Siri']
>>> list_3.pop()
'Siri'
>>> list_3
['Tom', 'Bob', 'Siri']

>>> list_3 = ['Tom','Bob','Siri','Siri']
>>> list_3.pop(1)
'Bob'
>>> list_3
['Tom', 'Siri', 'Siri']

del 后面跟上列表的名字，删除的是整个列表，后续无法访问；若要删列表的某一元素，可继续在列表名称后加上待删除元素的索引。另外，使用 clear() 方法，可以清空列表内的全部元素，使之变成一个空列表。例如：

>>> list_3 = ['Tom','Bob','Siri','Siri']
>>> del list_3[1]
>>> list_3
['Tom', 'Bob', 'Siri']

>>> del list_3
>>> list_3Traceback (most recent call last):
  File "<pyshell#30>", line 1, in <module>
    list_3
NameError: name 'list_3' is not defined

>>> list_3 = ['Tom','Bob','Siri','Siri']
>>> list_3.clear()
>>> list_3
[]

(5)列表切片

列表的切片与字符串的切片十分相似，在 Python 列表中，第一个元素的索引为 0，第二个元素的索引为 1，根据这种方法可以访问列表中的任何元素，与字符串切片相同，列表切片同样有三个参数，使用方式为：列表名[起始位置:终止位置:步长]。例如要输出列表的前三个元素，由于切片返回值不包含终止位置的元素，就需要指定索引为 0~3,即可输出索引为 0，1 和 2 的元素。例如：

>>> list_4 = ['A','B','C','D','E']
>>> list_4[0:3]
['A', 'B', 'C']

>>> list_4 = ['A','B','C','D','E']
>>> list_4[3:]
['D','E']

(6)列表的其他常用操作方法

• count()

• 可以返回某个元素在列表中出现的次数。例如：

>>> list_5 = [1,2,3,4,2,3,4,2]
>>> list_5.count(2)
3

• extend()

• 可以在列表末尾一次性追加另一个列表的全部元素，用于扩展，合并列表。例如：

>>> x = [1,2,3]
>>> y = [4,5,6]
>>> x.extend(y)
>>> x
[1,2,3,4,5,6]

• index()

• 返回列表中某元素第一次出现的索引。例如：

>>> list_6 = ['A','B','C','D','D']>>> list_6.index('D')3

• reverse()

• 反转列表内元素的排列顺序，不需要输入参数。例如：

>>> list_7 = ['A','B','C','D','D']
>>> list_7.reverse()
>>> list_7
['D', 'D', 'C', 'B', 'A']

• sort()

• 可以修改列表内元素的排列顺序，默认为升序。例如：

>>> list_8 = ['5','7','2','3']
>>> list_8.sort()
>>> list_8
['2', '3', '5', '7']

>>> list_8 = ['D','C','A','B']
>>> list_8.sort()
>>> list_8
['A', 'B', 'C', 'D']

元组

元组与列表相似，不同之处在于元组的元素不能修改，因此，元组类型的数据比列表数据更加安全，但不如列表类型灵活。

元组的基本操作

(1) 创建和访问元组

元组（tuple）的创建语法很简单，用逗号分隔开一些数据，Python 就会自动创建元组，也可以通过使用圆括号将数据括起来，数据之间用逗号分开即可。需要注意的是，如果创建的元组中只有一个数据，也必须在数据后面加上一个都好，否则无法创建元组。例如：

>>> 'How','are','you'
('How', 'are', 'you')
>>> tuple_0 = ('How', 'are', 'you')
>>> tuple_0
('How', 'are', 'you')

>>> 1,
(1,)
>>> tuple_0 = (1,)
>>> tuple_0
(1,)
>>> 1
1

元组的访问和列表一样，都是通过索引进行访问。例如：

>>> tuple_0 = ('red','blue','yellow','black')
>>> tuple_0[1]
'blue'
>>> tuple_0[1:3]
('blue','yellow')

(2) 更新、删除元组元素

元组的元素是不可以被修改的，但是可以对元组进行连接，可以使用 del 语句删除整个元组。例如：

>>> tuple_1 = ('apple','orange')
>>> tuple_2 = ('banana','pear')
>>> tuple_3 = tuple_1 + tuple_2
>>> tuple_3
('apple', 'orange', 'banana', 'pear')

>>> del tuple_3
>>> tuple_3
Traceback (most recent call last):
  File "<pyshell#69>", line 1, in <module>
    tuple_3
NameError: name 'tuple_3' is not defined

(3) 元组的内置函数

Python 为元组提供了一些内置函数，比如 len() 可以返回元组的元素数量，也就是元组的长度；max() 可以返回元组中的最大元素；min() 可以返回元组中的最小元素；tuple() 可以将其他序列转换为元组类型。例如：

>>> tuple_4 = (11,33,55,66)
>>> len(tuple_4)
4
>>> max(tuple_4)
66
>>> min(tuple_4)
11
>>> list_0 = [1,2,3,4]
>>> tuple(list_0)
(1,2,3,4)

集合

集合 (set) 不同于列表和元组类型，集合存储的元素是无序且不能重复的，元素类型是不可变数据类型，如整数，浮点数，字符串，元组等。由于元素之间没有顺序，因此集合类型不支持索引，不能够排序，比较。

集合的基本操作

(1) 集合的创建

创建集合可以直接用大括号 { } 将元素括起来也可以使用 set() 创建，但不能使用 { } 来创建空集合，因为 { } 是用来创建字典的。例如：

>>> set_0 = {'语文','数学','英语'}
>>> set_0
{'数学', '英语', '语文'}

>>> set_0 = set(('语文','数学','英语','英语'))
>>> set_0
{'数学', '英语', '语文'}

(2) 访问集合

由于集合的无序性，集合不能通过索引来访问集合中的元素，但是可以使用循环把集合中的元素逐一读取出来。例如：

>>> set_1 = {1,3,4,6,1,4,3,3,4,2,5}
>>> for number in set_1:
        # 基于集合的元素不可重复性，集合会自动删除重复元素，只保留一个
        print(number,end = ',')
1,2,3,4,5,6,

(3) 集合增加，删除元素

虽然集合类型不支持索引，但是依然可以向集合中添加和删除元素。若要添加的元素已经在集合中存在，则不会执行任何操作；若要添加的元素不在集合中，则会添加该元素。添加元素时使用 add() 方法，删除元素时使用 remove() 方法，该方法没有返回值，直接操作调用此方法的集合。例如：

>>> set_2 = {'苹果','香蕉','橘子'}
>>> set_2.add('香蕉')   # 向集合中添加已经存在的元素
>>> set_2.add('塑料袋') # 向集合中添加新元素
>>> set_2   # 只有新元素会添加成功
{'苹果','香蕉','橘子', '塑料袋'}

>>> set_2.remove('香蕉')
>>> set_2
{'苹果','橘子', '塑料袋'}

(4) 集合类型的操作符

集合类型有四个操作符，如下表所示。

操作符及运算	描述
X - Y	返回新的集合，包含在 X 但不在 Y 中的元素
X & Y	返回新的集合，包含既在 X 中又在 Y 中的元素
X ^ Y	返回新的集合，包含 X 和 Y 的非共同元素
X Y	返回新的集合，包含 X 和 Y 中的所有元素

上表中集合类型的操作符运算实例如下：

>>> X = {2,3,4}
>>> Y = {3,4,5}
>>> X - Y
{2}
>>> X & Y
{3, 4}
>>> X ^ Y
{2, 5}
>>> X | Y
{2, 3, 4, 5}

字典

字典（dict）是键值对的无序集合，字典中的每个元素包含用冒号隔开的 “键” 和 “值” 两部分，表示一种映射关系。字典中的 “键” 可以是 Python 中任意不可变的数据，如整数，浮点数，字符串等，而且 “值” 可以重复，但是 “键” 不可以重复。

字典的基本操作

(1) 字典的创建

字典是有大括号和键值对构成的，可以直接使用 { } 创建字典，也可以使用 dict() 创建。使用 dict() 创建字典时，会出现很多括号，这是因为 dict() 的参数可以是一个序列，不能是多个序列。例如：

>>> dict_0 = {'name':'张三', 'age':'50', 'gender':'男'}
>>> dict_0
{'name': '张三', 'age': '50', 'gender': '男'}

>>> dict_0 = dict(name = '张三', age = '50', gender = '男')
>>> dict_0
{'name': '张三', 'age': '50', 'gender': '男'}

>>> dict_0 = dict([('name','张三'), ('age','50'), ('gender','男')])
>>> dict_0
{'name': '张三', 'age': '50', 'gender': '男'}

(2) 访问字典的键值

要得到字典中的某个值，可以用字典名加上中括号获取，中括号中放入的时该值对应的键，也可以使用 get() 方法。如果键不在字典中会引发 KeyError。例如：

>>> dict_0 = {'name':'张三', 'age':'50', 'gender':'男'}
>>> dict_0['name']
'张三'
>>> dict_0.get('name')
'张三'
>>> dict_0['job']
Traceback (most recent call last):
  File "<pyshell#107>", line 1, in <module>
    dict_0
['job']KeyError: 'job'

(3) 更新字典

字典是一种动态结构，可以随时修改，删除字典中已经存在的键值对，也可以随时往字典中添加新的键值对。不过键值对的排列顺序与添加的顺序不同，Python 不关心键值对的添加顺序，只关心键和值之间的映射关系。删除键值对时，可以使用 del 语句指定字典名和需要删除的键值对的键。例如:

>>> dict_0 = {'name':'张三', 'age':'50', 'gender':'男'}
>>> dict_0['weight'] = '70kg'
>>> dict_0
{'name': '张三', 'age': '50', 'gender': '男', 'weight': '70kg'}
>>> dict_0['name'] = '李四'
>>> dict_0
{'name': '李四', 'age': '50', 'gender': '男', 'weight': '70kg'}
>>> del dict_0['gender']
>>> dict_0
{'name': '李四', 'age': '50', 'weight': '70kg'}

(4) 遍历字典

一个字典可能包含很多个键值对，可以使用 for 循环遍历字典中的键值对。例如：

snakes = {
    '牛奶':'3',
    '糖果':'1',
    '薯片':'5',
    '鸡腿':'6',
    '罐头':'10'
    }
(1)for k,v in snakes.items(): # items()
    (2)print("\nkey:" + k)
    (3)print("value:" + v)

以上代码 (1) 中,先声明两个变量 k，v ，分别存储字典中对应的键和值，items() 方法返回一个键值对列表，然后用 for 循环依次把每个键值对存储到对应的变量中。输出如下：

key:牛奶
value:3

key:糖果
value:1

key:薯片
value:5

key:鸡腿
value:6

key:罐头
value:10

(5)字典的操作方法

• clear()

• 用于清空字典内的所有键值对，该方法不需要传入参数，没有返回值。例如：

>>> dict_1 = {'color0':'red', 'color1':'green', 'color2':'blue'}
>>> dict_1.clear()
>>> dict_1
{}

• items()

• 返回一个字典的所有键值对组成的列表。例如：

>>> dict_1 = {'color0':'red', 'color1':'green', 'color2':'blue'}
>>> dict_1.items()
dict_items([('color0', 'red'), ('color1', 'green'), ('color2', 'blue')])

• key()

• 返回字典所有的键组成的列表。例如：

>>> dict_1 = {'color0':'red', 'color1':'green', 'color2':'blue'}
>>> dict_1.keys()
dict_keys(['color0', 'color1', 'color2'])

• values()

• 返回字典所有的值组成的列表。例如：

>>> dict_1 = {'color0':'red', 'color1':'green', 'color2':'blue'}
>>> dict_1.values()
dict_values(['red', 'green', 'blue'])

• update()

• 用于将一个字典的键值对更新到另一个字典中，该方法没有返回值。例如：

>>> dict_2 = {'color0':'red'}
>>> dict_3 = {'color1':'pink'}
>>> dict_2. update(dict_2)
>>> dict_2
{'color0':'red', 'color1':'pink'}

列合数据类型的公共运算方法

组合数据类型的公共数据运算符如下表所示。

运算符	描述	支持的数据类型
+	合并	字符串、列表、元组
*	复制	字符串、列表、元组
in	元素是否存在	字符串、列表、元组、字典
not in	素是否不存在	字符串、列表、元组、字典

组合数据类型的公共函数如下表所示。

函数	描述	支持的数据类型
len()	计算元素个数	列表、元组、集合、字典
del 或 del()	删除某一元素或整个数据结构	列表、元组、集合、字典
max()	返回最大值	列表、元组、集合、字典
min()	返回最小值	列表、元组、集合、字典

Part6结束语

首先，学习了以上内容，恭喜你已经来到 Python 世界！相信经过不懈的学习，你可以使用Python 做其他工具无法做到的事情。其次，诚实地说，Python 是一门博大精深的编程语言，想要达到熟练使用 Python 的境界并不是一日两日的事情。就像写文章要先学会写字一样，基础非常重要，笔者非常建议你多练习这一部分的内容。

Python 编程基础系列的第二篇将会讲解进阶的控制流程和函数。其实函数是非常有趣的内容，读者无需恐惧函数，相信经过学习，你也可以轻松拿捏函数！同时该系列第三篇将会讲解关于操作文件的知识，相信那一部分内容会对你有巨大的帮助。

参考资料

[1]python官方网站: https://www.python.org/

[2]Python3.8下载页面: https://www.python.org/downloads/release/python-3810/