HOME > 電算 > Python おそるおそる

Python おそるおそる

Python の基本的な部分について観察したとき、面白れえなあと思ってメモしたものなり。

全般的に http://www.python.jp/doc/release/tut/tut.html を参考にしたが、英語版 http://docs.python.org/tutorial/index.html のほうが新しいので、そちらを見なくてはならない場面もあった。がいして、英語のドキュメントのほうが充実しているはどうしてだろうか。そのほか個別に参考にしたものはそれぞれの箇所に記しておいたのだ。

私の無理解から、あるいは、単純たタイプミスから、間違いを書いている可能性は低くないよ。為念。

名前と =

以下「変数」という言葉を使わない。変数という言葉が「名前じたい」のことをいうのか、「名前が指し示すオブジェクト」のことをいうのか混乱しないようにしたつもり。（指すというのは be assigned to のこと）。

Python では、= の左辺に x を置いて

x=1

とすることにより、x なる名前が「1」を指し示すようになる。

一方、= の左辺に置かれない場合 x は「x が指し示すところのもの」をあらわす。たとえば、

x=1
print(x)

とすると、「x が指し示すところのもの」、つまり 1 が出力される。

したがって、x と y という名前があったときに、

y=x

とすることにより、y が「x が指し示すところのもの」を指し示すようになる。

x=1
y=x
print(y)
==> 1

の如し。

ところで、1+1 のごときは Python では式である。だから、eval('1+1')は 2 を返す。ところが、x=1 のごときは、式ではなくて文である。だから、eval('x=1') はエラーになる。これは、exec('x=1') としなければならない。（Python の名前というものが、LISP のシンボルと違い、一人前のオブジェクトではないことと関係があるのかもしれんなあ。ある人は言う「シンボル型は悪い考えではないが、インターンされた文字列があればほとんど利点はない。」http://practical-scheme.net/trans/IsPythonLisp-j.html）

文字列と数値

名前は、どんなオブジェクトでも指し示すことができる。したがって、名前に型はない。しかし、オブジェクトのほうには、とうぜん型というものがある。文字列とか、整数とか……

文字列

Python の手引を読むと、まず「Python の文字列は変更できぬ」と脅かされる。べつに、

>>> a="Hello"
>>> a="Bye"
>>> print a
Bye

ということができないわけではない。これは、文字列そのものを変更しているのではなくて、a という名前が別の文字列を指し示すように変更しているのだ。名前の文字列への割り当てをするとき何が起こるのか想像してみる。

文字列の結合

>>> print 'a' 'bc' 'd'   # これはよいが
abcd
>>> s='bc'
>>> print 'a' s 'd'      # これはエラー
>>> print 'a' + s + 'd'  # これならば良い
abcd

文字列をただ並べた場合、結合はスクリプトの実行以前に行われるので、名前の指す文字列をそこに展開することができない。これに対して、+ を使った結合は、実行時に行われるので、名前を展開することができる。

文字列の同一性

is はオブジェクトが同一たることを示し、== は値が同一たることを示す。

別々につくった文字列は、同じ字面でも別オブジェクト、だと予想してみる。

>>> a="dog and cat"
>>> b="dog and cat"
>>> a==b
True
>>> a is b
False

その通りに見える……

>>> c="dog and cat"
>>> d=c
>>> c is d
True

……もちろん、そりゃそうだわね。

下はむしろ奇妙に感じられる例。

>>> a="dog"
>>> b="dog"
>>> a is b
True

a という名前を 'dog' に割り当てたときに、Python はこれを名前リストに登録（intern）する。名前のために使われた文字列でなくても、名前に使われそうな文字列はあらかじめインターンしておく。その後 b に 'dog' を割り当てたときには、b が a が指すのと同一のオブジェクトを指すような形で再利用する。

文字列は「変更できない」から、これが混乱を引き起こすことはない。余談ながら……

>>> a=[1,2]
>>> b=[1,2]
>>> a is b
False

リスト（後述）は「変更できる」から、別途作成されたリストは常に別オブジェクト。そうじゃなきゃ大混乱が起こる。

数値

整数と小数で扱いが違うことは、見ての通り。

>>> 1 / 3
0
>>> 1.0 / 3
0.33333333333333331

同じ値の整数は、世界にひとつしか存在しない。

>>> a=1
>>> b=1
>>> a==b
True
>>> a is b
True

