文章来自这位大佬，但是他目前不用CSDN，也没有发布这篇文章

转载请注明出处

Python 越来越火爆

Python 在诞生之初，因为其功能不好，运转功率低，不支持多核，根本没有并发性可言，在计算功能不那么好的年代，一直没有火爆起来，甚至很多人根本不知道有这门语言。

随着时代的发展，物理硬件功能不断提高，而软件的复杂性也不断增大，开发效率越来越被企业重视。因此就有了不一样的声音，在软件开发的初始阶段，性能并没有开发效率重要，没必然为了节省不到 1ms 的时间却让开发量增加好几倍，这样划不过来。也就是开发效率比机器效率更为重要，那么 Python 就逐渐得到越来越多开发者的亲睐了。

在 12-14 年，云计算升温，大量创业公司和互联网巨头挤进云计算领域，而最著名的云核算开源渠道 OpenStack 就是基于 Python 开发的。

随后几年的备受关注的人工智能，机器学习首选开发语言也是 Python。

至此，Python 已经成为互联网开发的焦点。在「Top 10 的编程语言走势图」可以看到，Python 已经跃居第三位，而且在 2017 年还成为了最受欢迎的语言。

Python 开发薪资高

Python 开发人员是收入最高的开发人员之一，特别是在数据科学，机器学习和 Web 开发方面。

在北上广深一线城市上，Python 开发的薪资都达到了 2w+ 。

Python 容易入门且功能强大

如果你是一名初学者，学习 Python 就是你最好的选择，因为它容易学，功能强大，很容易就能构建 Web 应用，非常适合初学者作为入门的开发语言。

Python 还一度被爆纳入高考，收编到小学课本。

如果你有一定的编程语言基础，学习 Python 也是不错的选择，因为 Python 很可能就是未来开发的主流方向，多学一门语言，多一个防身技能。而且 Python 有强大的功能库，能非常快速的开发工具，为你的本职开发工作提供护航。

一、Python 简介

Python 是著名的“龟叔” Guido van Rossum 在 1989 年圣诞节期间，为了打发无聊的圣诞节而编写的一个编程语言。牛人就是牛人，为了打发无聊时间竟然写了一个这么牛皮的编程语言。

现在，全世界差不多有 600 多种编程语言，但流行的编程语言也就那么 20 来种。不知道你有没有听说过 TIOBE 排行榜。

这是 2017 年 2 月编程语言排行榜 TOP20 榜单：

还有就是 Top 10 编程语言 TIOBE 指数走势：

总的来说，这几种编程语言各有千秋，但不难看出，最近几年 Python 的发展非常的快，特别最近流行的机器学习，数据分析，更让 python 快速的发展起来。

Python 是高级编程语言，它有一个特点就是能快速的开发。Python 为我们提供了非常完善的基础代码库，覆盖了网络、文件、GUI、数据库、文本等大量内容，被形象地称作“内置电池（batteries included）”。用 Python 开发，许多功能不必从零编写，直接使用现成的即可。而且 Python 还能开发网站，多大型网站就是用 Python 开发的，例如 YouTube、Instagram，还有国内的豆瓣。很多大公司，包括 Google、Yahoo 等，甚至 NASA（美国航空航天局）都大量地使用 Python。

当然，任何编程语言有有点，也有缺点，Python 也不例外。那么 Python 有哪些缺点呢？

第一个缺点就是运行速度慢，和C程序相比非常慢，因为Python是_解释型语言_，你的代码在执行时会一行一行地翻译成CPU能理解的机器码，这个翻译过程非常耗时，所以很慢。而C程序是运行前直接编译成CPU能执行的机器码，所以非常快。

第二个缺点就是代码不能加密。如果要发布你的 Python 程序，实际上就是发布源代码。像 JAVA , C 这些编译型的语言，都没有这个问题，而解释型的语言，则必须把源码发布出去。

解释型语言和编译型语言

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Nou1P87t-1603023951181)(C:\Users\ASUS\Desktop\1-1912311J415L7.gif)]

二、Python 的安装

