Pythonのデータ型変換

概要

Pythonでデータ型に変換するサンプルをまとめました。特にバイト型は通信ソフトウェアの開発において重要です。

データ型変換元	データ型変換元
	byte型	int型	float型	str型
byte型	＊	○	○	○
int型	○	＊	○	○
float型	○	○	＊	○
str型	○	○	○	＊

データ型

ここで使うデータ型を以下に示します。

• byte型…
• int型…整数
• float型…浮動小数点数
• str型…文字列

データ型の定義方法

変数にデータ型を指定してデータを格納するコードを以下に示します。データ型を確認するときはtype関数を使用します。

byte型の定義方法

byte型のデータを変数に格納するコードを以下に示します。

# -*- coding: utf-8 -*-

#byte型
b_data1 = b'foo'
print(type(b_data1))
print(b_data1)

b_data2 = b"foo"
print(type(b_data2))
print(b_data2)

実行結果を以下に示します。

<class 'bytes'>
b'foo'
<class 'bytes'>
b'foo'

byte型の変数は、配列として使うことができます。ただし、int型に変換されます。

# -*- coding: utf-8 -*-
b_data = b'\x00\x01\xff'

print(type(b_data))
print(b_data)

print(type(b_data[0]))
print(b_data[0])

print(type(b_data[1]))
print(b_data[1])

print(type(b_data[2]))
print(b_data[2])

実行結果を以下に示します。

<class 'bytes'>
b'\x00\x01\xff'
<class 'int'>
0
<class 'int'>
1
<class 'int'>
255

int型の定義方法

int型のデータを変数に格納するコードを以下に示します。

# -*- coding: utf-8 -*-

#int型
i_data1 = 100
print(type(i_data1))
print(i_data1)

i_data2 = 99 ** 2
print(type(i_data2))
print(i_data2)

実行結果を以下に示します。

<class 'int'>
100
<class 'int'>
9801

float型の定義方法

float型のデータを変数に格納するコードを以下に示します。

# -*- coding: utf-8 -*-

#float型
f_data1 = 100.9
print(type(f_data1))
print(f_data1)

f_data2 = 99.9 ** 2
print(type(f_data2))
print(f_data2)

実行結果を以下に示します。

<class 'float'>
100.9
<class 'float'>
9980.010000000002

str型の定義方法

str型のデータを変数に格納するコードを以下に示します。

# -*- coding: utf-8 -*-

#str型
s_data1 = 'foo'
print(type(s_data1))
print(s_data1)

s_data2 = "bar"
print(type(s_data2))
print(s_data2)

実行結果を以下に示します。

<class 'str'>
foo
<class 'str'>
bar

str型の変数は、配列として使うことができます。

# -*- coding: utf-8 -*-

s_data = "-1.2"
print(type(s_data))
print(s_data)

print(type(s_data[0]))
print(s_data[0])

print(type(s_data[1]))
print(s_data[1])

print(type(s_data[2]))
print(s_data[2])

print(type(s_data[3]))
print(s_data[3])

実行結果を以下に示します。

<class 'str'>
-1.2
<class 'str'>
-
<class 'str'>
1
<class 'str'>
.
<class 'str'>
2

byte型データのデータ型変換

byte型データから変換するデータ型を以下に示します。

• int型
• float型
• str型

byte型データからint型データにデータ型変換

byte型データからint型データにデータ型変換するコードを以下に示します。structまたはfrom_bytesを使用します。

struct

structを使用する変換は、structをインポートする必要があります。

# -- coding: utf-8 --
import struct

b_data1 = b'\x7f'
print(type(b_data1))
print(b_data1)
# 符号なし整数(unsigned char) 1バイトとして変換
i_data1 = struct.unpack('B', b_data1)
print(type(i_data1))
print (i_data1)
print(type(i_data1[0]))
print (i_data1[0])

b_data2 = b'\x7f\x00'
print(type(b_data2))
print(b_data2)
# 符号なし整数(unsigned short) 2バイト
# リトルエンディアン(デフォルト)として変換
i_data2 = struct.unpack('H', b_data2)
print(type(i_data2))
print (i_data2)
print(type(i_data2[0]))
print (i_data2[0])