が、小数はこの限りに非ず

>>> a=1.0
>>> b=1.0
>>> a==b
True
>>> a is b
False

だから何なんだって言われそうだが、一応試した次第。

※None, False, '', 0, 0.0 はそれぞれに別のオブジェクトであり、すべて異なる型に属するが、論理演算ではみな「偽」。

リスト

リストは が順番をもって並んだものであり、各 はそれぞれに何らかのオブジェクトを指し示す——と考えることにせむ。ここで云う各 が指し示すオブジェクトは「リストの要素」と呼ばれる。

「名前=リスト」とすれば、名前がリストを指すようになる。これは名前を = の左辺に用いた場合の原則通りで、取り立ててリストに対してだけに言えることではない。

名前が = の左辺以外の場所に使われた場合、その名前は「その名前が指すオブジェクト」を表現すると前に述べた。もちろんこれは、その名前がリストを指している場合にも当てはまる。

リストと添字

リスト n に対して、添字 n (N=0,1,2,...)を用いて a[n] という表現をすることができる。a[n] は、= の左辺にない限りは、「リストの n+1 番目の が指すところのオブジェクト」、別の言い方をすれば n+1 番目の要素をあらわす。

>>> a=['hello', 'bye']
>>> a[0]
'hello'

したがって、

一方、= の左辺に a[n] を置いた場合、「リストの n+1 番目の 」が = の右辺にあるオブジェクトを指すようになる。これを用いてリストの要素を変更する（取り替える）ことができる。

次は入れ子リストを作っている様子。

リストの伸張

リストは伸張することができる。伸張しても、従前のオブジェクトと同一オブジェクトである。

>>> a=[1,2]
>>> b=a
>>> a.append(3)
>>> a
[1,2,3]
>>> b
[1,2,3]

スライスを使うと、さらに複雑なことが可能となる。

なお、リストの結合は + オペレータによって、新たなリスト・オブジェクトを作成することによっても行える。

※しばしば、Python のリストは変数と違い変更できると言われるが、それはこのような性質を言っているのであろう。

※Python のリストの説明としては、LISP の cdr が次のコンスセルを指しているようなものをつけた図を描きたくもなる。そのほうが一層、リストが伸張できることをよく表すに違いない。だが、実装はそうなっていないという。その証拠に　LISP のリストと異なり、後ろのほうの要素にアクセスするためにより長い時間が必要になる、ということはないそうだ。そして、Python のリストの途中に要素を挿入するような場合は、リストの後ろのほうに挿入するほうが前のほうに挿入するより時間が短くて済むそうである。このあたりから、いかなる実装がなされているか想像することはできるが、実際にコードを確かめたわけではない。

同一オブジェクトを要素として持つ、別のリストの作成

前々項の応用で、リストを複製できる。これは、浅い複製と呼ばれる。

この場合、スライス（後述）を使ってやれば、より便利である。

別の名前が同一のリストを指すようにする

名前を = の左辺以外の場所に置いた場合は、その名前は「その名前が指すオブジェクト」をあらわすのであるから、以下のようにして、別の名前が同一リストを指すようにすることができる。こうすれば、一つの名前を用いてしてリストの要素を変更すれば、べつの名前を使ってリストの要素を参照した場合にも、前に行った変更が反映されていることになる。C でいうリファレンス的な挙動とも言える。

リストを（深く）コピーする

リストの浅いコピーは前に見た。これに対して、新たなリストとして「そっくりではあるが別のアイデンティティをもつ要素」を指すリストを作成する場合、これを深いコピーと呼ぶ。これは、ライブラリをインポートすれば簡単に行える。ということで、省略。

スライス

リスト L に対して L[n:m] とか L[:] などという表現があり、スライス記法と呼ばれる。m, n は 0 または自然数で、リスト中の位置を表現する。たとえば L=[a,b,c] において

|   |   |   |
| a | b | c |
|   |   |   |
0   1   2   3

てな位置を示している。なお、L[:] は L[0:リストサイズ] のことである。

まず、スライス記法で表現されたものが = の左辺に登場したときを見る。

L=['a', 'b', 'c', 'd']

において、

L[1:3]=['j', 'k', 'l'] は、

リスト L の部分リスト L[1:3] を、['j', 'k', 'l'] を要素とするリストに置き換える。

補足。左辺がスライスとき、= の右辺はリストやタプル（後述）など（の iterable なもの）でなくてはならず、L[0:1]=1 はエラーになる。

