中信建投 & 课程

## 什么是Python？

Python是一种计算机程序设计语言。你可能已经听说过很多种流行的编程语言，比如非常难学的C语言，非常流行的Java语言，适合初学者的Basic语言，适合网页编程的JavaScript语言等等。

​

那Python是一种什么语言？

​

首先，我们普及一下编程语言的基础知识。用任何编程语言来开发程序，都是为了让计算机干活，比如下载一个MP3，编写一个文档等等，而计算机干活的CPU只认识机器指令，所以，尽管不同的编程语言差异极大，最后都得“翻译”成CPU可以执行的机器指令。而不同的编程语言，干同一个活，编写的代码量，差距也很大。

​

比如，完成同一个任务，C语言要写1000行代码，Java只需要写100行，而Python可能只要20行。

​

所以Python是一种相当高级的语言。

​

你也许会问，代码少还不好？代码少的代价是运行速度慢，C程序运行1秒钟，Java程序可能需要2秒，而Python程序可能就需要10秒。

​

那是不是越低级的程序越难学，越高级的程序越简单？表面上来说，是的，但是，在非常高的抽象计算中，高级的Python程序设计也是非常难学的，所以，高级程序语言不等于简单。

​

但是，对于初学者和完成普通任务，Python语言是非常简单易用的。连Google都在大规模使用Python，你就不用担心学了会没用。

​

用Python可以做什么？可以做日常任务，比如自动备份你的MP3；可以做网站，很多著名的网站包括YouTube就是Python写的；可以做网络游戏的后台，很多在线游戏的后台都是Python开发的。总之就是能干很多很多事啦。

​

Python当然也有不能干的事情，比如写操作系统，这个只能用C语言写；写手机应用，只能用Swift/Objective-C（针对iPhone）和Java（针对Android）；写3D游戏，最好用C或C++。

​

本篇教程将讲述Python基础的<font color=red>数据类型</font>

什么是Python？¶

Python是一种计算机程序设计语言。你可能已经听说过很多种流行的编程语言，比如非常难学的C语言，非常流行的Java语言，适合初学者的Basic语言，适合网页编程的JavaScript语言等等。

那Python是一种什么语言？

首先，我们普及一下编程语言的基础知识。用任何编程语言来开发程序，都是为了让计算机干活，比如下载一个MP3，编写一个文档等等，而计算机干活的CPU只认识机器指令，所以，尽管不同的编程语言差异极大，最后都得“翻译”成CPU可以执行的机器指令。而不同的编程语言，干同一个活，编写的代码量，差距也很大。

比如，完成同一个任务，C语言要写1000行代码，Java只需要写100行，而Python可能只要20行。

所以Python是一种相当高级的语言。

你也许会问，代码少还不好？代码少的代价是运行速度慢，C程序运行1秒钟，Java程序可能需要2秒，而Python程序可能就需要10秒。

那是不是越低级的程序越难学，越高级的程序越简单？表面上来说，是的，但是，在非常高的抽象计算中，高级的Python程序设计也是非常难学的，所以，高级程序语言不等于简单。

但是，对于初学者和完成普通任务，Python语言是非常简单易用的。连Google都在大规模使用Python，你就不用担心学了会没用。

用Python可以做什么？可以做日常任务，比如自动备份你的MP3；可以做网站，很多著名的网站包括YouTube就是Python写的；可以做网络游戏的后台，很多在线游戏的后台都是Python开发的。总之就是能干很多很多事啦。

Python当然也有不能干的事情，比如写操作系统，这个只能用C语言写；写手机应用，只能用Swift/Objective-C（针对iPhone）和Java（针对Android）；写3D游戏，最好用C或C++。

本篇教程将讲述Python基础的数据类型

# 基本的数据类型

​

在Python中，能够直接处理的数据类型有以下几种：

​

## 整数

​

Python可以处理任意大小的整数，包括负整数，写程序的时候表述与数学上的方法一样，例如：<font color=#0099ff>99</font>，<font color=#0099ff>-3</font>，<font color=#0099ff>6666</font> 等等。

​

## 浮点数 

​

