本文的文字及图片来源于网络,仅供学习、交流使用,不具有任何商业用途,如有问题请及时联系我们以作处理

在程序设计和编程中，会涉及到各种各样的数据类型，而不同的数据类型变量之间可以进行的运算是不同的。在python中，变量的定义虽然不需要声明数据类型，但是并不意味着数据的存储方式是相同的，python中的数据类型是指变量在内存中的对象的类型。

数据类型

python中主要的数据类型有：

• number
• string
• list
• tuple
• set
• dict
• class

其中class为自定义数据类型，除此之外是标准数据类型。

在标准数据类型中，number，string，tuple为不可变类型，list，dict，set为可变数据。

number

number是一种统称，主要包括int，float，complex，bool。

需要注意的是，在C/C++等语言中，会把int分为short，int，long等类型，但是在python中，只有一种int，此时的int相当于C/C++中的长整型。int类型的最大值可以利用sys得到，float类型的最大值可以则可以通过float函数得到：

1. import sys
2. 
   
3. print(sys.maxsize)
4. print(float('inf'))

结果为：

1. 9223372036854775807
2. inf

上面的结果inf并不是一个字符串，而是一个float类型，可以使用之前提到过的type函数进行验证：

type(float('inf'))

结果为：

float

除了type函数可以查看数据类型之外，还可以使用isinstance函数进行验证：

isinstance(float('inf'),float)

结果为：

True

内建函数isinstance的函数签名为：

isinstance(obj, class_or_tuple, /)

该函数返回值为bool，说明obj是否是类或者子类的一个实例。如果第二个参数是元组的形式，则是判断是否是元组内几种类型的一个，相当于对多个结果进行逻辑或运算。

函数type和isinstance都能够判断对象的类型，但是两者还是有些区别的，主要体现在对类对象的判定上。

1. class A:
2. pass
3. 
   
4. class B(A):
5. pass
6. 
   
7. print(type(A()) == A)
8. print(type(B()) == B)
9. print(type(B()) == A)
10. 
    
11. print(isinstance(A(),A))
12. print(isinstance(B(),A))
13. print(isinstance(B(),B))

结果为：

1. True
2. True
3. False
4. True
5. True
6. True

从上面的结果可以看出：

• type()不会认为子类是一种父类类型
• isinstance()会认为子类是一种父类类型

运算和运算符

number类型之间的所涉及到的运算主要是一些数值计算，分别为：