b_data3 = b'\x00\x7f'
print(type(b_data3))
print(b_data3)
# 符号なし整数(unsigned short) 2バイト
# ビッグエンディアンとして変換
i_data3 = struct.unpack('>H', b_data3)
print(type(i_data3))
print (i_data3)
print(type(i_data3[0]))
print (i_data3[0])

b_data4 = b'\x7f\x00'
print(type(b_data4))
print(b_data4)
# 符号なし整数(unsigned short) 2バイト
# リトルエンディアンとして変換
i_data4 = struct.unpack('<H', b_data4)
print(type(i_data4))
print (i_data4)
print(type(i_data4[0]))
print (i_data4[0])

b_data5 = b'\x7f\x00\x00\x00'
print(type(b_data5))
print(b_data5)
# 符号なし整数(unsigned int) 4バイトとして変換
i_data5 = struct.unpack('I', b_data5)
print(type(i_data5))
print (i_data5)
print(type(i_data5[0]))
print (i_data5[0])

b_data6 = b'\x7f\x00\x00\x00'
print(type(b_data6))
print(b_data6)
# 符号なし整数(unsigned long) 4バイトとして変換
i_data6 = struct.unpack('L', b_data6)
print(type(i_data6))
print (i_data6)
print(type(i_data6[0]))
print (i_data6[0])

b_data7 = b'\x81'
print(type(b_data7))
print(b_data7)
# 符号付き整数(unsigned char) 1バイトとして変換
i_data7 = struct.unpack('b', b_data7)
print(type(i_data7))
print (i_data7)
print(type(i_data7[0]))
print (i_data7[0])

b_data8 = b'\x81\xff'
print(type(b_data8))
print(b_data8)
# 符号付き整数(unsigned short) 2バイト
# リトルエンディアン(デフォルト)として変換
i_data8 = struct.unpack('h', b_data8)
print(type(i_data8))
print (i_data8)
print(type(i_data8[0]))
print (i_data8[0])

b_data9 = b'\xff\x81'
print(type(b_data9))
print(b_data9)
# 符号付き整数(unsigned short) 2バイト
# ビッグエンディアンとして変換
i_data9 = struct.unpack('>h', b_data9)
print(type(i_data9))
print (i_data9)
print(type(i_data9[0]))
print (i_data9[0])

b_data10 = b'\x81\xff'
print(type(b_data10))
print(b_data10)
# 符号付き整数(unsigned short) 2バイト
# リトルエンディアンとして変換
i_data10 = struct.unpack('<h', b_data10)
print(type(i_data10))
print (i_data10)
print(type(i_data10[0]))
print (i_data10[0])

b_data11 = b'\x81\xff\xff\xff'
print(type(b_data11))
print(b_data11)
# 符号付き整数(unsigned int) 4バイトとして変換
i_data11 = struct.unpack('i', b_data11)
print(type(i_data11))
print (i_data11)
print(type(i_data11[0]))
print (i_data11[0])

b_data12 = b'\x81\xff\xff\xff'
print(type(b_data12))
print(b_data12)
# 符号付き整数(unsigned long) 4バイトとして変換
i_data12 = struct.unpack('l', b_data12)
print(type(i_data12))
print (i_data12)
print(type(i_data12[0]))
print (i_data12[0])

b_data13 = b'\x7f'
print(type(b_data13))
print(b_data13)
i_data13 = int.from_bytes(b_data13, byteorder='little')
print(type(i_data13))
print(i_data13)

b_data14 = b'\x00\x7f'
print(type(b_data14))
print(b_data14)
i_data14 = int.from_bytes(b_data14, byteorder='big')
print(type(i_data14))
print(i_data14)

b_data15 = b'\x7f\x00'
print(type(b_data15))
print(b_data15)
i_data15 = int.from_bytes(b_data15, byteorder='little')
print(type(i_data15))
print(i_data15)

実行結果を以下に示します。

