
### 関数の再帰呼び出し

関数の再帰呼び出しとは、「関数 A の中から、この関数 A 自身を呼び出すこと」である。

「ある手続きを実行している最中に、同じ手続きを、違う対象について行う」といった入れ子構造になった処理。大きな問題が小さな問題に収束するように使う。

### 再帰のルール

1. 再帰終了条件を持つ
2. 状態を変更しながら再帰終了条件に進む
3. 再帰的に関数自身を呼び出す

### 再帰関数の定義

再帰関数の定義は 2 つある。

1. 終了条件。終了条件は、最小の問題を処理する箇所。再帰呼び出しをせずに直接的に値を返す。
2. 再帰条件。再帰条件は「より小さな問題」を処理するための再帰呼び出しを行う。

問題を小さく分解していけば最終的に最小の問題を経由し終了条件が満たされるので、再帰が終了する。

### 関数の再帰呼び出しの例

次は再帰処理のシンプルな例である。引数 n を減算した値を、関数 total で加算しながらループさせ、n が 0 までたどり着いたときに再帰を停止する。

```python
def total(n):
    if n < 1: # 0 の時、再帰を停止
        return 0
    return n + total(n - 1) # 引数を減らしていく

print(total(3))
# 6
# 3 + 2 + 1


## 階乗の計算の例

次は階乗の計算（何通りの組み合わせがあるか？）を計算する例。引数に渡された数値を -1 しながら乗算している。

python
def fac(n):
    if n == 1:
        return 1
    else:
        return n * fac(n - 1)

print(fac(3))
# 6
# 3 * 2 * 1 = 6
```

### リストのリストなど入れ子になったデータを平坦化するコード

```python
def flat(x):
    for i in x:
        if isinstance(i, list):
            for i_in in flat(i):
                yield i_in
        else:
            yield i

x = [1, 2, [3, 4, 5], [6, [7, 8, 9]]]
list(flat(x))

# [1, 2, 3, 4, 5, 6, 7, 8, 9]
```


Python : 再帰は大きな問題が小さな問題に収束するように使う


## TL;DR

f-string は式を埋め込める文字リテラルである。先頭に f を付け、`f{式}`と書く。`{}` の中に、全ての Python 式を書くことができる。

#### セパレーター

`:,` とすると、カンマのセパレーターを入れる。

```python
a = 10000000000
print(f'{a:,}')
# 10,000,000,000

print(f'{a:_}')
# 10_000_000_000
```

#### 文字の位置を指定する

`:` の後ろに整数をつけると、フィールドの最小の文字幅を指定できる。揃えたいときに便利。
`:` の後ろにキャレット、小なり、大なり を置くと文字方向を指定できる。

- `:^` は、文字を中寄せ
- `:<` は、文字を左寄せ
- `:>` は、文字を右寄せ

そして、数値分の残りを指定の文字で繰り返して埋める。

```python
passwd = 'password'

print(f'{passwd:*^20}')
# ******password******

print(f'{passwd:*<20}')
# password************

print(f'{passwd:ば>20}')
# ばばばばばばばばばばばばpassword
```

`:<10` だと、空白 10 個分が埋められる。

```python
key = 'hello'
value = 1.234

f = f'{key} = {value}'
print(f)
# hello = 1.234

f = f'{key:<10} = {value:.4f}'
# :<10     最小フィールド幅
# :.4f     有効桁数（4桁）
print(f)
# 'hello'    = 1.2340
```

#### 改行

冗長なコードは改行して表示することができる。

```python
n = [
    ('a', 1),
    ('b', 2),
    ('c', 3),
]
for i, (item, count) in enumerate(n):
    print(f'{i}: '
          f'{item:<10} = '
          f'{count}')

# 0: a          = 1
# 1: b          = 2
# 2: c          = 3
```

#### フォーマット指定

フォーマットを指定する。

```python
fl = 1111
print(f'値は{fl:.3f}である！')
# 値は1111.000である！
```

#### 入れ

子
入れ子 `{{}}` でフォーマットを指定する。

```python
point = 3
fv = 222.1111999

print(f'{fv:.{point}f}')
# 222.111
```

#### バイナリデータ変換

バイナリデータに変換する。

```python
fl = 45
print(f'bit は {fl:b}')
# bit は 101101

print(f'hex は {fl:x}')
# hex は 2d

print(f'int は {fl:d}')
# int は 45
```

#### 日付の整形

日付を整形する。

```python
import datetime
d = datetime.datetime(2022, 1, 4, 3, 15, 59)
print(f'{d:%Y-%m-%d %H:%M:%S}')
# 2022-01-04 03:15:59
```

#### 置換 (conversion)

値に対して str() を呼ぶ `!s` 、 repr() を呼ぶ `!r` 、 ascii() を呼ぶ `!a` がサポートされている。

```python
name = '12345'
print(f'hello {name!r}')
# hello '12345'

print(f'hello {name}')
# hello 12345
```

