python中常见内置类型简介

python中常见内置类型简介

根据python官方文档的介绍，python中主要的内置类型包括数值（Numeric），顺序（Sequence），映射（Mappings），类与类的实例对象（Class & Instances）以及异常（exception）。

这里就仅对数值（Numeric），顺序（Sequence），**映射（Mappings）**这三种最常见的的方法作小结

数值类型（Numeric Types）

python中的数值类型主要包括以下三种类型

• integers：对应于int类型
• floating pioint numbers：对应于float类型
• complex numbers：对应于complex类型

其中需要注意的是，Booleans类型是integer类型的一个子类。且python中的float类型对应于C语言中的double类型。通常，数值类型可以直接字面创建活着通过构造器创建，实例代码如下

a=1
b=1.0
a1=int(1)
b1=float(1)
print(type(a))	# <class 'int'>
print(type(b)) 	# <class 'float'>
print(type(a1))	# <class 'int'>
print(type(b1)) 	# <class 'float'>

complex类型则是复数类型，也就是高中所学设计实部和虚部的数，该类型基本不使用，这里便不作赘述

顺序类型（Sequence）

在python中常见顺序类型主要包括三种，分别是list，tuple以及range。还有其他专门为二进制数和文本字符串量身定制的顺序容器这里也不在赘述，有兴趣的同学可以查看bytearray类型和str了解。这里同样仅就最常见的顺序类型作总结。

关于上述三种顺序类型，可将其分为两种，分别是可变类型和不可变类型。顾名思义，评判的标准就是是否能对该类型的数据进行增删改操作。