1. print(5 + 3) # 加法
2. print(5 - 3) # 减法
3. print(5 * 3) # 乘法
4. print(5 / 3) # 除法
5. print(5 // 3) # 整除
6. print(5 % 3) # 取余
7. print(5 ** 3) # 乘方

string

python中的字符串可以用单引号，双引号或者三引号括起来进行定义，对于一些特殊字符可以使用转义字符进行转义。但是三引号和但双引号之间也存在一些差异：

1. a = 'hello world'
2. b = "hello world"
3. c = '''hello
4. world'''
5. d = """hello
6. world"""
7. 
   
8. print(a)
9. print(b)
10. print(c)
11. print(d)

结果为：

1. hello world
2. hello world
3. hello
4. world
5. hello
6. world

从上面的结果可以看出，使用三引号构建的字符串在打印时能够保持原有的格式，可以用来构建多行文本。

随机访问

与C/C++中字符串的随机访问类似，python中的字符串也可以利用[]进行随机访问，但与C/C++中的随机访问仍有区别：

1. s = 'abcdefghijklmnopqrstuvwxyz'
2. print(s[0])
3. print(s[25])
4. print(s[-1])
5. print(s[-26])
6. print(s[0:-1])
7. print(s[0:])
8. print(s[0::2])
9. print(s[-1::-1])
10. 
    
11. print(s + s)
12. print(s * 3)

结果为：

1. a
2. z
3. z
4. a
5. abcdefghijklmnopqrstuvwxy
6. abcdefghijklmnopqrstuvwxyz
7. acegikmoqsuwy
8. zyxwvutsrqponmlkjihgfedcba
9. abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz
10. abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz

从上边的结果可以看出：

• 下标0表示起始字符
• 下标-len也表示起始字符。
• 下标len-1表示末尾字符
• 下标-1也表示末尾字符
• 0:-1不包含末尾字符
• 0:包含末尾字符
• a:b:c的形式中，a表示起始位置，空默认为0，b表示终止位置，空默认为末尾，c表示步长，默认为1，可以借用这种形式实现倒序输出
• + 为字符串连接
• * 为对字符串进行复制

而对于字符串中本身要包含的字符，如果与转义字符的定义发生冲突，则可以在字符串前加上r来消除可能引起的歧义：

1. a = 'age\name'
2. print(a)
3. a = r'age\name'
4. print(a)

结果为：

1. age
2. ame
3. age\name

在本篇文章的开始提到字符串是不能改变的类型，这一点与C/C++类似，在C/C++中，如果定义了字符指针指向一个字符串，那么不能通过下标值的形式进行改变，在python中这样的操作同样是不允许的。

1. a = 'hello'
2. a[1] = '2'

如上边通过[]来修改a的元素值就是不被允许的，因此说python中的字符串是不可变类型。

list

list类似于C/C++中的vector，但是相较于vector有所不同，主要体现在：

• list中元素的数据类型可以不同
• list中元素的类型可以是number，string或者list
• list写在[]之间，元素之间使用逗号分隔
  

1. a = [10,'hello',[10,'hello'],(10,'hello'),{'hello':10,'world':20}]
2. print(a)

结果为：

[10, 'hello', [10, 'hello'], (10, 'hello'), {'hello': 10, 'world': 20}]

随机访问

list中数据的随机访问和string类型是一样的，包括字符串的 + 和 * 操作。

但与string不同，list是可变的类型：

1. a = [10,'hello',[10,'hello'],(10,'hello'),{'hello':10,'world':20}]
2. a[0] = 20
3. print(a)

结果为：

[20, 'hello', [10, 'hello'], (10, 'hello'), {'hello': 10, 'world': 20}]

tuple

tuple与元组类似，但也有所不同：

• tuple写在()中，元素之间用逗号分隔
• tuple中的元素是不可更改的

除此之外，tuple与list的使用方法大致无差。需要注意的是当tuple中只有一个元素时的定义形式：

1. a = (10,'hello')
2. b = (20)
3. c = (20,)
4. 
   
5. print(type(a))
6. print(type(b))
7. print(type(c))

结果为：

1. <class 'tuple'>
2. <class 'int'>
3. <class 'tuple'>

从上边的结果可以看出，当tuple中只存在一个元素时，需要在该元素后多加一个逗号，用来表明这是一个tuple，而不至于被解释成单个变量。

随机访问

tuple中数据的随机访问和string类型是一样的，包括字符串的 + 和 * 操作。

与string类似，tuple是不可变类型，但是这种不可变与string类型的不可变有些许区别：

1. a = (10,'hello',[10,'hello'],(10,'hello'),{'hello':10,'world':20})
2. a[2][0] = 20
3. print(a)

结果为：

(10, 'hello', [20, 'hello'], (10, 'hello'), {'hello': 10, 'world': 20})

从上面的结果可以看出，虽然tuple是不可变类型的，但当tuple中的元素是嵌套的可变数据类型时，又可以改变此嵌套元素的元素。

set

set是由一个或者多个不同的元素构成的，构成set的对象称为元素或成员。

由于set的特性，因此set的基本功能是用来进行成员关系测试或是删除重复元素。set类型的主要特点有：

• set使用{}或者set()函数进行构建
• 创建空set时必须使用set()而不是{}，空的{}创建的是dict
• 创建set的元素可以是嵌套类型，但必须是不可变类型
  

1. a = set([1,2,3,4])
2. b = {1,2,3,4}
3. c = set()
4. d = {}
5. e = {1,'hello',(1,'hello')}
6. 
   
7. print(type(a))
8. print(type(b))
9. print(type(c))
10. print(type(d))
11. print(e)

结果为：

1. <class 'set'>
2. <class 'set'>
3. <class 'set'>
4. <class 'dict'>
5. {1, (1, 'hello'), 'hello'}

运算及运算符

对于set来说，更多的是关注要测试的元素是否在set内，或者是进行set之间的集合运算：

1. a = set([1,2,3,4])
2. 
   
3. print(1 in a) # 在
4. print(5 not in a) # 不在
5. 
   
6. b = {3,4,5,6}
7. print(a - b) # 差集
8. print(a | b) # 并集
9. print(a & b) # 交集
10. print(a ^ b) # 并集-交集

结果为：

1. True
2. True
3. {1, 2}
4. {1, 2, 3, 4, 5, 6}
5. {3, 4}
6. {1, 2, 5, 6}

dict

dict与set和list等有所类似，但也有所不同，主要在于：

• list是有序的对象集合，dict则是无序的对象集合
• dict中的元素存储是通过key-value对来存储的，而不是类似于线性存储中的偏移存取的
• dict使用{}标识
• key必须是不可变类型
• key必须唯一
  

1. a = {}
2. a[1] = 'jack'
3. a['tom'] = 10
4. print(a)
5. 
   
6. a[1] = 'jane'
7. a['tom'] = 'jim'
8. print(a)
9. 
   
10. print(a.keys())
11. print(a.values())

结果为：

1. {1: 'jack', 'tom': 10}
2. {1: 'jane', 'tom': 'jim'}
3. dict_keys([1, 'tom'])
4. dict_values(['jane', 'jim'])

同时也可以通过dict()函数来进行dict类型的创建：

1. a = dict([[1,'hello'],['10',30]])
2. b = dict(tom = 'hello',jack = 30)
3. 
   
4. print(a)
5. print(b)

结果为：

1. {1: 'hello', '10': 30}
2. {'tom': 'hello', 'jack': 30}

只是如果要使用第二种类型构建dict类型的话，key类型不能为number，string等表达式，需要使用符合命名规范的变量名。

class

class类型此处不做介绍，在后期面向对象的时候会提到。

数据类型转换

既然提到数据类型，当然也会有数据类型的转换，python种内置了几种函数，用来进行各种数据类型之间的转换。

私信小编01即可获取大量Python学习资料