要学习一门语言，首先要看看它的数据类型。由于Python是一门动态语言，所以Python的变量在声明时不需要类型，只要写出名称即可。这里所用的Python版本是目前最新的Python 3.6.1。

数字类型

整数

在Python中只有一种整数类型，类似Java的BigInteger，可以扩展到无限大位。整数字面量可以是十进制、二进制、八进制或十六进制的。数字在输出的时候会以十进制输出，如果希望以其他形式输出，可以使用oct、hex、bin等几个内置函数转换。

在Python中运算符和其他语言类似。比较特殊的是除法，默认的/是小数除，而其他语言中的整除是//。乘方则是**。下面用一点例子来说明。

print('--------------整数类型--------------')
print(f'Integer type:{type(100)}')
print(f'Integer value:{100}')

# 各种进制
decimal = 100
binary_number = 0b1100
octal_number = 0o12374
hexadecimal = 0xcafe

print(f'八进制:{oct(decimal)}')
print(f'十六进制:{hex(decimal)}')
print(f'二进制:{bin(decimal)}')

# 特别的运算符
result = 5 / 3
print(f'/ 是小数除:{result}')
result = 5 // 3
print(f'// 是整除:{result}')
result = 5 ** 3
print(f'**是乘方:{result}')

浮点数

Python中的浮点数，就是遵循IEEE 754的双精度浮点数。浮点数也支持科学计数法。这里没什么说的。

print('--------------浮点数类型--------------')
print(f'Float type:{type(3.14)}')
print(f'Float value:{3.14}')

# 各种小数
float_number = 3.1415
exp_number = 0.31415e1
print(f'float:{exp_number}')

复数

Python还有一个特点，那就是内置了复数的支持。复数字面量使用a+bj来表示。复数的实部和虚部分别用real和imag来取得。

print('--------------复数类型--------------')
complex1 = 1 + 2j
complex2 = 2 + 3j
print('复数类型：', type(complex1))
print('复数：', complex1 + complex2)
print('复数{0}的实部：{1}，虚部是：{2}'.format(complex1, complex1.real, complex1.imag))
print('{0}的共轭复数是：{1}'.format(complex1, complex1.conjugate()))

布尔类型

Python支持布尔类型，真值和假值分别是True和False。

print('--------------布尔类型--------------')

print(f'Bool type:{type(True)}')
print(f'Bool value:{False}')

空类型

Python的空类型类似Java中的void或null。

print('--------------空类型--------------')
print(f'None type:{type(None)}')
print(f'None value:{None}')

字符串

Python字符串可以使用单引号'或双引号"来包括。它们之间没有任何区别。当使用一种引号的时候，字符串内部的另一种引号不需要转义。所以如果字符串内部要包含单引号，那么我们使用双引号包括更好。需要注意，Python字符串是不可变的。

多行字符串使用三个连续的引号来表示。为了美观，多行字符串的第一行往往另起一行，不过这样的话第一行实际上会是个空行。如果希望不要第一行的空行，可以在多行字符串上添加一个反斜杠\。

如果字符串引号前有一个字母r，说明这个字符串是一个原始（raw）字符串，其中的\n这样的字符不会转义，而是以字面量形式输出。

如果字符串引号前有一个字母f，表示这是一个格式化字符串。该字符串中的{variable}将会被实际的变量值所替换。该功能是Python 3.6中新增的。原始字符串和格式化字符串也可以混用。

下面是一些例子。

print('--------------字符串类型--------------')
print(f'String type:{type("")}')
print(f'string value:{"fuck"}')

multiLineString = '''\
这是一个多行字符串
首行的\\表示第一行被忽略
'''
print(multiLineString)

rawString = r"\n不会被转移"
print(f'原始字符串:{rawString}')

formattedString = f"{3.14}"
print(f'格式化字符串:{formattedString}')

列表

列表也是一种内置可变的数据结构，类似Java的List。Python的列表使用也很简单。新建列表需要空的一对方括号[]或者list()来新建一个空列表。列表有很多方法可以操作列表中的元素。直接看例子就行了。

print('--------------列表--------------')
# 新建列表
list1 = []
list2 = list()

# 插入元素
list1.append(1)
list1.append(2)
list1.extend(range(3, 6))
list1.insert(2, 9)

print(f'插入元素 list1:{list1}')

# 删除元素
list1.remove(5)
del list1[2]
print(f'删除元素 list1:{list1}')

# 清除列表
list1.clear()
print(f'清除列表 list1:{list1}')