因为 Python 是跨平台的，它可以运行在 Windows、Mac 和各种 Linux/Unix 系统上。目前，Python 有两个版本，一个是 2.x 版，一个是 3.x版，这两个版本是不兼容的。

至于在哪里下载，我建议大家最好直接官网下载，随时下载下来的都是最新版本。官网地址：https://www.python.org/

1、windows 系统下安装配置

如果是 windows 系统，下载完后，直接安装，不过这里记得勾上Add Python 3.6 to PATH，然后点 「Install Now」 即可完成安装。

这里要注意了，记得把「Add Python 3.6 to Path」勾上，勾上之后就不需要自己配置环境变量了，如果没勾上，就要自己手动配置。

如果你一时手快，忘记了勾上 「Add Python 3.6 to Path」，那也不要紧，只需要手动配置一下环境变量就好了。

在命令提示框中 cmd 上输入 ：

path=%path%;C:\Python 

特别特别注意： C:\Python 是 Python 的安装目录，如果你的安装目录是其他地方，就得填上你对应的目录。

安装完成后，打开命令提示符窗口，敲入 python 后，出现下面的情况，证明 Python 安装成功了。

而你看到提示符 >>> 就表示我们已经在 Python 交互式环境中了，可以输入任何 Python 代码，回车后会立刻得到执行结果。

2、Mac 系统下安装配置

MAC 系统一般都自带有 Python2.x 版本的环境，不过现在都不用 2.x 的版本了，所以建议你在 https://www.python.org/downloads/mac-osx/ 上下载最新版安装。

安装完成之后，如何配置环境变量呢？

先查看当前环境变量：

echo $PATH

然后打开 ~/.bash_profile(没有请新建)

vi ~/.bash_profile

我装的是 Python3.7 ，Python 执行路径为：/Library/Frameworks/Python. Framework/Versions/3.7/bin 。于是写入

export PATH="/Library/Frameworks/Python. Framework/Versions/3.7/bin:$PATH"

最后保存退出，激活运行一下文件：

source ~/.bash_profile

三、Python 的基础语法

print() 函数

这里先说一下 print() 函数，如果你是新手，可能对函数不太了解，没关系，在这里你只要了解它的组成部分和作用就可以了，后面函数这一块会详细说明的。

print() 函数由两部分构成 ：

1. 指令：print
2. 指令的执行对象，在 print 后面的括号里的内容

而 print() 函数的作用是让计算机把你给它的指令结果，显示在屏幕的终端上。这里的指令就是你在 print() 函数里的内容。

比如在上一章节中，我们的第一个 Python 程序，打印 print('Hello Python')

它的执行流程如下：

1. 向解释器发出指令，打印 ‘Hello Python’
2. 解析器把代码解释为计算器能读懂的机器语言
3. 计算机执行完后就打印结果

可能这里有人会问，为什么要加单引号，直接 print(Hello Python) 不行吗？

如果你写代码过程中，有这样的疑问，直接写一下代码，自己验证一下是最好的。

显然，去掉单引号后，运行结果标红了（报错），证明这是不可以的。

主要是因为这不符合 Python 的语法规则，去掉单引号后， Python 解释器根本没法看懂你写的是什么。

所以就报 SyntaxError: invalid syntax 的错误，意思是：语法错误。说明你的语句不合规则。

Python 语法的简要说明

每种语言都有自己的语法，不管是自然语言（英语，中文）还是计算机编程语言。

Python 也不例外，它也有自己的语法规则，然后编辑器或者解析器根据符合语法的程序代码转换成 CPU 能够执行的机器码，然后执行。

Python 的语法比较简单，采用缩进方式。

如上面的代码截图，以 # 开头的语句是注释，其他每一行都是一个语句，当语句以冒号 : 结尾时，缩进的语句视为代码块。

要注意的是 Python 程序是大小写敏感的，如果写错了大小写，程序会报错。

基本的数据类型和变量

0 、赋值

首先需要明确的是，Python中一切事物皆对象，变量是对对象在内存中的存储和地址的抽象。

什么是对象???

a = "abc"

