2019年7月15日17:24:49? ? ? ? ? ?? 地點：武漢

本人小白一枚記錄一下學python的一點心得，主要記錄python的基本數據類型。

python基本數據類型包括：int（整型），float（浮點型），complex（復數），string（字符串），dict（字典），list（列表），tuple（元祖），set（集合），bool（布爾值）。

記住查看數據類型時用type函數查看即可。

int — 整型

            
              a = 0
print(type(a))
b = 1 ** 8    # **表示乘方的意思，即10的8次方
print(type(b))    

#
              
                
#
                
              
            
          

int型簡而言之就是整數，沒有小數點的數字，包括正數，負數以及零 （0）。

float — 浮點型

            
              a = 1.
print(type(a))
b = -1.1
print(type(b))

#
              
                
#
                
              
            
          

那么什么是浮點型的數據呢？以上的代碼段顯示出來浮點型就相當于小數類型的數字，簡而言之就是只要有小數點就是浮點類型的數據，如a變量，它被賦值等于 1.?? 此時編譯器會自動默認小數點后面的數據為零，在自動補上。成為一個float類型的數據。

complex? — 復數

            
              complex


# class complex(object):
#     """
#     complex(real[, imag]) -> complex number
# 
#     Create a complex number from a real part and an optional imaginary part.
#     This is equivalent to (real + imag*1j) where imag defaults to 0.
#     """

            
          

這上面是pycharm編輯器對于復數的解釋，這也是一個高中的數學知識點，如：z=a+bi（a,b均為實數）的數稱為 復數， 其中a稱為實部，b稱為虛部，i 稱為虛數單位。這里不展開講解，不懂的同學可以自行百度搜索。

這里對多行#開后的字符串解釋一下，在對不熟悉的內容操作時，不知道其中包含的內置函數或者不懂字段是什么意思的時候使用一個萬能方法， Ctrl + 鼠標左鍵 點擊查詢即可。以上的多行#開頭的字符串粘貼來自 builtins.py 對complex的解釋。下面使用一下complex：

            
              a = complex(1,2)
print(a, type(a))   # 
              
                
b = complex(1)
print(b, type(b))     # 
                
                  
c = complex("1+2j")
print(c, type(c))    # 
                  
                    
d = complex(0)
print(d, type(d))



#  (1+2j) 
                    
                      

#  (1+0j) 
                      
                        

#  (1+2j) 
                        
                          

#  0j 
                          
                        
                      
                    
                  
                
              
            
          

由代碼塊可以看出來，我們的complex其中可以接受1個數字，2個數字，或者一個字符串（其中包括 real + imag*1j 這個結構）， 當complex有且僅有一個數字時，此數字不為0，則被real接收，若此數字等于0，則被imag接收。

?

string — 字符串

對于字符串這種入門級別的數據類型，和C，Java的處理方式，代碼如下：

            
              #String 字符串
a = 'hello world!'
print(a , type(a))      # hello world! 
              
                
b = "hello world!"
print(b , type(b))      # hello world! 
                
                  
c = "he'llo' wor'ld!'"
print(c, type(c))       # he'llo' wor'ld!' 
                  
                    
d = 'he"llo",wor"ld!"'
print(d, type(d))       # he"llo",wor"ld!" 
                    
                      
e = """hello world!"""
print(e, type(e))       # hello world! 
                      
                    
                  
                
              
            
          

由代碼塊可以看出來，我們的String類型的數據，可以由單引號和雙引號兩個引號給包括住，但是c和d變量可以看出來，雙引號可以在內包含著單引號，同樣的單引號也可以包含著雙引號。但是print的時候也被輸出出來了，當然雙引號包含同樣的雙引號，則被分割成了兩個字符串了。當然三個字符串也是可以的哦~

dict — 字典

這一個數據類型，不知道怎么在解釋看一下官方解釋吧

            
              class dict(object):
    """
    dict() -> new empty dictionary
    dict(mapping) -> new dictionary initialized from a mapping object's
        (key, value) pairs
    dict(iterable) -> new dictionary initialized as if via:
        d = {}
        for k, v in iterable:
            d[k] = v
    dict(**kwargs) -> new dictionary initialized with the name=value pairs
        in the keyword argument list.  For example:  dict(one=1, two=2)
    """
            
          

