了解数据类型之前，我们首先需要了解python中的变量创建。

0、变量创建

python中不需要为变量指定数据类型，在声明的同时赋值，

比如创建一个整型变量，在Java中：

// 第一步：声明变量类型
int num;
// 第二部：赋值，可以与第一步合并
num = 0;

在python中：

# 无需声明类型，在创建的同时赋值
num = 1

这样的操作可以同一行进行多个，比如：

num1,num2 = 1,1.5

这个技巧用来交换两个数的值非常方便。

>>> a, b = b , a
>>> a
54
>>> b
45

1、基本数据类型

python3中有六个标准的数据类型：

• Number（数字，包括int float bool complex）
• str（字符串）
• list（列表）
• tuple（元组）
• set（集合）
• dict（字典）

1.1、Number

1.1.1、Number类型

python中的数字类型是不可变类型，这意味着如果数字类型的值改变，将重新分配内存空间。每一个不同的值都是一个新的对象。

# 三个不同的数值对象
var1 = 1
var2,var3 = 10,11

# 可以用del语句删除对象引用
del var1
del var2,var3

python3支持的Number类型有：

1. int：整形（python3中int没有大小限制，只受机器内存大小的约束）
2. float：浮点数
3. bool：布尔值（和java中不同，python中的bool可以和数字0、1互转，这点和C类似）
4. complex：复数类型，由实数部分和虚数部分组成，实数部分和虚数部分都是浮点数（有别于Java和js，只有python支持复数）

可以使用type()查看类型、isinstance判断类型：

num1 = 1
print(type(num1))

num2 = 1.0
print(type(num2))

num3 = True
print(type(num3))

num4 = 4+3j
print(type(num4))

print(isinstance(num4, complex))

输出：

<class 'int'>
<class 'float'>
<class 'bool'>
<class 'complex'>
True

type和isinstance的差别：

• type()不会认为子类是一种父类类型。
• isinstance()会认为子类是一种父类类型（和java中的instanceof效果相同）。

1.1.2、基本数值运算

1、加减乘除余乘方

• 运算符 + , – , * , / , % , () 的使用规则大体上和Java一样
• 不同之处在于“/”一定返回float，如果想返回向下取整的int，需要使用“//”
• Python可以使用**实现幂乘方，比如5的2次方：5**2
• 和Java类似，浮点数和整数计算的时候，整数会被转为浮点数进行计算

