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

Processing3(WinPC)とMicro:bitの文字データ送受信

概要

WinPCとMico:bitが、シリアル通信(UART)を介して制御します。WinPCは、processing3で開発したアプリケーションからMicro:bitを制御します。

概要図

外部仕様

• Micro:bitのAボタンを押すと、B画面が表示されます。
• Bボタンを押すと、A画面が表示されます。

  

  A/B ボタン

• A/B画面の各画像をマウスでクリックすると、Micro:bitのLEDディスプレイにクリックした画像と同じものが表示されます。

  

  A Display

  

  B Display

基本的な接続

UART-USB変換を使用して、以下のようにMicro:bitとWin PCとを接続します。

基本的な接続

※購入するときは、乾電池ボックス、USBケーブルが付いているか確認することをおすすめします。

ProcessingとMicropython

ソフトウェアは、以下の順に説明します。

• Processing
• MicropythonとMicro:bit

Processing

以下の順に説明します。

• フロー
• コード

フロー

2つの四角形を画面に表示し、右の四角形は、Micro:bitから受信したとき、色が変わります。左の四角形は、マウスを画面にクリックしたとき、色が変わりMicro:bitにコマンドを送信します。 フローを以下に示します。

1. UARTポートを設定
2. 1秒ごとに表示されるフレーム数を30に設定(シリアル通信の送受信は約33.3msに実施)
3. フレーム(Processingのアプリ画面)を更新する毎に、シリアル通信の受信とマウスのクリックを確認
4. Micro:bitからシリアル通信の受信があった場合、コマンドに応じてA画面またはB画面を表示
5. マウスのクリックがあった場合、クリックされた画面をコマンドでMicro:bitに送信

コード

コードを以下に示します。

import processing.serial.*;
Serial serial;
int r; // 画面の表示状態　0:A display 1: B display

void setup(){
  size(400,400); //画面サイズ
  frameRate(30); //1秒ごとに30回表示
  
  textSize(60);       // テキストサイズの指定
  textAlign(CENTER);  // 文字配置
  serial = new Serial(this, "COM8", 9600); // シリアル通信の設定
  
  r = 0; // 画面の表示状態の初期化
}

void draw(){
  background(100); // 背景色の設定
  int idata;       // シリアル通信の受信データ数

  // シリアル通信制御部
  idata = serial.available();
  // println("rec:",idata);
  if (idata >= 1)
  {
    r = serial.read();
    // println("recdata:",r);
  }

  // 画面制御部
  if (r == 0){
     a_display();
  }else{
     b_display();
  }
}

void mousePressed()
{
  // マウスクリックした場合、マウスカーソルを検出
  int mouseposdata;
  if( 0 <= mouseX && mouseX < 200 && 0 <= mouseY && mouseY < 200){ // 左上
     mouseposdata = 1;
  }else if( 0 <= mouseX && mouseX < 200 && 200 <= mouseY && mouseY < 400){ // 左下
     mouseposdata = 2;
  }else if( 200 <= mouseX && mouseX < 400 && 0 <= mouseY && mouseY < 200){ // 右上
     mouseposdata = 3;
  }else if( 200 <= mouseX && mouseX < 400 && 200 <= mouseY && mouseY < 400){ // 右下
     mouseposdata = 4;
  }else{
     mouseposdata = 0; 
  }
  ctrl_write_serial(mouseposdata); // シリアル送信部へ
}

void ctrl_write_serial(int posdata){
  int i_senddata;
  
  i_senddata = r * 5 + posdata; // 送信データ生成
  serial.write(str(i_senddata));
  println("senddata:",i_senddata);

}

// A displayの表示
void a_display(){
  fill(135,206,250); // lightskyblue
  rect(0,0,200,200); // 左上
  fill(0);
  text("(^_^)", 100, 100); //HAPPY
   
  fill(135,206,235); // skyblue
  rect(0,200,200,200); // 左下
  fill(0);
  text("(>_<)", 100, 300); //SAD
 
  fill(127,255,212); // aquamarine
  rect(200,0,200,200); // 右上
  fill(0);
  text("('O')", 300, 100); //SURPRISED
 
  fill(64,224,208); // turqoise
  rect(200,200,200,200); // 右下
  fill(0);
  text("(-.-)", 300, 300); //SURPRISED
}

// B displayの表示
void b_display(){
  fill(240,255,255); // azure
  rect(0,0,200,200); // 左上
  fill(0);
  text("↑", 100, 100); // ARROW_N
  
  fill(240,255,240); // honeydew
  rect(0,200,200,200); // 左下
  fill(0);
  text("↓", 100, 300); // ARROW_S
  
  fill(240,248,255); // aliceblue
  rect(200,0,200,200); // 右上
  fill(0);
  text("→", 300, 100); // ARROW_E

  fill(224,255,255); // lightcyan
  rect(200,200,200,200); // 右下
  fill(0);
  text("←", 300, 300); // ARROW_W
}