浮点数也可以称为小数。叫做浮点数是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的。比如，<font color=#0099ff>1.11x10<sup>6</sup></font>和<font color=#0099ff>11.1x10<sup>5</sup></font>是完全相等的。对于很大或很小的浮点数，必须用科学计数法表示，把10用e替代，<font color=#0099ff>1.11x10<sup>6</sup></font>就是<font color=#0099ff>1.11e6</font>，或者<font color=#0099ff>11.1e5</font>，<font color=#0099ff>0.0000011</font>可以写成<font color=#0099ff>1.1e-6</font>。负数的话直接在前面加负号即可，例如：<font color=#0099ff>-1.1e-6</font>。

​

**需要注意的一点是，整数和浮点数在计算机内部存储的方式是不同的，<font color=red>整数</font>之间的运算永远是精确的，而<font color=red>浮点数</font>运算则可能会有四舍五入的误差。**

​

## 字符串 

​

字符串是以单引号<font color=#0099ff> ' </font>或双引号<font color=#0099ff> " </font>括起来的任意文本<font color=#0099ff>' '</font>或<font color=#0099ff>" "</font>只是一种表示方式，不是字符串的一部分，所以字符串<font color=#0099ff>'rice'</font>只有<font color=#0099ff>r</font>，<font color=#0099ff>i</font>，<font color=#0099ff>c</font>，<font color=#0099ff>e</font>这4个字符。如果要把<font color=#0099ff>'</font>本身也包括进字符里，那就可以用<font color=#0099ff>" "</font>括起来。如果字符串内部既包含<font color=#0099ff> ' </font>又包含<font color=#0099ff> " </font>怎么办呢？我们可以用转义字符<font color=#0099ff> \ </font>来标识，例如：<font color=#0099ff>'I\'m \"OK\"!'</font>表示的内容为：<font color=#0099ff>I'm "OK"!</font>

​

转义字符<font color=#0099ff>\</font>可以转义很多字符，比如<font color=#0099ff>\n</font>表示换行，<font color=#0099ff>\t</font>表示制表符，字符\本身也要转义，所以<font color=#0099ff>\\</font>表示的字符就是<font color=#0099ff>\</font>，用print()打印字符串看看结果如何：

基本的数据类型¶

在Python中，能够直接处理的数据类型有以下几种：

整数¶

Python可以处理任意大小的整数，包括负整数，写程序的时候表述与数学上的方法一样，例如：99，-3，6666 等等。

浮点数¶

浮点数也可以称为小数。叫做浮点数是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的。比如，1.11x10⁶和11.1x10⁵是完全相等的。对于很大或很小的浮点数，必须用科学计数法表示，把10用e替代，1.11x10⁶就是1.11e6，或者11.1e5，0.0000011可以写成1.1e-6。负数的话直接在前面加负号即可，例如：-1.1e-6。

需要注意的一点是，整数和浮点数在计算机内部存储的方式是不同的，整数之间的运算永远是精确的，而浮点数运算则可能会有四舍五入的误差。

字符串¶

字符串是以单引号 ' 或双引号 " 括起来的任意文本' '或" "只是一种表示方式，不是字符串的一部分，所以字符串'rice'只有r，i，c，e这4个字符。如果要把'本身也包括进字符里，那就可以用" "括起来。如果字符串内部既包含 ' 又包含 " 怎么办呢？我们可以用转义字符 \ 来标识，例如：'I\'m \"OK\"!'表示的内容为：I'm "OK"!

转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\表示的字符就是\，用print()打印字符串看看结果如何：

In [1]:

print('I\'m \"OK\"!')

I'm "OK"!

In [2]:

print('CHINA SECURITIES is\ngreat')

CHINA SECURITIES is
great

In [3]:

print('\\\t\\')

\	

## 布尔值

​

布尔值和布尔代数的表示完全一致，一个布尔值只有<font color=#0099ff>True</font>、<font color=#0099ff>False</font>两种值。Python中，既可以直接用<font color=#0099ff>True</font>、<font color=#0099ff>False</font>表示（<font color=red>一定要大写</font>），也可以通过布尔运算计算出来：

布尔值¶

布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值。Python中，既可以直接用True、False表示（一定要大写），也可以通过布尔运算计算出来：

In [4]:

True

Out[4]:

True

In [5]:

False

Out[5]:

