[TOC]

1.Python3简单介绍

Python的3.0版本，常被称为Python 3000，或简称Py3k。

Python 语言的广泛性 ：

• Web应用的开发
  服务器端编程，具有丰富的Web开发框架，如Django和TurboGears，快速完成一个网站的开发和Web服务。典型如国内的豆瓣、果壳网等；国外的Google、Dropbox等。

• 系统网络运维
  在运维的工作中，有大量重复性工作的地方，并需要做管理系统、监控系统、发布系统等，将工作自动化起来，提高工作效率，这样的场景Python是一门非常合适的语言。

• 科学与数字计算
  Python被广泛的运用于科学和数字计算中，例如生物信息学、物理、建筑、地理信息系统、图像可视化分析、生命科学等，常用numpy、SciPy、Biopython、SunPy等。

• 3D游戏开发
  Python有很好的3D渲染库和游戏开发框架，有很多使用Python开发的游戏，如迪斯尼卡通城、黑暗之刃。常用PyGame、Pykyra等和一个PyWeek的比赛。

• 图形界面开发
  Python可编写桌面图形用户界面，还可以扩展微软的Windows，常用Tk、GTK+、PyQt、win32等

• 网络编程
  除了网络和互联网的支持，Python还提供了对底层网络的支持，有易于使用的Socket接口和一个异步的网络编程框架Twisted Python

2.Python3安装

在Linux中安装Python3命令，在官网下载 https://www.python.org/downloads/source/

tar -zxvf Python-3.6.1.tgz
cd Python-3.6.1
./configure
make && make install
python3 -V

ipython 是一个 python 的交互式 shell（ i 代表 交互(interaction)），比默认的 python shell 好用得多，支持变量自动补全，自动缩进，支持 bash shell 命令，内置了许多很有用的功能和函数。

Linux 环境还可以使用以下命令安装：
pip install ipython
sudo apt-get install ipython #Ubuntu
yum install ipython  #c entos


环境变量配置：
setenv PATH "$PATH:/usr/local/bin/python"   //csh shell
export PATH="$PATH:/usr/local/bin/python"   // bash shell (Linux) 输入 
PATH="$PATH:/usr/local/bin/python"  //在 sh 或者 ksh shell 输入:
path=%path%;C:\Python   //在 Windows 设置环境变量:

Python 环境变量：

Python环境遍历

运行Python的三种模式

• 交互式解释器与脚本式编程
• 在 Cloud Studio 中运行 Python3 程序（推荐：https://studio.dev.tencent.com/）
• 使用交互式 ipython 运行 Python

以下为Python命令行参数：

Python命令行参数

3.Python3与Python2.X对比

不同点0：采用print输出时候格式不同，Py2 采用 ‘’,而python3智能采用()函数形式

#Py2
print a 

#py3
print(a)