為念。L=['a', 'b', 'c'] であるとして、添字を使った L[1]=['p','q'] により L の指すところのものは ['a',['p','q'],'c',] になるが、スライスを使った L[0:1]=['p','q'] では L の指すところのものは ['a','p','q','c'] になる。

スライス記法で表現されたものが、= の左辺以外に現れた場合、これは「もとのリストの部分リスト」を（浅く）複製して作成された新たなリストをあらわす。（LISP 愛好者の注意すべき点である）

関数

新しい言語を学ぶとき、関数の引数が値渡しなのか参照渡しなのかというのが、気になるものだ。Python では、文字列やリストの性質を考えてみると、このへんの事情は容易に想像がつく。

まず、文字列を引数にする関数を試してみる。

>>> def alterstring (s):
...     s='aho'
... 
>>> x='rikou'
>>> alterstring(x)
>>> print x
rikou

関数は、ローカルな名前空間に「x が指す文字列」を指す名前 s を登録し、

次に s が新たな文字列 'aho' を指すように変更する。

したがって、もとの x は相変わらず 'rikou' を指している。

次に、リストを受け取る関数を試してみる。

>>> def alterlist(t):
...     t[0]='aho'
... 
>>> y=['rikou']
>>> alterlist(y)
>>> print y[0]
aho

関数は、ローカルな名前空間に「y が指すリスト」を指す名前 t を登録し、

次に 「『t が指すリスト』の第一の 」が文字列 'aho' を指すように変更する。

したがって、y[0] は 'aho' に変わっている。

引数の受け取り

関数が受け取る引数の数は、不定でもよろしいそうだ。*をつけた仮引数を使うと、定義中で、それをタプルとして使うことができる。

>>> def r(a, *b):             # 仮引数 b は余った引数を引き受けるタプル
...     print a
...     for x in b:
...             print x
... 
>>> r(1,2,3)
1
2
3

シェルのロングオプションっぽく、キーワード引数を使った引数の渡し方がある。

>>> def f(a, b):
...     print a
...     print b
... 
>>> f(b=2, a=1)
1
2

不定の数のキーワード引数を与え、** つきの仮引数で受け取ると、関数定義の中ではそれを辞書として使える。

>>> def f(**t):
...     for k in t:
...             print k
...             print t[k]
... 
>>> f(name='Kabi', addr='Aichi')
name
Kabi
addr
Aichi

* と ** の混用などできるが、めんどいから
http://www.python.jp/doc/release/tut/node6.html#SECTION006720000000000000000
参照。

クラス

Python のクラスはごくリラックスした使い方ができるものだ。

# 中身がないクラス
>>> class c:             # 中身が空のクラス
...     pass
... 
>>> c.a=1                # クラス属性をセット
>>> i=c()                # インスタンス作成
>>> i.a2=2               # インスタンス属性をセット

クラス中でなされた関数定義は、第一引数として必ずインスタンス自身を受け取る。そのため、この第一引数には self という名前を与えるのが習慣となっている。

# クラスの設計（属性とメソッド）
>>> class c:
...  a=1                # クラス属性定義
...  def m(self,x):     # メソッド定義
...    return(self.a+x)
... 
>>> i=c()               # インスタンス作成
>>> i.m(2)              # 暗黙のうちに一つ目の引数が与えられ、それは自分自身
3

__init__ はクラス内で関数として定義され、インスタンスが作成されたときに自動的に実行されるメソッドとなる。

>>> class c:
...     def __init__(self):       # 関数 ___init___ は、
...             print(1)
... 
>>> i=c()                         # インスタンス作成時に自動的に実行される
1

単純な継承

>>> class p:
...     a=1
... 
>>> class c(p):
...     b=2
... 
>>> i=c()
>>> i.a
1
>>> i.b
2

多重継承

>>> class p1:
...     a=1
... 
>>> class p2:
...     b=2
... 
>>> class c(p1,p2):
...     c=3
... 
>>> i=c()
>>> i.a
1
>>> i.b
2
>>> i.c
3

（http://www2.lib.uchicago.edu/keith/courses/python/class/5/ 参考）

例外

文字列を整数に切り捨てようとすると、当然エラーになる。エラーの種類は、この場合 ValueError である。

>>> int("p")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: 'p'

