[阶段一] 2. Python数据类型

淩亂°似流年 2022-09-03 10:21 144阅读 0赞

### python数据类型介绍 ###

为了可以适应更多的使用场景，将数据划分为多种类型，每种类型都有着各自的特点和使用场景，帮助计算机高效的处理和展示数据。

数据每种类型的特点不一样，作用也不一样。数据类型是用来规定数据的，而不是来存储的，存储数据需要容器。

*  python 的数据类型：

数字类型
    
    字符串类型
    
    布尔类型
    
    空类型
    
    列表类型
    
    元组类型
    
    集合类型
    
    字典类型

元组与列表的区别在于：列表创建后可以修改，元组创建后不可以修改。

可变数据类型：列表、字典、集合
    
    不可变数据类型：数值，字符串、布尔值、元组

*  数字类型：

数字类型 又可以细分为 整型 和 浮点型。

整型就是我们说的整数，0 也是整数，但是特殊的整数。

`int` 既是整型的代表，又是定义整型的内置函数。定义一个整型，并不一定要使用 `int`。

*  浮点型：

浮点型 就是我们生活中的小数，凡是带有小数点的类型，都可以认为是浮点型。

`float` 既是浮点型的代表，又是定义浮点型的内置函数。定义浮点型时，并不一定要使用 `float`。

*  内置函数 `type`：

`type` 函数会返回变量的类型。例如：

# coding:utf-8
    
    
    name = 'xiaobai'
    age = 20
    weight = 60.0
    
    if __name__ == '__main__':
        print(type(name))
        print(type(age))
        print(type(weight))

*  字符串类型：

用 `''` 或 `""` 包裹的数据就是字符串。字符串中可以包含任意字符：如字母、数字、符号等，且没有先后顺序。

在 python 中，使用 `str` 来表示字符串类型，并且通过该函数来定义字符串。字符串是不可改变的。

*  内置函数 `id`：

`id` 函数会返回变量的内存地址。例如：

# coding:utf-8
    
    
    name = 'xiaobai'
    age = 20
    
    if __name__ == '__main__':
        print(id(name))
        print(id(age))

*  内置函数 `len`：

`len` 函数会返回字符串的长度。但 `len` 函数无法返回数字类型的长度，因为数字类型没有长度。例如：

# coding:utf-8
    
    
    name = 'xiaobai'
    age = 20
    
    if __name__ == '__main__':
        print(len(name))
        print(len(age))

*  内置成员运算符 `in`、`not in`：

成员运算符是用来判断数据中是否存在想要的成员。

成员运算符包括 `in` 和 `not in`，分别表示 存在 和 不存在，会返回 `True` 或 `False`。例如：

# coding:utf-8
    
    
    info = 'Python 是一门非常有魅力的语言'
    
    result = '魅力' in info
    print(result)
    
    result = '语言' not in info
    print(result)

*  内置函数 `max`、`min`：

python 中数据的大小关系：

中文符号 > 字母 > 数字 > 英文符号 > 空字符串

`max` 函数会返回数据中最大的成员。`min` 函数会返回数据中最小的成员。例如：

# coding:utf-8
    
    
    info = 'Python is a good code'
    
    print(max(info))
    print(min(info))

*  字符串的累加：

字符串不是数字，因此不能做减法、乘除法。

字符串可以进行拼接，使用 `+` 来完成，并不是常规意义上的加法。例如：

# coding:utf-8
    
    
    info1 = '天气好，要多锻炼身体。'
    info2 = '多锻炼身体，身体才会变得更好。'
    
    print(info1 + info2)

*  布尔类型：

对事物真假的判断，即 布尔类型。布尔类型只有两个布尔值，分别是 `True` 和 `False`，代表 真 和 假。

布尔类型有对应的内置函数 `bool`，`bool` 函数只会返回 `True` 或 `False`。

在数字中，0 表示 `False`，非 0 的数字表示 `True`。在字符串中，空字符串 `''` 表示 `False`，非空字符串表示 `True`。例如：

# coding:utf-8
    
    
    a = 0
    b = 1
    c = 0.0
    d = 0.1
    e = ''
    f = 'None'
    g = None
    
    if __name__ == '__main__':
        print(bool(a))
        print(bool(b))
        print(bool(c))
        print(bool(d))
        print(bool(e))
        print(bool(f))
        print(bool(g))

*  空类型：

不属于任何数据类型的类型 就是 空类型。

空类型只有一个固定值 `None`，它属于 `False` 的范畴。如果不确定类型的时候，可以使用空类型。

注意，空类型与空字符串不同，空类型表示什么都没有，而空字符串是字符串类型但值是空值。例如：

# coding:utf-8
    
    
    a = ''
    b = None
    
    if __name__ == '__main__':
        print(type(a))
        print(type(b))

