Python爬坑之基本数据类型

Python爬坑之基本数据类型

最近入了python的坑。由于本人是一名前端开发人员，因此本文就以一个前端的视角对比下JS和Python。本文是基于Python3进行说明
talk is cheap,show me the code.

---

先放一张图

Python3 中有六个标准的数据类型：

• Number 数字
• Str 字符串
• List 列表
• Tuple 元组
• Set 集合
• Dict 字典

其中：

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）
• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）

---

Number 数字

数字有四种类型 分别是：
1.整型(int) 2.浮点型 (float) 3.布尔类型(bool) 4.复数(complex)

• 整型和浮点型

  在python3中的整型只有一种 int， 浮点型也只有一种 float。

其余语言的整数:(short) (int) (long);
其余语言的浮点数:单精度(float) 双精度(double)

>>> type(1)
<class 'int'>    # 整型
>>> type(1.0)
<class 'float'>   # 浮点型
>>> type(1+1.0)
<class 'float'>   # 浮点型
>>> type(-1)
<class 'int'>     # 整型
>>> type(-1.0)
<class 'float'>    # 浮点型

• 布尔型

有些人可能会奇怪，尤为是前端。由于在 js中 数值型和 布尔型是两个不一样的类型。而在 python中 布尔型则是属于 数值型的。其实也不难理解， True就是 1， False就是 0嘛
python中的布尔值的首写字母必定是大写的

>>> type(False)
  <class 'bool'>  # bool类型
  >>> type(True)
  <class 'bool'>   # bool类型
  >>> int(True)
  1              # 由于布尔类型是数字的子类型， 因此True能够转换为1
  >>> int(False)
  0
  >>> bool(0.5)   # 非0 非空的数值 都是bool真值
  True
  >>> bool(-1)
  True
  >>> bool(0)   # 数值0 都是bool假值
  False
  >>> bool('')   # 空str 都是bool假值
  False
  >>> bool([])   # 空列表 都是bool假值
  False
  >>> bool(())   # 空元祖 都是bool假值
  False
  >>> bool({})   # 空集合 都是bool假值
  False
  >>> bool(None)   # 类型NoneType 都是bool假值
  False

关于复数complex科学计算会用到，通常的运用不多。我这里只做了解。

使用小写字母 j 来表示复数

>>> 35j
  35j

Str 字符串

Python中的字符串和JS中的字符串除了操做方式以外几乎没有什么区别

字符串表示

• 单双引号配合

  >>> "let's go baby!"   # 单双引号区分
   "let's go baby!"
   >>> 'let"s go baby~'
   'let"s go baby~'
   >>> 'let\'s go baby.'   # 转义(\)字符
   "let's go baby."

• 三引号多行换行

  >>> '''
      python字符串换行 有点像markdown
      python字符串换行 有点像markdown
      python字符串换行 有点像markdown
      '''
      '\npython字符串换行 有点像markdown\npython字符串换行 有点像markdown\npython字符串换行 有点像markdown\n'
                      # 三引号自动换行
  
      >>> print('反斜杠n的做用\n是回车\n测试')    # 转义字符 \n
      反斜杠n的做用
      是回车
      测试
      >>>

• 转义字符

  >>> print('hello \\n world')   # 经过双反斜杠\\ 来转义\n
    hello \n world
  
  >>> print(r'hello \n world')   # 经过前面加小写r 来来转义\n 加r以后变成原始字符串
    hello \n world

字符串运算

>>> 'hello'+'world'  # 简单字符串拼接
  'helloworld'
  >>> 'hello'*3      # 字符串相乘 注意：Python的字符串是能够相乘的 JS中除了数值型的字符串相乘是相应的数值乘法外，其他获得的结果全是NaN
  'hellohellohello'
  >>> 'helloworld'[0]   # 经过下标获取字符串单个元素
  'h'
  >>> 'helloworld'[-1]  # 从字符串的末尾开始数
  'd'

字符串截取(切片)

>>> 'helloworld'[0:5]  # 截取 从下标0开始向前数5位
    'hello'
  >>> 'helloworld'[0:-1]  # 截取 从下标0开始向后数1位
    'helloworl'
  >>> 'helloworld'[5:]  #  从向前数5个下标 自动截取到字符串的末尾
    'world'
  >>> 'helloworld'[-5:]  # 从向后数5个下标 自动截取到字符串的末尾
    'world'
  >>> 'helloworld'[:-5] # 从下标0开始 向后数5位
    'hello'
  >>> 'helloworld'[:5] # 从下标0开始 向前数5位
    'hello'

List 列表

基本能够理解为JS中的Array

>>> [1,2,3,4,5,6]  # 逗号分隔开
[1, 2, 3, 4, 5, 6]
>>> type([1,2,3,4,5,6])   # list类型
<class 'list'>
>>> [1,'str',2,True,3,4,False,5,6]  # 列表元素能够有多种类型
[1, 'str', 2, True, 3, 4, False, 5, 6]
>>>

列表的基本操做

• 访问 截取

  >>> ['a', 'b', 'c', 'd'][1]   # 访问列表中的某个元素
   'b'
   >>> ['a', 'b', 'c', 'd'][0:2]   # 截取列表
   ['a', 'b']
   >>> ['a', 'b', 'c', 'd'][-1:]   # 反向截取列表
   ['d']