Python解释器其实顺序干了两件事情：
1、在内存中创建一个字符串“abc”;
2、在内存中创建一个名为“a”的变量，并将“a”指向字符串“abc”(将“abc”的地址保存到“a”中)。
这样我们就能通过操作“a”而改变内存中的“abc”。

执行以下代码

a = "123"
b = a
a = "xyz"

执行第一句Python解释器创建字符串“123”和变量“a”,并把“a”指向“123”。

执行第二句，因为“a”已经存在，并不会创建新的对象，但会创建变量“b”,并把“b”指向“a”指向的字符串“123“。

执行第三句，首先会创建字符串“xyz”，然后把“xyz”的地址赋予“a“(“a”指向字符串“xyz”)。

(拷贝问题)

1、字符串

字符串英文 string ，是 python 中随处可见的数据类型，字符串的识别也非常的简单，就是用「引号」括起来的。

引号包括单引号 ' ' ，双引号 " " 和 三引号 ''' ''' ，比如 'abc' ，"123" 等等。

这里请注意，单引号 '' 或双引号 "" 本身只是一种表示方式，不是字符串的一部分，因此，字符串 'abc' 只有 a，b，c 这 3 个字符。

如果善于思考的你，一定会问？

为什么要有单引号 ' ' ，双引号 " " 和 三引号 ''' ''' 啊，直接定死一个不就好了，搞那么麻烦，那么多规则表达同一个东西干嘛？

对，一般来说一种语法只用一个规则来表示是最好的，竟然现在字符串有三种不同的表示，证明是有原因的。

那么我们先来看下这三种方式，来定义同样内容的字符串，再把它打印出来，看看是怎样的。

打印出来的结果是一样的。

那如果我们的字符串不是 两点水，是 两'点'水 这样呢？

这样就直接报错了。

但是要注意，用单引号 ' ' 不行，用双引号 " " 是可以的。

打印的结果也跟预想的一样：

至于三引号，也是一样的，如果字符串内容里面含有双引号，也是会报同样的错误的。那么这时候你就可以用三引号了。

那么用单引号，双引号定义的字符串就不能表示这样的内容吗？

并不是的，你可以使用转义字符。

比如单引号，你可以使用 \' 来表示，双引号可以使用 \" 来表示。

注意，这里的是反斜杠 \, 不是斜杆 / 。

了解了之后，直接程序测试一下：

运行结果如下：

最后，也提一下， 三引号 ''' ''' 是直接可以分行的。

运行结果：

2、整数

整数英文为 integer 。代码中的整数跟我们平常认识的整数一样，包括正整数、负整数和零，是没有小数点的数字。

Python 可以处理任意大小的整数，例如：1，100，-8080，0，等等。

运行结果：

当然，要注意了，如果数字你用引号括起来了，那就属于字符串，而不属于整数。比如 '100' , 这 100 是字符串，不是整数。

在现实世界中，整数我们通常会做计算，因此代码世界也是一样，整数可以直接加减乘除。

比如：

程序运行结果：

这里提示下大家，看看上面的例子，有没有发现什么？

看下 int4 打印出来的结果，是 0.5 , 是一个小数。

而我们上面对整数的定义是什么？

是没有小数点的数字。

因此 int4 肯定不是整数。

这里我们可以使用 type() 函数来查看下类型。

结果如下：

可以看到 int4 是 float 类型，而 int1 ,int2,int3 都是 int 整数类型。

那么 float 是什么类型呢？

float 是浮点数类型，是我们下面会说到的。

在说浮点数之前，各位可以看下 Python 的算术运算符有哪些，有个印象。

3、浮点数

浮点数的英文名是 float ，是指带小数的数字。

浮点数跟整数有很多类似的地方，但是浮点数是最折磨人的，也是最难让人捉摸透的。

就好比世界级的大佬 Herb Sutter 说的：「世上的人可以分为3类：一种是知道自己不懂浮点运算的；一种是以为自己懂浮点运算的；最后一种是极少的专家级人物，他们想知道自己是否有可能，最终完全理解浮点运算。」

为什么这么说呢？

看下面的例子 ，像整数一样，只是基本的浮点数加法运算。

可是运算结果，对于初学者来说，可能会接受不了。

