howto/python †

↑

コメント †

a = HOGE()  # クラスHOGEのインスタンスとして、オブジェクトを生成

type(a) == HOGE  # aがクラスHOGEのインスタンスの場合、真
isinstance( a, HOGE )  # aが、クラスHOGE又は HOGEを継承したクラスであれば、真

https://www.lifewithpython.com/2014/06/python-check-object-instance-class-relationship-by-type-isinstance.html
https://docs.python.org/ja/3.7/library/inspect.html # import inspect で、オブジェクトについていろいろ調べられるようである

type( hoge )        # function, methodなどではなく、HOGEと返ってきたら、クラスHOGEのインスタンスのようだ
type( hoge ).mro()  # 何のクラスのインスタンスかが出るようだ（クラス継承含む）
type( HOGE )  # typeが返ってきたらHOGEはクラス
type( HOGE )  # functionが返ってきたら関数
（例）
from pyscf import gto, scf
mol=gto.M( atom='H 0 0 0; H 0 0 1.4', basis='sto-3g' )
mf=scf.RHF( mol )
mf.kernel()

type( gto )  # moduleと返るので、モジュール
type( scf )  # moduleと返る
gto.__file__  # moduleがどのファイル(ディレクトリ階層と__init__.py)かがわかる

type( gto.M )  # functionと返るので、関数
               # def Mの定義は、ディレクトリ階層内や__init__.pyにあるはず

type( mol )        # pyscf.gto.mole.Moleと返るので、そのクラスのインスタンスらしい
type( mol ).mro()  # 何のクラスのインスタンスかが出るようだ（クラス継承含む）
=> [pyscf.gto.mole.Mole, pyscf.lib.misc.StreamObject, object]
#type( gto.mole.Mole )  # typeと返り、クラスらしい（インスタンスではないため、mro()は使えない）

type( scf.RHF )  # functionと返るので、関数
type( scf.RHF ).mro()
=> [function, object]

type( mf )      # pyscf.scf.hf.RHFと返るので、このクラスのインスタンスらしい
type(mf).mro()
=> [pyscf.scf.hf.RHF, pyscf.scf.hf.SCF, pyscf.lib.misc.StreamObject, object]

type( mf.kernel )  # methodと返るので、クラスメソッド
type( mf.kernel ).mro()
=> [method, object]

『オブジェクトによっては 値 を変更することが可能です。 値を変更できるオブジェクトのことを mutable と呼ぶ。 生成後に値を変更できないオブジェクトのことを immutable と呼ぶ。 （mutableなオブジェクトへの参照を格納している immutableなコンテナオブジェクトの値は、 その格納しているオブジェクトの値が変化した時に変化するが、コンテナがどのオブジェクトを 格納しているのかが変化しないのであれば immutableです。 immutable かどうかは値が変更可能かどうかと無関係。） オブジェクトが mutable かどうかはその型によって決まる』
[ref] https://docs.python.org/ja/3/reference/datamodel.html から改変

c.f.
オブジェクトは、同一性(identity)、型、値をもつ。
id() 関数は同一性を表す整数を返します。
CPython では、id(x) は x が格納されているメモリ上のアドレスを返す。
組み込みのデータ型のうち、list, set, dict型のみmutable。

def print_id_obj( obj ):
    print( 'id=', id(obj), '  obj=', obj )
a=1
b=a
print_id_obj(a)
print_id_obj(b)
print()
b=2
print_id_obj(a)
print_id_obj(b)

↑

ドキュメント †

Python標準ドキュメント　http://www.python.jp/ （ここの、メニューのドキュメントに和訳ドキュメントがある。全モジュール索引もあり）

インストールされている標準ライブラリはたいてい /usr/lib/pythonXX/内にある。

オブジェクトの属性を調べる。
引数無しだと、現在のスコープの名前を返す。

>>> dir( hoge )

オブジェクトのドキュメントを調べる（ドキュメンテーションが書かれていれば）

>>> help( hoge )

オブジェクトの型を知る

type(hoge)

オブジェクトのクラスを調べる

a.__class__  または  type( a )
↑

命名の慣例 †

Pythonの関数名：　英小文字とアンダースコアだけ、数字も可？
クラス名：　　　　大文字で始める。MyClassなど
メソッドの第１引数：　selfにする
アトリビュート、メソッドの先頭に _がついたもの：　外部から書き換えしてはいけないという印。（クラス内部で使用するものである）
アトリビュート、メソッドの先頭に __がついたもの：　外部からアクセス禁止される
2022/06/26

- pythonでの命名の慣例

* 先頭に _ をつけたものは外部から書き換え禁止。

* 先頭に __ をつけたものはアクセス禁止。

* 関数名は すべて小文字でスネークケース（単語をつなげる場合は _ でつなぐ）。

* 変数は すべて小文字でスネークケース。

* クラス名は アッパーキャメルケース（大文字から始め、単語をつなげる場合は最初を大文字にしてつなぐ）。

* 定数は すべて大文字でスネークケース。

* 破棄変数として _ 名のみの変数がある。eg) for _ in range(10): print( "hello" )