*  列表类型：

列表是一种有序，且元素可重复的集合类型。在 python 中，`list` 代表列表类型，可以用它定义一个列表。

在 python 中，列表中的元素存在于一个 `[]` 中，列表中的元素可以是各种类型（包括列表、元组、集合及字典），列表中的元素是可以任意改变的。

在 python 中，列表是一个无限制长度的数据结构，但要避免创建过大长度的列表。

使用 `max` 和 `min` 比较列表中元素的时候，列表中的元素不能是多个类型，如果元素类型不统一则会报错。

*  元组类型：

元组和列表一样，也是一种有序的，且元素可重复的集合类型。在 python 中，`tuple` 代表元组类型，可以用它定义一个元组。

在 python 中，元组中的元素存在于一个 `()` 中，元组中的元素也可以是各种类型（包括列表、元组、集合及字典）。和列表不同，元组中的元素是不可改变的，元组可看作不可变的列表。

在 python 中，元组是一个无限制长度的数据结构，但要避免创建过大长度的元组。元组比列表占用资源更小，因为元组是不可变的，一旦创建就不可更改。

使用 `max` 和 `min` 比较元组中元素的时候，元组中的元素不能是多个类型，如果元素类型不统一则会报错。

若元组中只有一个元素，这个元素后面需要加一个 `,`，否则就不是元组。

>>> t1 = (1)
    
    >>> type(t1)
    <class 'int'>
    
    >>> t1
    1
    
    >>> type(('hello'))
    <class 'str'>

>>> t2 = (1,)
    
    >>> type(t2)
    <class 'tuple'>
    
    >>> t2
    (1,)

*  字典类型：

字典是由多个键（key）及其对应的值（value）所组成的一种数据类型。在 python 中，`dict` 代表字典类型，可以用它定义一个字典。

在 python 中，字典中的元素存在于一个 `{}` 中，字典中的元素是类似 `key: value` 的键值对。字典中每一个元素的 `key` 必须是唯一的。

在 python 中，字典中元素的 `key` 支持字符串、数字和元祖类型，但不支持列表类型，因为 `key` 是不可变的。字典中元素的 `value` 支持 python 的所有数据类型。

*  数字的运算：

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>=</td> 
   <td>等于（赋值）运算符</td> 
   <td>c = a + b</td> 
  </tr> 
  <tr> 
   <td>+=</td> 
   <td>加法运算符</td> 
   <td>c += a 等价于 c = c + a</td> 
  </tr> 
  <tr> 
   <td>-=</td> 
   <td>减法运算符</td> 
   <td>c -= a 等价于 c = c - a</td> 
  </tr> 
  <tr> 
   <td>*=</td> 
   <td>乘法运算符</td> 
   <td>c *= a 等价于 c = c * a</td> 
  </tr> 
  <tr> 
   <td>/=</td> 
   <td>除法运算符</td> 
   <td>c /= a 等价于 c = c / a</td> 
  </tr> 
  <tr> 
   <td>%=</td> 
   <td>取模运算符</td> 
   <td>c %= a 等价于 c = c % a</td> 
  </tr> 
  <tr> 
   <td>**=</td> 
   <td>幂运算符</td> 
   <td>c **= a 等价于 c = c ** a</td> 
  </tr> 
  <tr> 
   <td>//=</td> 
   <td>整除运算符</td> 
   <td>c //= a 等价于 c = c // a</td> 
  </tr> 
 </tbody> 
</table>

需要注意的是，字符串只可以和数字做乘法，但字符串无法与字符串做乘法。同样的，列表和元祖也可以和数字做乘法，但字典不可以。

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>==</td> 
   <td>判断是否等于</td> 
   <td>a == b</td> 
  </tr> 
  <tr> 
   <td>!=</td> 
   <td>判断是否不等于</td> 
   <td>a != b</td> 
  </tr> 
  <tr> 
   <td>&gt;</td> 
   <td>判断是否大于</td> 
   <td>a &gt; b</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>判断是否小于</td> 
   <td>a &lt; b</td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>判断是否大于等于</td> 
   <td>a &gt;= b</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>判断是否小于等于</td> 
   <td>a &lt;= b</td> 
  </tr> 
  <tr> 
   <td>&lt;&gt;</td> 
   <td>判断是否不等于</td> 
   <td>a &lt;&gt; b</td> 
  </tr> 
  <tr> 
   <td>is</td> 
   <td>判断两个对象存储单元是否相同</td> 
   <td>a is b</td> 
  </tr> 
  <tr> 
   <td>is not</td> 
   <td>判断两个对象存储单元是否不同</td> 
   <td>a is not b</td> 
  </tr> 
 </tbody> 
</table>

> `<>` 在 python3 中已经弃用，仅 python2 中可用。

--------------------