2019年7月15日17:24:49? ? ? ? ? ?? 地點(diǎn)：武漢

本人小白一枚記錄一下學(xué)python的一點(diǎn)心得，主要記錄python的基本數(shù)據(jù)類(lèi)型。

python基本數(shù)據(jù)類(lèi)型包括：int（整型），float（浮點(diǎn)型），complex（復(fù)數(shù)），string（字符串），dict（字典），list（列表），tuple（元祖），set（集合），bool（布爾值）。

記住查看數(shù)據(jù)類(lèi)型時(shí)用type函數(shù)查看即可。

int — 整型

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

#
              
                
#
                
              
            
          

int型簡(jiǎn)而言之就是整數(shù)，沒(méi)有小數(shù)點(diǎn)的數(shù)字，包括正數(shù)，負(fù)數(shù)以及零 （0）。

float — 浮點(diǎn)型

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

#
              
                
#
                
              
            
          

那么什么是浮點(diǎn)型的數(shù)據(jù)呢？以上的代碼段顯示出來(lái)浮點(diǎn)型就相當(dāng)于小數(shù)類(lèi)型的數(shù)字，簡(jiǎn)而言之就是只要有小數(shù)點(diǎn)就是浮點(diǎn)類(lèi)型的數(shù)據(jù)，如a變量，它被賦值等于 1.?? 此時(shí)編譯器會(huì)自動(dòng)默認(rèn)小數(shù)點(diǎn)后面的數(shù)據(jù)為零，在自動(dòng)補(bǔ)上。成為一個(gè)float類(lèi)型的數(shù)據(jù)。

complex? — 復(fù)數(shù)

            
              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編輯器對(duì)于復(fù)數(shù)的解釋?zhuān)@也是一個(gè)高中的數(shù)學(xué)知識(shí)點(diǎn)，如：z=a+bi（a,b均為實(shí)數(shù)）的數(shù)稱(chēng)為 復(fù)數(shù)， 其中a稱(chēng)為實(shí)部，b稱(chēng)為虛部，i 稱(chēng)為虛數(shù)單位。這里不展開(kāi)講解，不懂的同學(xué)可以自行百度搜索。

這里對(duì)多行#開(kāi)后的字符串解釋一下，在對(duì)不熟悉的內(nèi)容操作時(shí)，不知道其中包含的內(nèi)置函數(shù)或者不懂字段是什么意思的時(shí)候使用一個(gè)萬(wàn)能方法， Ctrl + 鼠標(biāo)左鍵 點(diǎn)擊查詢即可。以上的多行#開(kāi)頭的字符串粘貼來(lái)自 builtins.py 對(duì)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 
                          
                        
                      
                    
                  
                
              
            
          

由代碼塊可以看出來(lái)，我們的complex其中可以接受1個(gè)數(shù)字，2個(gè)數(shù)字，或者一個(gè)字符串（其中包括 real + imag*1j 這個(gè)結(jié)構(gòu)）， 當(dāng)complex有且僅有一個(gè)數(shù)字時(shí)，此數(shù)字不為0，則被real接收，若此數(shù)字等于0，則被imag接收。

?

string — 字符串

對(duì)于字符串這種入門(mén)級(jí)別的數(shù)據(jù)類(lèi)型，和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! 
                      
                    
                  
                
              
            
          

由代碼塊可以看出來(lái)，我們的String類(lèi)型的數(shù)據(jù)，可以由單引號(hào)和雙引號(hào)兩個(gè)引號(hào)給包括住，但是c和d變量可以看出來(lái)，雙引號(hào)可以在內(nèi)包含著單引號(hào)，同樣的單引號(hào)也可以包含著雙引號(hào)。但是print的時(shí)候也被輸出出來(lái)了，當(dāng)然雙引號(hào)包含同樣的雙引號(hào)，則被分割成了兩個(gè)字符串了。當(dāng)然三個(gè)字符串也是可以的哦~

dict — 字典

這一個(gè)數(shù)據(jù)類(lèi)型，不知道怎么在解釋看一下官方解釋吧

            
              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)
    """
            
          

以上是官方的解釋?zhuān)F(xiàn)在我們?cè)趐ycharm中跑一下這個(gè)數(shù)據(jù)類(lèi)型

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

這個(gè)key和value是一個(gè)對(duì)應(yīng)的關(guān)系，它們以鍵值對(duì)的形式存在，對(duì)用冒號(hào)?:?分割，每個(gè)鍵值對(duì)之間用逗號(hào)?,?分割，整個(gè)字典包括在花括號(hào)?{}?中 。

注意： 鍵一般是唯一的，如果重復(fù)最后的一個(gè)鍵值對(duì)會(huì)替換前面的，值不需要唯一。

list — 列表

list的存在就如同字符串的存在，在多數(shù)計(jì)算機(jī)編程語(yǔ)法中都存在的一種基本數(shù)據(jù)類(lèi)型。官方的解釋如下:

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

很簡(jiǎn)單的一種數(shù)據(jù)類(lèi)型，咱們就快點(diǎn)過(guò)掉，舉個(gè)例子，如下：

            
              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型的數(shù)據(jù)填寫(xiě)在方括號(hào)內(nèi)，還是“雙引號(hào)”的字符串填寫(xiě)在方括號(hào)內(nèi)，還是{字典}的鍵值對(duì)填寫(xiě)在方括號(hào)內(nèi)。輸出結(jié)果都一樣，均為list型。以上可以得到無(wú)論什么數(shù)據(jù)類(lèi)型放置在 [ list ] 中均為 列表 。

tuple - 元組

這個(gè)是 元組 ，不是 元祖 （賣(mài)蛋糕的那個(gè)）。元組與列表類(lèi)似，不同之處在于元組的元素不能修改。

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

            
              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.
    """
            
          

