中信建投 & 课程

## 什么是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是一种计算机程序设计语言。你可能已经听说过很多种流行的编程语言，比如非常难学的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可以处理任意大小的整数，包括负整数，写程序的时候表述与数学上的方法一样，例如：99，-3，6666 等等。## 浮点数浮点数也可以称为小数。叫做浮点数是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的。比如，1.11x106和11.1x105是完全相等的。对于很大或很小的浮点数，必须用科学计数法表示，把10用e替代，1.11x106就是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()打印字符串看看结果如何：

基本的数据类型

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

整数

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

浮点数

浮点数也可以称为小数。叫做浮点数是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的。比如，1.11x106和11.1x105是完全相等的。对于很大或很小的浮点数，必须用科学计数法表示，把10用e替代，1.11x106就是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 isgreat

In [3]:

print('\\\t\\')

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

布尔值

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

In [4]:

True

Out[4]:

True

In [5]:

False

Out[5]:

False

In [6]:

1>0

Out[6]:

True

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

布尔值可以用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：

In [10]:

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

Out[10]:

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

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

In [11]:

len(week)

Out[11]:

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

可以使用索引来访问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会报一个IndexError错误。由于索引是从0开始的，最后一个元素的索引是列表长度 - 1。python支持从列表最后取元素，如果要取最后一个元素，可以用-1做索引，直接获取最后一个元素：

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

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

In [15]:

week[-1]

Out[15]:

'Friday'

In [16]:

week[-4]

Out[16]:

'Tuesday'

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

In [17]:

week.append('Saturday')week

Out[17]:

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

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

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

In [18]:

week.insert(6,'Sunday')week

Out[18]:

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

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

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

In [19]:

week.pop()week

Out[19]:

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

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

删除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 的列表数据类型包含更多的方法。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 还可以从列表中删除切片或清空整个列表(我们以前介绍过一个方法是将空列表赋值给列表的切片)。

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放入：

In [23]:

d['egg'] = 33d

Out[23]:

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

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

In [24]:

d['corn'] = 88d

Out[24]:

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

如果key不存在，dict就会报错。要避免key不存在的错误，有两种办法，一是通过 in 判断key是否存在，二是通过dict提供的 get 方法，如果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]:

删除一个key，使用pop(key)方法，对应的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必须是**不可变对象**。字符串、整数等都是不可变的，可以放心地作为key，而list是可变的，就不能作为key：

有下面几点需要注意：

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

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

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] = 6TypeError: unhashable type: 'list'

### **常见字典操作方法** D.clear() 删除字典内所有元素D.copy() 返回一个字典的复制D.fromkeys(seq,val) 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值D.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值D.has_key(key) 如果键在字典dict里返回true，否则返回falseD.items() 以列表返回可遍历的(键, 值) 元组数组D.keys() 以列表返回一个字典所有的D.keys()以列表返回一个字典所有的键D.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为defaultD.update(dict2) 把字典dict2的键/值对更新到dict里D.values() 以列表返回字典中的所有值D.pop(key) 删除一个键并返回它的值，类似于列表的pop,只不过删除的是一个键不是一个可选的位置del D[key] 删除键D[key] = 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新增或修改键

字典用法注意事项：

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

对新索引赋值会添加项

键不一定总是字符串

### 多种构造字典方式dict() 构造函数可以直接从 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 对更为方便:

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，使用 () ：

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

创造元组

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

In [40]:

t = ()t

Out[40]:

()

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

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

In [41]:

t = (3)t

Out[41]:

In [42]:

t = (3,)t

Out[42]:

(3,)

### 元组的连接如前面所说，元组是不可改的，但是可以连接可以使用 + 对元组进行连接，例如：

元组的连接

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

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

In [43]:

t1 = (2,3,5)t2 = ('Zhongxinjiantou','python')t3 = t1 + t2t3

Out[43]:

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

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

元组的删除

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

In [44]:

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

Out[44]:

('a', 2, 'b')

In [45]:

del t4t4

---------------------------------------------------------------------------NameError Traceback (most recent call last)<ipython-input-45-00422465996d> in <module>() 1 del t4----> 2 t4NameError: name 't4' is not defined

事实上，上面所说的元素不变是指每个元素的指向永远不变。即指向1，就不能改成指向2，指向一个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] = 7tup[2][1] = 11tup

Out[47]:

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

### 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内置方法。

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

重复元素在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可以做数学意义上的交并集等操作：

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，会报错。

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'

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

总结

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

本站仅提供存储服务，所有内容均由用户发布，如发现有害或侵权内容，请点击举报。