MicropythonとMicro:bit

以下の順に説明します。

• フロー
• コード
• 動作結果

フロー

フローを以下に示します。

1. UARTポートを設定
2. 100 ms毎に、受信状態とAボタン、Bボタンの状態を確認
3. データを受信したときは、LEDスクリーンに画像を表示
4. AボタンまたはBボタンが押されたときは、データを送信
5. 2に戻る(ループ)

コード

コードを以下に示します。

from microbit import *
# シリアル通信の設定
uart.init(baudrate=9600, bits=8, parity=None, stop=1, tx=pin0, rx=pin1)

while True:
    if uart.any(): # シリアル通信を受信
        s = uart.read()
        s_str = str(s.strip(), 'UTF-8') # 文字列データに変換
        if s_str == "1":　# A ディスプレイの左上をマウスクリック
            display.show(Image.HAPPY)
        elif s_str == "2":　# A ディスプレイの左下をマウスクリック
            display.show(Image.SAD)
        elif s_str == "3":　# A ディスプレイの右上をマウスクリック
            display.show(Image.SURPRISED)
        elif s_str == "4":　# A ディスプレイの右下をマウスクリック
            display.show(Image.ASLEEP)
        elif s_str == "6":　# B ディスプレイの左上をマウスクリック
            display.show(Image.ARROW_N)
        elif s_str == "7":　# B ディスプレイの左下をマウスクリック
            display.show(Image.ARROW_S)
        elif s_str == "8":　# B ディスプレイの右上をマウスクリック
            display.show(Image.ARROW_E)
        elif s_str == "9":　# B ディスプレイの右下をマウスクリック
            display.show(Image.ARROW_W)
        else:
            display.show(Image.NO)

    if button_a.is_pressed():
        # Aボタンが押されたことをPCに知らせる
        uart.write(b'\x01')
    elif button_b.is_pressed():
        # Bボタンが押されたことをPCに知らせる
        uart.write(b'\x00')
    else:
        pass
    sleep(100)　# Aボタン、Bボタン、シリアル通信の状況は、100 ms毎に確認

動作結果

• Micro:bitのAボタンを押すと、B画面を表示できました。
• Bボタンを押すと、A画面を表示できました。
• A/B画面の各画像をマウスでクリックすると、Micro:bitのLEDディスプレイにクリックした画像と同じものを表示できました。

※購入するときは、乾電池ボックス、USBケーブルが付いているか確認することをおすすめします。

Micro:bit同士をUARTでデータ通信

概要

2つのMicro:bit同士がUART通信でコマンドを送受信する。

概要図

基本的な接続

以下のように、ワニクリップで2つのMicro:bitを接続します。

基本的な接続

実際の接続状態

※購入するときは、乾電池ボックス、USBケーブルが付いているか確認することをおすすめします。

MicropythonとMicro:bit

以下の順に説明します。

• フロー
• コード
• 動作結果

フロー

フローを以下に示します。

1. UARTポートを設定
2. 100 ms毎に、受信状態とAボタンの状態を確認
3. データを受信したときは、受信したデータをLEDスクリーンに表示
4. Aボタンが押された場合は、"Hello A"の電文を送信(もう1つは"Hello B"を送信)
5. 2に戻る(ループ)

コード

コードを以下に示します。このコードは、

from microbit import *

sleep(5000)
uart.init(baudrate=9600, bits=8, parity=None, stop=1, tx=pin0, rx=pin1)
display.show(Image.HAPPY)

def Send(d):
    uart.write(d)

def Receive():
    if uart.any():
        r = uart.read()
        display.scroll(r)

while True:
    Receive()
    if button_a.is_pressed():
        Send("Hello A")
        sleep(500)
    sleep(20)

動作結果

Micro:bitのAボタンを押すと、もう1つのMicro:bitのLEDスクリーンに"Hello A"が表示できました。"Hello A"を受信したMicro:bitのAボタンを押すと、もう1つのMicro:bitのLEDスクリーンに"Hello B"が表示できました。

※購入するときは、乾電池ボックス、USBケーブルが付いているか確認することをおすすめします。

Micro:bit(GPIO)からTeraTeamに文字データ送信

概要

UART通信でWinPCのTeraTeamにコマンドを送信すると、Micro:bitは、受信したコマンドに応じてデータを送信します。ここでのUART通信の電文(コマンド)は改行コード付きです。また、UART-USB変換するデバイスを使います。

概要図