* 名前の末尾 _ は名前衝突を避けるために使用される（末尾 __ や  ___ なども）。

* 名前の先頭と末尾 __...__ はpythonが特別な用途として使っているもの。eg) __init__

* パッケージ名は すべて小文字の短い名前で _ は使わない。
  なお、パッケージ名はディレクトリ名やファイル名に対応している。
  eg) import tkinter の tkinter
  eg) import turtle の turtle

* モジュール名は すべて小文字の短い名前で _ を使ってもよい。
  なお、モジュール名は拡張子を除いたファイル名に対応している。
  eg) import tkinter.font の font

[ref]
https://qiita.com/shiracamus/items/bc3bdfc206b39e0a75b2
https://mako-note.com/ja/python-underscore/
https://python.softmoco.com/basics/python-naming-conventions.php

↑

正規表現を使ったファイル一覧の取得 †

>>> import glob
>>> print glob.glob('/dev/sd?')
['/dev/sda', '/dev/sdb']

その他、個々に置換するとき
>>> import re
>>> [ s.replace('/dev/','') for s in glob.glob('/dev/sd?') ]
['sda', 'sdb']
↑

tkinerモジュール †

(注) python2は Tkinter、python3は tkinterを importするようだ。名前が異なる。

お気楽 Python/Tkinter 入門 http://www.geocities.jp/m_hiroi/light/pytk01.html

1. Hello world! http://www.shido.info/py/tkinter1.html

PythonのTkinterを使ってみる https://qiita.com/nnahito/items/ad1428a30738b3d93762

↑

モジュールの再読み込み †

import hoge が既に実行されていた場合、再度 import hoge をしても何も実行はされない。再度、実行する場合は reloadが必要。

Python3.3まではimp.reload()
Python3.4以降はimportlib.reload()
https://docs.python.org/3/library/imp.html#imp.reload

>>> import imp
>>> imp.reload( module )  #なお、import moduleが以前になされていること。

なお、マニュアルをみると、完全に挙動が同じなるというわけでななさそうである。

↑

実行時間を測る †

>>> import time
>>> time1 = time.clock()
>>> time2 = time.clock()
>>> print( time2 - time1 )
0.0009600000000000164
>>>
>>> help( time ) ＃ドキュメントをみる
>>> time1 = time.clock(); time.sleep(10); time2 = time.clock(); print( time2 - time1 )
4.599999999999049e-05
↑

二次元配列を作る †

>>> a = [ [ str(i)+str(j) for j in range(8)]  for i in range(5) ]
>>> a
[['00', '01', '02', '03', '04', '05', '06', '07'], ['10', '11', '12', '13', '14', '15', '16', '17'], 
['20', '21', '22', '23', '24', '25', '26', '27'], ['30', '31', '32', '33', '34', '35', '36', '37'], 
['40', '41', '42', '43', '44', '45', '46', '47']]
>>> a[4][5]
'45'
>>> int(a[4][5])
45
>>> for i in range(5):
...   a[i]
...
['00', '01', '02', '03', '04', '05', '06', '07']
['10', '11', '12', '13', '14', '15', '16', '17']
['20', '21', '22', '23', '24', '25', '26', '27']
['30', '31', '32', '33', '34', '35', '36', '37']
['40', '41', '42', '43', '44', '45', '46', '47']
↑

いくつかの例 †

インタプリタ起動

$ python  #たいていpython2が起動するらしい
$ DISPLAY=hostname:0 python3 -B  #python3を起動、バイトコンパイルさせない(-Bオプション)、DISPLAYを指定。

$ export PYTHONDONTWRITEBYTECODE=t  #これでもバイトコンパイルさせないらしい

スクリプトの実行

$ DISPLAY=hoge:0 python3 -B filename.py  #filename.pyを実行する。
$ DISPLAY=hoge:0 ./filename.py           #filename.pyを実行する。

インタプリタを利用したいくつかの例

