Python中常用的有7种值（数据）的类型及type()语句的用法

0.Python中常用的有7种值（数据）的类型

Python 中的每个值都有一个数据类型。
在 Python 编程中，一切（万物）皆对象，数据类型实际上是类，变量是这些类的实例（对象）。

Python中的数据类型主要有：Number（数字）、Boolean（布尔）、String（字符串）、List（列表）、Tuple（元组）、Dictionary（字典）、Set（集合）。

其中又分为可变数据类型和不可变数据类型，可变数据类型是指可以随着函数的执行发生变化，而不可变数据类型不可以改变

1. 不可变数据类型（3个）：Number（数字）、Boolean（布尔）、String（字符串）、Tuple（元组）
2. 可变数据类型（4个）：List（列表）、Dictionary（字典）、Set（集合）

1. type()语句的使用方式

1. 类型：数字

• int（整型）

• float（浮点型）

• complex（复数）

  Py3.x 去除了 long 类型，现在只有一种整型int，表示为长整型

print(type(111)) # 这是单行注释，整数可以是任何长度，只受到可用内存的限制。```
print(type(111.0)) #浮点数精确到 15 位小数。
print(type(4+3j)) #复数以 x + yj 的形式写成，其中 x 是实部，y 是虚部。
'''
这是多行注释，用三个单引号
'''

>>> i = 2 ** 500  # 2 的 500 次幂
>>> i
3273390607896141870013189696827599152216642046043064789483291368096133796404674554883270092325904157150886684127560071009217256545885393053328527589376
>>> 
>>> f = 0.12345678901234567890
>>> f
0.12345678901234568  # 值被截断
>>> 
>>> c = 5+6j
>>> c
(5+6j)

2. 类型：布尔

print(type(True))

3. 类型：字符串
   字符串是 Unicode 字符的序列。
   可以使用单引号（''）或双引号（""）来表示字符串，多行字符串可以使用三重引号 ‘’’ 或 “”" 来表示。

print(type("湖南"))

>>> s = 'Hello, Python!'  # 单引号
>>> s
'Hello, Python!'
>>> 
>>> s = "Hello, World!"  # 双引号
>>> s
'Hello, World!'
>>> 
>>> s = '''Hello,  # 三重单引号
... Python!'''
>>> s
'Hello,\nPython!'
>>> 
>>> s = """  # 三重双引号
... Hello,
... World!
... """
>>> s
'\nHello,\nWorld!\n'

字符串可以被索引和截取，截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 开始，-1 为从末尾的开始位置。

>>> s = "Hello, World!"
>>>
>>> s[4]  # 第五个字符
'o'
>>>
>>> s[7:10]  # 第八个开始到第十个的字符
'Wor'
>>>
>>> s[-4:-1]  # 倒数第四个开始到倒数第一个的字符
'rld'
>>> s[0:-1]  # 从第1个开始到倒数第一个的字符
''Hello, World''
>>> s[:-1]  # 从第1个开始到倒数第一个的字符（0可省略）
''Hello, World''
>>>
>>> s[5] = 'p'  # 生成错误，字符串是不可变的
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

加号（+）是字符串的连接符， 星号（*） 表示复制当前字符串，紧跟的数字为复制的次数。

>>> s1 = "Hello,"
>>> s2 = " World!"
>>>
>>> s1 + s2  # 连接字符串
'Hello, World!'
>>>
>>> (s1 + s2) * 3  # 复制 3 次字符串
'Hello, World!Hello, World!Hello, World!'

4. 类型：列表
   列表是有序的元素序列，它是 Python 中使用最频繁的数据类型，非常灵活。
   列表中元素的类型可以不同，支持数字、字符串，甚至可以包含列表（所谓的嵌套）。
   列表用[] 标识，内部元素用逗号分隔。

print(type([1,2,3,4,5,6,7]))

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

>>> l = [3, 2, 5, 4, 1]
>>> l
[3, 2, 5, 4, 1]  # 有序
>>> 
>>> l[2]  # 第三个元素
5
>>> 
>>> l[0:3] # 从第一个元素到第三个元素
[3, 2, 5]
>>> 
>>> l[3:] # 从第三个元素开始的所有元素
[4, 1]

列表是可变的，意思是说，列表中元素的值可以被改变。

>>> l = [1, 2, 3]
>>> l[2] = 5  # 将第三个元素 3 变为 5
>>> l
[1, 2, 5]

5. 类型：元组
   元组与列表相同，也是有序序列，唯一的区别是元组是不可变的。
   元组适用于保护性的数据，通常比列表快，因为它不能动态更改。
   元组用() 标识，内部元素用逗号分隔。

print(type((1,2,3,4,5,6,7)))

元组也可以被索引和截取，但是不能被更改。

