python中常见内置类型简介

小咪咪 2022-11-16 00:59 226阅读 0赞

### 文章目录 ###

*  python中常见内置类型简介
 *   *  数值类型（Numeric Types）
     *  顺序类型（Sequence）
     *   *  List
         *  Tuple
         *  Range
     *  映射（Mappings）
     *   *  dict的构建
         *  dict的方法
     *  小结

# 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最常用的三种工具。在使用这些类型时，应当结合其具体特征，以及自身任务需求合理选择，才能最大限度发挥其作用。