>>> from turtle import *
>>> for i in range(6):    #図形が表示される
...     forward(100)
...     right(60)
... 
>>> a = "Python3 is awsome!"
>>> a . lower()
'python3 is awsome!'
>>> len(a)
18
>>> (1+2J)/5J
(0.4-0.2j)
>>> for item in [ 'a', 'b', 'c' ]:
...     print( item )
... 
a
b
c
>>> for c, item in enumerate( [ 'a', 'b', 'c' ] ):
...     print( c, item )
... 
0 a
1 b
2 c
>>> f=open("temp.txt", "w")
>>> for c in range(1,101):    #1から100までの数字をファイルに書き出す。
...     f.write( str(c) )
... 
>>> f.close()
>>> [ord(s) for s in "Python"]    #内包記法で文字コードのリストを作る
[80, 121, 116, 104, 111, 110]
>>> val=10; [ x for x in range(1,val+1) if val %x == 0 ]    #内包記法で10の約数のリストを作る
[1, 2, 5, 10]
>>> i = { "GMT" : "+000", "BST" : "+100", "EET" : "+200", "JST" : "+900" }
>>> i
{'BST': '+100', 'EET': '+200', 'JST': '+900', 'GMT': '+000'}
>>> i.items()
dict_items([('BST', '+100'), ('EET', '+200'), ('JST', '+900'), ('GMT', '+000')])
### dict_items(  ) が付く意味はなに？ 特殊メソッド__repr__の単なる仕様？
>>> import os
>>> os.walk("./")
>>> i=os.walk("./")
>>> next(i)
('./', ['QCLObot', 'ProteinDF_bridge', 'ProteinDF', 'ProteinDF_pytools', 'OpenFOAM', 'LOG_kiku'], 
['2dn2.pdb', '1omb-mod.pdb', 'LOG_kiku.tar', 'p3.py~', 'p3.py', 'temp.txt', 'fws.gro.pdb'])
>>> next(i)
('./QCLObot', ['.git', 'qclobot', 'scripts'], ['.gitignore', 'LICENSE', 'setup.py', 'README.md'])
### 現在作業中のディレクトリ、作業中ディレクトリ内のディレクトリのリスト、作業中ディレクトリ内のファイル
### のタプルがイテレータ(next(i))で次々と得られる。
>>> from decimal import Decimal
>>> Decimal( '0.1' ) * 3
Decimal('0.3')
### 自動型変換のルールは？ この*はDecimalクラスのメソッド __mul__が使われている。
>>> import sys
>>> sys.getfilesystemencoding()
'utf-8'
>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308,
 min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

スクリプトの例

--------------------------------------------------
#!/usr/bin/env python3                                                                                                     

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

import sys

def spamfactory( times ):
    """ スパム工場                                                                                                         

        
    """
    return "Spam ! " * times

print( spamfactory( 3 ) )

input()
--------------------------------------------------
$ ./p3.py

--------------------------------------------------
#!/usr/bin/env python3                                                                                            
#-*- coding:utf-8; -*-                                                                                            

import os

#p= "./LOG_kiku"                                                                                                  
p= "./"

for path, dirs, files in os.walk( p ):
    for f in files:
        print( path, ":", f )
--------------------------------------------------
$ ./p4.py

14章の例。みんなのPython 第３版, 柴田亨, ＳＢクリエイティブ (2012) から
ファイルはここちら todoapp.tar

↑

組み込みのデータ型 †

整数　　
浮動小数点　　
複素数　　
文字列　　
リスト　　[ 1, 2, 3 ]
タプル　　( 1, 2, 3 )   要素ひとつの場合は ( 1, )とする。( 1 ) = 1 = 整数の値などとなるため
ディクショナリ　{ k1:v1, k2:v2, k3:v3 }
bytes型　　
bool型　　
set型　　{ 1, 2, 3 }
iter　　イテレート可能なインスタンスに変換する

備考：
順番があるものが、シーケンス型。
書き換えが可能なものが、書き換え可能。（ディクショナリのキーなどに使える）
書き換え可能でない型は、文字列、タプルと、数値もらしい（一部ではなく、丸ごとの書き換えは可）。
メソッドの引数にすると、メソッドで値を書き換えても、呼び出し側では値は変更されない（値渡しに相当）。書き換え
可能なものもあるらしい（参照渡しに相当）。

型変換

int()　　文字列を数値に変換
float()　
str()　　
chr()　　数値を文字(列)に変換
hext　　数値を１６進数に変換
bin　　数値を２進数に変換
oct　　数値を８進数に変換

スライス

リストのインスタンスaについて、a[2:3]などとして要素を取り出すこと。

lambda式

 see Python文法詳細、p197、オライリー

i // 2

 整数除算。iが整数、浮動点小数でも切り捨て。

文字列操作

raw文字列　　r"C:\path\to\file"
split
join

アンパック代入

 a, b = c, d
 return  a, b
 a, b = foo(hoge)

リストのアンパック

L=[1, 2, 3]
*L  # 1 2 3 の並び（リストではない）
(使用例)
  def foo( a, b, c ):
      hogehoge
  foo( *L )

可変長引数

 *args    タプル
 **kwargs ディクショナリ

https://note.nkmk.me/python-args-kwargs-usage/

def a( *args, **kwargs ):
    print( "*args=", *args )
    #print( "**kwargs=", **kwargs )  # **kwargsは何？
    #print( type(**kwargs) )
    print( "args=", args )
    print( "*kwargs=", *kwargs )
    print( "kwargs=", kwargs )
a( 'zero', 1, 2, 3, term='TERM', val='VAL' )
（出力結果）
*args= zero 1 2 3
args= ('zero', 1, 2, 3)
*kwargs= term val
kwargs= {'term': 'TERM', 'val': 'VAL'}

ゲッターとセッター（プロパティ）

 x = property( getx, setx )　　# xはアトリビュート、getx, setxはゲッターとセッターのメソッド。としておくと、
                               # インスタンス.xで代入や参照ができる。

モジュールの検索順

１）カレントディレクトリ
２）環境変数PYTHONPATH
３）標準ライブラリ
４）site-packages

標準エラー出力に書き出す

print( "hoge", file=sys.stderr )
↑

import †

