Python數據類型

時間 2019-12-07

標籤 python 數據類型欄目 Python 简体版

原文原文鏈接

數據類型

按照如下幾個點展開數據類型的學習python

 
        #======================================基本使用====================================== 
       
        #一、用途 
       
        #二、定義方式 
       
        #三、經常使用操做+內置的方法 
       
        #======================================該類型總結==================================== 
       
        #存一個值or存多個值 
       
        #有序or無序 
       
        #可變or不可變（一、可變：值變，id不變。可變==不可hash 二、不可變：值變，id就變。不可變==可hash）

1、數字（int,float）

 
        """ 
       
        整型int 
       
        　　做用：年紀，等級，身份證號，qq號等整型數字相關 
       
        　　定義： 
       
        　　　　age=10 #本質age=int(10) 
       
        浮點型float 
       
        　　做用：薪資，身高，體重，體質參數等浮點數相關 
       
        定義： 
       
        salary=9999.9 #本質salary=float(9999.9) 
       
        """ 
       
        age  
        = 
        '18' 
       
        print 
        ( 
        type 
        ( 
        int 
        (age)))  
        # <class 'int'> 
       
        salary  
        = 
        '123.8' 
       
        print 
        ( 
        type 
        ( 
        float 
        (salary)))  
        # <class 'float'> 
       
        print 
        ( 
        bin 
        ( 
        16 
        ))   
        #0b10000 二進制 
       
        print 
        ( 
        oct 
        ( 
        17 
        ))   
        #0o21 八進制 
       
        print 
        ( 
        hex 
        ( 
        18 
        ))  
        #0x12 十六進制

2、字符串（str）

"""
字符串【有序不可變】
　　做用：名字，性別，國籍，地址等描述信息
　　定義：
　　　　name='tom' #本質 name = str('tom')
"""

# strip
name = '*tom**'
print(name.strip('*'))  # tom
print(name.lstrip('*'))  # tom**
print(name.rstrip('*'))  # *tom

# lower,upper
name = 'tom'
print(name.lower())  # tom
print(name.upper())  # TOM

# startswith,endswith
name = 'tom_en'
print(name.endswith('en'))  # True
print(name.startswith('tom'))  # True

# format的三種玩法
res = '{} {} {}'.format('egon', 18, 'male')
res = '{1} {0} {1}'.format('egon', 18, 'male')
res = '{name} {age} {sex}'.format(sex='male', name='egon', age=18)

# split
name = 'root:x:0:0::/root:/bin/bash'
print(name.split(':'))  # 默認分隔符爲空格  ['root', 'x', '0', '0', '', '/root', '/bin/bash']
name = 'C:/a/b/c/d.txt'
print(name.split('/', 1))  # 只想拿到頂級目錄 ['C:', 'a/b/c/d.txt']
name = 'a|b|c'
print(name.rsplit('|', 1))  # 從右開始切分['a|b', 'c']

# join
tag = ' '
print(tag.join(['tom', 'say', 'hello', 'world']))  # 可迭代對象必須都是字符串 tom say hello world
print('_'.join('abcd'))  # a_b_c_d

# replace
name = 'tom say hello world,tom say bye'
print(name.replace('tom', 'rose', 1))  # rose say hello world,tom say bye

# find
name = 'tom say hello world,tom say bye'
print(name.find('jack', 0, len(name)))  # -1 (找不到返回-1)查找子串第一次在母串中出現的位置，能夠本身指定位置範圍來搜查

# count
name = 'tom say hello world,tom say bye'
print(name.count('tom', 0, len(name)))  # 2 計算出子串 'tom'在母串中出現的次數，默認是在整個母串中查找，

# isdigit：能夠判斷bytes和unicode類型,是最經常使用的用於於判斷字符是否爲"數字"的方法
age = input('>>: ')
print(age.isdigit())

print('1'.isdecimal())  # True
print('1'.isdigit())  # True
print('1'.isnumeric())  # True