<class 'bytes'>
b'\x7f'
<class 'tuple'>
(127,)
<class 'int'>
127
<class 'bytes'>
b'\x7f\x00'
<class 'tuple'>
(127,)
<class 'int'>
127
<class 'bytes'>
b'\x00\x7f'
<class 'tuple'>
(127,)
<class 'int'>
127
<class 'bytes'>
b'\x7f\x00'
<class 'tuple'>
(127,)
<class 'int'>
127
<class 'bytes'>
b'\x7f\x00\x00\x00'
<class 'tuple'>
(127,)
<class 'int'>
127
<class 'bytes'>
b'\x7f\x00\x00\x00'
<class 'tuple'>
(127,)
<class 'int'>
127
<class 'bytes'>
b'\x81'
<class 'tuple'>
(-127,)
<class 'int'>
-127
<class 'bytes'>
b'\x81\xff'
<class 'tuple'>
(-127,)
<class 'int'>
-127
<class 'bytes'>
b'\xff\x81'
<class 'tuple'>
(-127,)
<class 'int'>
-127
<class 'bytes'>
b'\x81\xff'
<class 'tuple'>
(-127,)
<class 'int'>
-127
<class 'bytes'>
b'\x81\xff\xff\xff'
<class 'tuple'>
(-127,)
<class 'int'>
-127
<class 'bytes'>
b'\x81\xff\xff\xff'
<class 'tuple'>
(-127,)
<class 'int'>
-127

from_bytes

from_bytesを使用する変換を以下に示します。python3以上使用できます。

# -- coding: utf-8 --
import struct

b_data1 = b'\x7f'
print(type(b_data1))
print(b_data1)
i_data1 = int.from_bytes(b_data1, byteorder='little')
print(type(i_data1))
print(i_data1)

b_data2 = b'\x00\x7f'
print(type(b_data2))
print(b_data2)
i_data2 = int.from_bytes(b_data2, byteorder='big')
print(type(i_data2))
print(i_data2)

b_data3 = b'\x7f\x00'
print(type(b_data3))
print(b_data3)
i_data3 = int.from_bytes(b_data3, byteorder='little')
print(type(i_data3))
print(i_data3)

b_data4 = b'\xff\x81'
print(type(b_data4))
print(b_data4)
i_data4 = int.from_bytes(b_data4, byteorder='big', signed=True)
print(type(i_data4))
print(i_data4)

b_data5 = b'\x81\xff'
print(type(b_data5))
print(b_data5)
i_data5 = int.from_bytes(b_data5, byteorder='little', signed=True)
print(type(i_data5))
print(i_data5)

実行結果を以下に示します。

<class 'bytes'>
b'\x7f'
<class 'int'>
127
<class 'bytes'>
b'\x00\x7f'
<class 'int'>
127
<class 'bytes'>
b'\x7f\x00'
<class 'int'>
127
<class 'bytes'>
b'\xff\x81'
<class 'int'>
-127
<class 'bytes'>
b'\x81\xff'
<class 'int'>
-127

byte型データからfloat型データにデータ型変換

byte型データからfloat型データにデータ型変換するコードを以下に示します。

# -- coding: utf-8 --
import struct

b_data1 = b'\x7b\x14\x8e\x3f'
print(type(b_data1))
print(b_data1)
# 浮動小数点数4バイトとして変換
f_data1 = struct.unpack('f', b_data1)
print(type(f_data1))
print (f_data1)
print(type(f_data1[0]))
print (f_data1[0])

b_data2 = b'\xf0\x82\x96\x9b\x1d\xd89\x42'
print(type(b_data2))
print(b_data2)
# 浮動小数点数8バイトとして変換
f_data2 = struct.unpack('d', b_data2)
print(type(f_data2))
print (f_data2)
print(type(f_data2[0]))
print (f_data2[0])

b_data3 = b'\x3f\x9d\x70\xa4'
print(type(b_data3))
print(b_data3)
# 浮動小数点数4バイトとして変換
# ビッグエンディアンとして変換
f_data3 = struct.unpack('>f', b_data3)
print(type(f_data3))
print (f_data3)
print(type(f_data3[0]))
print (f_data3[0])

