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，由於元祖一樣具備不可變性。