print('②'.isdecimal())  # False
print('②'.isdigit())  # True
print('②'.isnumeric())  # True

print('二'.isdecimal())  # False
print('二'.isdigit())  # False
print('二'.isnumeric())  # True

print('Ⅳ'.isdecimal())  # False
print('Ⅳ'.isdigit())  # False
print('Ⅳ'.isnumeric())  # True #羅馬數字

print(b'1'.isdigit())  # True
# print(b'1'.isdecimal())#報錯
# print(b'1'.isnumeric())#True #報錯

print('4.3'.isdigit())  # False
print('4.3'.isdecimal())  # False
print('4.3'.isnumeric())  # False

print('-4'.isdigit())     # False
print('-4'.isdecimal())   # False
print('-4'.isnumeric())   # False

num = '-10'
if (num.startswith('-') and num[1:] or num).isdigit():
    print('num是整數')
else:
    print('num不是整數')


num = '-4.5'
import re
if re.match(r'^-?(\.\d+|\d+(\.\d+)?)', num):
    print('num是整數')
else:
    print('num不是整數')

num = '-10'
if num.lstrip('-').isdigit():
    print('num是整數')
else:
    print('num不是整數')

'''
總結:
    最經常使用的是isdigit,能夠判斷bytes類型,這也是最多見的數字應用場景
    若是要判斷中文數字或羅馬數字,則須要用到isnumeric 
'''

def capitalize(self) 首字母大寫
def casefold(self) 全部變小寫，casefold更強，不少未知的也會相應變小寫
def center(self, width, fillchar=None)設置寬度，並將內容居中
def count(self, sub, start=None, end=None)去字符串中尋找子序列的出現次數
def encode(self, encoding='utf-8', errors='strict')
def endswith(self, suffix, start=None, end=None)以什麼什麼結尾
def expandtabs(self, tabsize=8) 斷句tabsize的長度
def find(self, sub, start=None, end=None)從開始日後找，找到第一個以後，獲取其索引
def format(self, *args, **kwargs)格式化，將一個字符串中的佔位符替換爲指定的值
def format_map(self, mapping)格式化，傳入的值 {"name": 'alex', "a": 19}
def index(self, sub, start=None, end=None)找不到，報錯
def isalnum(self)字符串中是否只包含 字母和數字
def isalpha(self)是不是字母，漢字
def isdecimal(self)當前輸入是不是數字 2
def isdigit(self)②，2
def isidentifier(self)
def islower(self)
def isnumeric(self)②，2，二
def isprintable(self)
def isspace(self)
def istitle(self)
def isupper(self)
def join(self, iterable)
def ljust(self, width, fillchar=None)
def lower(self)
def lstrip(self, chars=None)
def maketrans(self, *args, **kwargs)
def partition(self, sep)分割爲三部分
def replace(self, old, new, count=None)將指定字符串替換爲指定字符串
def rfind(self, sub, start=None, end=None)
def rindex(self, sub, start=None, end=None)
def rjust(self, width, fillchar=None)
def rpartition(self, sep)
def rsplit(self, sep=None, maxsplit=-1)
def rstrip(self, chars=None)
def split(self, sep=None, maxsplit=-1)
def splitlines(self, keepends=None)
def startswith(self, prefix, start=None, end=None)
def strip(self, chars=None)
def swapcase(self)
def title(self)
def translate(self, table)
def upper(self)
def zfill(self, width)
 
# m = str.maketrans("aeiou", "12345")
# new_v = v.translate(m)

字符串函數