b_data4 = b'\xa4\x70\x9d\x3f'
print(type(b_data4))
print(b_data4)
# 浮動小数点数4バイトとして変換
# リトルエンディアンとして変換
f_data4 = struct.unpack('<f', b_data4)
print(type(f_data4))
print (f_data4)
print(type(f_data4[0]))
print (f_data4[0])

b_data5 = b'\xbf\x9d\x70\xa4'
print(type(b_data5))
print(b_data5)
# 浮動小数点数4バイトとして変換
# ビッグエンディアンとして変換
f_data5 = struct.unpack('>f', b_data5)
print(type(f_data5))
print (f_data5)
print(type(f_data5[0]))
print (f_data5[0])

b_data6 = b'\xa4\x70\x9d\xbf'
print(type(b_data6))
print(b_data6)
# 浮動小数点数4バイトとして変換
# リトルエンディアンとして変換
f_data6 = struct.unpack('<f', b_data6)
print(type(f_data6))
print (f_data6)
print(type(f_data6[0]))
print (f_data6[0])

b_data7 = b'\xc2\x39\xd8\x1d\x9b\x96\x82\xf0'
print(type(b_data7))
print(b_data7)
# 浮動小数点数8バイトとして変換
# ビッグエンディアンとして変換
f_data7 = struct.unpack('>d', b_data7)
print(type(f_data7))
print (f_data7)
print(type(f_data7[0]))
print (f_data7[0])

b_data8 = b'\xf0\x82\x96\x9b\x1d\xd8\x39\xc2'
print(type(b_data8))
print(b_data8)
# 浮動小数点数8バイトとして変換
# ビッグエンディアンとして変換
f_data8 = struct.unpack('<d', b_data8)
print(type(f_data8))
print (f_data8)
print(type(f_data8[0]))
print (f_data8[0])

実行結果を以下に示します。

<class 'bytes'>
b'{\x14\x8e?'
<class 'tuple'>
(1.1100000143051147,)
<class 'float'>
1.1100000143051147
<class 'bytes'>
b'\xf0\x82\x96\x9b\x1d\xd89B'
<class 'tuple'>
(111000001430.51147,)
<class 'float'>
111000001430.51147
<class 'bytes'>
b'?\x9dp\xa4'
<class 'tuple'>
(1.2300000190734863,)
<class 'float'>
1.2300000190734863
<class 'bytes'>
b'\xa4p\x9d?'
<class 'tuple'>
(1.2300000190734863,)
<class 'float'>
1.2300000190734863
<class 'bytes'>
b'\xbf\x9dp\xa4'
<class 'tuple'>
(-1.2300000190734863,)
<class 'float'>
-1.2300000190734863
<class 'bytes'>
b'\xa4p\x9d\xbf'
<class 'tuple'>
(-1.2300000190734863,)
<class 'float'>
-1.2300000190734863
<class 'bytes'>
b'\xc29\xd8\x1d\x9b\x96\x82\xf0'
<class 'tuple'>
(-111000001430.51147,)
<class 'float'>
-111000001430.51147
<class 'bytes'>
b'\xf0\x82\x96\x9b\x1d\xd89\xc2'
<class 'tuple'>
(-111000001430.51147,)
<class 'float'>
-111000001430.51147

byte型データからstr型データにデータ型変換

byte型データからstr型データにデータ型変換するコードを以下に示します。

# -- coding: utf-8 --
import codecs

b_data1 = b'\xe3\x81\x8f\xe3\x81\xbe\xe3\x81\x8a\xe3\x81\xb5\xe3\x81\x97\xe3\x81\x94\xe3\x82\x8d\xe3\x81\x86'
# utf-8として変換
s_data2 = b_data1.decode('utf-8')
print(type(s_data2))
print (s_data2)

b_data2 = b'\x82\xad\x82\xdc\x82\xa8\x82\xd3\x82\xb5\x82\xb2\x82\xeb\x82\xa4'
# Shift_JISとして変換
s_data3 = b_data2.decode('cp932')
print(type(s_data3))
print (s_data3)

実行結果を以下に示します。

<class 'str'>
くまおふしごろう
<class 'str'>
くまおふしごろう

