pythonデータ型の強制変換

7944 ワード

データ型の強制変換
あるデータを別のデータ型に変換する場合は、対応するタイプの関数に入れるだけです.
Numberタイプのデータ変換
強制的にintに変換
変換可能なデータ型
  • int整型
  • float浮動小数点型
  • boolブール型
  • str文字列(整数)
  • データへんかん
    #   (          )
    print(int(10))
    
    #    (            )
    print(int(10.999))
    
    #    (        ,           ,True=1,False=0)
    print(int(True))
    print(int(False))
    
    #    (                 )
    print(int('-123'))
    print(int('123'))

    強制的にfloatに変換
    変換可能なデータ型
  • int整型
  • float浮動小数点型
  • boolブール型
  • str文字列(整数、浮動小数点)
  • データへんかん
    #   (           ,    0)
    print(float(10))
    
    #    (         )
    print(float(10.999))
    
    #    (        ,           ,True=1.0,False=0.0)
    print(float(True))
    print(float(False))
    
    #    (                     )
    print(float('-123'))
    print(float('1234.134'))

    強制的にboolに変換
    変換可能なデータ型
    pythonのすべてのデータ型はブール型に変換できますが、結果は2つしかありません.TrueFalseです.
    データへんかん
    pythonでは,10種類のみのデータがboolに変換される値はFalseであり,残りはTrueである.
    #    ,python          False
    
    # 1、   (0)
    print(bool(0))
    
    # 2、   (0.0)
    print(bool(0.0))
    
    # 3、   (False)
    print(bool(False))
    
    # 4、  (0j)
    print(bool(0j))
    
    # 5、   (    )
    print(bool(''))
    
    # 6、  (   )
    print(bool([]))
    
    # 7、  (   )
    print(bool(()))
    
    # 8、  (   )
    print(bool(set()))
    
    # 9、  (   )
    print(bool({}))
    
    # 10、None(python   ,       )
    print(bool(None))

    強制的にcomplexに変換
    変換可能なデータ型
  • int整型
  • float浮動小数点型
  • boolブール型
  • complex複素
  • str文字列(整数、浮動小数点、複素)
  • データへんかん
    #   (       +0j)
    print(complex(10))
    
    #    (        +0j)
    print(complex(10.999))
    
    #    (        ,           ,True=1+0j,False=0j)
    print(complex(True))
    print(complex(False))
    
    #   (        ,0+0j=0j)
    print(complex(1234+341j))
    print(complex(0+0j))
    
    #    (            、           )
    print(complex('-123'))
    print(complex('1234.134'))
    print(complex('1234+0j'))

    数値タイプの自動変換
    異なるタイプの数字が一緒に演算されると、結果は精度の低いものから高いものへ自動的に変換されます.低精度の数と高精度の数を演算すると、最後に高精度数タイプになります
    精度が低い順にソート:
    bool -----> int -----> float ------> complex
  • boolとbool以外のデータ型演算結果はbool
  • ではありません.
  • complexは、任意のタイプのデータと演算するとcomplex
  • になります.
    #       bool     int    ,               int
    # bool + int
    res = True + 100
    print(res, type(res))
    
    # bool + float
    res = True + 100.11
    print(res, type(res))
    
    # bool + complex
    res = True + 0j
    print(res, type(res))
    
    # int + float
    res = 123 + 100.9
    print(res, type(res))
    
    # int + complex
    res = 123 + 0j
    print(res, type(res))
    
    # float + complex
    res = 100.0000 + 0j
    print(res, type(res))

    containerタイプの強制変換
    コンテナタイプの変換は、対応するコンテナの関数を使用して変換されます.
    文字列に変換
    変換をサポートするデータ型
    すべてのデータ型
    #   1、     
    print('[1, 2, 3]')
    
    #   2、  str  
    print(str([1, 2, 3]))
    # [1, 2, 3]
    
    #   3、  repr  
    print(repr([1, 2, 3]))
    # [1, 2, 3]
    
    # repr     :        ,     (     )
    lstvar = [1, 2, 3]
    res =  str(lstvar)
    print(repr(res))
    # '[1, 2, 3]'

    リストに変換
    変換をサポートするデータ型
    コンテナのみ
    注意点
    文字列の場合、各文字列は単独で要素としてリストに配置されます.
    辞書であれば、キーだけを残して、新しいリストを形成します.
    他の容器であれば、単純に既存のデータに基づいて[]を交換するだけです.
    # 1、   
    #                  
    var = 'hello motherland'
    print(list(var))
    # ['h', 'e', 'l', 'l', 'o', ' ', 'm', 'o', 't', 'h', 'e', 'r', 'l', 'a', 'n', 'd']
    
    # 2、  
    var = {'one': 1, 'two': 2, 'three': 3}
    print(list(var))
    # ['one', 'two', 'three']
    
    # 3、       
    var = (1, 3, 4, 5, 6)
    print(list(var))
    # [1, 3, 4, 5, 6]
    
    var = {1, 3, 4, 5, 6}
    print(list(var))
    # [1, 3, 4, 5, 6]

    メタグループに変換
    変換をサポートするデータ型
    コンテナのみ
    注意点
    文字列の場合、各文字列は個別に要素としてリストに配置されます.
    辞書の場合は、キーのみを保持し、新しいリストを作成します.
    他の容器であれば、単純に元のデータを基に交換するだけです()
    リストと同じです
    # 1、   
    #                  
    var = 'hello motherland'
    print(tuple(var))
    # ('h', 'e', 'l', 'l', 'o', ' ', 'm', 'o', 't', 'h', 'e', 'r', 'l', 'a', 'n', 'd')
    
    # 2、  
    var = {'one': 1, 'two': 2, 'three': 3}
    print(tuple(var))
    # ('one', 'two', 'three')
    
    # 3、       
    var = [1, 3, 4, 5, 6]
    print(tuple(var))
    # (1, 3, 4, 5, 6)
    
    var = {1, 3, 4, 5, 6}
    print(tuple(var))
    # (1, 3, 4, 5, 6)

    コレクションに変換
    サポートされるデータ型
    コンテナのみ
    注意点
    集合の変化はリスト、メタグループと同じで、単純に既存のデータに基づいて{}を交換するだけです.
    ただし、集合は無秩序であり、返される結果の要素の順序は固定されません.
    # 1、   
    #                  
    var = 'hello motherland'
    print(set(var))
    # {'d', 'r', ' ', 'h', 'n', 'e', 't', 'm', 'a', 'o', 'l'}
    
    # 2、  
    var = {'one': 1, 'two': 2, 'three': 3}
    print(set(var))
    # {'two', 'one', 'three'}
    
    # 3、       
    var = ['1', '3', '4', '5', '6']
    print(set(var))
    # {'5', '4', '6', '1', '3'}
    
    var = ('1', '3', '4', '5', '6')
    print(set(var))
    # {'5', '4', '6', '1', '3'}

    ただんようき
  • 一つの容器の中に一つの容器をネストし、この容器を二級容器と呼ぶ.ネストされた容器の中にもう一つの容器をネストし、最外層の容器を三級容器と呼ぶ.このように、4級、5級......
  • 容器のタイプは最外層の容器に依存し、異なるタイプの容器は互いにネストすることができるが、集合と辞書を除く.辞書のキーとセットの値はハッシュ可能なタイプでなければならないため、ハッシュ可能なデータ型Number、str、tuple;
  • マルチレベルコンテナには文字列は含まれません.文字列は特殊なコンテナであり、任意の文字は文字列の個別要素です.
  • #     
    #            
    var = [1, 2, [1, 2, 3]]
    
    #     
    #            ,             
    var = [1, 2, [3, 4, (5, 6)]]
    # ……
    
    #     
    #            ,             
    var = {'1': 1, '2': 2, '666': {'3': 3, '4': 4}}

    マルチレベルコンテナの値の取得
    #                    、             
    
    
    #   :          !!!    10
    No1_level4_container = [1, 2, 3, 4, (1, 2, 3, 4, {1: 1, 2: 2, "msr": [1, 2, 3, 4, 10]})]
    
    print("---     ")
    print(No1_level4_container)
    
    #          ,           ,    python       ,       
    
    # 1、     。        
    res = No1_level4_container[-1]  #                -1     
    print("---    ")
    print(res)
    
    # 2、     
    res = res[-1]
    res1 = No1_level4_container[-1][-1]
    print("---    ")
    print(res)
    print(res1)
    
    # 3、     msr    
    res = res['msr']
    print("---  msr")
    print(res)
    
    # 4、     10   -1  4
    res1 = res[-1]
    res2 = res[4]
    print('---    ')
    print(res1, res2)
    
    #   
    res = No1_level4_container[-1][-1]['msr'][-1]
    print('---    ')
    print(res)

    等長多段容器
  • 外層容器中の元素はすべて容器
  • である.
  • ネストされたコンテナ内の要素の個数は同じ
  • である.
    #        
    var = [(1, 2, 3,), (4, 5, 6,)]

    辞書の強転
    要求
    等長の二次容器でなければなりません.中の要素の数は2つでなければなりません.
    コンテナの変換
    #   dict      
    var = [('one', 1), ('two', 2)]
    dctvar = dict(var)
    print(dctvar)
    print(type(dctvar))
    # {'one': 1, 'two': 2}
    # 

    注意点
    リスト、メタグループ、コレクション、文字列の使用は推奨されません
    # 1、         、  ,              
    var = [(1, 2), [3, 4]]
    res = dict(var)
    print(res, type(res))
    
    # 2、       
    #        ,       ,      。      ,          ,                         。
    var = [{'1', 2}, {'2', 3}]
    res = dict(var)
    print(res)
    
    # 3、        
    #        ,     ,       。                  ,                ,              。
    var = [[1, 2], "ab"]
    print(dict(var))
    
    var = [[1, 2], "abc"]
    print(dict(var))    # error

    各データ型の関数の役割
    #               ,         false
    print(int())        # 0
    print(float())        # 0.0
    print(bool())        # false
    print(complex())    # 0j
    print(str())        # ''
    print(list())        # []
    print(tuple())        # ()
    print(set())        # set()
    print(dict())        # {}