3、列表（list）

 
        """ 
       
        列表【有序可變】 
       
        　　做用：多個裝備，多個愛好，多門課程，多本書籍等 
       
        　　定義： 
       
        　　　　[]內能夠有多個任意類型的值，逗號分隔 
       
        """ 
       
        # 建立 
       
        li  
        = 
        [ 
        'a' 
        ,  
        'b' 
        ,  
        'cc' 
        ,  
        4 
        ]   
        # 定義一個列表通常用這種就能夠 
       
        # li = list(['a','b','cc',4]) # 定義一個列表 
       
        # #增長 
       
        li.append( 
        5 
        )   
        # #在列表末尾 添加一個元素,li=['a', 'b', 'cc', 4, 5] 
       
        li.insert( 
        0 
        ,  
        'g' 
        )   
        # #在列表末尾 添加一個元素,li=['g', 'a', 'b', 'cc', 4] 
       
        li.extend([ 
        'gg' 
        ,  
        'kk' 
        ])   
        # 添加一個列表['gg','kk'], li=['a', 'b', 'cc', 4, 'gg', 'kk'] 
       
        # # 刪除 
       
        aa  
        = 
        li.pop()  
        #******pop 刪除的時候要保障元素存在，否則會報錯******， 
       
        print 
        (li,aa)   
        # 從尾部刪除一個元素,並返回刪除的元素 ['a', 'b', 'cc'] 4 
       
        aa  
        = 
        li.pop( 
        2 
        )   
        # 刪除索引爲2的元素,並返回刪除的元素['a', 'b', 4] cc 
       
        aa  
        = 
        li.remove( 
        'a' 
        )   
        # 從列表中移除，無返回值 'a',['b', 'cc', 4] None 
       
        li.clear()   
        # 清空列表[] 
       
        del 
        li[-1]   
        # 刪除最後一個 
       
        # # 修改 
       
        li[ 
        0 
        ]  
        = 
        'A'  
        # ['A', 'b', 'cc', 4] 
       
        # # 查找 
       
        print 
        (li.index( 
        'a' 
        ))   
        # 運行結果0 
       
        # 獲取該元素，在列表中的索引,（若是列表中有多個相同的元素，只會取找到的第一個元素的索引。 
       
        # 固然也可獲取某段範圍的索引print(liist1.index('d',2,5))） 
       
        # 找不到會報錯 
       
        print 
        (li.count( 
        'a' 
        ))   
        # 運行結果1  統計列表中有幾個a（元素） 
       
        # # 其餘 
       
        li.reverse()   
        # 反轉一個列表,li=[4, 'cc', 'b', 'a'] 
       
        for 
        i  
        in 
        li:   
        # 循環輸出列表元素 
       
        print 
        (i) 
       
        list1  
        = 
        [ 
        "a" 
        ,  
        "c" 
        ,  
        "b" 
        ,  
        "e" 
        ,  
        "d" 
        ] 
       
        list1.sort()   
        # 排序 
       
        print 
        (list1)   
        # ['a', 'b', 'c', 'd', 'e'] 
       
        # # python3.x系列的數據類型排序，字符串類型和數字類型不能一塊兒進行排序

4、元組（tuple）

 
        """ 
       
 
        元組【有序不可變】 
       
 
        　　做用：存多個值，對比列表來講，元組不可變（是能夠當作字典的key的），主要是用來讀 
       
 
        　　定義： 
       
 
        　　　　與列表類型比，只不過[]換成() 
       
 
        """ 
       

           
       
 
        t  
        = 
        ( 
        'a' 
        ,)   
        # 元祖只有一個元素時，須要加逗號, 和字符串區分開 
       
 
        t  
        = 
        ( 
        'a' 
        ,  
        'b' 
        ,  
        'b' 
        ,  
        'c' 
        )   
        # 定義一個元組 
       
 
        t  
        = 
        tuple 
        (( 
        'a' 
        ,  
        'b' 
        ,  
        'b' 
        ,  
        'c' 
        )) 
       

           
       
 
        print 
        (t.index( 
        'b' 
        ))   
        # 索引出元素第一次出現的位置，還能夠指定在某一範圍裏查找，這裏默認在整個元組裏查找輸出1 
       
 
        print 
        (t.count( 
        'b' 
        ))   
        # 計算元素出現的次數，這裏輸出2 
       
 
        print 
        ( 
        len 
        (t))   
        # 輸出遠組的長度，這裏輸出4 
       
 
        print 
        (t[ 
        1 
        : 
        3 
        ])   
        # 切片 輸出('b','b') 
       
 
        for 
        i  
        in 
        t: 
       
 
             
        print 
        (i)   
        # 循環打印出元組數據 
       