以上是官方的解釋，現在我們在pycharm中跑一下這個數據類型

            
              d = {"key1":"value1","key2":"value2"}
print(d,type(d))    # {'key1': 'value1', 'key2': 'value2'} 
              
            
          

這個key和value是一個對應的關系，它們以鍵值對的形式存在，對用冒號?:?分割，每個鍵值對之間用逗號?,?分割，整個字典包括在花括號?{}?中 。

注意： 鍵一般是唯一的，如果重復最后的一個鍵值對會替換前面的，值不需要唯一。

list — 列表

list的存在就如同字符串的存在，在多數計算機編程語法中都存在的一種基本數據類型。官方的解釋如下:

            
              class list(object):
    """
    list() -> new empty list
    list(iterable) -> new list initialized from iterable's items
    """
            
          

很簡單的一種數據類型，咱們就快點過掉，舉個例子，如下：

            
              L = [1, 2, 3]
print(L, type(L))       # [1, 2, 3] 
              
                
L = ["1, 2, 3"]
print(L,type(L))        # ['1, 2, 3'] 
                
                  
L = [{"key1" : "value1"}]
print(L, type(L))       # [{'key1': 'value1'}] 
                  
                
              
            
          

不管使用int型的數據填寫在方括號內，還是“雙引號”的字符串填寫在方括號內，還是{字典}的鍵值對填寫在方括號內。輸出結果都一樣，均為list型。以上可以得到無論什么數據類型放置在 [ list ] 中均為 列表 。

tuple - 元組

這個是 元組 ，不是 元祖 （賣蛋糕的那個）。元組與列表類似，不同之處在于元組的元素不能修改。

元組使用（小括號），列表使用 [ 方括號 ]。官方解釋如下：

            
              class tuple(object):
    """
    tuple() -> empty tuple
    tuple(iterable) -> tuple initialized from iterable's items
    
    If the argument is a tuple, the return value is the same object.
    """
            
          

在實際環境中如下：

            
              T = (1, 2, 3)
print(T, type(T))   # (1, 2, 3) 
              
                 
T = (1,)
print(T, type(T))   # (1,) 
                
                  
T = (1)    
print(T, type(T))    # 1 
                  
                    
T = (1.)
print(T, type(T))    # 1.0 
                    
                  
                
              
            
          

元祖很奇怪，只有 數字 添加在（小括號）中才為tuple類型，有且僅有一個數字但是要使用元祖類型時，必須在其后面添加一個逗號，否則就是int型或者float型。

那么元祖會不會和列表一樣呢？在其中添加String，list，dict會是怎么樣呢？運行結果如下：

            
              T = ("1, 2, 3")
print(T, type(T))       # 1, 2, 3 
              
                
T = ({"key1" : "value1"})
print(T, type(T))       # {'key1': 'value1'} 
                
                  
T = ([1, 2, 3])
print(T, type(T))       # [1, 2, 3] 
                  
                
              
            
          

在（小括號）中添加“雙引號”string型，結果成了 string字符串類型的數據類型

在（小括號）中添加{大括號}dict型，結果成了 dict字典類型的數據類型

在（小括號）中添加【方括號】list型，結果成了 list列表類型的數據類型

我們的元祖tuple真是個小淘氣，里面加了其他的數據類型就變了一個數據類型，外面的（小括號）也沒用咯~~

set? — 集合

集合（簡稱集）是數學中一個基本概念，它是集合論的研究對象，集合論的基本理論直到19世紀才被創立。最簡單的說法，即是在最原始的集合論——樸素集合論中的定義，集合就是“一堆東西”。集合里的“東西”，叫作元素。若x是集合A的元素，則記作x∈A。集合是把人們的直觀的或思維中的某些確定的能夠區分的對象匯合在一起，使之成為一個整體(或稱為單體)，這一整體就是集合。組成一集合的那些對象稱為這一集合的元素（或簡稱為元）。現代數學還用“公理”來規定集合。最基本公理例如：外延公理：對于任意的集合S1和S2，S1=S2當且僅當對于任意的對象a，都有若a∈S1，則a∈S2；若a∈S2，則a∈S1。無序對集合存在公理：對于任意的對象a與b，都存在一個集合S，使得S恰有兩個元素，一個是對象a，一個是對象b。由外延公理，由它們組成的無序對集合是唯一的，記做{a,b}。 由于a，b是任意兩個對象，它們可以相等，也可以不相等。當a=b時，{a,b}，可以記做或，并且稱之為單元集合。空集合存在公理：存在一個集合，它沒有任何元素。