プログラムを実行中に特定の種類のエラーが発生したとき、何らかの動作をさせたいなら、try, except を使う。かかるエラーを構文エラーなんかと区別して、例外と呼ぶ。もし finally 文があると、それは例外が出ても出なくても最後に実行される。

>>> try:
...     int("p")
... except ValueError:
...     print "oops"
... finally:
...     print "bye"
oops
bye

raise 文を用いて、強制的に例外を発生させることができる。

>>> raise NameError
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError

なお except 文がキャッチできなかった種類の例外は、その外側にパスされる。

>>> try:
...     try:
...             raise NameError
...     except ValueError:
...             print "I caught the value error"
... except NameError:
...     print "I caught the NameError"
... 
I caught the NameError

くり返し

while と for

while は他の多くの言語から類推されるところの働きをするが、for は C の for ではなくて、むしろシェルの for のように振る舞う。次項参照。

イテレータ

イテレータというのは、ひどく大雑把に言うと「next() メソッドを持ち、おしまいまでいくと StopIteration 例外を投げるようなオブジェクト」である。

リストの各要素や文字列中の各文字を頭からすべて調べるような場合、リストや文字列をからイテレータを作成し、これに対して next() メソッドを順々適用すればよろしい。最後までくると StopItaration という例外が投げられる。

>>> it=iter([1,2,3])
>>> it.next()
1
>>> it.next()
2
>>> it.next()
3
>>> it.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

[イテレータオブジェクトは、もとのオブジェクトへの "ポインタ" を保持しているので、この手続きはたいしてメモリを食わない。その反面、for ループ中でもとのオブジェクトを変更すると、それが（イテレータを通じて）次回以後の繰り返しに影響を及ぼすことになる。]

for 文は、与えられたオブジェクトからイテレータオブジェクトを得て、そのオブジェクトの next メソッドを実行し、n がこれを順々に指すようにして進み、最後に StopIteration 例外を投げられると停止する。

>>> for n in [1,2,3]
>>>    print n
...
1
2
3

もし、自作クラスが __iter__ メソッドを持ち、これがイテレータつまり「next() メソッドを持ち、おしまいまでいくと StopIteration 例外を投げるようなオブジェクト」を返すならば、それは for ループで使える。このとき返されるイテレータは自分自身でもかまわない。

リストに対するイテレーションを便利に

リストに対するイテレーション作業に使える便利な手段がさまざまに用意されている。map, zip, enumerate(list), reduce, 内包表現, 等々。

ひとつだけ、リストを結合する演算子 + の一般化を例として引いとこう。最高に高速な方法とは言えないだろうが、学ぶところがある。

>>> import operator
>>> a=[[1,2],[4,5,6]]
>>> reduce(operator.add,a)
[1,2,3,4,5,6]

余談ながら、入れ子リストの解消（flatten=平らにする）は、しばしば練習問題になるようだ。上の例とは違い、解消すべき入れ子の深さに制限がないものが、お題になるのを目にする。わしも考えてみむ。

def flatten(a):
    for n in reversed(range(len(a))):
            if type(a[n])==type([]):
                    flatten(a[n])
                    a[n:n+1]=a[n]

こんな感じ……。

>>> a=[1,[2,[3,[4]]]]
>>> flatten(a)
>>> a
[1, 2, 3, 4]

もとのリストを破壊しちゃうんだけどね……

リストに似た？ものたち

タプル

リストに似ているが、中身を変更できない。

丸カッコは入れ子にするとき以外は使わなくてよい。長さ 1 のタプルを作るときに注意。

# 長さ 2 のタプル
t=1,2
t=(1,2)
# 長さ 1 のタプル
t=1,
t=(1,)           # t=(1) は数値になってしまう
# 長さ 0 のタプル
t=()             # t= は構文エラー

タプルにリストを入れると、そのタプルはずっとそのリストを指し続けるが、リストの要素を変えることは可能。

>>> a=1
>>> a=[1]
>>> t=(a)
>>> t
[1]
>>> a[0]=2
>>> t
[2]

辞書

辞書という種類のオブジェクトがあるのだ。これは、キーと値の組。たいがい何でもキーにできるが、リストは駄目。値のほうは何でもいい。