5、字典（dict）

"""
字典【無序可變】
　　做用：存多個值,key-value存取，取值速度快
　　定義：
　　　　key必須惟一，必須是不可變類型，value能夠是任意類型
"""

# 建立：
info = {"name": "tom", "age": 18, "gender": "male"}  # 本質info=dict({"name":"tom","age":18})
# info=dict(name='tom',age=18,gender='male')
# info=dict([['name','tom'],('age',18)])
# info={}.fromkeys(('name','age','gender'),None) #{'name': None, 'gender': None, 'age': None}

# 增長
info['salary'] = 50000  # {'name': 'tom', 'age': 18, 'salary': 50000, 'gender': 'male'}

# 刪除
info.pop('age')  # 根據鍵刪除某一元素 d={'Michael': 95, 'Tracy': 85}
info.popitem()  # 隨機刪除
info.clear()  # {}

# 修改
info['age'] = '25'  # 若是沒有該key，則在字典建立新的的的key-value

# 查詢
info.get('age')  # 根據key獲取values，若是不存在返回None，這裏輸出75
'''
setdefault的功能
1：key存在，則不賦值，key不存在則設置默認值
2：key存在，返回的是key對應的已有的值，key不存在，返回的則是要設置的默認值
'''
print(info.setdefault('age', 50000))  # 18
print(info.setdefault('salary', 50000))  # 50000
print(info)  # {'age': 18, 'name': 'tom', 'salary': 50000, 'gender': 'male'}

# 其餘
print(len(info))  # 輸出字典長度
print('age' in info)  # python3 中移除了 has_key,要判斷鍵是否存在用in

for i in info:
    print(i)  # 循環默認按鍵輸出

for i in info.values():  # 循環按值輸出
    print(i)

for k, v in info.items():  # 循環按鍵值輸出
    print(k, v)

seq = ('Google', 'Runoob', 'Taobao')
seq2 = ('1', '2', '3')
d1 = dict.fromkeys(seq)
d2 = dict.fromkeys(seq,seq2)

print(d1) # {'Google': None, 'Taobao': None, 'Runoob': None}
print(d2) # {'Taobao': ('1', '2', '3'), 'Google': ('1', '2', '3'), 'Runoob': ('1', '2', '3')}

def clear(self)
def copy(self)
@staticmethod # known case
def fromkeys(*args, **kwargs)
def get(self, k, d=None)
def items(self)
def keys(self)
def pop(self, k, d=None)
def popitem(self)
def setdefault(self, k, d=None)
def update(self, E=None, **F)
def values(self)

字典函數