?

set集合最主要的一個點就是，它可以去重。

?

以上摘抄至百度，也就是一個數學的概念，那么在pycharm中是一個怎么樣的解釋呢。官方解釋如下：

            
              class set(object):
    """
    set() -> new empty set object
    set(iterable) -> new set object
    
    Build an unordered collection of unique elements.
    """
            
          

那么在環境中如何創建一個set集合出來呢：

            
              a = set(1,2,3)
print(a, type(a))
# TypeError: set expected at most 1 arguments, got 3
# TyperError:集合最多創建一個參數

a = set(1)
print(a, type(a))
# TypeError: 'int' object is not iterable
# 大致就是說int型也不行
            
          

以上錯誤示范，貼上來是為了提醒我自己的，那么正確的應該如何創建呢？

            
              a = set("hello world!")
print(a, type(a))
# {'o', 'e', 'd', 'l', '!', 'r', 'w', 'h', ' '} 
              
            
          

我們得到了一個由hello world！拆分成的一個個單獨字符，并且他們是無序的排列在set中。接著我們來嘗試，在set中加上大括號，中括號，及小括號

            
              #小括號的使用如下
b = ("hello world!")
a = set(b)
print(a, type(a))   # {'d', 'h', 'l', '!', ' ', 'r', 'o', 'e', 'w'} 
              
              
            
          

我們可以發現在set集合中添加上小括號，得到的還是一個set集合，但是有一點需要注意： 小括號中包含引號，則成為一個str類型的數據，也就是說和上面的正確示范無區別。

            
              # 中括號的使用
b = ["hello world!"]    # 
              
                
a = set(b)
print(a, type(a))   # {'hello world!'} 
                
              
            
          

在set集合中使用? [? 中括號list列表? ]? 數據類型，依舊可以得到一個set集合的數據類型，并且輸出的為一個有序的字符串類型。

            
              # 大括號的使用
a = {"key" : "value"}       # {'key': 'value'} 
              
                
b = set(a)
print(b ,type(b))       # {'key'} 
                
              
            
          

在set集合中使用 {? 大括號dict字典? }? 數據類型，依舊可以得到一個set集合的數據類型，但是只輸出了一個key值，并沒有輸出整的鍵值對。

?bool? —? 布爾值

bool表示布爾型變量，也就是邏輯型變量的定義符，以英國數學家、布爾代數的奠基人喬治·布爾（George Boole）命名。并且處在大多數計算機編程語言中。表示真假，官方解釋如下：

            
              class bool(int):
    """
    bool(x) -> bool
    
    Returns True when the argument x is true, False otherwise.
    The builtins True and False are the only two instances of the class bool.
    The class bool is a subclass of the class int, and cannot be subclassed.
    """
            
          

那么在實際使用中，應該如何處理呢？

            
              a = 1
print(a == 2)       # False
b = "hello"
print(b == "hello")      # True
print(True + False + 2)     # 3
x = y = (1,2,3)
z = (1,2,3)
print(x == z)        # True
print(id(x) == id(y))       # True
print(id(x) == id(z))       # Flase
            
          

任何值都可以作為bool值去使用，所以不需要強轉成一個固定的數據類型去鑒定True or Flase，bool不僅可以用來判斷正誤，也可以用參與計算，順便一提，即使兩個數據類型完全相同并且所含的元素也相同時，但其的id，即開辟的內存地址不同。

第二篇原創的博客~后面會詳細的各種數據類型所包含的各種方法。

?

?

竟然看完了，有什么意見可以在下面評論。謝謝觀看~~