>>> t={'a':1, 'b':2}                    # 文字列をキーにしてみる
>>> t['a']                              # こうやって値を取り出す
1
>>> t={[1,2]:'a', [3,4]:'b'}            # リストをキーにすると怒られる
>>> t={(1,2):'a', (3,4):'b'}            # タプルは OK
>>> t[(1,2)]                            # こうやって値を取り出す
'a'
>>> t={([1],):'a', ([2],):'b'}          # リストを納めたタプルも駄目

タプルはキーにできる。

>>> t={(1,2):'a', (1,2):'b'}
>>> t[(2-1,1+1)]
'b'

辞書から作ったイテレータの next メソッドはキーを返す。

>>> it=iter({'a':1, 'b':2})
>>> it.next()
'a'
>>> it.next()
'b'

だから、for 文を使って、

>>> a={'a':1, 'b':2}
>>> for x in a:
...     print x
...     print a[x]
... 
a
1
b
2

のように使うことができる。

関数の引数として辞書を渡すこともできる。

>>> def f(d):
...     for k in d:
...             print k
...             print d[k]
... 
>>> f({'a':1, 'b':2})
a
1
b
2

配列

配列というのは、まさにいわゆる配列であり、リストでもタプルでもない。これは、配列をサポートするモジュール（Numeric とか、numarray）を読み込まないと使えないらしい。リストやタプルと違い、作成したときにその要素の型が定まる。タプルと違い、要素を書き換えることはできるが、リストと違い伸張したりすることはできない。

リストやタプルよりも計算が早くできるというメリットがあるらしい。が、何より便利なのは、ベクトルの和とか差ができることかな。

テキストの処理

文字列の置換

文字列は変更できないが、しかしながら、メソッドを持つ。単純な置換は、

>>> "xccxccxcc".replace('cc','xx',2)
'xxxxxxxcc'

その他文字列に対するメソッドは http://www.python.jp/doc/release/lib/string-methods.html に書いてある。

正規表現を使った置換は、別項参照。

正規表現

Python には正規表現クラスというものがある。正規表現を使った文字列の置換は、

「文字列オブジェクト.置換メソッド(正規表現, 置換文字列)」
で文字列を変更するのではなく、
「正規表現オブジェクト.置換メソッド(置換文字列, 対象文字列)」
で新たな文字列を返させることによって行う。具体的には、

import re             # re モジュールをインポートし、
r = re.compile('a')   # 正規表現をコンパイルして RegexObject インスタンスを作り
r.sub('d', 'abc')     # そのインスタンスの sub メソッドを使い、置換結果を返さしめる
r.subn('d', 'abc', 1) # sub はすべて置換、subn は置換個数を制限できる

バックスラッシュによるエスケープ

バックスラッシュ一つを表現する正規表現オブジェクトを Python でつくるとき、re.compile メソッドの引数を '\\\\' と表記しなくてはならない。これは面倒に見える。

Perl で $variable =~ /regexp/ とするときの regexp には、正規表現または正規表現である文字列を与える。\\ は「正規表現」そのものであるから、Perl でバックスラッシュの表現として使うことができるし、'\\\\' は「\\ という文字列」で、\\ は正規表現だから、これも使える。

一方、Python では、re.compile(regexp) とするときの regexp には、正規表現そのものを与えることはできず、正規表現である文字列だけを与えることができる。そこで、'\\\\' のようにしてバックスラッシュ 2 つぶんの文字列をつくりだし、それを引数として与えるほかはない。

ただし、r'\\' という記法があり、これは '\\\\' と同等なので、正規表現たる文字列を作成するときには都合がよい。

Python と文字コード

長くなったので別項

マッチングなど

日本語のマッチングも、ユニコード型に対してなら問題がない。

（http://osksn2.hep.sci.osaka-u.ac.jp/~taku/osx/python/encoding.htmlを参考）

>>> r=re.compile(u'う')
>>> m=r.match(u'うんこ')
>>> print m.span()
(0,1)

ちゃんとマッチしていることがわかる。

標準出力にこの文字列をうまく表示させてやるのは、このこととは別の話である。

import sys
import codecs
sys.stdout = codecs.getwriter('utf_8')(sys.stdout)
sys.stdin  = codecs.getwriter('utf_8')(sys.stdout)

とすると、以後標準出入力に日本語を使える。

ファイルからの出入力

open はファイルオブジェクトを返す。（Windows や Macintosh の場合、rb、wb のようにするとバイナリモードになり、バイナリ・データの場合にはこれを使わないとマズいことになるそうだ）