import モジュール名
from モジュール名 import クラス名
　モジュール名は、ファイル名と同じ
　モジュール内のクラス名以外に、インスタンスや関数を指定できるようだ
クラスの初期化メソッド __init__
　ふつうは継承したクラスの初期化メソッドを super().__init__(hoge)として呼ぶ
新しい話題の投稿 | スレッド表示へ
importは、グローバルでも、ローカルにでも可能である。
import math
math.sin( 1.23 )
or
from math import sin
sin( 1.23 )

複素数の数学関数を利用するには import cmath をする
classはモジュールの中などに作られ、モジュールを importして継承クラスを作れる。

from book import Book
class Blog ( Book )
or
import book
class Blog ( book.Book )
↑

パッケージ †

ディレクトリ階層で束ねられたモジュールの集まり

↑

コメント †

#comment1
'''
comment2a
'''
"""
comment2b
"""
↑

その他 †

↑

パッケージとモジュールの構造（まとめ） †

↑

説明の前提（用語、予備知識） †

パッケージ = ディレクトリ, 例 mytp

サブパッケージ = サブディレクトリ, 例 mysp1

モジュール = ファイル, 例 mod01.pyなど

例

 mytp
 |-- __init__.py
 |-- mod01.py
 |-- mod02.py
 `-- mysp1
     |-- __init__.py
     |-- mod11.py
     `-- mod12.py
 インポートのために、mytpを含むディレクトリが PYTHONPATH環境変数などに含まれていること。

オブジェクト = モジュール、関数、などなど

オブジェクト名は、名前空間でもあり、名前空間には名前空間(オブジェクト)を階層的に含むようだ。 最初に pythonが実行している名前空間は __main__ である。 __main__で import hoge したとして、 __main__.hoge のような記述はできないようで、暗黙的に __main__. が付くと思われる。

名前空間に登録されている名前は dir() で知ることができる。

__name__                 # 現在の名前空間
dir( [オブジェクト名] )  # オブジェクト名(名前空間)に登録されている名前(名前空間)のリスト。
↑

(トップレベルの) パッケージのインポート †

import mytp  # mytp/__init__.pyがあれば実行される。
             # 現在の名前空間に mytpが追加されるが、mytp/__init__.pyが無かったり、空であれば、
             # mytpの名前空間もほぼ空のままであり mytp.mod01などは使用できない。
import mytp.mod01    # 現在の名前空間にmytpが追加され、mytpの名前空間に mod01が追加され、
                     # mod01モジュールの関数などが使用できる。
mytp.mod01.func01()
from mytp import mod01  # mytpディレクトリの mod01が、現在の名前空間に追加される。
                        # mod01モジュールの関数などが使用できる。
mod01.func01()
from mytp.mod01 import func01  # mytpディレクトリのmod01内の func01が、現在の名前空間に追加され、
                               # そのままで func01を使用できる。
                       # 追記：func01がモジュールスコープ(今の場合mod01)にて if文を使って条件に
                       #よって defされている関数であってもよいらしい。
func01()
  print( "* __name__ = ", __name__ )  # このパッケージ名 mytp となっている

  # __main__で import mytp として mytp.mod01.func01() が使用できるようになる。
  from mytp import mod01  # mytpの名前空間に mod01が追加される。mytp は . でもよいようだ
  from mytp import mod02  # mytpの名前空間に mod01が追加される。mytp は . でもよいようだ

  #このファイル ( 名前空間 mytp ) では mod01.func01() が使用できる。
  mod01.func01()

  # 関数は名前空間 mytp に登録されるため、 mytp.initmytp() で使用できる。
  def initmypt():
      print( "initmypt" )
↑

サブパッケージのインポート †

import mytp.mysp1        # mytp/__init__.pyがあれば実行される。
                         # 現在の名前空間に mytpが追加される。
                         # mytp/mysp1/__init__.pyがあれば実行される。
                         # mytp名前空間に mysp1が追加されるが、mysp1の名前空間はほぼ空であり、
                         # mytp.mysp1.mod11などは使用できない。(状況は import mytp と同じ)。
from mytp import mysp1   # mytp/__init__.pyがあれば実行される。
                         # mytp/mysp1/__init__.pyがあれば実行される。
                         # 現在の名前空間に mysp1が追加されるが、mysp1の名前空間はほぼ空であり、
                         # mysp1.mod11などは使用できない。(状況は import mytp と同じ)。
import mytp.mysp1.mod11    # mytp/__init__.pyがあれば実行される。
                           # mytp/mysp1/__init__.pyがあれば実行される。
                           # 現在の名前空間にmytpが追加され、mytpの名前空間に mysp1が追加され、
                           # mysp1の名前空間に mod11が追加され、
                           # mod11モジュールの関数などが使用できる。
mytp.mysp1.mod11.func11()
from mytp.mysp1 import mod11  # mytp/__init__.pyがあれば実行される。
                              # mytp/mysp1/__init__.pyがあれば実行される。
                              # mytp/mysp1ディレクトリの mod11が、現在の名前空間に追加される。
                              # mod11モジュールの関数などが使用できる。
mod11.func11()
from mytp.mysp1.mod11 import func11  # mytp/mysp1ディレクトリのmod11内の func11が、現在の名前空間に追加され、
                                     # そのままで func11を使用できる。