基本的な接続

以下のようにMicro:bitとWin PCとを接続します。なお、Wiｎ PCはTera Termをあらかじめインストールします。

基本的な接続

実際の接続状態

※購入するときは、乾電池ボックス、USBケーブルが付いているか確認することをおすすめします。

MicropythonとMicro:bit

以下の順に説明します。

• フロー
• コード
• 動作結果

フロー

フローを以下に示します。

1. UARTポートを設定
2. 100 ms毎に、AボタンまたはBボタンの状態を確認
3. AボタンまたはBボタンが押された場合は、押されたボタンの名前を送信
4. 2に戻る(ループ)

コード

コードを以下に示します。

from microbit import *

uart.init(baudrate=9600, bits=8, parity=None, stop=1, tx=pin0, rx=pin1)
uart.write("*** Micro:bit UART test ***\r\n")

while True:
    # Aボタン、Bボタンが押されている状況は、100 ms毎に確認
    if button_a.is_pressed():
        # Aボタンが押されたことをPCに知らせる
        uart.write("A button is pressed.\r\n")
    elif button_b.is_pressed():
        # Bボタンが押されたことをPCに知らせる
        uart.write("B button is pressed.\r\n")
    else:
        pass
    sleep(100)

動作結果

UART送受信の結果を以下に示します。Micro:bitのAボタンを押すと、"A button is pressed."がTera Termに表示されます。Bボタンを押すと、"B button is pressed."がTera Termに表示されます。

Tera Termのログ

※購入するときは、乾電池ボックス、USBケーブルが付いているか確認することをおすすめします。

TeraTeam(WinPC/親機)とMicro:bit(子機)の文字データ送受信

概要

UART通信でWinPCのTeraTeamにコマンドを送信すると、Micro:bitは、受信したコマンドに応じてデータを送信します。ここでのUART通信の電文(コマンド)は改行コード付きです。

概要図

基本的な接続

以下のようにMicro:bitとWin PCとを接続します。なお、Wiｎ PCはTera Termをあらかじめインストールします。

基本的な接続

TeraTeamとマクロ

以下の順に説明します。

• フロー
• コード

フロー

フローを以下に示します。

1. 開始コメントを表示
2. ループ開始
3. "TEMP"コマンドを送信したら、データを受信するまで待つ
4. 受信した温度データを表示
5. "LLVL"コマンドを受信したら、データを受信するまで待つ
6. 受信した明るさデータを表示
7. 10回のループしたら、完了する
8. 1.に戻る

コード

コードを以下に示します。

dispstr 'Test Start'#$0A

i = 10 ; 10回繰り返す。
while i>0
  dispstr 'TEMP=' ;温度データ取得のコマンドを送信
  sendln 'TEMP'
  timeout = 1
  waitln '#' ; 受信した温度データを表示

  dispstr 'LLVL=' ;明るさデータ取得のコマンドを送信
  sendln 'LLVL'
  timeout = 1
  waitln '#' ; 受信した明るさデータを表示

  i = i - 1
endwhile

dispstr 'Test End'#$0A

MicropythonとMicro:bit

以下の順に説明します。

• フロー
• コード
• 動作結果

フロー

フローを以下に示します。

1. UARTポートを設定
2. 200 ms毎に、コマンドの受信を確認
3. コマンドを受信した場合、そのコマンドを解析し、それに応じたデータを送信
4. 2に戻る(ループ)

コード

コードを以下に示します。

from microbit import *

uart.init(baudrate=9600, bits=8, parity=None, stop=1)
uart.write("\r\n*** UART test ***\r\n")

while True:
    if uart.any():
        s = uart.readline()
        s_str = s.strip()
        if s_str == b'TEMP':
            uart.write(str(temperature()) + '\r\n')
        elif s_str == b'LLVL':
            uart.write(str(display.read_light_level()) + '\r\n')
        else:
            uart.write('NG\r\n')
    sleep(200)

動作結果

UART送受信の結果を以下に示します。TereTeamのマクロを実行すると、Micro:bitが計測した温度と明るさのデータが表示されます。

Tera Termのログ

※購入するときは、乾電池ボックス、USBケーブルが付いているか確認することをおすすめします。

Micro:bit(親機)とTeraTeam(WinPC/子機)の文字データ送受信

概要

Micro:bitは、AボタンまたはBボタンを押されると、UART通信でWinPCのTeraTeamにコマンドを送信します。受信したTeraTeamは、押されたボタンに応じてデータを送信します。ここでのUART通信の電文は改行コード付きです。

概要図

基本的な接続

以下のようにMicro:bitとWin PCとを接続します。なお、Wiｎ PCはTera Termをあらかじめインストールします。