False

In [6]:

1>0

Out[6]:

True

布尔值可以用<font color=#0099ff>and</font>、<font color=#0099ff>or</font>和<font color=#0099ff>not</font>即与、或和非进行运算。

布尔值可以用and、or和not即与、或和非进行运算。

In [7]:

True and False

Out[7]:

False

In [8]:

1 > 2 or 3 < 10

Out[8]:

True

In [9]:

not 3 < 10

Out[9]:

False

## 列表

​

Python内嵌的数据类型主要包括以下两类：

​

### 有序：

​

List（列表），是有序集合，没有固定大小，可以通过对偏移量以及其他方法修改列表大小。列表的基本形式如：[1,2,3,4]

​

Tuple（元组），是有序集合，是不可变的，可以进行组合和复制运算后会生成一个新的元组。元组的基本形式比如：(1,3,6,10)

​

String（字符串），也是有序集合，字符串的基本形式比如：’hello’，这里不进行具体介绍。

​

### 无序：

​

Set（集合），是一个无序不重复元素的集。基本功能包括关系运算和消除重复元素。集合的基本形式如：set('abracadabra')

​

Dictionary（字典）是无序的键：值对 (key:value 对)集合，键必须是互不相同的(在同一个字典之内)。字典的基本形式如：{'jack': 4098, 'sape': 4139}

首先对列表进行介绍。

​

​

List（列表） 是 Python 中最通用的序列。列表是一个任意类型对象位置的相关有序集合，它没有固定大小。不像字符串，其大小是可以变的，通过对偏移量进行赋值以及其他各种列表的方法进行调用，可以修改列表大小。

​

### 索引是从0开始而非1开始！！

​

列表中值的分割用变量[头下标:尾下标]，就可以截取相应的列表，从左到右索引默认“0”开始的，从右到左索引默认-1开始，下标可以为空表示取到头或尾。可以对列表进行索引、切片等操作，看下面例子。

列表¶

Python内嵌的数据类型主要包括以下两类：

有序：¶

List（列表），是有序集合，没有固定大小，可以通过对偏移量以及其他方法修改列表大小。列表的基本形式如：[1,2,3,4]

Tuple（元组），是有序集合，是不可变的，可以进行组合和复制运算后会生成一个新的元组。元组的基本形式比如：(1,3,6,10)

String（字符串），也是有序集合，字符串的基本形式比如：’hello’，这里不进行具体介绍。

无序：¶

Set（集合），是一个无序不重复元素的集。基本功能包括关系运算和消除重复元素。集合的基本形式如：set('abracadabra')

Dictionary（字典）是无序的键：值对 (key:value 对)集合，键必须是互不相同的(在同一个字典之内)。字典的基本形式如：{'jack': 4098, 'sape': 4139} 首先对列表进行介绍。

List（列表） 是 Python 中最通用的序列。列表是一个任意类型对象位置的相关有序集合，它没有固定大小。不像字符串，其大小是可以变的，通过对偏移量进行赋值以及其他各种列表的方法进行调用，可以修改列表大小。

索引是从0开始而非1开始！！¶

列表中值的分割用变量[头下标:尾下标]，就可以截取相应的列表，从左到右索引默认“0”开始的，从右到左索引默认-1开始，下标可以为空表示取到头或尾。可以对列表进行索引、切片等操作，看下面例子。

列出一周5个工作日可以使用list：

列出一周5个工作日可以使用list：

In [10]:

week = ['Monday','Tuesday','Wednesday','Thursday','Friday']

week

Out[10]:

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

week是一个list，可以用len()获取其元素个数：

week是一个list，可以用len()获取其元素个数：

In [11]:

len(week)

Out[11]:

5

可以使用索引来访问list中的每一个位置上的元素，不过一定要记住<font color=red>**索引是从0开始的！！**</font>

可以使用索引来访问list中的每一个位置上的元素，不过一定要记住索引是从0开始的！！

In [12]:

week[0]

Out[12]:

'Monday'

In [13]:

week[3]

Out[13]:

'Thursday'

In [14]:

week[5]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-14-aab97e4d2f9f> in <module>()
----> 1 week[5]

IndexError: list index out of range