func11()
  print( "* __name__ = ", __name__ )  # このパッケージ名＋サブパッケージ名 mytp.mysp1 となっている

  # __main__で import mytp としてもこのサブパッケージは読み込まれない。
  # import mytp.mysp1 とすると mytp.mysp1.mod11.func11() などが使用できるようになる。
  from mytp.mysp1 import mod11  # mytp.mysp1の名前空間に mod11が追加される。mytp は . でもよいようだ
  from mytp.mysp1 import mod12  # mytp.mysp1の名前空間に mod12が追加される。mytp は . でもよいようだ

  # __main__で from mytp import mysp1 とすると mysp1 が名前空間に追加され、mysp1.mod11.func11()など
  # が使用できるようになる。

  #このファイル ( 名前空間 mytp.mysp1 ) では mod11.func11() などが使用できる。
  mod11.func11()

  # 関数は名前空間 mytp.mysp1 に登録されるため、 mytp.mysp1.initmysp1() で使用できる。
  def initmysp1():
      print( "initmysp1" )
↑

(__main__などからの) パッケージ、サブパッケージの使い方 †

1) myptや mytp.mysp1をインポートして、mytpからfunc11を指定する。

import mypt
mypt.mod01.func01()
import mytp.mysp1
mytp.mysp1.mod11.func11()
import mytp.mysp1 as subn
subn.mod11.func11()

2) mod01や mod11, mysp1をインポートして、mod01や mod11, mysp1からfunc11などを指定する。

from mytp import mod01
mod01.func01()
from mytp.mysp1 import mod11
mod11.func11()
from mytp import mysp1
mysp1.mod11.func11()
↑

関数の動的呼び出し †

モジュール mod11 の名前空間から、関数を実行するcallableの例

for i in dir( mod11 ):
    print( "================================================", "mod11."+i )
    if i[0:1] == "_":
        print( "SKIP" )
    else:
        if callable( eval("mod11."+i) ):
            print( "RUN" )
            print( eval(  "mod11."+i ) )
            eval(  "mod11."+i+"()" )
        else:
            print( "NOT-RUN" )
            print( eval(  "mod11."+i ) )
↑

複素数の扱い †

https://note.nkmk.me/python-complex/

↑

例外処理 †

↑

globalとnonlocal †

↑

yeild †

https://qiita.com/weedslayer/items/11de0f314ccbb70de812
returnは関数がそのまま終了する。これに対して、yeildは返値を渡し、制御を戻すが、再度関数が呼ばれると 続きから実行される。 返す値が無くなると、StopIteration例外が発生するようだ。

↑

printとformat †