f=open('/home/baka/a.txt', 'r')

※読み出し専用 r、書き込み専用 w、読み書き r+、追記 a

コーディングを指定して開くには、

import codecs
f=codecs.open('a.txt', 'r', 'utf_8')

※utf_8, euc_jp, shift_jis, etc.

>>> f.read()          # 指定サイズぶん読む、サイズ省略や負数の場合全部読む
>>> f.readline()      # 一行読む
>>> f.readlines()     # 指定サイズずつ読み、一行を完成させ、各行をリストにする

こうして読み出された文字列は、unicode 型オブジェクトであり、utf や EUC といったコーディングシステムでエンコードされたバイト並び（str 型オブジェクト）ではない。詳しくは別ページ「Python と文字コード」

一行ずつ読む別の読み出し方もある。

>>> for line in f:
        print line,

ファイルに書くには、

f.write('abc\n')

コーディングを指定して書くには、

import codecs
f=codecs.open('a.txt', 'w', 'utf_8')

ファイルを閉じる

f.close() 

細かなこと

コマンドライン引数。

import sys
arg = sys.argv[1]

オプションの処理はもちっと複雑。http://www.python.jp/doc/release/lib/optparse-tutorial.html 参考。

ソースファイルに文字列定数を書く場合、ファイル頭に

# coding: utf-8

とか書いておかねばならぬ。

では試しに使ってみむ

ファイル中の「阿呆」を「アホ」に変換して標準出力に出してみるのだ。

# coding: utf-8

import sys, codecs, re

regexp = u'阿呆'
replace = u'アホ'
infile=sys.argv[1]

sys.stdout = codecs.getwriter('utf_8')(sys.stdout)
r=re.compile(regexp)
f=codecs.open(infile, 'r', 'utf_8')
b=f.readlines()
for l in b:
	print r.sub(replace, l),
f.close()

[なお、ファイルへのパスは、ディレクトリ区切り記号にとらわれないですむように、os.path モジュールを使うのが正式だそうである。]

実行結果。

$ cat infile.txt 
あほ
阿呆
あほ
阿呆
$ python test.py infile.txt 
あほ
アホ
あほ
アホ

モジュールっぽいモジュール

re とかはすでに見た。他の標準のモジュールを見るのだ。

sqlite3 を使ってみる

Python のモジュールというのは恐しく充実していて、sqlite3 用のモジュールが標準でついている(Python 2.5 以後)。すごく簡単に使えそうだぞ。http://docs.python.org/library/sqlite3.html 参考。

>>> import sqlite3                         # ライブラリをインポート
>>> conn = sqlite3.connect('test.sqlite')  # データベースを開く
>>> cur = conn.cursor()                    # カーソル作成
>>> cur.execute("select * from mytable")   # SQL 文を発行
<sqlite3.Cursor object at 0xb7d03bc0>
>>> print cur.fetchone()                   # 結果を 1 行ぶん得る
(u'Mr. Holms', u'111-1111')
>>> print cur.fetchone()                   # もう 1 行ぶん
(u'Dr. Watson', u'222-2222')
>>> print cur.fetchone()                   # もう 1 行ぶん
None
conn.close()                               # データベースを閉じる

そこは sqlite の有り難さで、やはり恐ろしく簡単だ。注意：データベースを開くときに、該当するファイルがないと自動的にそのファイルが作成される。

SQL 文中に、名前を埋め込む場合、特別な方法を使わなければならない。placeholder として ? を使う。この仕組みは SQL インジェクションを防ぐためにある。また、埋め込まれる側のオブジェクトは、タプルでないといけなかったと思う。つまり、1 のかわりに、(1,) でなくてはならないんじゃなかったかな。

>>> cur.execute("insert into mytable (name, phone) values(?, ?)", (name,phone))
<sqlite3.Cursor object at 0xb7d03c20>
>>> conn.commit()

文字コードの問題については、別ページ「Python と文字コード」

雑多なこと

型

type で型がわかるという。

>>> type('a')
<type 'str'>

という具合だ。しかし、これはたんに型を表示するだけではない。

>>> c=type('a')
>>> c()
''

なんてことができるから、type が返すのは、型を作成する能力を持つクラスらしいのだ。

——目次——

HOME
├雑文
├写真
├壁紙
├馬鹿
├読書
├語学
│├英語
│└日本語
├電算
├地理
│└白地図
└ブログ