当索引超出了范围时，Python会报一个<font color=#0099ff>IndexError</font>错误。由于索引是从<font color=#0099ff>0</font>开始的，最后一个元素的索引是<font color=#0099ff>列表长度 - 1</font>。

​

python支持从列表最后取元素，如果要取最后一个元素，可以用<font color=#0099ff>-1</font>做索引，直接获取最后一个元素：

当索引超出了范围时，Python会报一个IndexError错误。由于索引是从0开始的，最后一个元素的索引是列表长度 - 1。

python支持从列表最后取元素，如果要取最后一个元素，可以用-1做索引，直接获取最后一个元素：

In [15]:

week[-1]

Out[15]:

'Friday'

In [16]:

week[-4]

Out[16]:

'Tuesday'

由于list是一个可变的有序表，所以我们可以往list中追加元素到末尾：

由于list是一个可变的有序表，所以我们可以往list中追加元素到末尾：

In [17]:

week.append('Saturday')

week

Out[17]:

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']

还可以吧元素插入到指定的位置，比如索引号为<font color=#0099ff>6</font>的位置：

还可以吧元素插入到指定的位置，比如索引号为6的位置：

In [18]:

week.insert(6,'Sunday')

week

Out[18]:

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']

删除list末尾的元素，使用<font color=#0099ff>pop()</font>方法：

删除list末尾的元素，使用pop()方法：

In [19]:

week.pop()

week

Out[19]:

['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']

删除list中指定位置的元素，使用<font color=#0099ff>pop(i)</font>方法，<font color=#0099ff>i</font>是对应的索引位置：

删除list中指定位置的元素，使用pop(i)方法，i是对应的索引位置：

In [20]:

week.pop(1)

week

Out[20]:

['Monday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']

把某个元素替换成别的元素，可以直接赋值给对应的索引位置：

把某个元素替换成别的元素，可以直接赋值给对应的索引位置：

In [21]:

week[0] = 'Tuesday'

week

Out[21]:

['Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']

### Python 的列表数据类型包含更多的方法。

​

<font color=#0099ff>list.append(x)</font> 把一个元素添加到列表的结尾。

​

<font color=#0099ff>list.extend(L)</font> 将一个给定列表中的所有元素都添加到另一个列表中。

​

<font color=#0099ff>list.insert(i, x)</font> 在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x)。

​

<font color=#0099ff>list.remove(x)</font> 删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。

​

<font color=#0099ff>list.pop([i])</font> 从列表的指定位置删除元素，并将其返回。如果没有指定索引，a.pop() 返回最后一个元素。元素随即从链表中被删除。(方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，这个经常会在 Python 库参考手册中遇到这样的标记。)

​

<font color=#0099ff>list.index(x)</font> 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。

​

<font color=#0099ff>list.count(x)</font> 返回 x 在链表中出现的次数。

​

<font color=#0099ff>list.sort(cmp=None, key=None, reverse=False)</font> 对列表中的元素进行排序（参数可以用来自定义排序方法，参考 sorted() 的更详细的解释）。

​

<font color=#0099ff>list.reverse()</font> 就地倒排链表中的元素

​

<font color=#0099ff>del list[i] </font>有个方法可以从列表中按给定的索引而不是值来删除一个子项：del 语句。它不同于有返回值的 pop() 方法。语句 del 还可以从列表中删除切片或清空整个列表(我们以前介绍过一个方法是将空列表赋值给列表的切片)。

Python 的列表数据类型包含更多的方法。¶

list.append(x) 把一个元素添加到列表的结尾。

list.extend(L) 将一个给定列表中的所有元素都添加到另一个列表中。

list.insert(i, x) 在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x)。

list.remove(x) 删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。

list.pop([i]) 从列表的指定位置删除元素，并将其返回。如果没有指定索引，a.pop() 返回最后一个元素。元素随即从链表中被删除。(方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，这个经常会在 Python 库参考手册中遇到这样的标记。)

list.index(x) 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。

list.count(x) 返回 x 在链表中出现的次数。

list.sort(cmp=None, key=None, reverse=False) 对列表中的元素进行排序（参数可以用来自定义排序方法，参考 sorted() 的更详细的解释）。

list.reverse() 就地倒排链表中的元素