# 加法
print(5+4)
# 减法
print(5-4)
# 乘法
print(5*4)
# 除法(返回浮点数)
print(5/4)
# 除法(返回整数)
print(5//4)
# 取余
print(5 % 4)
# 乘方
print(5**4)

1.1.3、数字类型转换

在混合运算时，整形会自动转成浮点型，整形和浮点型会自动转为复数。向下转时则需要显示转换：

• int(x) 将x转换为一个整数（x不能是复数）
• float(x) 将x转为一个浮点数（x不能是复数）
• complex(x) 将x转为虚部为0的复数
• complex(x,y) 转为实部为x、虚部为y的复数

1.2、str（字符串）

Python中的字符串用单引号(‘)或双引号(“)括起来（Java中字符串只能用双引号，单引号代表char）。

Python中没有单独的char类型，单字符在Python中也是作为一个字符串使用。但str可以直接作为字符数组使用，比如：

str = 'Runoob'

print(str)          #输出字符
print(str[0:-1])    #输出第一个到倒数第二个字符（[a,b[)包含a不包含b
print(str[0])       #输出字符串的第一个字符
print(str[-1])      #输出字符串的最后一个字符
print(str[2:5])     #输出第3个到第5个字符
print(str[2:])      #输出第3个到最后一个字符
print(str*2)        #输出两遍字符串
print(str+"TEST")  #连接字符串
print(r"asdfa\ndfasdfa")        #加上以后字符串不发生转义

注意：

• 1、反斜杠可以用来转义，要输出反斜杠需要输入”\\”
• 2、如果不想反斜杠发生转义，可以在字符串最前面加上r（或者R）
• 2、字符串可以用+运算符连接在一起，用*运算符重复。
• 3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
• 4、Python中的字符串不能改变，每次改变都会创建新的字符串对象

1.2.1、python转义字符

1.2.2、字符串格式化

Python中支持格式化字符的输出（和C相同）

1.2.3、多行字符串

Python程序中，一行就是一段代码，代码不需要用“；”分隔。如果一行代码想写在多行，可以使用“\”分隔，如果想输入“多行字符串”，则可以使用三引号（或者三单引号）：

a = '''多行字符串
不用转义就可以使用TAB
    不用转义就可以换行
'''
print(a)

1.3、list（列表）

python中的列表由“[]”标识。

且和Java中的List不同，Python中的列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。列表下标从0开始，或者从最后一个元素数，最后一个元素的下表是-1。

和字符串类似，加号（+）用于连接列表，*表示重复操作。

例如：

# 同一个列表中可以包含不同类型的元素
list1 = ['abcd',123412,['asdfa','asdf'],1324123,'asdfa']

# 和字符串的操作类似
print(list1)
print(list1[2])
print(list1[1:-1])
print(list1*2)
# 切片操作第一个值默认为0
print(list1[:-2])
# 切片操作第二个值默认为数组长度
print(list1[-2:])
# 可以将两个list相加（不能加其他类型）
print(list1+list1[2])

# 切片操作中，超出边界的索引会默认自动处理，不会报错
print(list1[:32])
print(list1[-100:])


# 还可以设置切片的步长，下面的2代表每两个取一个
print(list1[0::2])

虽然大多数操作和字符串类似，但是和字符串不同的是：字符串不能被改变，而list中的元素可以被改变。

注意：

• 切片操作，包括list[:]，获取到的是列表对象的浅拷贝。
• 过大的索引取值会报错，比如：

试图使用太大的索引会导致错误：

>>> list1[32]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

• 但是在切片操作中，过大索引则不会报错，一个过大的索引值(即大于列表实际长度)将被列表实际长度所代替，当上边界比下边界大时(即切片左值大于右值)就返回空列表。
• 切片返回的是列表的浅拷贝副本，对切片的操作不会影响原来的列表（改变指针，而不是改变值的情况下），但是有一种特殊的写法需要注意：

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # 替换某些值
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # 现在移除他们
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # 通过替换所有元素为空列表来清空这个列表
>>> letters[:] = []
>>> letters
[]

严格来说，这里并不算真正的切片操作，只是上面代码中赋值运算符左边的这种操作与切片操作形式一样而已。

list1 = ['abcd',123412,['asdfa','asdf'],1324123,'asdfa']

list2 = list1[:-2]
list1[:] = []

list2.append(4)
# 返回[]
print(list1)
# 返回['abcd', 123412, ['asdfa', 'asdf'], 4]
print(list2)

1.4、tuple（元组）

python中的元组由”（）“标识，类似于数组。

Tuple和List类似，不同之处在于：tuple中的元素不能修改，而list中的元素可以被改变。

和List类似，元祖中的元素的类型也可以不同。操作也和字符串类似，实际上字符串可以看作特殊的元组。

# 同一个元组中可以包含不同类型的元素
tuple = ('ansadfa',"asdfasd",2384,1.234,('asdfa',1234),[12341,12341])

print(tuple)
print(tuple[0])
print(tuple[1:3])
print(tuple[2:])
print(tuple*2)
print(tuple+tuple[4])

# 元组声明时可以不带括号
tuple2 = 1,2,3,4,6;

需要注意的是，虽然Tuple不可变，但是和Java中的“不可变”概念类似，其中的元素可能是可变的。比如上面的例子中的tuple包含一个List，这个List是可以改变的。

str、list和tuple都属于sequence（序列）。

注意：

In [34]: t = 1

In [35]: type(t)
Out[35]: int

In [36]: t = (1)

In [37]: type(t)
Out[37]: int

In [38]: t = 1,2

In [39]: type(t)
Out[39]: tuple

In [41]: t = ()

In [42]: type(t)
Out[42]: tuple

In [43]: t = (1,)

In [44]: type(t)
Out[44]: tuple

In [47]: 8 * (8)
Out[47]: 64

In [48]: 8 * (8,)
Out[48]: (8, 8, 8, 8, 8, 8, 8, 8)

• 直接使用t = ()得到是一个tuple，但是使用 t = (1) 得到的是一个int，同时注意，使用 t = (1,)得到的是一个tuple
• 当有多个元素时，可以不用括号声明。比如 t = 1,2,3 和 t = (1,2,3)一样

1.5、set（集合）

set和Java中的Set类似，是一个无序不重复的序列，基础功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

students = {'Tom','Jim',1341,"Tom",'T','o','m'}
students2 = set('Tom')  # 相当于{'T','o','m'}

# 输出集合，重复的元素会被自动去除
print(students)

# 使用in判断元素是否在集合中
if 'Tom' in students:
    print('Tom在集合中')
else :
    print('Tom不在集合中')

# Set可以进行集合运算
print(students - students2)       # 差集
print(students | students2)     # 并集
print(students & students2)     # 交集
print(students ^ students2)     # 不同时存在的元素

1.6、dict（字典）

字典和set都使用”{}”标识。

字典相当于Java中的map结构，是一种映射关系，是一个无序的键():值()对集合。

其中需要注意的是，key必须是不可变类型，比如不可以是list或者set，可以是Number、str或者tuple。

# 空字典
dict1 = {}
# 可以直接向字典添加元素
dict1['one'] = [12,2341,5145]
dict1[2] = "string"

print(dict1)
print(dict1['one'])
print(dict1.keys())     # 得到Key集合
print(dict1.values())   # 得到value集合

# 也可以在创建时指定，用逗号分隔key:value对
dict2 = {'name':'pierre','password':'12354316'}

# 还可以使用构造函数dict()创建，接收一个列表，列表元素为set
dict3 = dict([('a', 1), ('b', 2), ('c', 3)])
print(dict3)

dict4 = {x : x ** 2 for x in (2, 4, 6)}
print(dict4)

dict5 = dict(a=1,b=2,c=3)
print(dict5)