int型データのデータ型変換

int型データから変換するデータ型を以下に示します。

• byte型
• float型
• str型

int型データからbyte型データにデータ型変換

int型データからbyte型データにデータ型変換するコードを以下に示します。structまたはto_bytesを使用します。

struct

structを使用する変換は、structをインポートする必要があります。

# -- coding: utf-8 --
import struct

i_data1 = 127
print(type(i_data1))
print(i_data1)

# 符号なし整数(unsigned char) 1バイトとして変換
b_data1 = struct.pack('B', i_data1)
print(type(b_data1))
print (b_data1)

# 符号なし整数(unsigned short) 2バイト
# リトルエンディアン(デフォルト)として変換
b_data2 = struct.pack('H', i_data1)
print(type(b_data2))
print (b_data2)

# 符号なし整数(unsigned short) 2バイト
# ビッグエンディアンとして変換
b_data3 = struct.pack('>H', i_data1)
print(type(b_data3))
print (b_data3)

# 符号なし整数(unsigned short) 2バイト
# リトルエンディアンとして変換
b_data4 = struct.pack('<H', i_data1)
print(type(b_data4))
print (b_data4)

# 符号なし整数(unsigned int) 4バイトとして変換
b_data5 = struct.pack('I', i_data1)
print(type(b_data5))
print (b_data5)

# 符号なし整数(unsigned long) 4バイトとして変換
b_data6 = struct.pack('L', i_data1)
print(type(b_data6))
print (b_data6)

i_data2 = -127
print(type(i_data2))
print(i_data2)

# 符号付き整数(unsigned char) 1バイトとして変換
b_data7 = struct.pack('b', i_data2)
print(type(b_data7))
print (b_data7)

# 符号付き整数(unsigned short) 2バイト
# リトルエンディアン(デフォルト)として変換
b_data8 = struct.pack('h', i_data2)
print(type(b_data8))
print (b_data8)

# 符号付き整数(unsigned short) 2バイト
# ビッグエンディアンとして変換
b_data9 = struct.pack('>h', i_data2)
print(type(b_data9))
print (b_data9)

# 符号付き整数(unsigned short) 2バイト
# リトルエンディアンとして変換
b_data10 = struct.pack('<h', i_data2)
print(type(b_data10))
print (b_data10)

# 符号付き整数(unsigned int) 4バイトとして変換
b_data11 = struct.pack('i', i_data2)
print(type(b_data11))
print (b_data11)

# 符号付き整数(unsigned long) 4バイトとして変換
b_data12 = struct.pack('l', i_data2)
print(type(b_data12))
print (b_data12)

実行結果を以下に示します。

<class 'int'>
127
<class 'bytes'>
b'\x7f'
<class 'bytes'>
b'\x7f\x00'
<class 'bytes'>
b'\x00\x7f'
<class 'bytes'>
b'\x7f\x00'
<class 'bytes'>
b'\x7f\x00\x00\x00'
<class 'bytes'>
b'\x7f\x00\x00\x00'
<class 'int'>
-127
<class 'bytes'>
b'\x81'
<class 'bytes'>
b'\x81\xff'
<class 'bytes'>
b'\xff\x81'
<class 'bytes'>
b'\x81\xff'
<class 'bytes'>
b'\x81\xff\xff\xff'
<class 'bytes'>
b'\x81\xff\xff\xff'

to_bytes

to_bytesを使用する変換を以下に示します。python3以上使用できます。

# -- coding: utf-8 --
i_data1 = 61712
print(type(i_data1))
print(i_data1)

b_data1 = i_data1.to_bytes(2, 'big') # 2バイトでビッグエンディアン
print(type(b_data1))
print(b_data1)

b_data2 = i_data1.to_bytes(4, 'little') # 4バイトでリトルエンディアン
print(type(b_data2))
print(b_data2)

i_data2 = -128
print(type(i_data2))
print(i_data2)

b_data3 = i_data2.to_bytes(4, 'big', signed=True) # 2バイトでビッグエンディアン
print(type(b_data3))
print(b_data3)