基本的な接続

TeraTeamとマクロ

以下の順に説明します。

• フロー
• コード

フロー

フローを以下に示します。

1. 開始コメントを表示
2. ループ開始
3. タイムアウトを30秒に設定
4. タイムアウトしたら、ループを終了する
5. "GETDATE"コマンドを受信したら、日付を送信
6. "GETTIME"コマンドを受信したら、現在の時間を送信
7. 10秒待つ
8. 10回のループしたら、完了する
9. 1.に戻る

コード

コードを以下に示します。

dispstr 'Test Start'#13#10
; 10回繰り返す。
i = 10
while i>0
  dispstr 'Waiting for reception'#13#10

  ; タイムアウトを30秒に設定。
  timeout = 30
  ; 文字列 "GETDATE" か "GETTIME" を待つ。
  waitln 'GETDATE' 'GETTIME'
  
  ; タイムアウトなら、:timeout へジャンプ。
  if result=0 then
     dispstr 'Time out'#13#10
     goto macro_end
  endif
  ; "GETDATE" が来たなら、日付を送信
  If result=1 then
     ; 現在の日付を取得してMicro:bitに送信
     getdate datestr
     sendln datestr
     dispstr 'Send Date'#13#10
  endif
  ; "GETTIME" が来たなら、時間を送信
  If result=2 then
     ; 現在の時間を取得してMicro:bitに送信
     gettime timestr
     sendln timestr
     dispstr 'Send Time'#13#10
  endif

  pause 10
  i = i - 1
endwhile

:macro_end
dispstr 'Test End'#13#10

MicropythonとMicro:bit

以下の順に説明します。

• フロー
• コード
• 動作結果

フロー

フローを以下に示します。

1. UARTポートを設定
2. 100 ms毎に、AボタンまたはBボタンの状態を確認
3. AボタンまたはBボタンが押された場合は、コマンドを送信
4. コマンドを送信したら、データの受信を200ms待ち、データを受信
5. 2に戻る(ループ)

コード

コードを以下に示します。

from microbit import *

uart.init(baudrate=9600, bits=8, parity=None, stop=1, tx=None, rx=None)
uart.write("*** Micro:bit UART test ***\r\n")

s = ""

def get_return():
    sleep(200)
    if uart.any():
        s = uart.readline()
        display.scroll(s.strip())

while True:
    if button_a.is_pressed():
        uart.write("GETDATE\r\n")
        get_return()
    elif button_b.is_pressed():
        uart.write("GETTIME\r\n")
        get_return()
    else:
        pass
    sleep(100)

動作結果

UART送受信の結果を以下に示します。Micro:bitのAボタンを押すと、"Send Date"がTera Termに表示され、Micro:bitのLEDディスプレイに日付が表示されます。Bボタンを押すと、"Send Time"がTera Termに表示され、Micro:bitのLEDディスプレイに時間が表示されます。

Tera Termのログ

※購入するときは、乾電池ボックス、USBケーブルが付いているか確認することをおすすめします。

Micro:bitからTeraTeam(WinPC)に文字データ送信

概要

Micro:bitのAボタンまたはBボタンを押すと、UART通信でWinPCのTeraTeamに文字データ(押されたボタンの名前)を送信します。

概要図

基本的な接続

以下のようにMicro:bitとWin PCとを接続します。なお、Wiｎ PCはTera Termをあらかじめインストールします。

基本的な接続

MicropythonとMicro:bit

以下の順に説明します。

• フロー
• コード
• 動作結果

フロー

フローを以下に示します。

1. UARTポートを設定
2. 100 ms毎に、AボタンまたはBボタンの状態を確認
3. AボタンまたはBボタンが押された場合は、押されたボタンの名前を送信
4. 2に戻る(ループ)

コード

コードを以下に示します。

from microbit import *

uart.init(baudrate=9600, bits=8, parity=None, stop=1, tx=None, rx=None)
uart.write("*** Micro:bit UART test ***\r\n")

while True:
    # Aボタン、Bボタンが押されている状況は、100 ms毎に確認
    if button_a.is_pressed():
        # Aボタンが押されたことをPCに知らせる
        uart.write("A button is pressed.\r\n")
    elif button_b.is_pressed():
        # Bボタンが押されたことをPCに知らせる
        uart.write("B button is pressed.\r\n")
    else:
        pass
    sleep(100)

動作結果

UART送受信の結果を以下に示します。Micro:bitのAボタンを押すと、"A button is pressed."がTera Termに表示されます。Bボタンを押すと、"B button is pressed."がTera Termに表示されます。

Tera Termのログ

※購入するときは、乾電池ボックス、USBケーブルが付いているか確認することをおすすめします。