del list[i] 有个方法可以从列表中按给定的索引而不是值来删除一个子项：del 语句。它不同于有返回值的 pop() 方法。语句 del 还可以从列表中删除切片或清空整个列表(我们以前介绍过一个方法是将空列表赋值给列表的切片)。

## 字典（dictionary）

字典在某些语言中可能称为 联合内存 (associative memories) 或 联合数组 (associative arrays)。序列是以连续的整数为索引，与此不同的是，字典以"关键字"为索引，关键字可以是任意不可变类型，通常用字符串或数值。如果元组中只包含字符串和数字，它可以作为关键字，如果它直接或间接地包含了可变对象，就不能当做关键字。不能用列表做关键字，因为列表可以用索引、切割或者 append() 和 extend() 等方法改变。

​

字典是无序的键：值对 (key:value 对)集合，键必须是互不相同的(在同一个字典之内)。使用大括号创建一个空的字典：{}。初始化列表时，在大括号内放置一组逗号分隔的键：值对，这也是字典输出的方式。

​

字典的主要操作是依据键来存储和取值。也可以用 del 来删除键：值对(key:value)，从一个不存在的键中取值会导致错误。

字典（dictionary）¶

字典在某些语言中可能称为 联合内存 (associative memories) 或 联合数组 (associative arrays)。序列是以连续的整数为索引，与此不同的是，字典以"关键字"为索引，关键字可以是任意不可变类型，通常用字符串或数值。如果元组中只包含字符串和数字，它可以作为关键字，如果它直接或间接地包含了可变对象，就不能当做关键字。不能用列表做关键字，因为列表可以用索引、切割或者 append() 和 extend() 等方法改变。

字典是无序的键：值对 (key:value 对)集合，键必须是互不相同的(在同一个字典之内)。使用大括号创建一个空的字典：{}。初始化列表时，在大括号内放置一组逗号分隔的键：值对，这也是字典输出的方式。

字典的主要操作是依据键来存储和取值。也可以用 del 来删除键：值对(key:value)，从一个不存在的键中取值会导致错误。

In [22]:

d = {'rice':35, 'wheat':101, 'corn':67}

print(d)

print(d['rice'])

{'corn': 67, 'wheat': 101, 'rice': 35}
35

把数据放入dict还可以直接通过key放入：

把数据放入dict还可以直接通过key放入：

In [23]:

d['egg'] = 33

d

Out[23]:

{'corn': 67, 'egg': 33, 'rice': 35, 'wheat': 101}

一个key只能对应一个value，多次对一个key放入value，后面的值会把前面的值冲掉：

一个key只能对应一个value，多次对一个key放入value，后面的值会把前面的值冲掉：

In [24]:

d['corn'] = 88

d

Out[24]:

{'corn': 88, 'egg': 33, 'rice': 35, 'wheat': 101}

如果key不存在，dict就会报错。要避免key不存在的错误，有两种办法，一是通过<font color=#0099ff> in </font>判断key是否存在，二是通过dict提供的<font color=#0099ff> get </font>方法，如果key不存在，可以返回None（返回None的时候Python的交互式命令行不显示结果），或者自己指定的value：

如果key不存在，dict就会报错。要避免key不存在的错误，有两种办法，一是通过 in 判断key是否存在，二是通过dict提供的 get 方法，如果key不存在，可以返回None（返回None的时候Python的交互式命令行不显示结果），或者自己指定的value：

In [25]:

d['meat']

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-25-d3e7ffd8023e> in <module>()
----> 1 d['meat']

KeyError: 'meat'

In [26]:

'meat' in d

Out[26]:

False

In [27]:

d.get('meat')

In [28]:

d.get('meat',45)

Out[28]:

45

删除一个key，使用<font color=#0099ff>pop(key)</font>方法，对应的value也会从dict中删除：

删除一个key，使用pop(key)方法，对应的value也会从dict中删除：

In [29]:

d.pop('rice')

d

Out[29]:

{'corn': 88, 'egg': 33, 'wheat': 101}

有下面几点需要注意：

1. dict内部存放的顺序和key放入的顺序是没有关系的

2. dict查找和插入的速度极快，不会随着key的增加而增加，但是需要占用大量的内存，内存浪费多