print( hogehoge, end='' )  #printで改行しない
  end='\t' だと最後にtabが出力
  sep=',' で複数出力する時のセパレータを指定
  file=ファイルオブジェクト でファイルに出力
          fo=open('file.txt', 'w'）とし、file=fo とし、使った後で fo.close()
  flush=True で、出力後にフラッシュ

https://note.nkmk.me/python-format-zero-hex/
https://note.nkmk.me/python-numpy-set-printoptions-float-formatter/ 

'フォーマット指定の文字列'.format( arg1, arg2, ... )  #フォーマットされた文字列を作る（printで出力させる）
'{: >+6,}'.format(+123)  #例 
{} のところが argNになる
{ や } をそのまま出力する場合には {{ や }} とする
:  の次が空白だと、余った部分が空白で埋められる。
+  で正の数でも符号を表示、
>6 は6文字以下（6文字以上あるとはみ出して表示）
,  で3桁ずつ,を付ける
{:10x}      で10桁の16進数表示
{: >+12.2f} で12文字以下で、小数点以下が2桁で表示
{: >+12.2e} で同様に指数表現（小数点以下2桁で指数表現）
{: >+12.2g} で有効数字2桁で表示
例）
  print('{: >+6,}'.format(+1234567))
  print('{:10x}'.format(+1234567))
  print('{: >+12.2f}'.format(+1234567))
  print('{: >+12.2e}'.format(+1234567))
  print('{: >+12.2g}'.format(+1234567))
  +1,234,567
      12d687
   +1234567.00
     +1.23e+06
      +1.2e+06
numpyのndarray型のデータをフォーマット指定する場合
  numpy.set_printoptions( formatter={ 'complex_kind' : '{: >+20.4f}'.format } )
  でcomplex128型のデータのndarrayのオブジェクトを出力をすると、
  [     +0.2967-0.4617j      +0.2967-0.4617j]
  などとなる
↑

scipyモジュール †

↑

scipy.integrate.RK45クラスの説明 †

https://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.RK45.html
import scipy.integrate; help(scipy.integrate.RK45) も同じ情報が表示される
c.f. help(scipy.integrate.solve_ivp)

http://www.physics.okayama-u.ac.jp/~otsuki/lecture/CompPhys2/ode/ode.html
RK45は5次のルンゲクッタ法を使用して、4次のルンゲクッタ法のステップサイズを制御している。 また、マニュアル help(solve_ivp) によると、RK45は複素数も利用できる。 ただし、初期値が実数であっても、複素数のデータ型で与えること。

↑

numpyモジュール †

↑

ndarray型と matrix型 †

以下は 二次元配列の ndarray型
( type(a)でオブジェクトの型を調べられる。また、下の float64の 64などは環境依存だろう )

a=numpy.zeros( (2,2) )  # 2行2列のfloat64のゼロで初期化した二次元配列を作る
                        # a.dtypeは float64

a=numpy.array( [[1,2],[3,4]] )  # 組み込みリスト型から、二次元配列を作る
                                # a.dtypeは int64, リストの要素が整数なので
 
a=numpy.empty( (2,2) )  # 2行2列のfloat64の未初期化の二次元配列を作る
                        # a.dtypeは float64

a=numpy.array( [[1,2],[3,4]], dtype='complex128')  # dtype指定もできる
                                                   # ビット数を省略するとpythonの組込み型のビット数(環境依存)となる
b=numpy.zeros_like( a, dtype='float64' )   # aと同じ配列サイズのゼロで初期化した多次元配列を作る
b[:,:] = 1.2                 #すべての要素を 1.2にする
b = b.astype( numpy.int64 )  #要素のdtypeをint64に変換する。要素は型変換される
以下は matrix型（二次元配列に限定され、扱いはndarrayと同じではない）

a=numpy.matrix( [[1,2],[3,4]] )   # 組み込みリスト型から作る
                                  # a.dtypeは int64, リストの要素が整数なので

scipyモジュールは、matrixは使わずに、ndarrayを利用しているようだ。

ndarrayで要素毎に型の違う配列を扱う事も出来るが、その場合には pandasモジュールの方が便利らしい。

行列の用意、初期化など https://note.nkmk.me/python-numpy-zeros-ones-full/
データ型の指定、など https://note.nkmk.me/python-numpy-dtype-astype/

numpy.ndarray型 https://note.nkmk.me/python-list-array-numpy-ndarray/
二次元配列と行列の演算など https://note.nkmk.me/python-numpy-matrix/

↑

Python組み込み型変数のビット数を調べる †

numpy.float_  #らしい。この例は floatについて調べている
↑

２次元配列と行列 †

ndarrayの要素・行などの参照 https://note.nkmk.me/python-numpy-select-element-row-column-array/ 

a=numpy.array( [[1,2],[3,4]] ) の２次元配列のとき

a[0,1] や a[0][1] は (0,1)要素

スライスで参照できる、代入もできる
a[0,:]   は 0行目の１次元配列（次元がひとつ減る）
a[0:1,:] は 0行目からなる２次元配列
a[:,0]   は 0列目からなる１次元配列（次元がひとつ減る）
a[:,0:1] は 0列目からなる２次元配列
a[:,0] = 9  #参照したすべての要素に 9を代入（右辺が配列の場合、サイズが合うなどすれば代入可）
  次元がひとつ減る => スライスではなく、数字の指定で減る

２次元配列や１次元配列を使って行列演算ができる。 numpy.dot関数、 dotメソッド や @ メソッド、で掛算（matrix型の場合は * メソッドも掛算）。

なお、２次元配列と１次元配列の掛算では、 １次元配列が、演算の左にある場合は行ベクトル、右にある場合は列ベクトルの２次元配列のように扱われる。 そして、１次元配列同士の掛算は内積になる。

dtype型の違う２次元配列（行列）の演算は、高いほうの型に変換されるようである。（どちらが高い型かの順番は？）

ブーリアンインデックスによる参照、代入も可

a[ :, (True,True,False,False) ]

ファンシーインデックスによる参照、代入も可

a[ :, (0,1) ]   #参照する列の添え字を指定（重複可）、代入も可。
a > 5       # 配列aの各要素が、条件に対して Trueか Falseかになった配列(ブーリアンインデックス)が返る
a[ a > 5 ]  # 5より大きい要素のみを指定して参照、代入も可。参照の結果は１次元配列化されて得られる

複数の次元で指定する場合は a[ numpy.ix_( (False,True,True), (True,False,True,False) ) ] のように ix_関数 を使わないと正しく指定できない。 また、 ３次元以上の配列は、ひとつの次元で指定することしか出来ないようである（期待通りの結果にはならないとのこと）。

(※注) 配列がビューではなく、コピーで作られてしまっている場合（生じうる？）は、代入しても値は変化しない

↑

多次元配列の次元を減らす †

多次元配列を１次元化する https://note.nkmk.me/python-numpy-ravel-flatten/
多次元配列の次元を減らす https://codechacha.com/ja/python-flatten-list/ 

a=numpy.arange(12).reshape( (3, 4) )  # 0～11の要素をもつ 3x4行列
a.reshape(-1)  # 数字ひとつなので１次元配列。サイズ -1は自動で決められる(この場合は要素数)
a.ravel()   #可能な限りビューを返す
a.flatten() #データはビューでは無く、必ずコピーされる
などなど

多次元配列の形状を変える https://note.nkmk.me/python-numpy-reshape-usage/ 

a=numpy.arange(12).reshape( (3,4) )
a.reshape( (4,3) )  # データはコピーされるが、データの１次元的なメモリー配置変わらなく
                    # サイズが切り直されるような形。
                    # 可能な限りビューが返る。
a.reshape( (4,3) ).copy()  # 明示的にコピーを返したい場合
# 引数で、変換順序 order='C' (デフォルト) や 'F' などの指定はできるが、使い道はない？
# a.reshape( (4,3) ) をそのまま端末に出力した場合と、printで出力した場合で、表示のされ方が異なる。
# order='C' や order='F' を指定した場合の挙動がよくわからない。

配列の次元、サイズを調べる

a=numpy.arange(12).reshape( (3, 4) )
a.ndim
a.shape
↑

メソッドの調べ方 †

reshapeメソッドの仕様を調べる

import numpy as np
type( a )
# aが numpy.ndarray のとき
help( np.ndarray )  # import numpy as np してると、typeで numpy. と出るが、numpy. ではなく np. で指定する
# reshapeメソッドの説明はあるが、numpy.reshapeを見よとある
help( np.reshape )
# 引数newsharpは、intか intのタプルとある
↑

ビュー(view)とコピー(copy) †

https://note.nkmk.me/python-numpy-view-copy-shares-memory/

a.copy()  #コピーを生成する
rcd = a.base is None  #Trueなら、ビューである
↑

numpy.stack, hstack, vstack †

a = numpy.arange(4).reshape( (-1,) ) +100  #[100 101 102 103]
b = numpy.arange(4).reshape( (-1,) ) +200  #[200 201 202 203]

numpy.hstack( [a,b] )  # [100 101 102 103 200 201 202 203] になる

numpy.vstack( [a,b] )  # [[100 101 102 103]
                       #  [200 201 202 203]]
numpy.stack( [a,b], axis=0 )  # hstackと同じ

numpy.stack( [a,b], axis=1 )  # [[100 200]
                              #  [101 201]
                              #  [102 202]
                              #  [103 203]]
↑

numpy.meshgrid †

ax = numpy.linspace(0,4,5).astype(int)    #[   0    1    2    3    4]
ay = numpy.linspace(10,14,5).astype(int)  #[  10   11   12   13   14]

x, y = numpy.meshgrid( ax, ay )
# x
# [[   0    1    2    3    4]
#  [   0    1    2    3    4]
#  [   0    1    2    3    4]
#  [   0    1    2    3    4]
#  [   0    1    2    3    4]]
# y
# [[  10   10   10   10   10]
#  [  11   11   11   11   11]
#  [  12   12   12   12   12]
#  [  13   13   13   13   13]
#  [  14   14   14   14   14]]
for j in range(4,0,-1):
    for i in range(0,4,+1):
        print( " {: >2d}-{: >2d}".format(x[j,i], y[j,i]), end="" )
    print()
#  0-14  1-14  2-14  3-14
#  0-13  1-13  2-13  3-13
#  0-12  1-12  2-12  3-12
#  0-11  1-11  2-11  3-11
xx = x / 2.0
yy = y / 2.0
for j in range(4,0,-1):
    for i in range(0,4,+1):
        print( " {: >3.1f}-{: >3.1f}".format(xx[j,i], yy[j,i]), end="" )
    print()
# 0.0-7.0 0.5-7.0 1.0-7.0 1.5-7.0
# 0.0-6.5 0.5-6.5 1.0-6.5 1.5-6.5
# 0.0-6.0 0.5-6.0 1.0-6.0 1.5-6.0
# 0.0-5.5 0.5-5.5 1.0-5.5 1.5-5.5
↑

numpy.diff †

a = np.arange(10).reshape( (-1,) );  b = a*a    # b[i] , i=0～9
c = numpy.diff( b, n=1 )   # c[i] = b[i+1] - b[i] , i=0～8
d = numpy.diff( c, n=1 )   # d[i] = c[i+1] - c[i] , i=0～7
numpy.diff( b, n=2 )       # d[i]と同じ(n回 diffを繰り返す)。二階微分の、中央差分近似に対応
↑

numpy.where †

a = numpy.arange(10).reshape( (-1,) )
numpy.where( 5<a, 9.5, 0.5 )    # 配列aの要素が条件( 5< )を満たすとき 9.5、否なら 0.5
numpy.where( 5<a )              # 条件を満たす要素だけの配列（のタプルが返る）
numpy.where( 5<a )[0]           # 条件を満たす要素だけの配列
↑

mpi4pyモジュール †

MPIモジュールによる並列化
importすると、並列実行すると思われる。

comm = MPI.COMM_WORLD
↑

anacondaなどによる環境作成 †

↑

パッケージ(pythonやモジュール)のインストール方法の種類 †

python自体のインストールと利用バージョン切替

モジュール・パッケージのインストールと使用・不使用切替

anacondaによる condaコマンドは、

  1. 科学計算技術計算のモジュールが豊富(らしい)
  2. condaによる環境切替ができる（pythonバージョンやモジュール）

そのため、モジュール間の依存バージョン、依存するpython自体のバージョン、の整合性をとるには condaが楽だろう。 なお、"環境"は、実際には仮想ではないが "仮想環境"と日本語では呼ばれているようだ。

↑

リンク †

↑

conda環境の利用方法 †

conda activate [環境名]  #アクティベート（環境を設定）
conda deactivate         #デアクティベート（環境を終了）
conda create -n 環境名 [python[=バージョン] [パッケージ名[=バージョン]] [...]]  #環境作成
conda remove -n 環境名 --all  #環境の削除

conda create --help  #コマンドcreateのヘルプ
(補足)
conda create -n hoge により、インストール場所のanaconda3/{pkgs,envs} や ~/.conda/{pkgs,envs} に
パッケージや環境が置かれるようだ。

例えば appbinユーザにより /share/apps/anaconda3に anacondaがインストールされているとする。
シェルコマンド
  eval "$(/share/apps/anaconda3/bin/conda shell.bash hook)"
により、appbinや他のユーザは conda環境を利用できる。
- appbinユーザにより作成された環境は anaconda3/{pkgs,envs} にファイルが置かれ、他のユーザも利用できる。
- 他のユーザが環境を作った場合には ~/{pkgs,envs} にファイルが置かれて、そのユーザのみが利用できる。
- conda create -p pathEnvName により、環境のファイルを置く場所を指定できるため、そのユーザ以外も利用
できるようにできる、らしい。
conda info       #condaの情報
conda info -e    #環境のリスト
conda -V         #バージョン
conda -h         #ヘルプ
conda config --help     #コマンドconfigのヘルプ
anaconda search --help  #コマンドsearchのヘルプ
conda search [-c チャネル] [--full-name] パッケージ名  #パッケージのバージョンに対応するpythonのバージョン表示
conda install パッケージ名[=バージョン]    #現在の環境に、パッケージをインストール
conda uninstall パッケージ名  #現在の環境から、パッケージをアンインストール
conda list [-n 環境名]                   #インストールされているパッケージのリスト
なお、anaconda下で pipを使ったパッケージのインストールは condaで入れたパッケージを壊しうるので避ける。

デフォルト以外のチャンネル： https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/channels.html

環境の保存や、それを使った環境作成
 conda env export > ファイル名.yml
 conda env create -n 新しい環境名 -f ファイル名.yml
 or
 conda list --export > ファイル名.txt
 conda create -n 新しい環境名 -f ファイル名.txt
base環境の複製？
 conda create -n 新しい環境名 [python=バージョン] anaconda
conda clean --all  #不要なパッケージやキャッシュを削除
conda create -n 新しい環境名 --clone もとの環境名  #環境名を変更する
conda remove -n もとの環境名 --all
conda config --set env_prompt "({default_env}) "  #デフォルトでconda環境のときに付くプロンプトのプレフィックス
conda config --set env_prompt "p:"                #プロンプトプレフィックスを変更

conda config --set changeps1 false  #プロンプトを変更しない
echo $CONDA_SHLVL                   #0以外でconda環境であることを確認できる

conda config --set auto_activate_base false  #conda環境に入ったとき自動的にbase環境をactivateしない、たぶん。
アップデート
 conda update -n base -c defaults conda   #condaのupdate
 conda update conda;conda update anaconda;conda update --all  #anacondaのアップデート、らしい

アンインストール
 次のものを削除するようだ。
 インストール先のanaconda3 ディレクトリ
 ~/.conda ディレクトリ
 ~/.condarc ファイル
 ~/.bashrcに追加された conda initialize のブロック
jupyterパッケージをインストールしている場合
  cd
  jupyter notebook --no-browser --port=8800 --ip=0.0.0.0
  示されたURLをwebブラウザで開く。
  なお、ポートが使われていたら、1増えた番号が使われるようだ。
↑

弘大JupyterHub †

↑

Jupyter Notebook †

↑

長い出力部分の表示切替 †

↑

括弧などの入力補完(autoCloseBrackets)をオフにする †

from notebook.services.config import ConfigManager
c = ConfigManager()
c.update('notebook',
         {"CodeCell": {"cm_config": {"autoCloseBrackets": False}}})
を実行して、ノートブックを開きなおす。設定は ~/.jupyter/nbconfig/notebook.json に保存される。
↑

ipynbをpyに変換する †

jupyter nbconvert --to python hogehoge.ipynb   #==> hogehoge.pyが作られる
↑

jupytextを使えるようにする(ipynbとpyの同期) †

デフォルト以外のチャンネル https://docs.conda.io/projects/conda/en/latest/user-guide/concepts/channels.html → https://conda-forge.org/feedstock-outputs/ より conda-forgeにあるパッケージとして jupytextを検索して https://github.com/conda-forge/jupytext-feedstock を参考に、

$ conda activate py370
$ conda install jupytext --channel conda-forge

jupyter notebookを起動して hoge.ipynbファイルを開く→ファイル→Jupytext →Pair Notebook with light Scriptにチェックを入れる。 これで hoge.ipynbと hoge.pyが同期される。 [ref] https://qiita.com/ku_a_i/items/ccdeb7f1d9384fb4767b

トップ   新規 一覧 単語検索 最終更新   ヘルプ   最終更新のRSS