# 栈操作
list2.append(1)
list2.append(2)
list2.pop()
print(f'list2:{list2}')

元组

元组和列表类似，不过需要注意，元组是不可变的。元组的主要作用就是让函数方便的返回多个值。创建空元组，可以使用()或者tuple()来创建。需要注意假如元组只有一个元素，那么需要在后面添加一个逗号。元组的值也可以方便的解构出来。

print('--------------元组--------------')
print(f'tuple type:{type((5,))}')

tuple1 = ()
tuple1 = tuple()
tuple2 = (1, 2, 3, 4, 5)
tuple3 = (50,)
tuple2 = (5, 6)
a, b = tuple2
print(f'a={a},b={b}')

集合

集合表示不重复的元素组合。要创建集合，只要把元素放到一对花括号中即可。如果需要空集合，不能使用{}，而应该使用set()来创建。如果需要不可变集合，使用frozenset。集合的简单使用列在下面了。

print('--------------集合--------------')
print(f'set type:{type(set())}')

set1 = set()
set2 = {1, 2, 3, 4}

# 添加元素
set1.add(3)
set1.add(4)
set1.add(9)
print(f'set1 :{set1}')

# 删除元素
set1.remove(4)

# 不可变集合
set1 = frozenset(set1)

# 集合操作
print(f'交:{set1 & set2}')
print(f'并:{set1 | set2}')
print(f'差:{set1 - set2}')
print(f'对称差集:{set1 ^ set2}')

字典

字典是键值对的集合，类似于Java中的Map类型。需要注意的是Python的字典的键必须是不可变类型，也就是说键必须是数字、元组、字符串这样的对象才行。由于列表等类型是可变的，所以它们不能用作键。

创建字典使用空花括号对{}或者dict()构造函数。字典也包含了各种方法用于对元素进行操作。值得注意的几个字典的函数：keys()返回键列表；values()返回值列表；items()返回键值对组成的列表。

print('--------------字典--------------')
print(f'dict type:{type({})}')

# 创建字典
dict1 = {}
dict2 = dict()
dict2 = {1: 2, 2: 4, 3: 6}

# 字典操作
dict1[1] = 1
dict1[2] = 2
print(f'dict1:{dict1}')

dict1[2] = 3
print(f'dict1:{dict1}')

del dict1[2]
print(f'dict1:{dict1}')

# 键值集合
print(f'dict2.keys:{dict2.keys()}')
print(f'dict2.values{dict2.values()}')
for k, v in dict2.items():
    print(f"[{k}:{v}]", end=' ')
print()

集合操作

序列类型

前面说的列表、元组、字符串这些都是序列类型。它们支持功能强大的切片操作。切片操作使用切片操作符[:]，会返回对应开闭区间的元素集合。如果只指定了一边的索引，那么另外一边自动扩展到端点处。

索引还可以是负数，表示从后往前数，最后一个元素索引是-1，倒数第二个是-2，以此类推。另外如果索引超出序列范围也不用担心，解释器会忽略多余的长度。

print('--------------序列类型--------------')
longString = 'abcdefghijklnm'

print(f'整个序列:{longString[:]}')
print(f'前5个:{longString[0:5]}')
print(f'后5个:{longString[-6:-1]}')
print(f'前五个之后的所有:{longString[6:]}')
print(f'后五个前面所有的:{longString[:-6]}')
print(f'所有元素:{longString[0:1000]}')

字符串、元组都是不可变的对象。所以它们的切片只能用来读取。如果是列表的话，我们还可以修改切片的值。下面的代码就将列表的一个切片修改为另一个列表。

longList = [1, 2, 2, 3, 4, 56, 6, 7, 8, 9, 0]

print(f'longList:{longList}')
longList[0:3] = [5]
print(f'longList:{longList}')

列表解析

python的列表还支持一种复杂的操作，叫做列表解析。它可以使用一个序列生成另一个列表，灵活使用的话功能非常强大。列表解析需要使用for循环语法。下面是一个将列表转换为平方列表的例子。

squareList = [i * i for i in range(1, 10)]

它与下面的for循环等价，但是写法更简洁。

for i in range(1,10):
    squareList.append(i*i)

Python官方教程上有几个更复杂的例子。例如，列表解析还可以解析多个变量，以及if表达式。

[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]

上面的列表解析表达式与下面的等价。

>>> for x in [1,2,3]:
...     for y in [3,1,4]:
...         if x != y:
...             combs.append((x, y))