3. dict的key必须是<font color=red>**不可变对象**</font>。字符串、整数等都是不可变的，可以放心地作为key，而list是可变的，就不能作为key：

有下面几点需要注意：

1. dict内部存放的顺序和key放入的顺序是没有关系的
2. dict查找和插入的速度极快，不会随着key的增加而增加，但是需要占用大量的内存，内存浪费多
3. dict的key必须是不可变对象。字符串、整数等都是不可变的，可以放心地作为key，而list是可变的，就不能作为key：

In [30]:

k = [3,4,5]

d[k] = 6

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-30-725fccd6cc45> in <module>()
      1 k = [3,4,5]
----> 2 d[k] = 6

TypeError: unhashable type: 'list'

### **常见字典操作方法**  

​

<font color=#0099ff>D.clear()</font> 删除字典内所有元素

​

<font color=#0099ff>D.copy()</font> 返回一个字典的复制

​

<font color=#0099ff>D.fromkeys(seq,val)</font> 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

​

<font color=#0099ff>D.get(key, default=None)</font> 返回指定键的值，如果值不在字典中返回default值

​

<font color=#0099ff>D.has_key(key)</font> 如果键在字典dict里返回true，否则返回false

​

<font color=#0099ff>D.items()</font> 以列表返回可遍历的(键, 值) 元组数组

​

<font color=#0099ff>D.keys()</font> 以列表返回一个字典所有的D.keys()以列表返回一个字典所有的键

​

<font color=#0099ff>D.setdefault(key, default=None) </font> 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

​

<font color=#0099ff>D.update(dict2) </font> 把字典dict2的键/值对更新到dict里

​

<font color=#0099ff>D.values() </font> 以列表返回字典中的所有值

​

<font color=#0099ff>D.pop(key) </font> 删除一个键并返回它的值，类似于列表的pop,只不过删除的是一个键不是一个可选的位置

​

<font color=#0099ff>del D[key] </font> 删除键

​

<font color=#0099ff>D[key] </font> = 42新增或修改键

​

### 字典用法注意事项：

​

1. 序列运算无效，字典元素间是没有顺序的概念

​

2. 对新索引赋值会添加项

​

3. 键不一定总是字符串

​

​

常见字典操作方法¶

D.clear() 删除字典内所有元素

D.copy() 返回一个字典的复制

D.fromkeys(seq,val) 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

D.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值

D.has_key(key) 如果键在字典dict里返回true，否则返回false

D.items() 以列表返回可遍历的(键, 值) 元组数组

D.keys() 以列表返回一个字典所有的D.keys()以列表返回一个字典所有的键

D.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

D.update(dict2) 把字典dict2的键/值对更新到dict里

D.values() 以列表返回字典中的所有值

D.pop(key) 删除一个键并返回它的值，类似于列表的pop,只不过删除的是一个键不是一个可选的位置

del D[key] 删除键

D[key] = 42新增或修改键

字典用法注意事项：¶

1. 序列运算无效，字典元素间是没有顺序的概念

2. 对新索引赋值会添加项

3. 键不一定总是字符串

### 多种构造字典方式

​

<font color=#0099ff>dict()</font> 构造函数可以直接从 key-value 对中创建字典

多种构造字典方式¶

dict() 构造函数可以直接从 key-value 对中创建字典

In [31]:

dict([('john', 4139), ('mike', 4127), ('lucy', 4098)])

Out[31]:

{'john': 4139, 'lucy': 4098, 'mike': 4127}

In [32]:

dict.fromkeys(['a','b'],0) #创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

Out[32]:

{'a': 0, 'b': 0}

In [33]:

dict(zip(['a','b','c'],[1,2,3]))

Out[33]:

{'a': 1, 'b': 2, 'c': 3}

In [34]:

{k:v for (k,v) in zip(['a','b','c'],[1,2,3])}

Out[34]:

{'a': 1, 'b': 2, 'c': 3}

此外，字典推导式可以从任意的键值表达式中创建字典:

此外，字典推导式可以从任意的键值表达式中创建字典:

In [35]:

{x: x**2 for x in (2, 4, 6)}

Out[35]:

{2: 4, 4: 16, 6: 36}