b_data4 = i_data2.to_bytes(4, 'little', signed=True) # 4バイトでリトルエンディアン
print(type(b_data4))
print(b_data4)

実行結果を以下に示します。

<class 'int'>
61712
<class 'bytes'>
b'\xf1\x10'
<class 'bytes'>
b'\x10\xf1\x00\x00'
<class 'int'>
-128
<class 'bytes'>
b'\xff\xff\xff\x81'
<class 'bytes'>
b'\x81\xff\xff\xff'

int型データからfloat型データにデータ型変換

int型データからfloat型データにデータ型変換するコードを以下に示します。

# -- coding: utf-8 --

i_data = 1
print(type(i_data))
print(i_data)

f_data = float(i_data)
print(type(f_data))
print(f_data)

実行結果を以下に示します。float型データに変換されると、小数点以下の数字が表記されることに注意してください。

<class 'int'>
1
<class 'float'>
1.0

int型データからstr型データにデータ型変換

int型データからstr型データにデータ型変換するコードを以下に示します。

# -- coding: utf-8 --

i_data = 1
print(type(i_data))
print(i_data)

s_data = str(i_data)
print(type(s_data))
print(s_data)

実行結果を以下に示します。

<class 'int'>
1
<class 'str'>
1

float型データのデータ型変換

float型データから変換するデータ型を以下に示します。

• byte型
• int型
• str型

float型データからbyte型データにデータ型変換

float型データからbyte型データにデータ型変換するコードを以下に示します。

# -- coding: utf-8 --
import struct

f_data1 = 1.1100000143051147
print(type(f_data1))
print(f_data1)
# 浮動小数点数4バイトとして変換
b_data1 = struct.pack('f', f_data1)
print(type(b_data1))
print (b_data1)

f_data2 = 111000001430.51147
print(type(f_data2))
print(f_data2)
# 浮動小数点数8バイトとして変換
b_data2 = struct.pack('d', f_data2)
print(type(b_data2))
print (b_data2)

f_data3 = 1.23
print(type(f_data3))
print(f_data3)
# 浮動小数点数4バイトとして変換
# ビッグエンディアンとして変換
b_data3 = struct.pack('>f', f_data3)
print(type(b_data3))
print (b_data3)

# 浮動小数点数4バイトとして変換
# リトルエンディアンとして変換
b_data4 = struct.pack('<f', f_data3)
print(type(b_data4))
print (b_data4)

f_data4 = -1.23
print(type(f_data4))
print(f_data4)
# 浮動小数点数4バイトとして変換
# ビッグエンディアンとして変換
b_data5 = struct.pack('>f', f_data4)
print(type(b_data5))
print (b_data5)

# 浮動小数点数4バイトとして変換
# リトルエンディアンとして変換
b_data5 = struct.pack('<f', f_data4)
print(type(b_data5))
print (b_data5)

f_data5 = -111000001430.51147
print(type(f_data5))
print(f_data5)
# 浮動小数点数8バイトとして変換
# ビッグエンディアンとして変換
b_data6 = struct.pack('>d', f_data5)
print(type(b_data6))
print (b_data6)

# 浮動小数点数8バイトとして変換
# ビッグエンディアンとして変換
b_data7 = struct.pack('<d', f_data5)
print(type(b_data7))
print (b_data7)

実行結果を以下に示します。int型データに変換されたとき、小数点以下の数値が削除されていることに注意してください。

<class 'float'>
1.1100000143051147
<class 'bytes'>
b'{\x14\x8e?'
<class 'float'>
111000001430.51147
<class 'bytes'>
b'\xf0\x82\x96\x9b\x1d\xd89B'
<class 'float'>
1.23
<class 'bytes'>
b'?\x9dp\xa4'
<class 'bytes'>
b'\xa4p\x9d?'
<class 'float'>
-1.23
<class 'bytes'>
b'\xbf\x9dp\xa4'
<class 'bytes'>
b'\xa4p\x9d\xbf'
<class 'float'>
-111000001430.51147
<class 'bytes'>
b'\xc29\xd8\x1d\x9b\x96\x82\xf0'
<class 'bytes'>
b'\xf0\x82\x96\x9b\x1d\xd89\xc2'