在實(shí)際環(huán)境中如下：

            
              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 
                    
                  
                
              
            
          

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

那么元祖會(huì)不會(huì)和列表一樣呢？在其中添加String，list，dict會(huì)是怎么樣呢？運(yùn)行結(jié)果如下：

            
              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] 
                  
                
              
            
          

在（小括號(hào)）中添加“雙引號(hào)”string型，結(jié)果成了 string字符串類(lèi)型的數(shù)據(jù)類(lèi)型

在（小括號(hào)）中添加{大括號(hào)}dict型，結(jié)果成了 dict字典類(lèi)型的數(shù)據(jù)類(lèi)型

在（小括號(hào)）中添加【方括號(hào)】list型，結(jié)果成了 list列表類(lèi)型的數(shù)據(jù)類(lèi)型

我們的元祖tuple真是個(gè)小淘氣，里面加了其他的數(shù)據(jù)類(lèi)型就變了一個(gè)數(shù)據(jù)類(lèi)型，外面的（小括號(hào)）也沒(méi)用咯~~

set? — 集合

集合（簡(jiǎn)稱(chēng)集）是數(shù)學(xué)中一個(gè)基本概念，它是集合論的研究對(duì)象，集合論的基本理論直到19世紀(jì)才被創(chuàng)立。最簡(jiǎn)單的說(shuō)法，即是在最原始的集合論——樸素集合論中的定義，集合就是“一堆東西”。集合里的“東西”，叫作元素。若x是集合A的元素，則記作x∈A。集合是把人們的直觀的或思維中的某些確定的能夠區(qū)分的對(duì)象匯合在一起，使之成為一個(gè)整體(或稱(chēng)為單體)，這一整體就是集合。組成一集合的那些對(duì)象稱(chēng)為這一集合的元素（或簡(jiǎn)稱(chēng)為元）?，F(xiàn)代數(shù)學(xué)還用“公理”來(lái)規(guī)定集合。最基本公理例如：外延公理：對(duì)于任意的集合S1和S2，S1=S2當(dāng)且僅當(dāng)對(duì)于任意的對(duì)象a，都有若a∈S1，則a∈S2；若a∈S2，則a∈S1。無(wú)序?qū)洗嬖诠恚簩?duì)于任意的對(duì)象a與b，都存在一個(gè)集合S，使得S恰有兩個(gè)元素，一個(gè)是對(duì)象a，一個(gè)是對(duì)象b。由外延公理，由它們組成的無(wú)序?qū)鲜俏ㄒ坏模涀鰗a,b}。 由于a，b是任意兩個(gè)對(duì)象，它們可以相等，也可以不相等。當(dāng)a=b時(shí)，{a,b}，可以記做或，并且稱(chēng)之為單元集合。空集合存在公理：存在一個(gè)集合，它沒(méi)有任何元素。

?

set集合最主要的一個(gè)點(diǎn)就是，它可以去重。

?

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

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

那么在環(huán)境中如何創(chuàng)建一個(gè)set集合出來(lái)呢：

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

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

以上錯(cuò)誤示范，貼上來(lái)是為了提醒我自己的，那么正確的應(yīng)該如何創(chuàng)建呢？

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

我們得到了一個(gè)由hello world！拆分成的一個(gè)個(gè)單獨(dú)字符，并且他們是無(wú)序的排列在set中。接著我們來(lái)嘗試，在set中加上大括號(hào)，中括號(hào)，及小括號(hào)

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

我們可以發(fā)現(xiàn)在set集合中添加上小括號(hào)，得到的還是一個(gè)set集合，但是有一點(diǎn)需要注意： 小括號(hào)中包含引號(hào)，則成為一個(gè)str類(lèi)型的數(shù)據(jù)，也就是說(shuō)和上面的正確示范無(wú)區(qū)別。

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

在set集合中使用? [? 中括號(hào)list列表? ]? 數(shù)據(jù)類(lèi)型，依舊可以得到一個(gè)set集合的數(shù)據(jù)類(lèi)型，并且輸出的為一個(gè)有序的字符串類(lèi)型。

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

在set集合中使用 {? 大括號(hào)dict字典? }? 數(shù)據(jù)類(lèi)型，依舊可以得到一個(gè)set集合的數(shù)據(jù)類(lèi)型，但是只輸出了一個(gè)key值，并沒(méi)有輸出整的鍵值對(duì)。

?bool? —? 布爾值

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

            
              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.
    """
            
          

那么在實(shí)際使用中，應(yīng)該如何處理呢？

            
              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值去使用，所以不需要強(qiáng)轉(zhuǎn)成一個(gè)固定的數(shù)據(jù)類(lèi)型去鑒定True or Flase，bool不僅可以用來(lái)判斷正誤，也可以用參與計(jì)算，順便一提，即使兩個(gè)數(shù)據(jù)類(lèi)型完全相同并且所含的元素也相同時(shí)，但其的id，即開(kāi)辟的內(nèi)存地址不同。

第二篇原創(chuàng)的博客~后面會(huì)詳細(xì)的各種數(shù)據(jù)類(lèi)型所包含的各種方法。

?

?

竟然看完了，有什么意見(jiàn)可以在下面評(píng)論。謝謝觀看~~