对于第一个还好，0.55+0.41 等于 0.96 ，运算结果完全一致。可是后面两个，你会发现怎么出现了那么多个零。

这是因为计算机对浮点数的表达本身是不精确的。保存在计算机中的是二进制数，二进制对有些数字不能准确表达，只能非常接近这个数。

所以我们在对浮点数做运算和比较大小的时候要小心。

4、布尔值

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

布尔值可以用 and、or 和 not 运算。

and 运算是与运算，只有所有都为 True，and 运算结果才是 True。

or 运算是或运算，只要其中有一个为 True，or 运算结果就是 True。

not 运算是非运算，它是一个单目运算符，把 True 变成 False，False 变成 True。

5、空值

基本上每种编程语言都有自己的特殊值——空值，在 Python 中，用 None 来表示

空值并不是0或者false!! 他有自己的类型

List（列表）

0、存储结构

链表 数组

1、什么是 List （列表）

List （列表）是 Python 内置的一种数据类型。 它是一种有序的集合，可以随时添加和删除其中的元素。

那为什么要有 List （列表）呢？

我们用一个例子来说明。

现在有一个团队要出去玩，要先报名。如果用我们之前学过的知识，那么就是用一个字符串变量把他们都记录起来。

但是这样太麻烦了，而且也不美观。

在编程中，一定要学会偷懒，避免「重复性工作」。如果有一百个成员，那么你及时是复制粘贴，也会把你写烦。

这时候就可以使用列表了。

就这样，一行代码就可以存放 N 多个名字了。

2、怎么创建 List（列表）

从上面的例子可以分析出，列表的格式是这样的。

其实列表就是用中括号 [] 括起来的数据，里面的每一个数据就叫做元素。每个元素之间使用逗号分隔。

而且列表的数据元素不一定是相同的数据类型。

比如：

list1=['两点水','twowter','liangdianshui',123]

这里有字符串类型，还有整数类型。

我们尝试把他打印出来，看看打印的结果是怎样的。

结果如下：

3、如何访问 List（列表）中的值

就像一开始的例子，我们有时候不需要把全部人员的姓名都打印出来，有时候我们需要知道第 3 个报名的人是谁？前两名报名的是谁？

那么怎么从列表中取出来呢？

换种问法就是，怎么去访问列表中的值？

这时候我们可以通过列表的下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符。

例如：

name = ['一点水', '两点水', '三点水', '四点水', '五点水']# 通过索引来访问列表
print(name[2])
# 通过方括号的形式来截取列表中的数据
print(name[0:2])

输出的结果：

可见，我们需要知道知道 name 这个列表中第三个报名的是谁？只需要用 name[2] 就可以了。

这里你会问，为什么是 2 ，不是 3 呢？

这是因为在编程世界中，都是从 0 开始的，而不是我们生活习惯中从 1 开始。

所以需要知道第三个是谁？

那就是 name[2] 就可以了。

从例子来看，我们还把 name[0:2] 的结果打印出来了。

从打印结果来看，只打印了第一，第二个元素内容。

这里可能会有疑问？

为什么不是打印前三个啊，不是说 2 就是第 3 个吗？

那是因为这是左闭右开区间的。

所以 name[0:2] 的意思就是从第 0 个开始取，取到第 2 个，但是不包含第 2 个。

还是那句话，为了更好的理解，可以多去尝试，多去玩编程。

所以你可以尝试下下面的各种方式：

看看输出的结果：

根据输出的结果和上面讲到的知识，就很容易理解其中的一些用法了。

## 4、怎么去更新 List（列表） ##

还是一开始的例子，我们用代码记录了报名人的名字，那后面可能会有新人加入，也有可能会发现一开始写错名字了，想要修改。

这时候怎么办呢？

这时候可以通过索引对列表的数据项进行修改或更新，也可以使用 append() 方法来添加列表项。

name = ['一点水', '两点水', '三点水', '四点水', '五点水']# 通过索引对列表的数据项进行修改或更新
name[1]='2点水'
print(name)# 使用 append() 方法来添加列表项
name.append('六点水')
print(name)

输出的结果：

5、怎么删除 List（列表） 里面的元素