> 置換 (conversion) フィールドにより書式変換前に型の強制変換が実施されます。通常、値の書式変換は `__format__()` によって実施されます。しかしながら、場合によっては、文字列として変換することを強制したり、書式指定の定義をオーバーライドしたくなることもあります。 `__format__()` の呼び出し前に値を文字列に変換すると、通常の書式変換の処理は飛ばされます。現在 3 つの変換フラグがサポートされています: 値に対して str() を呼ぶ `!s` 、 repr() を呼ぶ `!r` 、 ascii() を呼ぶ `!a`。 [string --- 一般的な文字列操作 — Python 3.10.0b2 ドキュメント](https://docs.python.org/ja/3/library/string.html)

#### 計算

計算を行う。

```python
s = 10
print(f'{s + 1}')
# 11

w = 'world '
f'hello {w * 3}'
# 'hello world world world'

import math
print(f'{math.pi:.2f}')
# 3.14
```

#### テキスト

テキストを代入する。

````python
w = 'world'
f'hello {w}'
# 'hello world'

file_name = 'flower.jpg'
alt_name = '花の写真です'
f'<img src="{file_name}" alt="{alt_name}">'
# <img src="flower.jpg" alt="花の写真です">
``

`

#### 式をそのまま表示する
`=` は名前を表示する。`=`` の直後に `:` を入れると、配置や幅を指定できる。
```python
a = 'apple'
b = 'banana'

print(f'{a}, {b}')
# apple, banana

# = を付ける
print(f'{a=}, {b=}')
# a ='apple', b ='banana'

# 配置.幅
print(f'{a=:10.2}, {b=:.3}')
# a = ap        , b =ban
````

#### 関数

関数の結果を返す。

```python
def func():
    return 'hoge'

print(f'{func()}')
# hoge
```

#### リスト

リストの要素を返すこともできる。

```python
img = ['flower.jpg', '花の写真です']
f'<img src="{img[0]}" alt="{img[1]}">'
# <img src="flower.jpg" alt="花の写真です">

w = ['apple', 'banana', 'cherry']
f'{w[1].title()}'
# 'Banana'
```

式を複数入れられる。

```python
w = ['apple', 'banana', 'cherry']
f'{w[0].capitalize()} is not the same as...{w[1].rjust(20)}.'
# 'Apple is not the same as...              banana.'
```


Python: f-string（f 文字列）と「:」の便利な使い方


## TL;DR

Python 3 では、文字列データを表すのに bytes と str がある。bytes のインスタンスは符号なし 8 ビット値で構成され、ASCII（文字コードの標準規格） エンコーディングで表示される。str は Unicode コードポイントの文字列を含む。

### bytes 型 と str 型 のポイント

- str と bytes は同時に扱えない
- ファイルにバイナリデータを書き込む場合、バイナリモードでオープンしなければならない
- bytes は 8 ビットの値の列を含む
- str は Unicode コードポイントの文字列を含む

#### バイナリデータについて

データ形式を大別すると、テキストとバイナリに分類される。バイナリデータとは、文字・画像・音楽・動画などテキストデータ以外のデータ。人が見ても意味が不明瞭なデータである。

バイナリデータを操作するためのものは 2 つある。

- bytes:イミュータブル（変更不可）。バイトのタプルのようなもの
- bytearray:ミュータブル（変更可）。バイトのリストのようなもの

[組み込み型 — Python 3.10.0b2 ドキュメント](https://docs.python.org/ja/3/library/stdtypes.html#binary-sequence-types-bytes-bytearray-memoryview)

#### bytes 型

bytes 型はコンピューターにとって扱いやすいバイト配列を扱う。バイトの不変なシーケンス（複数の要素を順番に並べたデータ型）である。str 型は人が読み書きしやすいが、bytes 型はコンピューターにとって扱いやすい。ハードディスクに直接保存可能である。

b の後で、クォートで囲むとバイト型になる。次のコードでは、encode() を使い文字列をエンコードしている。

```python
# str を bytes に変換する
s = 'café'
print(type(s))
b = s.encode('utf8')
print(b)
print(type(b))

# bytes を str に変換する
bb = b'd\xc3\xa9j\xc3\xa0 vu'
s = bb.decode('utf8')
print(s)
print(type(s))
```

#### str 型

str 型は文字列を扱う。str は Unicode コードポイントの不変なシーケンスである。人間が読み書きしやすい形式にするため、エンコード (str -> bytes) とデコード (bytes -> str) を行う。

### bytes と str の変換

Python では、文字列をバイト列に変換するには str オブジェクトの encode メソッドを使用し、逆にバイト列を文字列に変換するには bytes オブジェクトの decode メソッドを使用する。

#### encode メソッド

encode メソッドを使うと、str を bytes に変換できる。エンコードには様々な方式があるが、一般的によく使われるのは UTF-8 である。

```python
# str を bytes に変換する
s = 'café'
b = s.encode('utf8')
print(b)
```

#### decode メソッド

decode メソッドを使うと、bytes を str に変換できる。エンコードした方式と同じ方式を指定する。

```python
# bytes を str に変換する
bb = b'd\xc3\xa9j\xc3\xa0 vu'
s = bb.decode('utf8')
print(s)
```

Python の文字列とバイト列の取り扱いは独特な部分もあるので、使い分けや変換方法を理解しておくと便利である。


Python 3 では、文字列データを表すのに bytes と str がある。bytes のインスタンスは符号なし 8 ビット値で構成され、ASCII（文字コードの標準規格） エンコーディングで表示される。str は Unicode コードポイントの文字列を含む。

Python: bytes 型 と str 型の違い。変換方法


## TL;DR

MySQL へ接続するモジュール mysqlclient を使うには、インポートの際に MySQLdb と記述する必要がある。

### mysqlclient のインストール

MySQL と mysqlclient をインストールする。

```python
brew install mysql
pip install mysqlclient
```

[mysqlclient · PyPI](https://pypi.org/project/mysqlclient/)

### mysqlclient のインポート

```python
import MySQLdb
```

インポートしたときに ModuleNotFoundError エラーが出る場合は、[インポートしたときに「ModuleNotFoundError」になる場合の対処法](https://commte.net/7655)を参考にするとよい。

### Python DB API のバージョンを確認する

インポートが正しく動いたら、データベースのモジュールが PEP 249 に準拠しているか調べておこう。Python の扱うデータベース API は、[PEP 249](https://www.python.org/dev/peps/pep-0249/)によって、API 仕様の統一がされている。

#### apilevel

データベースのモジュールが、PEP 249 に準拠しているか調べたい場合、apilevel を使う。apilevel は、サポートされているデータベース API レベルを示す文字列定数である。現在、文字列「1.0」と「2.0」のみが許可されている。

```python
import MySQLdb
print(MySQLdb.apilevel)
# 2.0
```

2.0 と表示された。DB API 2.0 に準拠している。

### データベース作成

次に、データベースを作る。sample というデータベースを作成してみよう。mysql をたたいた後で、create database を入れる。

```python
mysql
create database sample;
```

### データベースに接続しテーブルを作る

基本的なメソッドは次のとおり

#### connect

データベースに接続するために `connect()` メソッドを使用します。このメソッドは、データベースへの接続を表すコネクションオブジェクトを返します。

```python
db = MySQLdb.connect(host="localhost", user="username", passwd="password", db="sample")
```

ここで、`"username"` と `"password"` は実際の MySQL のユーザ名とパスワードに置き換えてください。

#### cursor

データベースに対して操作を行うためには、カーソルオブジェクトが必要です。これはコネクションオブジェクトの `cursor()` メソッドを使用して取得できます。

```python
cursor = db.cursor()
```

#### execute

SQL コマンドを実行するためには、カーソルオブジェクトの `execute()` メソッドを使用します。

以下の例では、新しいテーブルを作成します。

```python
cursor.execute("CREATE TABLE example (id INT, name VARCHAR(20));")
```

### with 文の使い方

with 文を使うと、データベースの接続やカーソルの取得、そして処理が完了した後のクリーンアップを一連のブロック内で自動的に行うことができます。

```python
with MySQLdb.connect(host="localhost", user="username", passwd="password", db="sample") as db:
    with db.cursor() as cursor:
        cursor.execute("CREATE TABLE example (id INT, name VARCHAR(20));")
```

with 文を使うことで、データベース接続が適切に閉じられ、リソースのリークを防ぐことができます。また、エラーが発生した場合でも、接続が適切に閉じられることが保証されます。

---

以上が mysqlclient（MySQLdb）の基本的な使用方法です。これらの手順を踏むことで、Python から MySQL に対する様々な操作を行うことが可能になります。さらに詳しく知りたい方は、公式ドキュメンテーションを参照してください。


この記事ではPythonでMySQLに接続するためのモジュールmysqlclient（MySQLdb）の使用方法について説明します。具体的なインストール手順、インポート方法、APIバージョンの確認方法、データベース作成、データベース接続とテーブル作成、およびwith文の使用について詳しく説明します。

Python: MySQL へ接続するモジュール mysqlclient（MySQLdb）の使い方


## TL;DR

モジュールをインストールした後、ファイルに「import モジュール名」を記載すると ModuleNotFoundError というエラーが出る場合の対処法。

ModuleNotFoundError が出たときは、次の 3 点を確認する。

1. モジュールが格納されているパスを確認する
2. .bashrc に PYTHONPATH を記述する
3. .bashrc を再読み込みする

### ModuleNotFoundError

ModuleNotFoundError は、モジュールが読み込めていないことを表している。

インポートを試みたがモジュールが読み込めない、そういった場合に表示される。

例えば、MySQL へ接続するモジュール mysqlclient を インストールし、test.py というファイルの冒頭にインポート文を記述したとしよう。

```python
import MySQLdb
```

しかし、いざ Python を走らせようとすると、次のようにモジュールの読み込みエラーがでる。

```bash
Traceback (most recent call last):
  File "/Users/ユーザー名/projects/Python/test.py",
  line 1, in <module>
    import MySQLdb
ModuleNotFoundError: No module named 'MySQLdb'
```

こういうケースでは、モジュール名の見直しを行うか、.bashrc に モジュール検索パスである PYTHONPATH を指定してあげると解決することがある。

### 手順

#### モジュールが格納されているパスを確認する

次の方法でモジュールがインストールされているパスを調べる。pprint を使って、パスを整形表示したほうが見やすい。

```python
>>> import sys
>>> import pprint
>>> pprint.pprint(sys.path)
['',
 '/Users/ユーザー名/.pyenv/versions/3.9.6/lib/python39.zip',
 '/Users/ユーザー名/.pyenv/versions/3.9.6/lib/python3.9',
 '/Users/ユーザー名/.pyenv/versions/3.9.6/lib/python3.9/lib-dynload',
 '/Users/ユーザー名/.pyenv/versions/3.9.6

/lib/python3.9/site-packages']
```

上記の場合、パスは通っている。モジュールは「site-packages」以下に格納されている。

パスが通ってない場合は、モジュールが格納されている場所を探し、ディレクトリを直接確認してみよう。

```bash
ユーザー
└── .pyenv
    └── versions
        └── 3.9.6
            └── lib
                └── python3.9
                    └── site-packages
                        ├── MySQLdb
                        ├── numpy
                        ├── path
                        └── pip
```

そして、パスを追加する。

```python
>>> sys.path.append('パス')
```

#### .bashrc に PYTHONPATH を記述する

.bashrc に、先程調べたモジュールのパスを追加する。.bashrc の場所は、Mac の場合 `/Users/ユーザー名/` の中にある。

PYTHONPATH の記述方法はこちらである。PYTHONPATH は、モジュールファイルのデフォルトの検索パスを追加する。

```bash
$ export PYTHONPATH="モジュールへのパス:${PYTHONPATH}"
```

ディレクトリパスの最後にはスラッシュは付けない。

```bash
$ export PYTHONPATH="/Users/ユーザー名/.pyenv/versions/3.9.6/lib/python3.9/site-packages:${PYTHONPATH}"
```

> この環境変数のフォーマットは、(Unix ならコロン、 Windows ならセミコロン) で区切られた 1 つ以上のディレクトリパスです。存在しないディレクトリは警告なしに無視されます。 [コマンドラインと環境 — Python 3.10.0b2 ドキュメント](https://docs.python.org/ja/3/using/cmdline.html#envvar-PYTHONPATH)

#### .bashrc を再読み込み

保存したら、忘れずに.bashrc を再読み込みする。

```bash
$ source ~/.bashrc
```

私の場合はこれで無事に稼働した。

### 上述した方法でも動かない場合

何かの理由で .bashrc を編集できない場合、次のように、py ファイルの上部に sys.path.addend()メソッドを直接記述することで動く可能性がある。

```python
import sys
sys.path.append("/Users/ユーザー名/.pyenv/versions/3.9.6/lib/python3.9/site-packages")

import numpy as np
```


モジュールをインストールした後、ファイルに「import モジュール名」を記載すると ModuleNotFoundError というエラーが出る場合の対処法について説明します。

Python: インポートしたときに「ModuleNotFoundError」になる場合の対処法


## TL;DR

Python 標準ライブラリである collections の Counter()関数は要素数の計算を行う。出現の回数を集計する場合などに便利である。

### Counter()クラス のポイント

- ハッシュ（辞書）可能なオブジェクトを数え要素数を返す
- イテラブル、マッピング、キーワード引数のオブジェクトを数える
- 和集合・減算・積集合などが可能
- subtract()で減算を行う
- most_common()で要素を降順で返す

```python
c = Counter()
# 空のカウンターを作成する

c = Counter('gallahad')
# イテラブルなカウンター作成

c = Counter({'red': 4, 'blue': 2})
# マッピング

c = Counter(cats=4, dogs=8)
# キーワード引数セット
```

> ハッシュ可能なオブジェクトを数え上げる辞書（dict）のサブクラス。要素を辞書のキーとして保存し、そのカウントを辞書の値として保存するコレクション。 [collections --- コンテナデータ型 — Python 3.10.0b2 ドキュメント](https://docs.python.org/ja/3/library/collections.html?highlight=collections%20counter#collections.Counter)

### Counter()

要素数を数える。存在しない要素には 0 を返す。

```python
from collections import Counter
c = Counter(['a', 'a', 'b', 'c'])
c['a']
# 2
```

イテラブルな要素を数える。イテラブルなオブジェクトとは、リスト、タプル、辞書、文字列など複数の要素を持ったオブジェクトを指す。

次のコードでは、タプルや文字もイテラブルなのでカウントされている。

```python
c = Counter('abbbd')
c
# Counter({'a': 1, 'b': 3, 'd': 1})

c = Counter(('a', 'a', 'a', 'b', 'c', 'c'))
c
# Counter({'a': 3, 'b': 1, 'c': 2})
```

#### 結合

リストの結合。

````python
one = Counter(['a', 'a', 'a', 'b', 'c', '
```markdown
c', 'c'])
two = Counter(['a', 'b', 'b', 'b', 'c'])
three = one + two
print(three)
# Counter({'a': 4, 'b': 4, 'c': 3})
````

#### 差分

```python
one = Counter(['a', 'a', 'a', 'b', 'c', 'c', 'c'])
two = Counter(['a', 'b', 'b', 'b', 'c'])
three = one - two
print(three)
# Counter({'a': 2, 'c': 2})
```

#### 交差点

```python
one = Counter(['a', 'a', 'a', 'b', 'c', 'c', 'c'])
two = Counter(['a', 'b', 'b', 'b', 'c'])
three = one & two
print(three)
# Counter({'a': 1, 'b': 1, 'c': 1})
```

#### 積集合

```python
one = Counter(['a', 'a', 'a', 'b', 'c', 'c', 'c'])
two = Counter(['a', 'b', 'b', 'b', 'c'])
three = one | two
print(three)
# Counter({'a': 3, 'b': 3, 'c': 3})
```

### most_common()

最も一般的な要素を降順で返す。

```python
c = Counter('abbbccccd')
print(c.most_common())
# [('c', 4), ('b', 3), ('a', 1), ('d', 1)]
```

引数を指定すると、その数だけ要素を返す。

```python
print(c.most_common(2))
# [('c', 4), ('b', 3)]
```

このように、Counter()は非常に便利な関数で、Python のコーディングにおいて頻繁に使用される。データ分析や情報処理の際には特に役立つツールである。


Python 標準ライブラリである collections の Counter()関数は要素数の計算を行う。出現の回数を集計する場合などに便利である。

Python: カウンタ。Counter()関数で要素数を計算する


## TL;DR

Requests-HTML は、Web スクレイピングを簡単に操作にするモジュールである。HTML のパースなどページを取り出して目的の要素を処理する。Requests-HTML の作者である Kenneth Reitz 氏 は、HTTP クライアントインターフェースとして広く使われている [Requests](https://github.com/psf/requests) モジュールの作者でもある。設計はクリーンだ。Requests-HTML は、ページに含まれているすべてのリンクやコンテンツ全体の他、HTML 要素の属性を知ることができる。作者の github [psf/requests-html](https://github.com/psf/requests-html)によると、次の情報を得ることができると書かれている。

- JavaScript サポート
- CSS セレクター
- XPath セレクター
- 模擬ユーザーエージェント
- リダイレクトの自動フォロー
- 接続プール
- Cookie の永続性
- 非同期サポート

### インストール コマンド

```python
pipenv install requests-html
```

colab にはプリインストールされていない。colab 上でインストールする場合は次のコマンドをコードセルに入力する。

```python
!pip install requests-html
```

### CSS セレクタを見つける

ターゲットのスクレイピング先に記述された html ソースコードがこちらだったとする。

```python
<h2 class="title">httpbin.org
    <small>
        <pre class="version">0.9.2</pre>
    </small>
</h2>
```

#### find()

find() メソッドの中で要素名を指定することにより html の中に記述されたセレクタを見つけることができる。id でも クラス名でも指定可能。

````python
from requests_html import HTMLSession
session = HTMLSession()
r = session.get('https://httpbin.org/')

id_name = r.html.find('.title', first=True)
print(id_name)

# first=True
#

 about:
Requests-HTMLを使い、Webスクレイピングを簡単に操作する方法を説明しています。HTMLのパースやページ要素の処理、JavaScriptサポート、CSS、XPathセレクターなどについて、さまざまなメソッドやコマンドを紹介しています。

以下、Markdown形式です：

```markdown
---
id: '7628'
title: 'Python: Requests-HTML の使い方'
date: '2021-11-26'
description: 'この記事では、PythonのRequests-HTMLモジュールを用いてWebスクレイピングを簡単に操作する方法について解説します。'
tag: [python]
posttype: 'blog'
---

Requests-HTML は、Web スクレイピングを簡単に操作にするモジュールである。HTML のパースなどページを取り出して目的の要素を処理する。

Requests-HTML の作者である Kenneth Reitz 氏 は、HTTP クライアントインターフェースとして広く使われている [Requests](https://github.com/psf/requests) モジュールの作者でもある。設計はクリーンだ。

Requests-HTML は、ページに含まれているすべてのリンクやコンテンツ全体の他、HTML 要素の属性を知ることができる。

作者の github [psf/requests-html](https://github.com/psf/requests-html)によると、次の情報を得ることができると書かれている。

- JavaScript サポート
- CSS セレクター
- XPath セレクター
- 模擬ユーザーエージェント
- リダイレクトの自動フォロー
- 接続プール
- Cookie の永続性
- 非同期サポート

### インストール コマンド

```python
pipenv install requests-html
````

colab にはプリインストールされていない。colab 上でインストールする場合は次のコマンドをコードセルに入力する。

```python
!pip install requests-html
```

### CSS セレクタを見つける

ターゲットのスクレイピング先に記述された html ソースコードがこちらだったとする。

```python
<h2 class="title">httpbin.org
    <small>
        <pre class="version">0.9.2</pre>
    </small>
</h2>
```

#### find()

find() メソッドの中で要素名を指定することにより html の中に記述されたセレクタを見つけることができる。id でも クラス名でも指定可能。

````python
from requests_html import HTMLSession
session = HTMLSession()
r = session.get('https://httpbin.org/')

id_name = r.html.find('.title',

 to save space ...
```python
id_name = r.html.find('.title', first=True)
print(id_name.text)
# httpbin.org
# 0.9.2
````

.find() メソッドのパラメータ一覧と find()メソッドの記述例は表で示されています。.attrs をつけると、class 名や id 名などの属性を表示できます。

### URL に関する処理

次のコードは URL に関する情報を返します。.html.links にすると、リンクのリストを取得するが、.html.absolute_links は、ページ上のすべてのリンクのリストを絶対形式で取得します。

```python
from requests_html import HTMLSession
session = HTMLSession()
r = session.get('https://httpbin.org/')

print(r)
# <Response [200]>

print(r.html.url)
# https://httpbin.org/

print(r.html.absolute_links)
# {''https://github.com/...', 'https://httpbin.org/...', ...}
```

### メソッド一覧

メソッド一覧は以下の表で示されています。

| 記述法                  | 対象             |
| ----------------------- | ---------------- |
| r.html.links()          | リンク           |
| r.html.absolute_links() | 絶対形式のリンク |
| r.html.find()           | CSS セレクタ     |
| r.html.base_url()       | ベースとなる URL |
| r.html.render()         | JavaScript 取得  |

そして以下の表には、様々な情報を取得する方法が示されています。

| 記述法              | 取得                     |
| ------------------- | ------------------------ |
| xxxx.text           | テキストコンテンツ       |
| xxxx.full_text      | 全文コンテンツ           |
| xxxx.attr           | 属性（class 名や id 名） |
| xxxx.html           | HTML                     |
| xxxx.absolute_links | リンク                   |
| xxxx.search         | テキスト検索             |
| xxxx.xpath          | XPath                    |

### title を取得する

メタ情報のタイトルは、head > title で取得できます。

```python
from requests_html import HTMLSession
session = HTMLSession()
r = session.get('https://ja.wikipedia.org/')

id_name = r.html.find('head > title', first=True)
print(id_name.text)

# Wikipedia
```

### 要素内の文章を抽出

.text パラメータをつけることで、要素内のテキストを抽出できます。

```python
from requests_html import HTMLSession
session = HTMLSession()
r = session.get('https://httpbin.org/')

id_name = r.html.find('.title', first=True)
print(id_name.text)

# httpbin.org
# 0.9.2
```

.full_text は全文コンテンツを取得します。余白と改行はそのまま表示されます。

### 掘り下げて検索

結果に、.find をつけて、掘り下げて目的の要素を探すことができます。

```python
from requests_html import HTMLSession
session = HTMLSession()
r = session.get('https://httpbin.org/')
id_name =

 r.html.find('.title', first=True)
print(id_name.find('small > .version', first=True).text)
# 0.9.2
```

### 要素を検索

.search メソッドを使うと、文字列のパターンに一致する情報を探すことができます。探したい情報を "{}" で囲むと、その情報が出力されます。

```python
from requests_html import HTMLSession
session = HTMLSession()
r = session.get('https://httpbin.org/')
id_name = r.html.find('.title', first=True)
print(id_name.search('httpbin.org{}'))
# {'': '\n    \n        0.9.2\n    '}
```

### JavaScript の取得

r.html.render() をつけると JavaScript で動的に生成される情報も取得できます。

```python
from requests_html import HTMLSession
session = HTMLSession()
r = session.get('https://httpbin.org/')
r.html.render()
print(r.html.search('httpbin.org{}'))
# {'': '\n    \n        0.9.2\n    '}
```

### XPath の利用

.find メソッドを使って XPath を利用することも可能です。

```python
from requests_html import HTMLSession
session = HTMLSession()
r = session.get('https://httpbin.org/')
result = r.html.xpath('//title')
print(result[0].text)
# httpbin.org
```

以上、Requests-HTML の基本的な使い方について説明しました。これを使えば、Web スクレイピングがより簡単になるでしょう。本記事が皆さんの参考になれば幸いです。


この記事では、WebスクレイピングのためのPythonモジュール、Requests-HTMLの使い方について解説します。作者のGitHubリポジトリや、インストール方法、CSSセレクタの見つけ方、URLに関する処理、そしてJavaScriptの取得方法など、具体的なコード例を交えながら紹介しています。

Python: Requests-HTML の使い方


## TL;DR

BeautifulSoup モジュール は、HTML や XML ファイルからタイトルやヘディングを取得することができるモジュールである。正規表現を組み合わせれば、様々な情報を整形して取得することが可能である。

### BeautifulSoup モジュールのポイント

- HTML から要素を取得出力する
- html タグは除去可能
- 深い階層の要素まで絞り込みできる

```python
pip install beautifulsoup4
```

ドキュメント：[Beautiful Soup 4.9.0 documentation](https://www.crummy.com/software/BeautifulSoup/bs4/doc/)

### 基本の形

find() メソッドの引数に条件を指定することで、html のタグを取得することができる。Tag は BeautifulSoup の Tag オブジェクトのことである。

```python
# Tag オブジェクトを返す
soup.find("タグ")

# 指定した属性に一致するTagオブジェクトを返す
soup.find(属性=属性値)

# 指定したタグと属性に一致するTagオブジェクトを返す
soup.find("タグ", 属性=属性値)

# Tag のシーケンス
soup.find_all("タグ")

# タグの名前
Tag.name

# タグの中のテキスト
Tag.text

# 属性の値
Tag.get("属性名")
```

#### 使用例

```python
print(soup.p)
# <p class="text_en">Lorem ipsum dolor sit amet consequat.</p>

print(soup.a)
# <a class="underline" href="#">これはダミーリンクです。</a>
```

#### find メソッド

次は、変数 html_doc に、ダミー HTML を格納し、find メソッドによって p タグの中身を取得する例である。

```python
html_doc = """
<!DOCTYPE html>
<html lang="ja">

<head>
  <meta charset="UTF-8">
  <title>HTML Document Template</title>
  <meta name="description" content="これはhtmlのテンプレートです。">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
</head>

<body>
  <h1>Hello, World!</h1>
  <p class="text_en">Lorem ipsum dolor sit amet, consectetuer adipiscing elit.</p>
  <p class="text_ja">これはダミーのパラグラフです。</p>
  <a class="underline" href="#">これはダミーリンクです。</a>
</body>

</html>
"""

from bs4 import BeautifulSoup
soup = BeautifulSoup(html_doc, 'html.parser')

# pタグのみを取得
print(soup.find('p'))
# <p class="text_en">Lorem ipsum dolor sit amet, consectetuer adipiscing elit.</p>

# pタグ内のテキストのみを取得
print(soup.find('p').text)
# Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
```

#### find_all メソッド

find_all メソッドを使用すれば、特定のタグが持つすべての要素を取得することが可能である。

```python
# 全てのpタグを取得
print(soup.find_all('p'))
# [<p class="text_en">Lorem ipsum dolor sit amet, consectetuer adipiscing elit.</p>, <p class="text_ja">これはダミーのパラグラフです。</p>]

# pタグ内の全てのテキストを取得
for tag in soup.find_all('p'):
    print(tag.text)
# Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
# これはダミーのパラグラフです。
```

#### get メソッド

get メソッドを使うと、タグの属性を取得することができる。

```python
# href属性を取得
print(soup.find('a').get('href'))
# #
```

BeautifulSoup は非常に強力で、HTML や XML の解析に広く使用されています。以上がその基本的な使い方になりますが、これらのメソッドや機能を組み合わせることで、様々な情報抽出や加工が可能です。


この記事ではPythonのBeautifulSoupモジュールの使い方について詳しく説明します。BeautifulSoupはHTMLやXMLファイルからタイトルやヘディングなどの情報を抽出することができ、正規表現と組み合わせることで更に柔軟な情報抽出が可能です。

Python: BeautifulSoup 使い方（タイトル・HTML 取得など）


## TL;DR

HTTP クライアントインターフェースとして広く使われている Requests モジュールは、HTTP リソースを簡単に使うためのサードパーティ製のライブラリである。HTTP レスポンスの情報が格納されたオブジェクトが返される。

### スクレイピング

Requests モジュールを使って、REST API や Web スクレイピング（データ収集と加工）ができる。Web ページをダウンロード、情報抽出を行った上で、自動レポート作成も簡単にできてしまう。

※ HTTP（Hypertext Transfer Protocol）はリクエストとレスポンスを交換するプロトコル。

### Requests モジュール のポイント

- requests は get()で GET リクエストを実行する
- 戻り値にレスポンスが入ったオブジェクトを得ることができる
- テキスト表示や URL を返す様々な属性が用意されている

Requests のインストール

```python
pip install requests

```

##### リクエスト一覧

| リクエスト      | 意味   |
| --------------- | ------ |
| requests.get    | GET    |
| requests.post   | POST   |
| requests.put    | PUT    |
| requests.delete | DELETE |
| requests.head   | HEADER |

使用例

```python
r = requests.put('https://httpbin.org/put', data={'key': 'value'})
r = requests.delete('https://httpbin.org/delete')
r = requests.head('https://httpbin.org/get')
r = requests.options('https://httpbin.org/get')

```

次のコードは、[httpbin.org](https://httpbin.org/) という URL に向けて GET を実行し、そこから得られる結果を print 出力している。

ローカルファイルを開くのと同じようにリモートファイルを開くことができる。ただし、読み込みモードしか使えない。

※ [httpbin.org](https://httpbin.org/) は HTTP のリクエストとレスポンスサービス。API の通信テストに活用できるので、メモしておくとよいだろう。

```python
import requests

r = requests.get("https://httpbin.org/")
print(r.text)

```

結果

```python
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <title>httpbin.org</title> ...

```

##### Response 属性一覧

r と呼ばれる Response オブジェクトから、必要な情報を全て取得することができる。

| 属性          | 意味                        |
| ------------- | --------------------------- |
| r             | Response [レスポンスコード] |
| r.status_code | ステータスコード            |
| r.text        | body をテキスト形式で返す   |
| r.url         | URL を返す                  |
| r.encoding    | エンコーディング            |
| r.headers     | レスポンス                  |
| r.json()      | JSON 形式                   |

##### JSON

JSON データを扱う場合、組み込みの JSON デコーダーもある。r.json()と記述する。デコードが失敗した場合、r.json()例外が発生する。

```python
payload = {'k1': 'v1', 'k1': 'v2'}
r = requests.get("http://httpbin.org/get", params=payload)
r.json()

```

結果

```python
{'args': {'k1': 'v2'},
 'headers': {'Accept': '*/*',
  'Accept-Encoding': 'gzip, deflate',
  'Host': 'httpbin.org'...
 'url': 'http://httpbin.org/get?k1=v2'}

```

##### r.status_code

ステータスコードの表示。

```python
r = requests.get("http://httpbin.org/get")
print(r.status_code)

# 200

```

##### r.encoding

```python
r = requests.get("http://httpbin.org/get")
print(r.encoding)

# None

```

##### r.headers

```python
r = requests.get("http://httpbin.org/get")
print(r.headers)

# {'Date': 'Sat, 20 Nov 2021 02:08:13 GMT', ...}

```

### パラメータを渡す

パラメータは params の中に入れる。キーワード引数を辞書（ハッシュ）で指定することで、GET パラメータを付けることができる。

```python
payload = {'k1': 'v1', 'k1': 'v2'}
r = requests.get("http://httpbin.org/get", params=payload)
print(r.text)

```

結果

```python
{
  "args": {
    "k1": "v2"
  },
  "headers": {
    "Accept": "*/*",
    "Accept-Encoding": "gzip, deflate",
    "Host": "httpbin.org",
  },
  "url": "http://httpbin.org/get?k1=v2"
}

```

### URL

url をつけると、エンコードされた URL そのものを表示する。

```python
payload = {'k1': 'v1', 'k1': 'v2'}
r = requests.get("http://httpbin.org/get", params=payload)
print(r.url)
# http://httpbin.org/get?k1=v2

```

### POST

post()関数や put()関数 API も利用できる。

```python
import requests
r = requests.post('https://httpbin.org/post', params={'japan' : 'blue'})
r.json()

```

結果

```python
{'args': {'japan': 'blue'},
 'data': '',
 'files': {},
 'form': {},
 'headers': {'Accept': '*/*',...

```

エンコードしたデータを送信する場合、data 引数に辞書を渡す。

```python
import requests
payload = {'k1': 'v1', 'k1': 'v2'}
r = requests.post('https://httpbin.org/post', data=payload)
print(r.text)

```

結果

```python
{
  "args": {},
  "data": "",
  "files": {},
  "form": {
    "k1": "v2"
  },
  "headers": {
    ...
  },
  "json": null,
  "url": "https://httpbin.org/post"
}

```

JSON 文字列を指定する場合。

```python
import requests
import json

payload = {'k1': 'v1', 'k1': 'v2'}
r = requests.post('https://httpbin.org/post', json=json.dumps(payload))
print(r.text)

```

結果

```python
{
  "args": {},
  "data": "\"{\\\"k1\\\": \\\"v2\\\"}\"",
  "files": {},
  "form": {},
  "headers": {

```

#### 参考

- [Requests: HTTP for Humans™ — Requests 2.26.0 documentation](https://docs.python-requests.org/en/latest/)
- [Python 基礎＆実践プログラミング](https://amzn.to/3nysB1q)
- [Python コードレシピ集](https://amzn.to/3HBGmEt)


HTTP クライアントインターフェースとして広く使われている Requests モジュールは、HTTP リソースを簡単に使うためのサードパーティ製のライブラリで

Python: Requests モジュールの使い方（スクレイピング、データ収集など）


## TL;DR

SQLite は Python の標準ライブラリとして実装され、通常のファイルにデータベースを格納する。SQlite を使うための sqlite3 モジュールが提供されている。

### sqlite3 モジュール のポイント

- connect()でコネクションを生成する
- cousor()でオブジェクトを返す
- execute()でテーブル作成、データ作成、情報表示を行う
- データベースが存在しない場合は自動で生成される
- すでにデータベースが存在する場合 CREATE を実行するとエラーになる
- 特殊文字列の`':memory:'` を指定するとメモリ内にデータベースを作る
- with を合わせて使うのがよい

#### 基本の形

変数を cur とした。最初に使用例を記載する。詳しい解説は後述する。

※ 次は省略した形で記述しているので、そのまま打ち込んでも反映されない。

```python
import sqlite3

with sqlite3.connect('ファイル名.db') as conn:

  # カーソルオブジェクトを返す
  cur = conn.cursor()

  # テーブルを作る
  cur.execute()

  # データを入れる
  cur.execute()

  # 情報を引き出す
  cur.execute('SELECT * FROM person')
  print(cur.fetchall())

  # SQL命令文を実行後にデータベースへの変更を行う
  conn.commit()
```

こちらが具体的に記述した内容。新しいデータベース test.db が作られる。すでにファイルが存在する場合はエラーになる。

```python
import sqlite3
with sqlite3.connect('test.db') as conn:
    cur = conn.cursor() # カーソルオブジェクトを返す
    # テーブルを作る
    cur.execute("""CREATE TABLE person
    (id integer,
    name text)
    """)
    # Insert実行
    cur.execute("""INSERT INTO person
    (id, name) VALUES (1, 'user1')
    """)
    # 情報を引き出す
    cur.execute('SELECT * FROM person')
    print(cur.fetchall())
    # [(1, 'user1')]

    # SQL命令文を実行後にデータベースへの変更を行う
    conn.commit()
```

メソッドを簡単に解説しておこう。

| メソッド      | 処理                                           |
| ------------- | ---------------------------------------------- |
| cursor()      | カーソルオブジェクトを返す                     |
| execute()     | テーブル作成、データ作成、情報表示             |
| conn.commit() | SQL 命令文を実行後にデータベースへの変更を行う |

カーソルはクエリを実行し、その結果を調べる。

##### なぜ、commit()が必要なのか？

> このメソッドは現在のトランザクションをコミットします。このメソッドを呼ばないと、前回 commit() を呼び出してから行ったすべての変更は、他のデータベースコネクションから見ることができません。もし、データベースに書き込んだはずのデータが見えなくて悩んでいる場合は、このメソッドの呼び出しを忘れていないかチェックしてください。

[sqlite3 --- SQLite データベースに対する DB-API 2.0 インターフェース — Python 3.10.0b2 ドキュメント](https://docs.python.org/ja/3/library/sqlite3.html)

### SQL 基本コマンド

sqlite3 モジュールを扱うためには、SQL コマンドの知識が必要なので、少しばかり SQL の基本的なコマンドをおさらいをする。

SQL 文は、DDL と DML という 2 つのカテゴリに分類される。DDL はデータ定義言語、DML はデータ操作言語である。

#### DDL（データ定義言語）

DDL とは、表・データベース・ユーザー作成・削除・許可などの処理である。

| 操作                             | パターン                       |
| -------------------------------- | ------------------------------ |
| データベース作成                 | CREATE DATABASE データベース名 |
| データベースの選択               | USE データベース名             |
| データベースと表の削除           | DROP DATABASE データベース名   |
| 表の作成                         | CREATE TABLE テーブル名        |
| 表の削除                         | DROP TABLE テーブル名          |
| 表の全ての行削除                 | TRUNCATE TABLE テーブル名      |
| データベースやテーブル構成の変更 | ALTER                          |

#### DML（データ操作言語）

DML は、データ挿入・選択・更新・削除などの処理を行う。実際に使われる SQL 文のほとんどは DML である。

| 操作                 | パターン                                    |
| -------------------- | ------------------------------------------- |
| 行追加（データ登録） | INSERT INTO テーブル名                      |
| すべての行と列の選択 | SELECT \* FROM テーブル名                   |
| 全ての行の特定列     | SELECT カラム名 FROM テーブル名             |
| 一部の行削除         | DELETE FROM テーブル名 WHERE コンディション |
| テーブル行の更新     | UPDATE                                      |

[入門 Python 3 第 2 版](https://amzn.to/2Z5khNk)より

SQL がどういった働きをするのかご理解いただけたら、次に SQLite のコマンド操作方法を学ぶ。

### SQLite

SQlite は、軽くて優れたオープンソースのデータベースである。MySQL や PostgreSQL などのリレーショナルデータベースと比較すると機能は限定的だがシンプルに扱える。ブラウザ・スマートフォンも組み込みデータベースとして SQLite を使っている。

sqlite の基本コマンドの使用例を示しておく。

#### CREATE（テーブルの作成）

```python
sqlite> CREATE TABLE テーブル名 (カラム1 データ型, カラム2 データ型);
```

#### INSERT INTO（テーブルにデータを登録）

```python
sqlite> INSERT INTO テーブル名 (カラム1, カラム2) VALUES (データ, データ);
```

SQLite のコマンド操作方法を理解したところで、いよいよ SQlite を使うための Python sqlite3 モジュールについて説明する。ここからが本論である。

### sqlite3.connect

sqlite3 モジュールを扱うときは、コンテキストマネージャー（[with 文の前後で処理を実行する](https://commte.net/7472)）の with を合わせて使うのがよい。なぜなら、ファイルが確実に閉じられるからである。

with を使わない場合、.close()を記述しなくてはいけなくなる。

##### isolation_level

次のコードでは、commit()の代わりに`isolation_level=None` を埋め込み、**自動コミットモード** にした。isolation_level は、現在のデフォルト分離レベルを取得設定する。

SQL の記述は長く分かりにくいので、視認性を高めるためにトリプルクォートの中に記述し改行させた。

```python
import sqlite3
with sqlite3.connect('test.db', isolation_level=None) as conn:
    # isolation_level=None は自動コミットモード
    cur = conn.cursor() # カーソルオブジェクトを返す
    # テーブルを作る
    cur.execute("""CREATE TABLE person
    (id integer,
    name text)
    """)
    # Insert実行
    cur.execute("""INSERT INTO person
    (id, name) VALUES (1, 'user1')
    """)
    # 情報を引き出す
    cur.execute('SELECT * FROM person')
    print(cur.fetchall())
    # [(1, 'user1')]
```

上述したコードの流れを次に示す。

1.  connect()：データベースへ接続（開設）する
2.  cursor()：クエリを管理するカーソルオブジェクトを作る
3.  execute()：SQL を実行する

SQL の処理を簡単に解説する。

| SQL の記述 | 処理内容       |
| ---------- | -------------- |
| CREATE     | テーブルを作る |
| INSERT     | データを入れる |
| SELECT     | 情報を引き出す |

コードの最終行に記述した fetchall() メソッドは、一致した全ての行のリストとして受け取る働きをする。

※ すでにデータベースが存在する場合、CREATE を実行すると、エラーが返る。

作成したデータベースを、実際にコマンドで確認してみよう。まずは、OS のターミナルを立ち上げ、登録したデータが表示されるか確認する。

### SQLite コマンドで確認

##### SQLite3 がインストールされているか確認

```python
sqlite3 -version
3.28.0
```

##### SQLite3 を起動する

```python
sqlite3 test.db
```

##### テーブルの一覧を見る

```python
sqlite> .table
# person
```

##### スキーマを表示する

```python
sqlite> .schema person
```

スキーマが表示された

```python
CREATE TABLE person
    (id integer,
    name text);
```

##### テーブルの中

```python
sqlite> SELECT * FROM person;
```

テーブルが表示された。

```python
1|user1
```

[sqlite3 --- SQLite データベースに対する DB-API 2.0 インターフェース — Python 3.10.0b2 ドキュメント](https://docs.python.org/ja/3/library/sqlite3.html)


SQLite は Python の標準ライブラリとして実装され、通常のファイルにデータベースを格納する。SQlite を使うための sqlite3 モジュールが

2022-1-14

Python : 再帰は大きな問題が小さな問題に収束するように使う

2021-12-7

Python: f-string（f 文字列）と「:」の便利な使い方

2021-12-06

Python: bytes 型と str 型の違い。変換方法

2021-12-02

Python: MySQL へ接続するモジュール mysqlclient（MySQLdb）の使い方

2021-12-01

Python: インポートしたときに「ModuleNotFoundError」になる場合の対処法

2021-11-29

Python: カウンタ。Counter()関数で要素数を計算する

2021-11-26

Python: Requests-HTML の使い方

2021-11-25

Python: BeautifulSoup 使い方（タイトル・HTML 取得など）

2021-11-24

Python: Requests モジュールの使い方（スクレイピング、データ収集など）

2021-11-22

Python: SQL の基本コマンドと sqlite3 モジュール

2022-1-14

Python : 再帰は大きな問題が小さな問題に収束するように使う

2021-12-7

Python: f-string（f 文字列）と「:」の便利な使い方

2021-12-06

Python: bytes 型 と str 型の違い。変換方法

2021-12-02

Python: MySQL へ接続するモジュール mysqlclient（MySQLdb）の使い方

2021-12-01

Python: インポートしたときに「ModuleNotFoundError」になる場合の対処法

2021-11-29

Python: カウンタ。Counter()関数で要素数を計算する

2021-11-26

Python: Requests-HTML の使い方

2021-11-25

Python: BeautifulSoup 使い方（タイトル・HTML 取得など）

2021-11-24

Python: Requests モジュールの使い方（スクレイピング、データ収集など）

2021-11-22

Python: SQL の基本コマンドと sqlite3 モジュール

Python: bytes 型と str 型の違い。変換方法