6、集合（set）

 
        """ 
       
        集合【無序可變】 
       
        　　做用：去重，關係運算 
       
        　　定義： 
       
        　　　　 1：每一個元素必須是不可變類型(可hash，可做爲字典的key) 
       
        2:沒有重複的元素 
       
        3：無序 
       
        4：能夠包含多個元素，用逗號分割， 
       
        """ 
       
        a  
        = 
        { 
        1 
        ,  
        2 
        ,  
        3 
        ,  
        4 
        ,  
        5 
        ,  
        6 
        ,  
        7 
        ,  
        8 
        ,  
        9 
        } 
       
        b  
        = 
        { 
        1 
        ,  
        3 
        ,  
        9 
        ,  
        10 
        ,  
        11 
        } 
       
        a.add( 
        10 
        )   
        # 添加一個元素 
       
        a.discard( 
        1 
        )   
        # 刪除元素1，不存在的話不報錯 
       
        a.remove( 
        1 
        )   
        # 刪除元素1，不存在的話報錯 
       
        a.pop()   
        # 隨機刪除 
       
        a.update([ 
        1 
        ,  
        8 
        ,  
        34 
        ])   
        # 更新，沒有就添加，有就不添加 
       
        # 並集 
       
        a.union(b) 
       
        a | b 
       
        # 返回一個新的集合包含a和b的全部元素 
       
        # 交集 
       
        a.intersection(b) 
       
        a & b 
       
        # 返回一個新的集合包含a和b的公共元素 
       
        # 差集 
       
        a.difference(b) 
       
        a  
        - 
        b 
       
        # 返回一個新的集合，包含a中的元素，可是沒有b中的元素 
       
        # 對稱差集 
       
        a.symmetric_difference(b) 
       
        print 
        (a ^ b) 
       
        # 返回一個新的集合包含 a和b中不重複的元素

數據類型總結

【有序】: 列表，元組
【無序】: 字典，集合
【可變】:列表，字典，集合
【不可變】：數字，字符串，元組
【存單值】:數字，字符串
【存多值】:列表，元組，字典

其餘

1、格式化

 
          res1 
          = 
          '{} {} {}' 
          . 
          format 
          ( 
          'tom' 
          , 
          18 
          , 
          'male' 
          ) 
         
 
          res2 
          = 
          '{1} {0} {1}' 
          . 
          format 
          ( 
          'tom' 
          , 
          18 
          , 
          'male' 
          ) 
         
 
          res3 
          = 
          '{name} {age} {gender}' 
          . 
          format 
          (gender 
          = 
          'male' 
          ,name 
          = 
          'tom' 
          ,age 
          = 
          18 
          ) 
         
 
          res4 
          = 
          '{name} {age} {gender}' 
          . 
          format 
          ( 
          * 
          * 
          { 
          "name" 
          :  
          "tom" 
          ,  
          "age" 
          :  
          18 
          , 
          "gender" 
          : 
          "male" 
          }) 
         
 
          print 
          (res1)  
          #tom 18 male 
         
 
          print 
          (res2)  
          #18 egon 18 
         
 
          print 
          (res3)  
          #tom 18 male 
         
 
          print 
          (res4)  
          #tom 18 male 
         

             
         
 
          msg 
          = 
          'i am %s my hobby is %s' 
          % 
          ( 
          'seven' 
          , 
          'paly' 
          ) 
         
 
          tpl  
          = 
          "%(name)s age %(age)d" 
          % 
          { 
          "name" 
          :  
          "tom" 
          ,  
          "age" 
          :  
          18 
          } 
         
 
          print 
          (msg)  
          #i am seven my hobby is paly 
         
 
          print 
          (tpl)  
          #tom age 18 
         

2、切片

 
        s 
        = 
        'abcdefghigk' 
       
 
        print 
        (s[ 
        0 
        : 
        3 
        ])  
        #截取第一位到第三位的字符  #abc 
       
 
        print 
        (s[:] ) 
        #截取字符串的所有字符 #abcdefghigk 
       
 
        print 
        (s[ 
        6 
        :])  
        #截取第七個字符到結尾 #ghigk 
       
 
        print 
        (s[: 
        - 
        3 
        ] ) 
        #截取從頭開始到倒數第三個字符以前 #abcdefgh 
       
 
        print 
        (s[ 
        2 
        ])  
        #截取第三個字符 #c 
       
 
        print 
        (s[ 
        - 
        1 
        ] ) 
        #截取倒數第一個字符 #k 
       
 
        print 
        (s[:: 
        - 
        1 
        ])  
        #創造一個與原字符串順序相反的字符串 #kgihgfedcba 
       
 
        print 
        (s[ 
        - 
        3 
        : 
        - 
        1 
        ] ) 
        #截取倒數第三位與倒數第一位以前的字符 #ig 
       
 
        print 
        (s[ 
        - 
        3 
        :])  
        #截取倒數第三位到結尾 #igk 
       
 
        print 
        (s[ 
        0 
        : 
        10 
        : 
        2 
        ]) 
        #每隔一個，取一個值 #acegi 
       
 
        print 
        (s[ 
        0 
        : 
        10 
        : 
        3 
        ]) 
        #每隔2個，取一個值 #adgg 
       