>>> t = (3, 2, 5, 4, 1)
>>> t
(3, 2, 5, 4, 1)  # 有序
>>> 
>>> t[1]  # 第二个元素
2
>>> 
>>> t[0:2] # 从第一个元素到第二个元素
(3, 2)
>>> 
>>> t[0] = 10  # 生成错误，元组是不可变的
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

虽然元组中的元素不可变，但它可以包含可变的对象，例如：List（列表）。
构造一个空的或者包含一个元素的元组比较特殊，所以要采用一些额外的语法规则：

>>> tup1 = ()  # 空元组
>>> tup2 = (5, )  # 一个元素，需要在元素后添加逗号

6. 类型：集合
   集合是一个无序不重复元素集。
   集合用 {} 标识，内部元素用逗号分隔。
   可以使用大括号 {} 或者 set() 函数创建集合，注意： 要创建一个空集合，必须使用 set() 而不是 {}，因为 {} 用于创建一个空字典。

a={1,2,3,4,5,6,7}
print(type(a))

既然集合是无序的，那么索引就没有任何意义，也就是说，切片操作符 [] 不起作用。

>>> s = {"Java", "Python", "PHP"}
>>> s
{'PHP', 'Python', 'Java'}  # 无序
>>> 
>>> s[1]  # 生成错误，不支持索引
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support indexing

不重复，是指集合中相同的元素会被自动过滤掉，只保留一份。

>>> s = {"PHP", "Python", "Java", "Python", "PHP"}
>>> s
{'PHP', 'Python', 'Java'}  # 去重

除了去重之外，还常用于成员关系的测试。

>>> if ('Python' in s) :
...      print('Python 在集合中')
... else :
...      print('Python 不在集合中')
... 
Python 在集合中

集合之间也可执行运算，例如：并集、差集、交集。

>>> a = set('abcdefg')
>>> b = set('abghijk')
>>> 
>>> a
{'b', 'f', 'e', 'd', 'a', 'c', 'g'}
>>> b
{'b', 'k', 'h', 'i', 'j', 'a', 'g'}
>>> 
>>> a - b  # 差集
{'f', 'c', 'd', 'e'}
>>> 
>>> a | b  # 并集
{'b', 'k', 'f', 'h', 'i', 'e', 'j', 'd', 'a', 'c', 'g'}
>>> 
>>> a & b  # 交集
{'b', 'a', 'g'}
>>> 
>>> a ^ b  # 对称差 - 不同时存在的元素
{'e', 'c', 'k', 'f', 'h', 'i', 'j', 'd'}

对称差公式：A Δ B = (A − B) ∪(B − A)。也可表示为两个集合的并集减去它们的交集：A Δ B = (A ∪B) − (A ∩B)。

7. 类型：字典
   字典是键值对的无序集合。
   通常在有大量的数据时会使用，在检索数据时字典做了优化，必须知道要检索的 value 所对应的 key。
   字典用 {} 标识，其中的每个元素都以 key:value对的形式出现，key 和 value 可以是任何类型。
   注意： 字典中的 key 必须是唯一的。

a={'admin':'pwd'}
print(type(a))

可以用 key 来检索相应的 value，但相反则不行。

>>> d = {}  # 创建空字典
>>> d['name'] = 'Python'  # 增加新的键/值对
>>> d['site'] = 'www.python.org'
>>> 
>>> d
{'name': 'Python', 'site': 'www.python.org'}
>>> 
>>> d['site']  # 键为 'site' 的值
'www.python.org'
>>> 
>>> d['Python']  # 生成错误，不能用 value 检索 key
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Python'

字典有一些内置的函数，例如：keys()、values()、clear() 等。

>>> d.keys()  # 所有键
dict_keys(['name', 'site'])
>>> 
>>> d.values()  # 所有值
dict_values(['Python', 'www.python.org'])
>>> 
>>> d.clear()  # 清空字典
>>> d
{}

2. isinstance()判断一个变量的类型

可以使用type(变量名称)方法，返回变量的数据类型；2.isinstance(变量名称，数据类型)，只能返回True或False

a=111
print(isinstance(a,int))

3.数据类型的转换

可以使用不同的类型转换函数来转换不同的数据类型，例如：int()、float()、str()等。
从 int 转换为 float：

>>> float(5)
5.0

从 float 到 int 的转换，值将会被截断（使其接近零）：

>>> int(10.8)
10
>>> 
>>> int(-10.8)
-10

字符串的转换必须包含兼容的值：

>>> float('2.5')
2.5
>>> 
>>> str(25)
'25'
>>> 
>>> int('str')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'str'

甚至可以将一个序列转换为另一个序列：

>>> set([1, 2, 3])
{1, 2, 3}
>>> 
>>> tuple({4, 5, 6})
(4, 5, 6)
>>> 
>>> list('hello')
['h', 'e', 'l', 'l', 'o']

要转换为字典，每个元素必须是一对：

>>> dict([[1, 'value'], ['key', 2]])
{1: 'value', 'key': 2}