那既然这样，肯定会有人中途退出的。

那么我们就需要在列表中，把他的名字去掉。

这时候使用 del 语句来删除列表的的元素

name = ['一点水', '两点水', '三点水', '四点水', '五点水']print(name)# 使用 del 语句来删除列表的的元素
del name[3]
print(name)

输出的结果:

你看输出的结果，列表中已经没有了 四点水 这个数据了。证明已经删除成功了。

6、List（列表）运算符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

Python 表达式	结果	描述
len([1, 2, 3])	3	计算元素个数
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
[‘Hi!’] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	复制
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print x,	1 2 3	迭代

7、List （列表）函数&方法

函数&方法	描述
len(list)	列表元素个数
max(list)	返回列表元素最大值
min(list)	返回列表元素最小值
list(seq)	将元组转换为列表
list.append(obj)	在列表末尾添加新的对象
list.count(obj)	统计某个元素在列表中出现的次数
list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)	将对象插入列表
list.pop(obj=list[-1])	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)	移除列表中的一个元素（参数是列表中元素），并且不返回任何值
list.reverse()	反向列表中元素
list.sort([func])	对原列表进行排序

8、实例

最后通过一个例子来熟悉了解 List 的操作

例子：

#-*-coding:utf-8-*-
#-----------------------list的使用----------------------------------# 1.一个产品，需要列出产品的用户，这时候就可以使用一个 list 来表示
user=['liangdianshui','twowater','两点水']
print('1.产品用户')
print(user)# 2.如果需要统计有多少个用户，这时候 len() 函数可以获的 list 里元素的个数
len(user)
print('\n2.统计有多少个用户')
print(len(user))# 3.此时，如果需要知道具体的用户呢？可以用过索引来访问 list 中每一个位置的元素，索引是0从开始的
print('\n3.查看具体的用户')
print(user[0]+','+user[1]+','+user[2])# 4.突然来了一个新的用户，这时我们需要在原有的 list 末尾加一个用户
user.append('茵茵')
print('\n4.在末尾添加新用户')
print(user)# 5.又新增了一个用户，可是这个用户是 VIP 级别的学生，需要放在第一位，可以通过 insert 方法插入到指定的位置
# 注意：插入数据的时候注意是否越界，索引不能超过 len(user)-1
user.insert(0,'VIP用户')
print('\n5.指定位置添加用户')
print(user)# 6.突然发现之前弄错了，“茵茵”就是'VIP用户'，因此，需要删除“茵茵”；pop() 删除 list 末尾的元素
user.pop()
print('\n6.删除末尾用户')
print(user)# 7.过了一段时间，用户“liangdianshui”不玩这个产品，删除了账号
# 因此需要要删除指定位置的元素，用pop(i)方法，其中i是索引位置
user.pop(1)
print('\n7.删除指定位置的list元素')
print(user)# 8.用户“两点水”想修改自己的昵称了
user[2]='三点水'
print('\n8.把某个元素替换成别的元素')
print(user)# 9.单单保存用户昵称好像不够好，最好把账号也放进去
# 这里账号是整数类型，跟昵称的字符串类型不同，不过 list 里面的元素的数据类型是可以不同的
# 而且 list 元素也可以是另一个 list
newUser=[['VIP用户',11111],['twowater',22222],['三点水',33333]]
print('\n9.不同元素类型的list数据')
print(newUser)

拷贝问题)

tuple（元组）

1、什么是元组 （tuple）

上一节刚说了一个有序列表 List ，现在说另一种有序列表叫元组：tuple 。

tuple 和 List 非常类似，但是 tuple 一旦初始化就不能修改。
也就是说元组（tuple）是不可变的，那么不可变是指什么意思呢？

元组（tuple） 不可变是指当你创建了 tuple 时候，它就不能改变了，也就是说它也没有 append()，insert() 这样的方法，但它也有获取某个索引值的方法，但是不能赋值。

那么为什么要有 tuple 呢？

那是因为 tuple 是不可变的，所以代码更安全。

所以建议能用 tuple 代替 list 就尽量用 tuple 。

2、怎样创建元组（tuple）

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