如果关键字都是简单的字符串，有时通过关键字参数指定 key-value 对更为方便:

如果关键字都是简单的字符串，有时通过关键字参数指定 key-value 对更为方便:

In [36]:

D = dict(a=1,b=2,c=3)

D 

Out[36]:

{'a': 1, 'b': 2, 'c': 3}

In [37]:

{c:c*4 for c in 'Zhongxinjiantou'}#默认是集合

Out[37]:

{'Z': 'ZZZZ',
 'a': 'aaaa',
 'g': 'gggg',
 'h': 'hhhh',
 'i': 'iiii',
 'j': 'jjjj',
 'n': 'nnnn',
 'o': 'oooo',
 't': 'tttt',
 'u': 'uuuu',
 'x': 'xxxx'}

In [38]:

{c:c*4 for c in ['Zhongxinjiantou']}

Out[38]:

{'Zhongxinjiantou': 'ZhongxinjiantouZhongxinjiantouZhongxinjiantouZhongxinjiantou'}

In [39]:

{c.lower():c*4+'!' for c in 'Zhongxinjiantou'}

Out[39]:

{'a': 'aaaa!',
 'g': 'gggg!',
 'h': 'hhhh!',
 'i': 'iiii!',
 'j': 'jjjj!',
 'n': 'nnnn!',
 'o': 'oooo!',
 't': 'tttt!',
 'u': 'uuuu!',
 'x': 'xxxx!',
 'z': 'ZZZZ!'}

## 元组（tuple）

元组（tuple）¶

tuple是另一种有序的数据类型，与list比较类似。主要不同的一点是tuple被创建后就不能对其进行修改。所以，tuple与list不同，没有append(),pop(),insert()这些方法可以使用。获取元素的方法和list是一样的，可以通过索引来访问（也是从0开始的），只不过不能赋值成为其他的元素。

​

因为tuple不可变，所以代码更安全。如果可以的话，我们尽量使用tuple代替list。

​

### 创造元组

​

定义一个空的tuple，使用<font color=#0099ff> () </font>：

tuple是另一种有序的数据类型，与list比较类似。主要不同的一点是tuple被创建后就不能对其进行修改。所以，tuple与list不同，没有append(),pop(),insert()这些方法可以使用。获取元素的方法和list是一样的，可以通过索引来访问（也是从0开始的），只不过不能赋值成为其他的元素。

因为tuple不可变，所以代码更安全。如果可以的话，我们尽量使用tuple代替list。

创造元组¶

定义一个空的tuple，使用 () ：

In [40]:

t = ()

t

Out[40]:

()

只有1个元素的元组在进行定义的时候，需要加一个逗号<font color=#0099ff> **,** </font>来消除歧义，否则定义的就不是一个元组而是元素本身：

只有1个元素的元组在进行定义的时候，需要加一个逗号 , 来消除歧义，否则定义的就不是一个元组而是元素本身：

In [41]:

t = (3)

t

Out[41]:

3

In [42]:

t = (3,)

t

Out[42]:

(3,)

### 元组的连接

​

如前面所说，元组是不可改的，但是可以连接

​

可以使用<font color=#0099ff> + </font>对元组进行连接，例如：

元组的连接¶

如前面所说，元组是不可改的，但是可以连接

可以使用 + 对元组进行连接，例如：

In [43]:

t1 = (2,3,5)

t2 = ('Zhongxinjiantou','python')

t3 = t1 + t2

t3

Out[43]:

(2, 3, 5, 'Zhongxinjiantou', 'python')

### 元组的删除

​

元组中的元素不能被删除，但是我们可以使用<font color=#0099ff> del </font>删除整个元组，删除后可以重新定义：

​

元组的删除¶

元组中的元素不能被删除，但是我们可以使用 del 删除整个元组，删除后可以重新定义：

In [44]:

t4 = ('a',2,'b')

t4

Out[44]:

('a', 2, 'b')

In [45]:

del t4

t4

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-45-00422465996d> in <module>()
      1 del t4
----> 2 t4

NameError: name 't4' is not defined

事实上，上面所说的元素不变是指每个元素的指向永远不变。即指向<font color=#0099ff>1</font>，就不能改成指向<font color=#0099ff>2</font>，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的，例如：