不同点1：`反引号在Python2.x可用使用,Python3被废弃;其中原因之一与单引号容易混淆

>>> a = 1024
>>> b = "weiyigeek"
>>> print( b + a)   #3.x
>>> print b + a     #2.x
# 都会报错 ，解决方法
>>> print b + `a`  #2.x  
Weiyigeek1024        #其实repr与``是一致得能够把结果字符串转化为合法得Python表达式;
>>> print( b + repr(a))   #3.x 同上
>>> print( b + str(a))   #3.x

不同点2：ptthon2中的raw_input()与Python3的input函数功能相同
描述：raw_input函数在py3中已经删除，与input函数合并为一个；

>>> name = raw_input("请输入您的姓名：")  #2.x
请输入您的姓名：WeiyiGeek
>>> print(name)
WeiyiGeek

不同点3：ptthon2中的有cmp比较函数而Python3中是不存在的

#cmp(字符串,字符串) 或者 cmp(int,int) 比较字符串和整形
>>> cmp(1,2)   #前者小于后者返回 -1
-1
>>> cmp("abc","abb")  #前者大于后者返回 1
1
>>> cmp("abc","abc")  #前者等于后者返回 0
0

不同点4：ptthon2与Python3中字符集不同
Python2种容易中文乱码,所有往往使用三种方法进行解决：

#方法1；文件开头声明
# -*- coding:utf-8 -*-

#方法2：
unicode_str = unicode('中文',encoding="utf-8");
print unicode_str.encode('utf-8');

#方法3：打开文件采用codes.open代替open函数；
import codecs
codecs.open('filename',encoding='utf-8');

补充：

#在未指定编码集的适合容易报错
UnicodeDecodeError: 'ascii' codec can't decode byte 0xe4 in position 0: ordinal not in range(128)'

#发现是ascii编码的问题，在自己程序代码前面加上以下几句，即可解决问题：
import sys
reload(sys)
sys.setdefaultencoding('gb18030')

不同点5：python3.5和Python2.7在套接字返回值解码上有区别:
str通过encode()方法可以编码为指定的bytes，反过来如果我们从网络或磁盘上读取了字节流是bytes,把bytes变为str就需要用decode()方法;

#Python3 - encode
>>> "我是一个网络安全从业者".encode('utf-8')
b'\xe6\x88\x91\xe6\x98\xaf\xe4\xb8\x80\xe4\xb8\xaa\xe7\xbd\x91\xe7\xbb\x9c\xe5\xae\x89\xe5\x85\xa8\xe4\xbb\x8e\xe4\xb8\x9a\xe8\x80\x85'
>>> "我是一个网络安全从业者".encode('gbk')
b'\xce\xd2\xca\xc7\xd2\xbb\xb8\xf6\xcd\xf8\xc2\xe7\xb0\xb2\xc8\xab\xb4\xd3\xd2\xb5\xd5\xdf'

#Python3 - decode 
se.decode('gbk')
'我是一个网络安全从业者'
>>> b'\xe6\x88\x91\xe6\x98\xaf\xe4\xb8\x80\xe4\xb8\xaa\xe7\xbd\x91\xe7\xbb\x9c\xe5\xae\x89\xe5\x85\xa8\xe4\xbb\x8e\xe4\xb8\x9a\xe8\x80\x85'.decode('utf-8')
'我是一个网络安全从业者'

不同点6：python3、2有区别pip安装软件的区别

#mysql包的区别
py2：pip install mysql-python
py3：pip install mysqlclient

4.Python3基础语法

4.1 Python中文编码

Python中默认的编码格式是 ASCII 格式，在没修改编码格式时无法正确打印汉字，所以在读取中文时会报错所有代码中包含中文，就需要在头部指定编码。
案例1：Python第一个程序Hello Wrold：

#解决方法：只要在文件开头加入 # -*- coding: UTF-8 -*- 或者 #coding=utf-8 就行了
#!/usr/bin/python3
#coding=utf-8
# -*- coding: UTF-8 -*-
# -*- coding: cp936 -*-
print("Hello World, Python 3.x! 唯一")
print("你好，世界");

Python中文编码

注意事项：
Python3.X 源码文件默认使用utf-8编码，所以可以正常解析中文,无需指定 UTF-8 编码,但在开发得时候需要设置 py 文件存储的格式为 UTF-8，否则会出现类似以下错误信息

4.2 Python基础语法学习

在 Python 中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头，且标识符是区分大小写；

单下划线：以单下划线_foo开头的不能直接访问的类属性，需通过类提供的接口进行访问,不能用 from xxx import * 导入。
双下划线：双下划线开头的 __foo 代表类的私有成员，以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识，如 __init__() 代表类的构造函数。

Python 变量定义：
Python 中的变量不需要声明，每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建；
由于Python是弱类型语言类型属于对象，变量是没有类型的，变量仅仅是一个对象的引用（一个指针）,且一个变量可以通过赋值指向不同类型的对象，比如：
等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值，Python允许你同时为多个变量赋值；当你指定一个值时,Number 对象就会被创建，可以使用 del语句 删除一些对象引用；

a=[1,2,3]
a="Runoob"
#以上代码中，[1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，她仅仅
#是一个对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。

在 python 中，strings, tuples, 和 numbers 是 不可更改的对象，而 list,dict ,set则是 可以修改的对象。

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

案例：Python变量赋值：

#!/usr/bin/python3
# -*- coding:UTF-8 -*-
# 功能：变量的定义与使用

int1 = 23
float1 = 100.0
string = "WeiyiGeek" 
print("姓名：",string,"年龄：",int1, "分数：", float1,end="\n") 

a = b = c = 1   #创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值
print(a,b,c,end="\n") 

a,b,c = 1, 2, "WeiyiGeek"  #两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "runoob" 分配给变量 c。
print(a,b,c,end=" ")

del a,b
print(a,b,c,end=" ")  # 这里会说 a ,b not define （未定义）

Python变量赋值

python 保留字符与函数帮助：
这些保留字不能用作常数或变数，或任何其他标识符名称；内置函数帮助及Python3的输出格式:

>>> 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']
#BIF=built-in functions  
>>>dir(__builtins__)
>>>help(int)
>>>print("string")

Python 中注释：
采用 # ‘’’ “”” 来注释代码，注意除了第一个都是成对使用，在输出函数中也能进行注释输出；

#以下实例我们可以输出函数的注释：
def a():
    '''这是文档字符串'''
    pass
print(a.__doc__)  #   输出结果为：这是文档字符串

Python 行和缩进：
在Python代码块不再像其他语言一样使用{}来控制类，函数以及其他逻辑判断，而是以缩进的方式；
因此，在 Python 的代码块中必须使用相同数目的行首缩进空格数；建议你在每个缩进层次使用 单个制表符 或 两个空格 或 四个空格 , 切记不能混用;
注意事项： 缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。

Python 中空行含义：
函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错；但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构; 记住：空行也是程序代码的一部分。

Python 多行语句：
通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠()来实现多行语句；但是在 [], {}, 或 () 中的多行语句直接使用’,’来分割，不需要使用反斜杠()；
在同一行中使用多条语句，语句之间使用分号(;)分割。

案例：验证多行语句于，输入语句在一行的分割

#!/usr/bin/python3
# -*- coding:UTF-8 -*-
# 功能：验证Python多行语句
one = 1
two = 2
three = 3
add = one +\
    two +\
    three
print("add =",add);print(add);   #输出放在一行使用;分割

Python 模块导入:
在 python 用 import 或者 from…import 来导入相应的模块。

• 将整个模块(somemodule)导入 |import modulename |
• 从某个模块中导入某个函数 | from modulename import function |
• 从某个模块中导入多个函数,格式为 | from modulename import function1,function1 |
• 将某个模块中的全部函数导入 | from somemodule import * |

4.3 Python基础数据类型

Python3 中有六个标准的数据类型：
Number（数字） String（字符串） List（列表） Tuple（元组）Set（集合）Dictionary（字典）

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）

数据类型别名：

• 序列类型：列表/元祖/字符串
• 映射容器：字典（存放对象）

4.3.1 整型(intger)

Python整型数据变量

复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示,复数的实部a和虚部b都是浮点型;
e记法：15e10 => 15*10的10次方 = 150000000000.0;在交互模式中，最后被输出的表达式结果被赋值给变量 _ 。

案例：

>>> price = 113.0625
>>> _ = 0
>>> price + _    #此处， _ 变量应被用户视为只读变量。 
113.0625
>>> round(_, 2)
113.06

#!/usr/bin/python3
# -*- coding:UTF-8 -*-
# 功能：基础数据类型,与输入输出函数的使用

#----integer----#
temp = input("请输入数字：")
print("输入值为 : ",temp, " | 类型:",type(temp))
temp = '5'
number = int(temp)   #将字符转成整数类型
print("字符转换整数 : ",number," | 类型:",type(number))
temp  = True
temp =  4+3j  #复数类型
print("复数:",temp," | 类型:",type(temp),end="\n\n")

Python整型数据变量案例

注意事项：
1)Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。
2)Python3 中，把 True 和 False 定义成关键字了，它们的值还是 1 和 0，它们可以和数字相加。
3)Python3 中，使用十六进制和八进制来代表整数： number = 0xA0F # 十六进制 0o37 # 八进制
4)负数中j可以不分大小写的

4.3.2 字符串(string)

python 中单引号和双引号使用完全相同且字符串 不能被改变，使用三引号(‘’’或”””)可以指定一个多行字符串进行跨行，WYSIWYG（所见即所得）格式；

Python 不支持单字符类型,单字符在 Python 中也是作为一个字符串使用,如 str =’a’ ；字符串中可以包含换行符、制表符以及其他特殊字符。

python 字符串可以用 + 运算符连接在一起，用 * 运算符重复，按字面意义级联字符串，如”this “ “is “ “string”会被自动转换为this is string。

Python 通过索引截取字符串中字符，语法格式如下：变量[头下标:尾下标]（有两种索引方式，从左往右以0开始，从右往左以-1开始）
[:] 截取字符串中的一部分，遵循左闭右开原则，str[0,2] 是不包含第 3 个字符的。

Python字符串索引

Python转义字符:
反斜杠可以用来转义，使用r可以让反斜杠不发生转义， 如 r”this is a line with \n” 则\n会显示，并不是换行。

Python字符串格式化

Python字符串格式化：
基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中，与 C 中 sprintf 函数一样的语法。

Python字符串格式化

Python格式化操作符辅助指令

案例：

#!/usr/bin/python3
#coding:utf-8
#功能：字符串类型详解
##----String-----#
word = '字符串'
sentence = "这是一个句子."
paragraph = """
    这是一个段落，
    可以由多行组成
"""
A = " THIS A"
B = "String !"
C = A + B   #拼接字符串
print(C,end="\n")
print("段落:",paragraph)

#字符串的截取的语法格式如下：变量[头下标:尾下标:步长] 
str1 = '0123456789'
print(str1[0:-1])           # 输出第一个到倒数第二个的所有字符
print(str1[2:5])            # 输出从第三个开始到第五个的字符
print(str1[-2])             # 到数第二个数
print(str1 * 2)             # 输出字符串两次 (关键字 * 重复)
print('数值:' + str1)       # 连接字符串 (关键字 + 拼接)

##----字符转义-----#
print('hello\nWeiyi')     # 使用反斜杠(\)+n转义特殊字符
print(r'c:\\windows')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义

var = "Hello"
print("拼接字符串：\a",var[:5]+" World!")

#原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法
print (r'\n')
print (R'\n')

print("我叫 %s 今年 %d 岁 %#X  数值：%5.3f" % ('小明',10,255,12.85455)) #格式化字符串
print("\u6211\u662f\u6700\u559c\u7231\u0050\u0079\u0074\u0068\u006f\u006e") #unicode 输出

#进制的转换
"%o" % 10   #'12'   || "%#o" % 10  #'0o12'
"%X" % 10    #'A'    || "%#X" % 10  #'0XA'
"%x" % 10    #'a'     ||  "%#x" % 10   #'0xa'

#浮点数格式化
"%5.2f" %27.658  #'27.66'
"%5.2f" %27         #'27.00'
"%f" %27              #float类型,小数点后保留6位数 '27.000000'
"%e" % 10000000   #'1.000000e+07'
"%.2e" % 27.658     #'2.77e+01

"%g" % 28.444455     #智能选择 '28.4445'
"%g" % 28261465     #'2.82615e+07'

"%5d" %5       #'    5'
"%-5d" %5      #'5    ' - 用于左对其
"%+d" % 5      #'+5'  + 用于取正数和负数
"%+d" % -5    #'-5'

"%010d" % 5   #'0000000005'
"%-010d" % 5   #加个负号来个left对其,而这时0不会填充'5    

print('%s' % "I love you")           #格式化字符串 'I love you' (常规方式)

#%f格式化定点数,M.N(M表示最小长度,N表示小数点后的位数?) 推荐方法

'{0:1f}{1}'.format(27.586,"Gb")    # '27.586000Gb'
'{0:.1f}{1}'.format(27.586,"Gb")   # '27.6Gb'  保留小数点后一位数值
"%c %c %c"  %  (97,98,99)         #格式化字符Ascll码转换 'a b c'
'%d + %d = %d' % (4 ,5 ,4+5)   #格式化整数 '4 + 5 = 9'

>>> "{:+.2f} {:+.2f}".format(3.1415926,-1)  #带符号保留小数点后两位
'+3.14 -1.00'
>>> "{:.0f}".format(3.1415926,-1)  #不带小数提取
'3'
>>> "{:0>2d}".format(3)  #补充左边以零补充
'03'
>>> "{:0<2d}".format(3)  #补充右边以零补充
'30'
>>> "{:,}".format(30000000)  #以逗号分割的数字格式
'30,000,000'
>>> "{:.2%}".format(0.2657)  #百分比格式
'26.57%'
>>> "{:.2e}".format(10000000000000)  #指数记发
'1.00e+13'
>>> "{:10d}".format(100)  #右对齐 10个单位的宽度
'       100'
>>> "{:<10d}".format(100) #左对齐
'100       '
>>> "{:^10d}".format(100) #中间对齐
'   100

Python字符串案例

注意事项：

• 在Python2中，普通字符串是以8位ASCII码进行存储的，而在Python3中，所有的字符串都是16位Unicode字符串表示的，使用的语法是在字符串前面加上前缀 u；
• 与 C 字符串不同的是，Python 字符串不能被改变，向一个索引位置赋值，比如word[0] = ‘m’会导致错误。

4.3.3 列表(list)

序列于列表是Python中最基本的数据结构,是使用最频繁的数据类型,可以进行的操作包括索引（从0开始）, 切片（slice组合[start:stop,step]）, 加，乘，检查成员;列表中元素的类型可以不相同（关键是还可以是列表）；可以对Python列表的数据项进行修改或更新；

格式：列表是写在方括号 [] 之间、用逗号分隔开的元素列表，如 变量[头下标:尾下标]，和字符串一样列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

Python列表

重点：列表推导（解析）
列表推导式（List Comprehensions）也叫列表解析，灵感取值函数式编程语言Haskell，它是一个非常有用和灵活的工具，可以用来动态的创建列表。

语法：

[有关A的表达式 for A in B]
如：list1 = list(x**2 for x in range(10))  #[0, 1, 4, 9, 16, 25, 36, 49, 64, 81])

案例1：

#!/usr/bin/python3
#coding:utf-8
#功能:验证列表(LIST)
             #-4 , -3 , -2  , -1   ,0
createlist = [1,1.0,True,"WEIYIGEEK",'c']
pjlist = ['Python','Version 3']
print(createlist) #完整列表

print(createlist[0])   #输出列表第一个元素
print(createlist[1:3])  #从第二个开始输出到第三个元素
print(createlist[-3:]) #从倒数第3个到倒数第一个元素  (特别值得关注输出从倒数第三个元素后的所有元素)
print(pjlist * 2)            # 输出两次列表
print(createlist + pjlist)   # 列表拼接

createlist[0] = 'This is a demo'  #与Python字符串不一样的是，列表中的元素是可以改变的
print(createlist[:]) #完整列表

letters = ['h','e','l','l','o']
print(letters[1:4:2])  #步长实验 1-e  3-l

Python列表案例1

案例2：

#!/usr/bin/python3
#coding:utf-8
#功能：列表类型详解
#更新列表
L=['Google', 'Runoob', 'Taobao']
print("L[1]列表修改前：",L[1],end=" ")
L[1] = 'Weiyigeek'
print("修改后：",L[1],end="\n")

#删除列表元素
del L[2]
print ("删除L[2]后的列表 : ", L)

#列表长度
print (len(L))

#列表组合
print(L+[1,2,3])

#列表重复
print(L * 2)

#判断是否处于列表中
print('Weiyigeek' in L)

#迭代
for x in range(len(L)):
    print(x,L[x],len(L[x]))

#嵌套列表 类似于二维数组
x = [[1,2,3],['a','b','c']]
print(x[0][1])  #输出2
print(x[1][1])  #输出b#!/usr/bin/python3
#coding:utf-8
#功能：列表类型详解

#V1.创建普通列表
L=['Google', 'Runoob', 'Taobao']

#V2.创建混合列表(嵌套的列表)
mix = [1,'list0',2.3,[1,2,3]]

#V3.创建空列表
empty = []


#更新列表 （也可以交换数组）
print("L[1]列表修改前：",L[1],end=" ")
L[1] = 'Weiyigeek'
print("修改后：",L[1],end="\n")

#删除列表元素
del L[2]
print ("删除L[2]后的列表 : ", L)

#列表长度
print (len(L))

#列表组合
print(L+[1,2,3])

#列表重复
print(L * 2)

#判断是否处于列表中
print('Weiyigeek' in L)

#迭代
for x in range(len(L)):
    print(x,L[x],len(L[x]))

#嵌套列表 类似于二维数组
print(mix[3][1])  #输出2

#补充列表解析
list1 = [(x,y) for x in range(10) for y in range(10) if x % 2 == 0 if y % 2 != 0] #x能整除的2，而y不能整除2进行显示（x.y）
print(list1)
#[(0, 1), (0, 3), (0, 5), (0, 7), (0, 9), (2, 1), (2, 3), (2, 5), (2, 7), (2, 9), (4, 1), (4, 3), (4, 5), (4, 7), (4, 9), (6, 1), (6, 3), (6, 5), (6, 7), (6, 9), (8, 1), (8, 3), (8, 5), (8, 7), (8, 9)]
#等价于下面
list2 = []
for x in range(10):
    for y in range(10):
        if  (x % 2 == 0) & (y % 2 !=0):
            list2.append((x,y))
print(list2)


#列表解析进阶
list1 = ['1.Jost do it','2.一切皆有了能','3.让编程改变世界']
list2 = ['2.李宁','3.鱼C工作室','1.Nick']
list3 = [name+':'+title[2:] for title in list1 for name in list2 if name[0] == title[0]]  #采用列表解析的方式进行 当for循环首字符变例一致的时候输出
print(list3)  #['1.Nick:Jost do it', '2.李宁:一切皆有了能', '3.鱼C工作室:让编程改变世界']

Python列表案例2

注意事项:
1)列表是可以修改里面的元素的值，如 list[0] = ‘This is a demo’ ;
2)Python 列表截取可以接收第三个参数，参数作用是截取的步长以下实例在索引 1 到索引 4 位置并设置为步长为 2（间隔一个位置）来截取字符串；
3)通过赋值得到列表，会 随着父列表的顺序的变化而变化,

4.3.4 元组(tuple)

元组tuple是戴上了 枷锁的列表（与数值/字符串类型一样不能随意对其元素改变），由于列表功能强大，需要进行一定的限制，

格式：元组写在小括号 () 里，元素之间用逗号隔开（也可以直接 tuple = 1,2,3,4 方式）。

我们主要从创建和访问元组，更新和删除一个元组，元组相关的操作符进行学习：
拼接操作符(两边的数据类型要一致)
重复操作符( 8 * (8,))
关系操作符(大于、小于等)
成员操作符([in] [not in])
逻辑操作符(not>and>or)

案例：

#!/usr/bin/python3
#coding:utf-8
#功能:验证Tuple元组 , 元组tuple 戴上了枷锁的列表
tuple1 = ('abc',789,2.23,'WEIYIGEEK',70.2)
pjtuple = ('Python','Version 3.7.2')

print(tuple1[1:3])       #从下标索引为1到下标索引为2的元素打印出来(注意元素的个数 3 -1 = 2)
print(pjtuple * 2)       #重复
print(tuple1 + pjtuple)  #拼接

#构造包含 0 个或 1 个元素的元组比较特殊
tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
print("空元组",tup1)
print("一个元素",tup2)

#功能：元组tuple 戴上了枷锁的列表
tup = (1,2,3,4)  #定义一个元组
temp = 1,2,3,4   #另外一钟方法也能定义一个元组(值得学习)
print("类型：",type(temp))  #类型： <class 'tuple'>
print("tuple创建：",8 * (8,)) #(两种方式必须有逗号)  tuple创建： (8, 8, 8, 8, 8, 8, 8, 8)
print("切片：",temp[1:3])  #切片slice(也可以利用此来拷贝元组) 切片： (2, 3)

temp = ('小明','小经','小陈','小郑')
temp = temp[:2] + ('郑老师',) +temp[2:] #利用切片方式分成两段加入新elements再拼接,注意逗号和类型. #拼接的元组： ('小明', '小经', '郑老师', '小陈', '小郑')
print("拼接的元组：",temp)
del temp #面向对象的编程语言就有回收机制
print(tup * 2)   #(1, 2, 3, 4, 1, 2, 3, 4)
L = ('Google', 'Taobao', 'Runoob')
print("{0} , {1} , {2}".format(L[-1],L[1],L[0]))  #格式化输出元组  Runoob , Taobao , Google


#补充：生成器推导式(genexpr)
e = (i for i in range(10))
next(e)  # 1
next(e)  # 2
next(e)  # 3
next(e)  # 4
next(e)  # 5

for each in e:
    print(each, end = " ")


#补充：实现 1 + 2 + 3 .。。 + 100 = 5050 
Sum = sum( i for i in range(101))
print("Sum =",Sum)  #5050
#####执行结果#####
# 5 6 7 8 9
# Sum = 5050

Python元组案例

注意事项:
1) 虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
2) 注意构造包含 0 或 1 个元素的元组的特殊语法规则,及空元组。
3) 元组/列表/字符串都属于 sequence（序列）都有共同点：通过索引获取元素（支持负数索引），可通过分片的方法得到一个范围内的元素的集合，有很多的共同的操作符如 重复操作符，拼接操作符，成员关系操作符
4) 元组不存在列表推导式,而是生成器推导式 genexpr 之中;

4.3.5 集合(set)

集合（set）是一个无序的不重复元素序列，是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员，基本功能是进行成员关系测试和删除重复元素。

格式：使用大括号 { } 或者 set() 函数创建集合；如 parame = {value01,value02,…} ，set(value);

格式：set1 = {1,2,3,4,5,6}
     set2 = set(1,2,3,4,5,6)

案例：

#!/usr/bin/python3
#coding:utf-8
#功能:验证set 集合 (区分大小写)

student = {"weiyigeek","WEIYIGEEK","陶海鹏","郑老狗","陈挥铭",'WEIYIGEEK'}
print(student) # 输出集合(随机排序)，重复的元素被自动去掉

#成员测试
if 'weiyigeek' in student:
    print("weiyigeek 存在!")
else:
    print("不存在!")

# set 可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

# 下面运算是值得学习的 集合可以进行 差集
print(a - b)     # a 和 b 的差集
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素

#功能：集合set
set1 = {'weiyi','geek',12.345}
set2 = set("Python")
print(type(set1),set1)  #输出无序
print(type(set2),set2)  #输出无序

print(set1 - set2)   #类似列表推导式，同样集合支持集合推导式(Set comprehension)  #{'geek', 'weiyi', 12.345}
a = {x for x in 'abcasdsadsa' if x not in 'abc'}  # 显示 {'d', 's'}字符  , print(a) 集合支持集合推导式(Set comprehension)

tuple1 = (1.1,2.2,3.3,ord('a'))  #必须是同一类型
print(sum(tuple1))               # 6.6

print(sorted([23,56,2,16,96,12,14]))

temp = [23,56,2,16,96,12,14]
print(list(reversed(temp)))

print(list(enumerate([23, 56, 2, 16, 96, 12, 14])))
print((1,2.3,4))

Python集合案例

注意事项:
1) 与列表推导式类似，同样集合支持集合推导式(Set comprehension)
2) 创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

4.3.6 字典数据(dict)

字典是另一种可变容器模型，且可存储任意类型对象，是集合的表亲；字典与集合两者之间的区别 在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，空字典用 { } 标识，它是一个无序的键(key - 必须唯一不能重复) : 值(value - 使用不可变类型) 的集合。
使用构造函数 dict() 可以直接从键值对序列中构建字典，格式如下所示：

dict(([key,value],[key,value])) #创建字典
dict1 = {'name':"weiyigeek",[key,value]}

案例：

#!/usr/bin/python3
#coding:utf-8
#功能:Dictionary 字典类型 是一个 Key与Value,与set集合都使用{}来标识
d = {key1 : value1, key2 : value2 }
d['key1']               /**字典访问方式*/
d['key1] = value   /**字典赋值*/
del d['key1']       /**删除指定字典的键值*/
del d                   /**删除字典**/

createdict = {}
createdict['one'] = "1 - Python3"
createdict['two'] = "2 - Version 3.7.2"
tinydict = {'name':"weiyigeek",'age':21,'love':"Python3 PHP html5 JAVASCRIPT"}

print(createdict)  #输出字典值/value
print(createdict['one']) #输出键为 'one' 的值
print(tinydict.keys()) #输出所有键
print(tinydict.values(),end="\n\n") #输出所有值


#构造函数 dict() 可以直接从键值对序列中构建字典
cdict1 = dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])  #方式1 可迭代对象方式来构造字典
cdict2  = dict(Runoob=1, Google=2, Taobao=3)                  #方式2 传入关键字
cdict3  =  dict((['a',2],['b',3]))                           #方式3 传入内嵌列表
cdict4  = dict(zip(['one', 'two', 'three'], [1, 2, 3]))     #方式4 映射函数方式来构造字典
jiecheng = {x: x**2 for x in (2, 4, 6)}              ##方式5 字典推导式
print(cdict1)
print(cdict2)
print(jiecheng)

#补从字典推导式
>>> x = {i: i % 2 for i in range(10)}   #这里是计算表达式
{0: 0, 1: 1, 2: 0, 3: 1, 4: 0, 5: 1, 6: 0, 7: 1, 8: 0, 9: 1}

>>> y = {i: i % 2 == 0 for i in range(10)}   #这里是条件表达式
{0: True, 1: False, 2: True, 3: False, 4: True, 5: False, 6: True, 7: False, 8: True, 9: False}

Python字典案例

注意事项:
1) 列表是有序的对象集合，字典是无序的对象集合（类似于JSON）
2) 键必须是唯一的，但值则不必 ,值可以取任何数据类型，但键必须是不可变的(字符串，数字或元组)
3) 不允许同一个键出现两次，创建时如果同一个键被赋值两次，后一个值会覆盖前值。
4) 字典也有自己的推导式