tuple1=('两点水','twowter','liangdianshui',123,456)
tuple2='两点水','twowter','liangdianshui',123,456

创建空元组

tuple3=()

元组中只包含一个元素时，需要在元素后面添加逗号

tuple4=(123,)

如果不加逗号，创建出来的就不是 元组（tuple），而是指 123这个数了。

这是因为括号 () 既可以表示元组（tuple），又可以表示数学公式中的小括号，这就产生了歧义。

所以如果只有一个元素时，你不加逗号，计算机就根本没法识别你是要进行整数或者小数运算还是表示元组。

因此，Python 规定，这种情况下，按小括号进行计算，计算结果自然是 123，而如果你要表示元组的时候，就需要加个逗号。

具体看下图 tuple4 和 tuple5 的输出值

3、如何访问元组（tuple）

元组下标索引也是从 0 开始，元组（tuple）可以使用下标索引来访问元组中的值。

#-*-coding:utf-8-*-tuple1=('两点水','twowter','liangdianshui',123,456)
tuple2='两点水','twowter','liangdianshui',123,456print(tuple1[1])
print(tuple2[0])

输出的结果：

4、修改元组 （tuple）

可能看到这个小标题有人会疑问，上面不是花了一大段来说 tuple 是不可变的吗？

这里怎么又来修改 tuple （元组） 了。

那是因为元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，还有通过修改其他列表的值从而影响 tuple 的值。

具体看下面的这个例子：

#-*-coding:utf-8-*-
list1=[123,456]
tuple1=('两点水','twowater','liangdianshui',list1)
print(tuple1)
list1[0]=789
list1[1]=100
print(tuple1)

输出的结果：

('两点水', 'twowater', 'liangdianshui', [123, 456])
('两点水', 'twowater', 'liangdianshui', [789, 100])

可以看到，两次输出的 tuple 值是变了的。我们看看 tuple1 的存储是怎样的。

可以看到，tuple1 有四个元素，最后一个元素是一个 List ，List 列表里有两个元素。

当我们把 List 列表中的两个元素 124 和 456 修改为 789 和 100 的时候，从输出来的 tuple1 的值来看，好像确实是改变了。

但其实变的不是 tuple 的元素，而是 list 的元素。

tuple 一开始指向的 list 并没有改成别的 list，所以，tuple 所谓的“不变”是说，tuple 的每个元素，指向永远不变。注意是 tupe1 中的第四个元素还是指向原来的 list ，是没有变的，我们修改的只是列表 List 里面的元素。

5、删除 tuple （元组）

tuple 元组中的元素值是不允许删除的，但我们可以使用 del 语句来删除整个元组

#-*-coding:utf-8-*-tuple1=('两点水','twowter','liangdianshui',[123,456])
print(tuple1)
del tuple1