事实上，上面所说的元素不变是指每个元素的指向永远不变。即指向1，就不能改成指向2，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的，例如：

In [46]:

tup = (1,2,[3,4,5])

tup

Out[46]:

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

In [47]:

tup[2][0] = 7

tup[2][1] = 11

tup

Out[47]:

(1, 2, [7, 11, 5])

### Python 的元组数据类型包含更多的方法。

​

<font color=#0099ff>tup.index(x, [start, [stop]]))</font> 返回元组中start到stop索引中第一个值为 x 的元素在整个列表中的索引。如果没有匹配的元素就会返回一个错误。

​

<font color=#0099ff>tup.count(x)</font> 返回 x 在元组中出现的次数。

​

<font color=#0099ff>cmp(tuple1, tuple2)</font> 比较元组中两个元素。

​

<font color=#0099ff>len(tuple)</font> 计算元组元素个数。

​

<font color=#0099ff>max(tuple)</font> 返回元组中元素最大值。

​

<font color=#0099ff>min(tuple)</font> 返回元组中元素最小值。

​

<font color=#0099ff>tuple(seq)</font> 将列表转换为元组。

​

<font color=red>元组不提供字符串、列表和字典中的方法。</font> 如果相对元组排序，通常先得将它转换为列表并使其成为一个可变对象，才能获得使用排序方法，或使用sorted内置方法。

Python 的元组数据类型包含更多的方法。¶

tup.index(x, [start, [stop]])) 返回元组中start到stop索引中第一个值为 x 的元素在整个列表中的索引。如果没有匹配的元素就会返回一个错误。

tup.count(x) 返回 x 在元组中出现的次数。

cmp(tuple1, tuple2) 比较元组中两个元素。

len(tuple) 计算元组元素个数。

max(tuple) 返回元组中元素最大值。

min(tuple) 返回元组中元素最小值。

tuple(seq) 将列表转换为元组。

元组不提供字符串、列表和字典中的方法。 如果相对元组排序，通常先得将它转换为列表并使其成为一个可变对象，才能获得使用排序方法，或使用sorted内置方法。

## 集合（set）

​

与dict类似，set也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。创建一个set，需要提供一个list作为输入集合：

集合（set）¶

与dict类似，set也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。创建一个set，需要提供一个list作为输入集合：

In [48]:

s = set([3,4,5])

s

Out[48]:

{3, 4, 5}

重复元素在set中会被自动被过滤，通过<font color=#0099ff>add(key)</font>方法往set中添加元素，重复添加不会有效果，通过<font color=#0099ff>remove(key)</font>方法可以删除元素,例如：

重复元素在set中会被自动被过滤，通过add(key)方法往set中添加元素，重复添加不会有效果，通过remove(key)方法可以删除元素,例如：

In [49]:

s = set([3,3,4,4,5,5,6,6,7])

s

Out[49]:

{3, 4, 5, 6, 7}

In [50]:

s.add(1)

s

Out[50]:

{1, 3, 4, 5, 6, 7}

In [51]:

s.add(1)

s

Out[51]:

{1, 3, 4, 5, 6, 7}

In [52]:

s.remove(5)

s

Out[52]:

{1, 3, 4, 6, 7}

由于set是无序和无重复元素的集合，所以两个set可以做数学意义上的交并集等操作：

由于set是无序和无重复元素的集合，所以两个set可以做数学意义上的交并集等操作：

In [53]:

s1 = set([3,4,5,6])

s2 = set([5,6,7,8,9])

s1 & s2

Out[53]:

{5, 6}

In [54]:

s1 | s2

Out[54]:

{3, 4, 5, 6, 7, 8, 9}

与dict一样，set同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部不会有重复元素。所以把list放入set，会报错。

与dict一样，set同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部不会有重复元素。所以把list放入set，会报错。

In [55]:

s = set([1,2,[1,2]])

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-55-806dee2b7dcf> in <module>()
----> 1 s = set([1,2,[1,2]])

TypeError: unhashable type: 'list'

## 总结

总体而言，几种基础数据类型有相似之处，可根据实际应用场景来选择。

总结¶

总体而言，几种基础数据类型有相似之处，可根据实际应用场景来选择。