• 可变类型：可以对该类型的对象实例进行增删改操作，代表类型有``list`
• 不可变类型：不能对该对象实例进行增删改操作，代表类型tuple以及range

List

构造一个list实例对象的方法常见的有如下几种

y = []
y1 = list()
y2 = list
print(y)	# []
print(y1) # []
print(y2) # <class 'list'>

注意看，其中第一第二种方法都可以成功获得list对象，但在打印第三种方法构造出来的对象时返回的却是其类型名。这里在做进一步尝试，请看如下代码

y2 = list
y3 = list
print(y2==y3) # ture

由此可知，如果在调用构造器时，没有加()，则会返回其类型。

有了list对象，接下来就可以对其进行系列增删改操作，这里列举几种常见的增删改操作如下

y1.append(1) # 向y1种增加元素 1
print(y1) # [1]

y1+='2'
# y1+=2 报错
print(y1) #[1,'2'] 

注意：使用+=追加元素时，要求被追加元素应当是可迭代类型，这里int不是可迭代类型，而str是可迭代类型，因此可以使用+=方法。

那么疑问来了，究竟如何判断某个类型是否是可迭代类型呢？这里提供一个方法，使用下属代码方法

from collections import Iterable

print(isinstance(y1, Iterable)) #true

是不是又涨姿势了，以后用+=来秀操作了hhh。

此外，还有一些其他常见操作这里就直接列举了

y1.insert(i,x) #向y1中第[i]个元素的位置出插入元素x
y1.clear() # 	清除y1中所有数据
y1.remove(1) # 清除y1中的元素1
y1.pop([i]) # 取出y1中第[i]个元素，同时将其从容器中移除

Tuple

Tuple是不可变类型，也就是说一旦一个tuple被创建了，其内容就不可变了，官网中给出的构造方法是

class tuple([iterable])

其同样要求传入一个迭代类型来实现tuple的创建，常见使用方法如下

k = (1,2,3)
print(k) # (1,2,3)

k1 = tuple(1) # 报错！1不是迭代类型
k1 = tuple([1]) # 正确

Range

Range类型在for循环中使用最多，官网给出的构造方法有

class range(stop)
class range(start, stop[, step])

这里直接给出官网的例子

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]
>>> list(range(0, 10, 3))
[0, 3, 6, 9]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> list(range(0))
[]
>>> list(range(1, 0))
[]

映射（Mappings）

映射类官方文档给出的就只有dict，也就是字典类型一种。字典类型是可变类型，是一个存放着<k，v>键值对的容器，其有如下几种方法构建

dict(**kwarg)
dict(mapping, **kwarg)
dict(iterable, **kwarg)	# **kwarg表示 key=value的赋值

源码中给出的构造方法有

dict()：创建一个空的字典类型

dict(mapping)：构造方法，参数类型为mapping。

dict(iterable)：构造方法，参数类型为iterable。

dict(**kwargs)：构造方法，参数类型为key=value。

当然除了上述几种方法，也可以组合实现

dict(mapping,**kwargs)：

下面是官方文档给出的实例

>>> a = {'one': 1, 'two': 2, 'three': 3}
>>> b = dict({'three': 3, 'one': 1, 'two': 2})
>>> c = dict([('two', 2), ('one', 1), ('three', 3)])	
>>> d = dict(zip(['one', 'two', 'three'], [1, 2, 3]))	
>>> e = dict(one=1, two=2, three=3)
>>> f = dict({'one': 1, 'three': 3}, two=2)
>>> a == b == c == d == e == f
True

小结：也许大家被上面方法绕晕了，这里稍微来理一下思路，接着往下看，首先字典的创建有两种方法

dict的构建

• 方法1：直接创建<k,y>对，不使用dict关键字。这种方法方便快捷，也经常使用，如

  构造方法1

  >>> a = {'one': 1, 'two': 2, 'three': 3}
  print(isinstance(a, Iterable)) # true
  print(isinstance(a, Mapping)) # true
  

• 同时我们也可以看到，字典类型既是iterable也是mapping

---

• 方法2：使用dict构造方法，通过向内部传参实现字典对象的构造，根据传参内容还可以分为如下几种

  1. 传递mapping类型：代码实例如下：

     构造方法2

     >>> b = dict({'three': 3, 'one': 1, 'two': 2})
     

     • 很明显，这种方法就相当于调用了b=dict(a)，因为a就是mapping类型

     ---

  2. 传递iterable类型：代码实例如下：

     k = [('two', 2), ('one', 1), ('three', 3)]	# list类型
     m = dict(k)
     print(isinstance(k, Iterable)) 	 # true
     print(isinstance(k, Mapping))  	 # false
     print(isinstance(m, Iterable))   # true
     print(isinstance(m, Mapping))	  	# true
     

     • 由此可以发先，除了给dict传入mapping类型的数据外，还可以给其传入iterable型的数据，最典型的就是list和tuple型数据。但是否是任意的list和tuple都可以传呢？接着往下看。

     k = [(1, 2, 1), (2, 3, 4)]
     m = dict(k) # 报错
     

     ValueError: dictionary update sequence element #0 has length 3; 2 is required

     • 由此可知，如果希望向dict中传入iterable类型的数据让其成为mapping，就必须保证传入的数据的元素个数为2，也就是这里要求list中的每个元素的长度都为2。由此可知，如果希望让iterable的数据转换为mapping，最理想的容器是使用list而非tuple。

     构造方法3

     >>> c = dict([('two', 2), ('one', 1), ('three', 3)])	
     

     ---

     • 此外，python中也提供了一个zip工具，帮助实现一维list的二维化，请看如下代码

     z = zip(['one', 'two', 'three'], [1, 2, 3])
     print(z)		# <zip at 0x7fb23119ca40> 
     
     for data in z:
       print(data)		#	('one', 1) ('two', 2) ('three', 3)
     

     • 注意：这里python3以后为了节约内存，这里z封装成了地址，但仍然可以遍历查看zip后的数据。基于结果，很容易得出，经过zip后的数据内容为[('one', 1),('two', 2),('three', 3)]。即成功实现二维化，如此一来便可以再次构造dict对象，也就是如下代码

     构造方法4

     >>> d = dict(zip(['one', 'two', 'three'], [1, 2, 3]))	
     

     ---

  3. 传递**kwargs类型

     • 这里需要说明一下，在python中除了这里的**kwargs还有*args。这里稍稍提一下他两的区别。
       • **kwargs：表示key=value对，也就是一组必须严格使用a=b的格式传递的数据
       • *args：则表示单个数据，是一组单值变量。
     • 这里允许使用这种方法传递参数，也就很好理解了，请看如下代码

     构造方法5

     >>> e = dict(one=1, two=2, three=3)
     

     ---

  4. 传递(mapping,**kwargs)组合类型

     • 这种方法也就显而易见了，直接上代码

     构造方法6

     >>> f = dict({'one': 1, 'three': 3}, two=2)
     

dict的方法

有了dict对象，其对应的方法就很简单了，这里直接列出一些常用的方法

d = {'one': 1, 'two': 2, 'three': 3}

# 根据key查询value
print(d['one'])

# 查询所有key（返回list）
list(d.keys())  # ['one', 'two', 'three'] 转换成list
list(d)  # ['one', 'two', 'three'] 获得d的所有key

# 增加key-value
d['four'] = 4

# 删除key-value
del d['four']

# 根据key 修改 value
d['three'] = 3

# 删除所有元素
d.clear()

# 浅拷贝
a = d.copy()

# 获取对应key的value
d.pop('one')	# 1

# 获取最后装入dict的key-value对
d.popitem()	# three 3

# 获取key对应的value 无对应value则返回0
d.get('one',0)

小结

本文重点讲述python中的三种最常用的内置类型，其中list，tuple，dict是python最常用的三种工具。在使用这些类型时，应当结合其具体特征，以及自身任务需求合理选择，才能最大限度发挥其作用。