一、标准数据类型

在Python3 中有六个标准的数据类型，分别是：
1、Number（数字）
2、String（字符串）
3、List（列表）
4、Tuple（元组）
5、Sets（集合）
6、Dictionary（字典）

而在Python3 的六个标准数据类型中又可分为以下两大类：
不可变数据（四个）： Number（数字）、String（字符串）、Tuple（元组）、Sets（集合）；
可变数据（两个）： List（列表）、Dictionary（字典）。

二、变量

Python 中的变量不需要事先声明。
每个变量在使用前都必须先赋值，变量赋值以后该变量才会被创建。
变量就是变量，它没有类型，类型是变量所指的内存中对象的类型。
使用=号来给变量进行赋值。
例如：

  1. #!/usr/bin/env
  3. #演示变量的创建
  4. a = 1           #整型变量
  5. b = 1.0         #浮点型变量
  6. c = "xiaoxiao"  #字符串
  8. #输出以上变量的值
  9. print(a)
  10. print(b)
  11. print(c)

输出结果如下：

  1. 1
  2. 1.0
  3. xiaoxiao

三、数据类型 之 Number（数字）

python3 支持的数字类型有 int、float、bool、complex（复数）。
在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
内置的 type() 函数可以用来查询变量所指的对象类型。
例如：

  1. #!/usr/bin/env
  2. i = 1
  4. #输出变量的类型
  5. print(type(i))

还可以使用isinstance()函数判断类型是否符合，例如：

  1. #!/usr/bin/env
  2. i = 1
  4. #判断变量的类型,真输出为True，假输出为False
  5. print(isinstance(i,int))

type()与isinstance()两者的区别：
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。

注意：在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。
在 Python3 中，把 True 和 False 定义成关键字，但它们的值还是 1 和 0，它们可以和数字相加。
del关键字，可以删除对象的引用(删除多个的时候用,逗号分割)，例如：

  1. #!/usr/bin/env
  2. i = 1
  4. print(i)
  5. del i
  6. print(i)

以上代码的第一次输出语句可以成功的被解释，第二次的输出语句会报错，因为使用del关键字把对象的引用给删除了，就会报未定义的错误。

注意：
1、可以同时为多个变量赋值，如a, b = 1, 2。
2、一个变量可以通过赋值指向不同类型的对象。
3、数值的除法包含两个运算符时：一个/返回一个浮点数，两个//返回一个整数。
4、在混合计算时，会把整型转换成为浮点数。

四、数据类型 之 String（字符串）

Python中的字符串用单引号或双引号括起来的，同时使用反斜杠 \ 转义特殊字。

字符串的截取的语法格式如下：
变量[头下标:尾下标]
索引从0 开始，-1 为从末尾的开始位置。

加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，紧跟的数字为复制的次数。
示例代码如下：

  1. #!/usr/bin/env
  2. str = 'xiaoxiao'
  4. print(str)          # 输出字符串
  5. print(str[0:-1])    # 输出第一个到倒数第二个的所有字符
  6. print(str[0])       # 输出字符串第一个字符
  7. print(str[2:5])     # 输出从第三个开始到第五个的字符
  8. print(str[2:])      # 输出从第三个开始的后的所有字符
  9. print(str * 2)      # 输出字符串两次
  10. print(str + "666")  # 连接字符串

输出结果如下：

  1. xiaoxiao
  2. xiaoxia
  3. x
  4. aox
  5. aoxiao
  6. xiaoxiaoxiaoxiao
  7. xiaoxiao666

Python 没有单独的字符类型，一个字符就是长度为1的字符串。
注意：
1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
2、字符串可以用+运算符连接在一起，用*运算符重复。
3、字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
4、字符串不能改变。

五、数据类型 之 List（列表）

Python中的List列表，就像PHP中的数组一样，不过有一些相较不同的特质。
List的索引从0开始，-1 为从末尾的开始位置。
加号 +是列表连接运算符，星号 * 是重复操作，就跟字符串一样。
示例代码如下：

  1. #!/usr/bin/env
  2. list_01 = ['qwer', 123, 12.33, 'xiaoxiao', 60.2]
  3. list_02 = [456, 'xiaoxiao']
  5. print(list_01)               # 输出完整列表
  6. print(list_01[0])            # 输出列表第一个元素
  7. print(list_01[1:3])          # 从第二个开始输出到第三个元素
  8. print(list_01[2:])           # 输出从第三个元素开始的所有元素
  9. print(list_02 * 2)           # 输出两次列表
  10. print(list_01 + list_02)     # 连接列表