• 列表的运算

  >>> ['a', 'b', 'c', 'd']+['e','f']   # 相似于JS中的 [].concat()
    ['a', 'b', 'c', 'd', 'e', 'f']
    >>> ['aaa'] * 2    # 列表的乘法  注意：JS中不支持数组的乘法哦
    ['aaa', 'aaa']

• 判断列表中的元素是否存在

  >>> 3 in [1,2,3]   # 相似于JS中的arr.indexOf()
  True
  >>> 3 in [7,8,9]
  False
  >>> 3 not in [7,8,9]
  True

Tuple 元组

元组的定义和列表基本一致。可是主要有两个特色 1 元祖使用()小括号来表示 2 元祖不可变

>>> type((1,2,3))   # tuple元祖类型
<class 'tuple'>
>>> (1,2,3,4,5,6)   # 逗号隔开
(1, 2, 3, 4, 5, 6)
>>> (1,True,'str',2)   # 元素能够有多种类型
(1, True, 'str', 2)
>>> (1, 2, 3, 4, 5, 6)[0]   # 经过下标访问元素
1
>>> (1, 2, 3, 4, 5, 6)[0:3]   # 元祖截取
(1, 2, 3)
>>> (1,2,3)+(4,5,6)   # 元祖相加 和list操做同样 相似JSON数组操做[].concat
(1, 2, 3, 4, 5, 6)
>>> (1,2,3)*2   # 元组乘法 同列表
(1, 2, 3, 1, 2, 3)
>>>

• 列表和元祖的区别
  tuple 不可变，因此代码更安全。若是可能，能用 tuple 代替 list 就尽可能用 tuple

Set 集合

特色

• 集合无序的 序列是有序的

  >>> {1,2,3,4,5,6}    # 用大括号来定义集合
     {1, 2, 3, 4, 5, 6}
     >>> type({1,2,3,4,5,6})   # 集合是 set类型
     <class 'set'>
     >>> {1,2,3,4,5,6}[0]   # 会报错 由于集合是无序的 因此没法经过下标来访问集合中的元素

• 集合是不重复的 会自动过滤掉重复的元素

  >>> {1,1,1,2,2,2,5,6,6,7,8,7,7,7}   # 自动过滤重复元素
  {1, 2, 5, 6, 7, 8}

集合的运算

• 差集 交集 并集

  >>> type(set())   # set()用来定义一个空的集合 若是直接用{}来定义空集合，那么此时它的类型不是set 而是dict
  <class 'set'>
  >>> len({1,2,3})   # len() 求集合的长度
  3
  >>> 1 in {1,2,3}   # 判断某个元素是否存在于集合中
  True
  >>> 1 not in {1,2,3}  # 判断某个元素是否不存在于集合中
  False
  >>> {1,2,3,4,5,6} - {3,4}  # 差集： 剔除两个集合中共有的元素
  {1, 2, 5, 6}
  >>> {1,2,3,4,5,6} & {3,4,7}   # 交集： 求两个集合中的共有的元素
  {3, 4}
  >>> {1,2,3,4,5,6} | {3,4,7}   # 并集： 求两个集合中全部的不重复的元素
  {1, 2, 3, 4, 5, 6, 7}

Dict 字典

特色

1. key/value 形式 (相似于 JS 中对象的key/value)
2. 字典的 key 不能重复
3. 字典的 key 必须是不可变的类型 `int str tuple`

字典的相关操做

>>> {1:1,2:2,3:3}   # key/value形式定义字典
{1: 1, 2: 2, 3: 3}
>>> type({1:1,2:2,3:3})  # dict类型
<class 'dict'>
>>> {(1,2,3):'元祖是不可变的',2:2,3:3}   # 元祖是能够做为key的 由于元祖具备不可变的特性
{(1, 2, 3): '元祖是不可变的', 2: 2, 3: 3}
>>> {'name':'tiger', 'age':'25'}['name']   # 字典经过key去访问vlue 和JS中的对象基本一致
'tiger'
>>> {'name':'tiger', 'age':'25', 'name':'pig'}   # 字典的key不能重复  key重复了虽然不会报错 可是后面的key会覆盖掉前面的key
{'age':'25', 'name':'pig'}

总结

此时，再回看一遍文章开头放的图 脑中对Python基本数据结构就比较清晰了:

首先，咱们把Python的基本数据结构分为两类: 数字 和 组。数字类型又分为了整型 浮点型 布尔型和复数型，这些概念刚才也讲过了，相对简单，就很少赘述。主要说下组的概念:

• 组
  组类型又能够分为序列 集合 和字典。

  • 序列

    • 特色： 序列是有序的，能够经过下标或者索引去访问其中的元素，好比说 列表 元祖 和 字符串它们都是序列，均可以经过索引去访问其中的元素。但注意其中的字符串和元祖是不可变的。

  • 集合

    • 特色： 集合是无序且元素是不能重复的，因此不能经过下标或者索引去访问其中的元素，固然也不能切片

  • 字典

    • 能够简单的将其理解为JS中的对象，可经过key去访问其value。其中key必须是不可变的，好比 数字 字符串 甚至元祖均可以做为字典的key，由于元祖一样具备不可变性。