三、enumerate

　　爲一個可迭代的對象添加序號，可迭代的對象你能夠理解成能用for循環的就是可迭代的。默認是編號是從0開始，能夠設置從1開始git

四、三目運算

　　三目運算符能夠簡化條件語句的縮寫，可使代碼看起來更加簡潔，三目能夠簡單的理解爲有三個變量，它的形式是這樣的 name= k1 if 條件 else k2 ，若是條件成立，則 name=k1，不然name=k2，下面從代碼裏面來加深一下理解，從下面的代碼明顯能夠看出三目運算符可使代碼更加簡潔。python3.x

5、淺copy和深copy

對於字典、列表等數據結構，深拷貝和淺拷貝有區別，從字面上來講，能夠看出深拷貝能夠徹底拷貝，淺拷貝則沒有徹底拷貝。api

 
        #字典只有頂級對象(源變了，深淺copy沒變) 
       
 
        import 
        copy   
        #導入copy模塊 
       
 
        info  
        = 
        { 
        'name' 
        : 
        'tom' 
        , 
        'age' 
        : 
        18 
        }   
        #原始字典 
       
 
        info_copy  
        = 
        copy.copy(info)  
        #淺拷貝 
       
 
        info_deep  
        = 
        copy.deepcopy(info)  
        #深拷貝 
       
 
        print 
        (info) 
       
 
        print 
        (info_copy) 
       
 
        print 
        (info_deep) 
       
 
        id 
        (info); 
        id 
        (info_copy); 
        id 
        (info_deep)   
        #3個不一樣的對象,id不同 
       
 
        info[ 
        'age' 
        ]  
        = 
        19  
        #源變了，深淺copy沒變 
       

           
       
 
        #字典嵌套可變對象 （源和淺copy變了，深copy沒變） 
       
 
        import 
        copy   
        #導入copy模塊 
       
 
        info  
        = 
        { 
        'name' 
        : 
        'tom' 
        , 
        'age' 
        : 
        18 
        , 
        'job' 
        :[ 
        'it' 
        , 
        'design' 
        ]}   
        #原始字典 
       
 
        info_copy  
        = 
        copy.copy(info)  
        #淺拷貝 
       
 
        info_deep  
        = 
        copy.deepcopy(info)  
        #深拷貝 
       

           
       
 
        id 
        (info); 
        id 
        (info_copy); 
        id 
        (info_deep)   
        #3個不一樣的對象,id不同 
       
 
        info[ 
        'job' 
        ][ 
        0 
        ]  
        = 
        'boss'  
        #源和淺copy變了，深copy沒變 
       
 
        print 
        (info) 
        #{'age': 18, 'job': ['boss', 'design'], 'name': 'tom'} 
       
 
        print 
        (info_copy) 
        #{'age': 18, 'job': ['boss', 'design'], 'name': 'tom'} 
       
 
        print 
        (info_deep)  
        #{'age': 18, 'job': ['it', 'design'], 'name': 'tom'} 
       

           
       
 
        ''' 
       

           
       
 
        深淺copy都是對源對象的複製，佔用不一樣的內存空間。 
       
 
        若是源對象只有一級目錄的話，源作任何改動，不影響深淺拷貝對象 
       
 
        若是對象不止一級目錄，源作任何改動，都要影響淺拷貝，但不影響深 拷貝 
       
 
        ''' 
       