6、tuple （元组）运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
(‘Hi!’,) * 4	(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print(x)	1 2 3	迭代

7、元组内置函数

方法	描述
len(tuple)	计算元组元素个数
max(tuple)	返回元组中元素最大值
min(tuple)	返回元组中元素最小值
tuple(seq)	将列表转换为元组

8、实例

最后跟列表一样，来一个实例，大家也可以多尝试，去把元组的各种玩法玩一遍。

name1 = ('一点水', '两点水', '三点水', '四点水', '五点水')name2 = ('1点水', '2点水', '3点水', '4点水', '5点水')list1 = [1, 2, 3, 4, 5]# 计算元素个数
print(len(name1))
# 连接,两个元组相加
print(name1 + name2)
# 复制元组
print(name1 * 2)
# 元素是否存在 (name1 这个元组中是否含有一点水这个元素)
print('一点水' in name1)
# 元素的最大值
print(max(name2))
# 元素的最小值
print(min(name2))
# 将列表转换为元组
print(tuple(list1))

输出的结果如下：

这里本蒟蒻也写过一篇针对列表list, 元组tuple, 字符串str 的基本操作，有兴趣的可以去瞅瞅：
Python 序列（列表list, 元组tuple, 字符串str）合集

字典(Dictionary)

1、什么是 dict（字典）

上一章节，我们学习了列表（List） 和 元组（tuple） 来表示有序集合。

而我们在讲列表（list）的时候，我们用了列表（list） 来存储用户的姓名。

name = ['一点水', '两点水', '三点水', '四点水', '五点水']

那么如果我们为了方便联系这些童鞋，要把电话号码也添加进去，该怎么做呢？

用 list 可以这样子解决：

name = [['一点水', '131456780001'], ['两点水', '131456780002'], ['三点水', '131456780003'], ['四点水', '131456780004'], ['五点水', '131456780005']]

但是这样很不方便，我们把电话号码记录下来，就是为了有什么事能及时联系上这些童鞋。

如果用列表来存储这些，列表越长，我们查找起来耗时就越长。

这时候就可以用 dict （字典）来表示了，Python 内置了 字典（dict），dict 全称 dictionary，如果学过 Java ，字典就相当于 JAVA 中的 map，使用键-值（key-value）存储，具有极快的查找速度。

name = {'一点水': '131456780001', '两点水': '131456780002', '三点水': '131456780003', '四点水': '131456780004', '五点水': '131456780005'}

2、dict （字典）的创建

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

dict = {key1 : value1, key2 : value2 }

注意：键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的。

创建 dict（字典）实例：

dict1={'liangdianshui':'111111' ,'twowater':'222222' ,'两点水':'333333'}
dict2={'abc':1234,1234:'abc'}

3、访问 dict （字典）

我们知道了怎么创建列表了，回归到一开始提出到的问题，为什么使用字典能让我们很快的找出某个童鞋的电话呢？

name = {'一点水': '131456780001', '两点水': '131456780002', '三点水': '131456780003', '四点水': '131456780004', '五点水': '131456780005'}print(name['两点水'])

输出的结果：

131456780002

可以看到，如果你知道某个人的名字，也就是 key 值， 就能很快的查找到他对应的电话号码，也就是 Value 。

这里需要注意的一点是：如果字典中没有这个键，是会报错的。

4、修改 dict （字典）

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对

#-*-coding:utf-8-*-
dict1={'liangdianshui':'111111' ,'twowater':'222222' ,'两点水':'333333'}
print(dict1)
# 新增一个键值对
dict1['jack']='444444'
print(dict1)
# 修改键值对
dict1['liangdianshui']='555555'
print(dict1)

输出的结果：

{'liangdianshui': '111111', 'twowater': '222222', '两点水': '333333'}
{'liangdianshui': '111111', 'twowater': '222222', '两点水': '333333', 'jack': '444444'}
{'liangdianshui': '555555', 'twowater': '222222', '两点水': '333333', 'jack': '444444'}

5、删除 dict （字典）

通过 del 可以删除 dict （字典）中的某个元素，也能删除 dict （字典）

通过调用 clear() 方法可以清除字典中的所有元素

#-*-coding:utf-8-*-
dict1={'liangdianshui':'111111' ,'twowater':'222222' ,'两点水':'333333'}
print(dict1)
# 通过 key 值，删除对应的元素
del dict1['twowater']
print(dict1)
# 删除字典中的所有元素
dict1.clear()
print(dict1)
# 删除字典
del dict1

输出的结果：

{'liangdianshui': '111111', 'twowater': '222222', '两点水': '333333'}
{'liangdianshui': '111111', '两点水': '333333'}
{}

6、 dict （字典）使用时注意的事项

(1) dict （字典）是不允许一个键创建两次的，但是在创建 dict （字典）的时候如果出现了一个键值赋予了两次，会以最后一次赋予的值为准

例如：

#-*-coding:utf-8-*-
dict1={'liangdianshui':'111111' ,'twowater':'222222' ,'两点水':'333333','twowater':'444444'}
print(dict1)
print(dict1['twowater'])

输出的结果：

{'liangdianshui': '111111', 'twowater': '444444', '两点水': '333333'}
444444

(2) dict （字典）键必须不可变，可是键可以用数字，字符串或元组充当，但是就是不能使用列表

例如：

#-*-coding:utf-8-*-
dict1={'liangdianshui':'111111' ,123:'222222' ,(123,'tom'):'333333','twowater':'444444'}
print(dict1)

输出结果：

{'liangdianshui': '111111', 123: '222222', (123, 'tom'): '333333', 'twowater': '444444'}

(3) dict 内部存放的顺序和 key 放入的顺序是没有任何关系

和 list 比较，dict 有以下几个特点：

• 查找和插入的速度极快，不会随着key的增加而变慢

• 需要占用大量的内存，内存浪费多

而list相反：

• 查找和插入的时间随着元素的增加而增加

• 占用空间小，浪费内存很少

7、dict （字典） 的函数和方法

方法和函数	描述
len(dict)	计算字典元素个数
str(dict)	输出字典可打印的字符串表示
type(variable)	返回输入的变量类型，如果变量是字典就返回字典类型
dict.clear()	删除字典内所有元素
dict.copy()	返回一个字典的浅复制
dict.values()	以列表返回字典中的所有值
popitem()	随机返回并删除字典中的一对键和值
dict.items()	以列表返回可遍历的(键, 值) 元组数组

set

python 的 set 和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素。

set 和 dict 类似，但是 set 不存储 value 值的。

1、set 的创建

创建一个 set，需要提供一个 list 作为输入集合

set1=set([123,456,789])
print(set1)

输出结果：

{456, 123, 789}

传入的参数 [123,456,789] 是一个 list，而显示的 {456, 123, 789} 只是告诉你这个 set 内部有 456, 123, 789 这 3 个元素，显示的顺序跟你参数中的 list 里的元素的顺序是不一致的，这也说明了 set 是无序的。

还有一点，我们观察到输出的结果是在大括号中的，经过之前的学习，可以知道，tuple (元组) 使用小括号，list (列表) 使用方括号, dict (字典) 使用的是大括号，dict 也是无序的，只不过 dict 保存的是 key-value 键值对值，而 set 可以理解为只保存 key 值。

回忆一下，在 dict （字典） 中创建时，有重复的 key ，会被后面的 key-value 值覆盖的，而 重复元素在 set 中自动被过滤的。

set1=set([123,456,789,123,123])
print(set1)

输出的结果：

{456, 123, 789}

2、set 添加元素

通过 add(key) 方法可以添加元素到 set 中，可以重复添加，但不会有效果

set1=set([123,456,789])
print(set1)
set1.add(100)
print(set1)
set1.add(100)
print(set1)

输出结果：

{456, 123, 789}
{456, 123, 100, 789}
{456, 123, 100, 789}

3、set 删除元素

通过 remove(key) 方法可以删除 set 中的元素

set1=set([123,456,789])
print(set1)
set1.remove(456)
print(set1)

输出的结果：

{456, 123, 789}
{123, 789}

4、set 的运用

因为 set 是一个无序不重复元素集，因此，两个 set 可以做数学意义上的 union(并集), intersection(交集), difference(差集) 等操作。

例子：

set1=set('hello')
set2=set(['p','y','y','h','o','n'])
print(set1)
print(set2)# 交集 (求两个 set 集合中相同的元素)
set3=set1 & set2
print('\n交集 set3:')
print(set3)
# 并集 （合并两个 set 集合的元素并去除重复的值）
set4=set1 | set2
print('\n并集 set4:')
print(set4)
# 差集
set5=set1 - set2
set6=set2 - set1
print('\n差集 set5:')
print(set5)
print('\n差集 set6:')
print( set6)# 去除海量列表里重复元素，用 hash 来解决也行，只不过感觉在性能上不是很高，用 set 解决还是很不错的
list1 = [111,222,333,444,111,222,333,444,555,666]  
set7=set(list1)
print('\n去除列表里重复元素 set7:')
print(set7)

运行的结果：

{'h', 'l', 'e', 'o'}
{'h', 'n', 'o', 'y', 'p'}交集 set3:
{'h', 'o'}并集 set4:
{'h', 'p', 'n', 'e', 'o', 'y', 'l'}差集 set5:
{'l', 'e'}差集 set6:
{'p', 'y', 'n'}去除列表里重复元素 set7:
{555, 333, 111, 666, 444, 222}