Python の基本単位

基本単位

　　リテラルは，C/C++ における定数に相当します．

文字列およびバイト列リテラル
　　文字列リテラルおよびバイト列リテラル（ bytes 型リテラル）は，対応する一重引用符「 ' 」，または，二重引用符「 " 」で囲まれます．Python においては，二つの引用符は同じ意味になります．また，バイト列リテラルに対しては，常に b や B が接頭します．文字列リテラルおよびバイト列リテラルは，C/C++ における文字列定数と似ていますが，C/C++ においては，いずれも二重引用符で囲んだ文字列定数として扱われます．また，C/C++ における文字定数（一重引用符）と文字列定数（二重引用符）との区別はありません．なお，バイト列リテラルは ASCII 文字のみを含むことができます．
```
>>> "文字列"
'文字列'
>>> '文字列'
'文字列'
>>> b"abc"
b'abc'
>>> b"文字列"   # エラー（ ASCII 文字だけ可能）
				
```
　　文字列中の \ が付加された \n などの文字は，文字列を表示する際，エスケープシーケンスとしての機能を発揮します（ \n は改行機能）．バックスラッシュ \ をそのまま表示させたい場合は，バックスラッシュ \ によってエスケープしてやる必要があります（これらは，C/C++ においても同様）．また，文字ごとにエスケープ処理を行いたくない場合は，文字 r または R を接頭させることによって，バックスラッシュをリテラル文字として扱うことができます．print() はオブジェクトを表示するための組み込み関数です．Python においては，文字列，数値，数値の集まり，など，ほとんどのものをオブジェクトと呼びます．ここでは，文字列を表します．
```
>>> print("a\nbc")
a
bc
>>> print("a\\nbc")
a\nbc
>>> print(r"a\nbc")
a\nbc
				
```
　　文字列は，+ 演算子を使用して連結させることができ，* 演算子で反復（このような機能，必要？）させることができます．また，文字列リテラルをスペースで区切って並べると，それらは自動的に連結されます．
```
>>> 2 * "abc" + "efg" + "hij"
'abcabcefghij'
>>> 2 * "abc" "efg" "hij"
'abcefghijabcefghij'
				
```
　　複数行に亘る文字列は，対応する 3 連の引用符 '''，または，""" によって可能です．
```
>>> """
... abc
... def
... ghi
... """
'\nabc\ndef\nghi\n'
				
```
　　上の例に示すように，行末の改行は文字列に含まれますが，行末に \ を付加することによって改行を含まない内容にすることも可能です．
```
>>> """\
... abc\
... def
... ghi\
... """
'abcdef\nghi'
				
```

Python において使用できるエスケープシーケンスは以下の通りです． \newline 行末に \ を記述するとその行の改行が無視される \\ バックスラッシュ（円記号） \' 一重引用符（シングルクォーテーション） \" 二重引用符（ダブルクォーテーション） \a ベル \b バックスペース \f 改ページ \n 行送り \r 復帰 \t 水平タブ \v 垂直タブ \ooo 8進表記による ASCII 文字 \xhh 16進表記による ASCII 文字
以下に示すエスケープシーケンスは，文字列に対してだけ有効です． \N{name} Unicode データベース中で name という名前の文字 \uxxxx 16-bit の十六進値 xxxx を持つ文字 \Uxxxxxxxx 32-bit の十六進値 xxxxxxxx を持つ文字

数値リテラル
　　数値リテラルには 3 種類あります．整数( integer )，浮動小数点数( floating point number )，及び，虚数（ imaginary number ）です．複素数リテラルは存在しませんが，複素数は実数と虚数の和として作れます．また，数値リテラルには符号が含まれていないことに注意してください．-10 のような数値は，実際には単項演算子 (unary operator) - とリテラル 10 を組み合わせたものとして処理されます．

　　整数リテラルは，10 進数，8 進数 0ohhhh，16 進数 0xhhhh，または，2 進数 0bhhhh を使用して表現できます（ o，x，b は大文字でも良い）．なお，値がメモリ上に収まるかどうかという問題を除けば，整数リテラルには長さの制限がありません．
```
>>> 15
15
>>> 0xf
15
>>> 0o17
15
>>> 0b1111
15
				
```
　　真偽値も整数リテラルの一種であり，False と True の値をとります．真偽値を表すブール型は整数型の派生型であり，ほとんどの状況でそれぞれ 0 と 1 のように振る舞います．
```
>>> True
True
>>> False
False
>>> 10 + True
11
>>> 10 + False
10
				
```
　　浮動小数点数リテラルの取りうる値の範囲は実装に依存します．なお，数値はすべて 10 進数であり，仮数部と指数部を使用して表現する場合，その基数は常に 10 となります．
```
>>> 12345.01
12345.01
>>> 1234501e-2
12345.01
				
```
　　虚数リテラルは，aj （ aJ ）のように表現し，実数部が 0.0 の複素数を表します．実数部がゼロでない複素数を生成するには，( 3 + 4j ) のように虚数リテラルに浮動小数点数を加算するか，または，組み込み関数 complex() を使用します．
```
>>> 3.14j   # 3.14J でも良い
3.14j
>>> 2.5 + 3.14j
(2.5+3.14j)
>>> complex(2.5, 3.14)
(2.5+3.14j)
>>> complex(2.5, 3.14).real   # 実数部の参照（参照だけ可能）
2.5
>>> complex(2.5, 3.14).imag   # 虚数部の参照（参照だけ可能）
3.14
				
```

　　C/C++ において，変数は，数値や文字を記憶するメモリ内の特定の領域に着けられた名前です．リテラルとは異なり，あらかじめそこに記憶されるデータが常に決まっているわけではありません．しかし，データの型（整数，浮動小数点数，文字列等）により，必要とする領域の大きさや表現方法が異なりますので，ある変数が示す領域に任意のデータを記憶するわけにはいきません．そこで，C/C++ においては，前もって，その領域に記憶すべきデータの型（ type ）を指定してやる必要があります．これを，変数の型宣言と言います．例えば，x を整数（ int 型の数値）を記憶する変数としたとき，

int x = 10;

のような方法で型宣言を行います．ただし，「 = 10 」の部分は，変数 x にその初期値として 10 を記憶するための記述であり，必要がなければ書く必要はありません．その際は，整数を記憶する際に必要な領域だけが確保されます．一度型宣言を行うと，関数内で宣言した場合は関数内のその宣言以降，関数外で宣言した場合は関数外の他の位置で変数 x を再び宣言したり，他の型の値を代入したりすることはできなくなります．例えば，

int x = 10;
x = 20;
x = 1.3;
x = "abc";

において，2 行目は正しい文ですが，3 行目に対しては警告が発生され，4 行目はエラーになります．

　　しかし，Python においては，代入または入力したデータによって，その変数の型が決まります．ただし，Python の場合は，変数が示す場所(アドレス)にデータ自身が記憶されているわけではなく，変数はデータ（オブジェクト）が記憶されている場所への参照（場所のアドレス）を表しています．従って，C/C++ のように，変数の型という表現は不適切ですが，今後，混乱が生じない範囲で使用していきます．例えば，下の例において，a は整数リテラル 10 への参照（整数型の変数），また，c は複素数リテラルへの参照（複素数型の変数）を表す変数となります．この点は，比較演算子の項でより詳細に説明します．このように，Python における変数は，a は整数リテラル 10 のアドレス，また，c は複素数リテラル 1 + 2j のアドレスを表しているように見えますので，C/C++ におけるポインタと似ています．また，3 行目のように，変数 a に，先に代入した値と異なる型（文字列）の値を記憶することも可能であり，この時点で，変数 a は文字列型の変数となります．

>>> a = 10
>>> c = complex(1, 2)
>>> a = "abc"

　　変数に対してその型を宣言しなくてはならないという規則は，非常に面倒なように感じられるかと思いますが，他の場所で別の目的に使用していた変数の値を誤って変更してしまったなどの誤りを防いでくれます．特に，複数の人で作成する大規模なプログラムの場合，同じ変数名を使用しないように管理することはほとんど不可能です．この様な点からも，Python のようなインタプリータ言語は，大規模なプログラム作成には不向きです．

識別子（名前）

　　識別子とは，変数，関数，クラス等の名前に相当します．ASCII 範囲では，C/C++ と同様，アルファベット，下線 _，及び，数字（先頭の文字を除く）を利用できます．ただし，下線 _ から始まる識別子には，以下に示すように，特別な意味がある場合があります（ * の部分は，任意の文字列）．: _*　　from module import * で import されません．また，対話インタプリタでは，直前に行われた評価の結果を記憶するために識別子「 _ 」が使われます．; __*__　　システムで定義された (system-defined) 名前です．; __*　　そのクラスのプライベートな名前とみなされ，コードが生成される前により長い形式に変換されます．
また，以下に示す識別子は，Python 言語におけるキーワード (keyword) として使われ，通常の識別子として使うことはできません． False class finally is return None continue for lambda try True def from nonlocal while and del global not with as elif if or yield assert else import pass break except in raise

演算子と式

比較と論理演算
　　Python には以下に示すような比較演算子が存在します．これらの演算子は，オブジェクト（データ）の値同士を比較します．
```
    <  ： より小さい  a < b
    >  ： より大きい  a > b
    <= ： 以下  a <= b
    >= ： 以上  a >= b
    == ： 等しい      a == b
    != ： 等しくない  a != b
				
```
また，以下に示すような比較演算も可能です．
```
    is     ： 同じオブジェクト  a is b
    is not ： 同じオブジェクトではない  a is not b
				
```
```
		# 整数の場合，文字列の場合も同じ
01	>>> a = 10
02	>>> b = 10
03	>>> a == b, a is b
04	(True, True)
05	>>> b = a
06	>>> a == b, a is b
07	(True, True)
08	>>> b = 20
09	>>> a == b, a is b
10	(False, False)
11	>>> a, b
12	(10, 20)
		# 浮動小数点数の場合，虚数（複素数）の場合も同じ
13	>>> c = 1.2
14	>>> d = 1.2
15	>>> c == d, c is d
16	(True, False)
17	>>> d = c
18	>>> c == d, c is d
19	(True, True)
20	>>> d = 1.3
21	>>> c == d, c is d
22	(False, False)
23	>>> c, d
24	(1.2, 1.3)
				
```
　　代入とは，= 記号の右辺で得られた結果を左辺で指定した変数が示す領域に記憶することです．01，02 行目においては，整数リテラル 10 が変数 a，b が示す領域に記憶されます．03，04 行目を見ると，値の比較においても，オブジェクトの比較においても，両者は等しくなっています．このことは，整数リテラル 10 が記憶領域のいずれかの場所にただ一つだけ記憶されており，変数 a，b はその（オブジェクトの）アドレスを指していることになります．つまり，変数 a，b は，C/C++ におけるポインタと非常に似ています（下の左図）．従って，変数 b の値を変数 a に代入しても（ 05 行目），その結果は変わりません．また，変数 b の値を変更すると（ 08 行目），変数 b は異なる整数リテラル 20 を指すことになり，両者はいずれの比較においても異なってきます（ 09，10 行目，下の右図）．当然，変数 b の値を変更しても，変数 a の値は変化しません（ 11，12 行目）．下の左図の状態において，リテラル 10 を直接修正すれば，変数 a と b の値が同時に変化するはずですが，それを実行する演算子が存在しない，リテラルの値を修正できない，などの点から，Python では不可能です．

　　しかし，浮動小数点の場合は多少異なってきます．変数 c や d がポインタであることに違いはないのですが，13 行目～ 16 行目から明らかなように，全く同じ値のリテラルであっても，異なる場所に記憶されている（異なるオブジェクトである）ことを意味します（下の左図）．ただし，変数 c を変数 d に代入すれば，整数の場合と同じような状態になります（ 17 行目～ 19 行目，下の右図）．

　　下に示すのは，C/C++ によって，上と似たような内容のプログラムを書いた例です．01 行目～ 07 行目では，const 指定によって，Python のように，定数の値を変更できなくしています．08 行目～ 14 行目のように変更可能に設定すると，13 行目に示すように，ポインタを介して変数 cc10 の値を変更可能になります．この場合，変数 a2 と b2 は同じ場所を指していますので，a2 が指す値も変化します．先ほど，Python における変数がポインタと似ていると話しましたが，このプログラムに見るように，多少異なっています．
```
		// const
01	const int c10 = 10, c20 = 20;
02	const int *a1, *b1;   // a1，b1 は int 型に対するポインタ
03	a1 = &c10;   // Python における a = 10 に対応
04	b1 = &c10;   // Python における b = 10 に対応
05	printf("%d %d\n", *a1, *b1);   // 出力は 10 10（間接演算子 * の使用）
06	b1 = &c20;   // Python における b = 20 に対応
07	printf("%d %d\n", *a1, *b1);   // 出力は 10 20（間接演算子 * の使用）
		// const でない
08	int cc10 = 10;
09	int *a2, *b2;
10	a2 = &cc10;
11	b2 = a2;   // a2 と b2 の値（アドレス）が等しくなる
12	printf("%d %d\n", *a2, *b2);   // 出力は 10 10（間接演算子 * の使用）
13	*b2 = 20;   // ポインタ a1 が指す値も変化（間接演算子 * の使用）
14	printf("%d %d\n", *a2, *b2);   // 出力は 20 20（間接演算子 * の使用）
				
```
　　以上述べた演算子を利用して，以下に示すような論理演算が可能です．
```
    式1 or 式2  ： 論理和（式1 または 式2 が True であれば True，そうでなければ False）
    式1 and 式2 ： 論理積（式1 及び 式2 が True であれば True，そうでなければ False）
    not 式      ： 否定（式 が False であれば True，そうでなければ False）
				
```
　　C/C++ とは異なり，例えば，「 x < y < z 」が「 x < y and y < z 」とほぼ等価になることに注意してください．
```
>>> (3 < 2) and (2 < 5)
False
>>> 3 < 2 < 5
False
>>> 3 < 4 < 5
True
				
```
数値演算
　　Python には以下に示すような数値演算を行うための演算子が存在します．なお，C/C++ と同様，代入と加算を同時に行う演算子 += など，-=，*=，・・・も可能です．ただし，C/C++ とは異なり，インクリメント演算子 ++，デクリメント演算子 -- や条件演算子 = ? : が存在しないことに注意してください．
```
    +  ： 加算（複素数に対しても可能），結合  x + y
    -  ： 減算（複素数に対しても可能），符号の変更  x - y, -x
    *  ： 乗算（複素数に対しても可能），繰り返し  x * y, *x
    ** ： 冪乗（複素数に対しても可能，C/C++ では，pow / pow を利用）  x ** y
    /  ： 除算（結果は浮動小数点数，複素数に対しても可能）  x / y
    // ： 除算（小数点以下を切り捨て，C/C++ では，コメントを表す）  x // y
    %  ： 剰余（浮動小数点数に対しても可能）  x % y
				
```
　　C/C++ においては，/ 演算子による除算の結果は，除数及び被乗数の型によって決まります．両者とも整数型であれば小数点以下が切り捨てられます．また，% 演算子は，除数，被乗数，共に整数の場合に対してだけ使用可能です．浮動小数点数演算における剰余を計算するためには，fmod / fmod を使用します．
```
>>> a = 10
>>> a += 5   # a = a + 5 と同じ
>>> a
15
>>> a / 2
7.5
>>> a // 2
7
				
```
以上の演算子を使用した演算と共に，複素数に対しては，以下に示すような処理が可能です．
```
    c.conjugate()   ： 複素数 c の共役複素数
    c.real          ： 複素数 c の実部
    c.imag          ： 複素数 c の虚部
				
```
```
>>> a = complex(1, 2)
>>> a
(1+2j)
>>> a.conjugate()
(1-2j)
>>> a.real
1.0
>>> a.real = 5   // エラー，参照だけが可能
				
```
　　その他，以下に示すようなインスタントメソッド，クラスメソッドも利用可能です．なお，すぐ下に示すのは，それ以降に詳細説明を行っている項目の目次になっています．急がれる方は，目次項目だけを簡単に眺め，詳細な説明を省略し，ビット単位の演算に進んでください．
- int.bit_length()
  
  　　整数に対して，符号と先頭の 0 は除いて二進数で表すために必要なビットの数を返す．
  >>> a = 3 >>> bin(a) '0b11' >>> a.bit_length() 2
- int.to_bytes(length, byteorder, *, signed=False)
  
  　　整数を表すバイト列を返す．整数は length バイトで表される．byteorder が "big" なら，最上位のバイトがバイト配列の最初に，また，"little" なら，最上位のバイトがバイト配列の最後に来る．signed 引数は，整数を表すのに 2 の補数を使うかどうかを決定する．signed が False で，負の整数が与えられたなら，OverflowError が送出される．
- classmethod int.from_bytes(bytes, byteorder, *, signed=False)
  
  　　与えられたバイト列の整数表現を返すクラスメソッドである．
  >>> a = -3 >>> bin(a) '-0b11' >>> a.to_bytes(4, byteorder='big', signed=True) b'\xff\xff\xff\xfd' >>> int.from_bytes(b'\xff\xff\xff\xfd', byteorder='big', signed=True) -3
- float.as_integer_ratio()
  
  　　比が元の浮動小数点数とちょうど同じで，かつ，分母が正である一対の整数を返す．
  >>> a = (0.25).as_integer_ratio() >>> a (1, 4)
- float.is_integer()
  
  　　浮動小数点数が有限の整数値なら True を，そうでなければ False を返す．
  >>> (3.2).is_integer() False >>> (3.0).is_integer() True
- float.hex()
  
  　　浮動小数点数の 16 進文字列表現を返す．
- classmethod float.fromhex(s)
  
  　　16 進文字列表現 s で表される浮動小数点数を返すクラスメソッドである．
  >>> (3.14).hex() '0x1.91eb851eb851fp+1' >>> float.fromhex('0x1.91eb851eb851fp+1') 3.14
　　C/C++ との大きな違いの一つは，虚数に対応する型が存在し，複素数に対する演算が簡単に行えることです．しかし，C++ においても，complex を使用すれば，
```
#include <iostream>
#include <complex>

using namespace std;

int main()
{
	complex<double> x1(1.0, 2.0), x2(3.0), x3 = 2.0, x4 = 2i, x5;
	cout << "x1:" << x1 << "，x2:" << x2 << "，x3:" << x3 << "，x4:" << x4 << "，x5:" << x5 << endl;
	cout << "x1 + x2 = " << (x1 + x2) << endl;
	cout << "x1 - x2 = " << (x1 - x2) << endl;
	cout << "x1 * x2 = " << (x1 * x2) << endl;
	cout << "x1 / x2 = " << (x1 / x2) << endl;
	cout << "abs(x1) = " << abs(x1) << endl;
	cout << "x1 の共役複素数 = " << conj(x1) << endl;

	return 0;
}
				
```
のように，複素数演算を簡単に行えます．なお，上のプログラムを実行すると以下に示すような結果が得られます．
```
x1:(1,2)，x2:(3,0)，x3:(2,0)，x4:(0,2)，x5:(0,0)
x1 + x2 = (4,2)
x1 - x2 = (-2,2)
x1 * x2 = (3,6)
x1 / x2 = (0.333333,0.666667)
abs(x1) = 2.23607
x1 の共役複素数 = (1,-2)
				
```

ビット単位の演算

Python には，整数に対して，以下に示すようなビット単位の演算を行う演算子が存在します．なお，C/C++ と同様，>>=，・・・等の演算も可能です． << ：左にビットシフト a << 3 >> ：右にビットシフト a >> 3 & ：ビットごとの論理積 x & y | ：ビットごとの論理和 x | y ^ ：ビットごとの排他的論理和 x ^ y ~ ： 1 の補数（ 0 と 1 の逆転） ~x

静岡理工科大学

菅沼ホーム

索引