输出结果如下：

  1. ['qwer', 123, 12.33, 'xiaoxiao', 60.2]
  2. qwer
  3. [123, 12.33]
  4. [12.33, 'xiaoxiao', 60.2]
  5. [456, 'xiaoxiao', 456, 'xiaoxiao']
  6. ['qwer', 123, 12.33, 'xiaoxiao', 60.2, 456, 'xiaoxiao']

注意：
1、List写在方括号之间，元素用逗号隔开。
2、和字符串一样，List可以被索引和切片。
3、List可以使用+操作符进行拼接。
4、List中的元素是可以改变的。

六、数据类型 之 Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。
我们可以暂且理解为，一个不能改变内部结构的数组。
元组写在小括号 () 里，元素之间用 , 逗号隔开。
例如：

  1. #!/usr/bin/env
  2. tuple_01 = ('qwer', 123, 12.33, 'xiaoxiao', 60.2)
  3. tuple_02 = (456, 'xiaoxiao')
  5. print(tuple_01)               # 输出完整元组
  6. print(tuple_01[0])            # 输出元组第一个元素
  7. print(tuple_01[1:3])          # 从第二个开始输出到第三个元素
  8. print(tuple_01[2:])           # 输出从第三个元素开始的所有元素
  9. print(tuple_02 * 2)           # 输出两次元组
  10. print(tuple_01 + tuple_02)    # 连接元组

输出结果如下：

  1. ('qwer', 123, 12.33, 'xiaoxiao', 60.2)
  2. qwer
  3. (123, 12.33)
  4. (12.33, 'xiaoxiao', 60.2)
  5. (456, 'xiaoxiao', 456, 'xiaoxiao')
  6. ('qwer', 123, 12.33, 'xiaoxiao', 60.2, 456, 'xiaoxiao')

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

  1. #!/usr/bin/env
  2. tuple_01 = ()       #空元组
  3. tuple_02 = (456,)   #一个元素的元组，需要在结尾加上逗号
  5. print(tuple_01)
  6. print(tuple_02)

输出结果如下：

  1. ()
  2. (456,)

string、list和tuple都属于sequence（序列），也就是可使用下标进行序位截取。
注意：
1、与字符串一样，元组的元素不能修改。
2、元组也可以被索引和切片。
3、构造包含0或1个元素的元组的特殊语法规则。
4、元组也可以使用+操作符进行拼接。

七、数据类型 之 Set(集合)

集合（set）是一个无序不重复元素的序列。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，
注意：
创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建语法如下：

  1. param = {value01,value02,...}
  2. 或者
  3. set(value)

例如：

  1. #!/usr/bin/env
  2. #一个手机的集合
  3. phone = {'huawei','xiaomi','vivo','iphone','vivo','oppo'}
  5. print(phone)

输出结果如下，重复的元素会自动去掉（每次运行程序的结果可能会不一致，因为是无序的）

  1. {'vivo', 'oppo', 'xiaomi', 'huawei', 'iphone'}

另一种创建的方式，例如：

  1. #!/usr/bin/env
  2. a = set('abcd')
  3. b = set('cd')
  5. print(a - b)  # a和b的差集
  6. print(a | b)  # a和b的并集
  7. print(a & b)  # a和b的交集
  8. print(a ^ b)  # a和b中不同时存在的元素

输出结果如下：

  1. {'a', 'b'}
  2. {'d', 'a', 'c', 'b'}
  3. {'d', 'c'}
  4. {'a', 'b'}

八、数据类型 之 Dictionary（字典）

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用”{ }“标识，它是一个无序的键(key) : 值(value)对集合。
键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。
上面的解释是不是听得迷迷糊糊的，其实我们可以理解Python中的字典，就是JS中的json对象。
例如：

  1. #!/usr/bin/env
  2. dict = {"name":"xiaoxiao","age":18,"sex":"male"}
  4. print(dict)                 #输出完整的字典
  5. print(dict["name"])         #输出键为name的值
  6. print(dict.keys())          #输出所有的键
  7. print(dict.values())        #输出所有的值

输出结果如下：

  1. {'name': 'xiaoxiao', 'age': 18, 'sex': 'male'}
  2. xiaoxiao
  3. dict_keys(['name', 'age', 'sex'])
  4. dict_values(['xiaoxiao', 18, 'male']

注意：
1、字典是一种映射类型，它的元素是键值对。
2、字典中的键必须为不可变类型，且不能重复。
3、创建空字典使用 { }。

文章努力渲染中，请稍等片刻....