float型データからint型データにデータ型変換

float型データからint型データにデータ型変換するコードを以下に示します。

# -- coding: utf-8 --

f_data = 1.234
print(type(f_data))
print(f_data)

i_data = int(f_data)
print(type(i_data))
print(i_data)

実行結果を以下に示します。int型データに変換されたとき、小数点以下の数値が削除されていることに注意してください。

<class 'float'>
1.234
<class 'int'>
1

float型データからstr型データにデータ型変換

float型データからstr型データにデータ型変換するコードを以下に示します。

# -- coding: utf-8 --

f_data = 1.234
print(type(f_data))
print(f_data)

s_data = str(f_data)
print(type(s_data))
print(s_data)

実行結果を以下に示します。

<class 'float'>
1.234
<class 'str'>
1.234

str型データのデータ型変換

str型データから変換するデータ型を以下に示します。

• byte型
• int型
• float型

str型データからbyte型データにデータ型変換

str型データからbyte型データにデータ型変換するコードを以下に示します。

# -- coding: utf-8 --

import codecs

s_data1 = 'くまおふしごろう'
print(type(s_data1))
print(s_data1)

# utf-8として変換
b_data1 = s_data1.encode('utf-8')
print(type(b_data1))
print (b_data1)

# Shift_JISとして変換
b_data2 = s_data1.encode('cp932')
print(type(b_data2))
print (b_data2)

実行結果を以下に示します。

<class 'str'>
くまおふしごろう
<class 'bytes'>
b'\xe3\x81\x8f\xe3\x81\xbe\xe3\x81\x8a\xe3\x81\xb5\xe3\x81\x97\xe3\x81\x94\xe3\x82\x8d\xe3\x81\x86'
<class 'bytes'>
b'\x82\xad\x82\xdc\x82\xa8\x82\xd3\x82\xb5\x82\xb2\x82\xeb\x82\xa4'

str型データからint型データにデータ型変換

str型データからint型データにデータ型変換するコードを以下に示します。

# -- coding: utf-8 --

s_data = "1"
print(type(s_data))
print(s_data)

i_data = int(s_data)
print(type(i_data))
print(i_data)

実行結果を以下に示します。

<class 'str'>
1
<class 'int'>
1

16進数表記のstr型データからint型データに変換することもできます。

# -- coding: utf-8 --
s_data1 = '1234'
print(type(s_data1))
print(s_data1)
i_data1 = int(s_data1, 10) # 10進数表記として変換
print(type(i_data1))
print(i_data1)

s_data2 = '0x1234'
print(type(s_data2))
print(s_data2)
i_data2 = int(s_data2, 16) # 10進数表記として変換
print(type(i_data2))
print(i_data2)

s_data3 = '1234'
print(type(s_data3))
print(s_data3)
i_data3 = int(s_data3, 16) # 10進数表記として変換
print(type(i_data3))
print(i_data3)

実行結果を以下に示します。

<class 'str'>
1234
<class 'int'>
1234
<class 'str'>
0x1234
<class 'int'>
4660
<class 'str'>
1234
<class 'int'>
4660

浮動小数点数の文字列を使った場合(以下のコード)、エラーになります。

# -- coding: utf-8 --

s_data = "1.234"
print(type(s_data))
print(s_data)

i_data = int(s_data)
print(type(i_data))
print(i_data)

str型データからfloat型データにデータ型変換

str型データからfloat型データにデータ型変換するコードを以下に示します。

# -- coding: utf-8 --

s_data = "1.234"
print(type(s_data))
print(s_data)

f_data = float(s_data)
print(type(f_data))
print(f_data)

実行結果を以下に示します。

<class 'str'>
1.234
<class 'float'>
1.234

整数の文字列をfloat型にデータ型変換した場合(以下のコード)、小数点以下の数字が付きます。

# -- coding: utf-8 --

s_data = "1"
print(type(s_data))
print(s_data)

f_data = float(s_data)
print(type(f_data))
print(f_data)

実行した結果を以下に示します。

<class 'str'>
1
<class 'float'>
1.0