
## 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 モジュールが

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


## TL;DR

JSON（JavaScript Object Notation）は、JavaScript のサブセット。様々な API や言語で、潑剌とサポートされているデータ交換形式のテキストフォーマットである。プロパティのみを含むことが可能であり、メソッドを含むことはできない。

### なぜ JSON を使うのか？

JSON を使えば、ネットワークを通してデータを転送できる。プログラミング言語間のデータの受け渡しがスムーズになるのは相違ない。

複雑な記号を使わず、データをシンプルに見せるのがブレース{}とブラケット\[\]である。シンプルに記述できるので、可視性も高い。言語にも依存しない。

このような次第で、Python の構文としても有効で密接な関係がある。

### json の基本的な記述方法

基本的な記述方法は次のコードである。変数名と値をコロンで区切りペアで記述する。

```python
{ "name": "yamada", "age": 27 }
```

葉脈をくっきりさせ可読性を高めるために、改行を用いることが多い。改行時のインデント幅は左に空白スペース 2 か 4 を入れるのが適切である。

```python
{
  "foo_1": 1,
  "foo_2": 2,
  "foo_3": 3,
  "foo_4": 4
}
```

JSON では汎用的な次の型を扱うことができる。

- null
- 文字列
- int、float
- 真偽値
- 配列

### JSON を辞書に変換

Python には JSON を簡単に辞書に変換する標準の json モジュールがある。loads()の引数に JSON 文字列を指定する。次のコードでは、json モジュールをインポートして、キーを指定して値を取り出している。

```python
import json

json_t = """

{
  "sns": ["twitter", "facebook", "instagram"],
  "items": [111, 222, 333],
  "users": [
    {"name": "山田", "id": 1},
    {"name": "鈴木", "id": 2}
  ]
}
"""

d = json.loads(json_t)
print(d)

# ダブルクオーテーションが、シングルクォーテーションに変わっている。
# {'sns': ['twitter', 'facebook', 'instagram'], 'items': [111, 222, 333], 'users': [{'name': '山田', 'id': 1}, {'name': '鈴木', 'id': 2}]}

print(d["sns"][0])
# twitter

print(d["users"][0]["id"])
# 1
```

### 時間を JSON に変換

datetime オブジェクトの JSON 変換

```python
import datetime
import json
n = datetime.datetime.utcnow()
json.dumps(n, default=str)

# "2021-11-18 06:48:35.464328"
```

### 辞書を JSON に変換

辞書を json に変換する。indent はインデント幅を指定し見やすくすることができる。`ensure_ascii=False` を使うと日本語を日本語としてそのままの形式で出力する。

```python
import json

d = {'sns': ['twitter', 'facebook', 'instagram'], 'items': [111, 222, 333], 'users': [{'name': '山田', 'id': 1}, {'name': '鈴木', 'id': 2}]}
j = json.dumps(d, indent=2, ensure_ascii=False)
print(j)
```

上の出力結果。シングルクォーテーションがダブルクオーテーションに変わっている。

```python
{
  "sns": ["twitter", "facebook", "instagram"],
  "items": [111, 222, 333],
  "users": [
    {
      "name": "山田",
      "id": 1
    },
    {
      "name": "鈴木",
      "id": 2
    }
  ]
}
```

[json --- JSON エンコーダおよびデコーダ — Python 3.10.0b2 ドキュメント](https://docs.python.org/ja/3/library/json.html)


JSON（JavaScript Object Notation）は、JavaScript のサブセット。様々な API や言語で、潑剌とサポートされているデータ

Python: JSON とは何か？（loads、dumps など）


## TL;DR

csv モジュールは、CSV ファイルを読み込みパースする標準ライブラリである。csv モジュールを使うと CSV ファイルの読み込みや書き出し、追記ができる。

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

- csv.reader クラスは、CSV ファイルの読み込みを行う
- csv.writer クラスは、CSV ファイルの書き込みを行う
- for 文の前に next()を入れるとヘッダを読み飛ばすことができる
- リスト内包表記が使える
- DictReader()クラスは、辞書のリストを作る
- ライブラリ Pandas を使っても、CSV の読み出しができる

### CSV ファイルを作る

csv.writer クラスは、CSV ファイルの書き込みを行う。余分な改行コードを防ぐために、open 時に newline='' を指定する。

```python
import csv
sns = [
     ['名称', '色'],
     ['twitter', 'red'],
     ['instagram', 'pink']
]

with open('sns.csv', 'w', newline='') as f:
    c = csv.writer(f)
    c.writerows(sns)
```

以下のような表が生成された。

| 名称      | 色   |
| --------- | ---- |
| twitter   | red  |
| instagram | pink |

newline='' については、[csv --- CSV ファイルの読み書き — Python 3.10.0b2 ドキュメント](https://docs.python.org/ja/3/library/csv.html#id3)において次のように書かれている。

> newline='' が指定されない場合、クォートされたフィールド内の改行は適切に解釈されず、書き込み時に \\r\\n を行末に用いる処理系では余分な \\r が追加されてしまいます。csv モジュールは独自 (universal) の改行処理を行うため、newline='' を指定することは常に安全です。

※ open 関数を使うと、指定したファイルを開き、ファイルを読み書きするためのオブジェクトを得ることができる。open 関数は with 文と合わせて使い、as の後方の変数にファイルオブジェクトが格納される。

参考：[コンテキストマネージャ with 文](https://commte.net/7472)

#### CSV ファイルに追記する

次に、writerows()を使い、先程作成した sns.csv に追記した。

```python
import csv
add = [
     ['名称', '色'],
     ['twitter', 'blue'],
     ['instagram', 'pink'],
     ['facebook', 'darkblue']
]
with open('sns.csv', 'w', newline='') as f:
    w = csv.writer(f)
    w.writerows(add)
```

以下のような表に変更された。

| 名称      | 色       |
| --------- | -------- |
| twitter   | blue     |
| instagram | pink     |
| facebook  | darkblue |

### CSV ファイルを読み込む

sns.csv を読み込んでみよう。csv.reader クラスは、CSV ファイルの読み込みを行う。デフォルトだと、列はカンマ、行は`\n` で分割される。

```python
import csv
with open('sns.csv', newline='') as f:
    c = csv.reader(f)
    for i in c:
        print(i)

# ['名称', '色']
# ['twitter', 'blue']
# ['instagram', 'pink']
# ['facebook', 'darkblue']
```

### ヘッダを読み飛ばす

csv ファイルのヘッダを読み飛ばしたい場合は、for 文の前に、next()を入れる。

```python
import csv
with open('sns.csv', newline='') as f:
    c = csv.reader(f)
    header = next(c) # ヘッダを読み飛ばす
    for i in c:
        print(i)

# ['twitter', 'blue']
# ['instagram', 'pink']
# ['facebook', 'darkblue']
```

### リスト内包表記

[リスト内包表記](https://commte.net/7505#list-in)を使ってデータを表示することもできる。for 文で抽出できる行を作ってくれる。

```python
import csv
with open('sns.csv', 'r', newline='') as f:
    c = csv.reader(f)
    g = [i for i in c]
print(g)

# [['名称', '色'], ['twitter', 'blue'], ['instagram', 'pink'], ['facebook', 'darkblue']]
```

### DictReader()

DictReader() クラスを使うと辞書のリストにすることができる。

```python
import csv
with open('sns.csv', 'r', newline='') as f:
    c = csv.DictReader(f, fieldnames=['first', 'last'])
    g = [i for i in c]
print(g)

# [OrderedDict([('first', '名称'), ('last', '色')]), OrderedDict([('first', 'twitter'), ('last', 'blue')]), OrderedDict([('first', 'instagram'), ('last', 'pink')]), OrderedDict([('first', 'facebook'), ('last', 'darkblue')])]
```

### DictWriter()

DictWriter() クラスを使って、CSV ファイルを作る。writeheader() を呼び出し、CSV ファイルの先頭に名前を書き込む。

```python
import csv
namelist = [
              {'first' : 'yamada', 'last' : 'taro'},
              {'first' : 'sato', 'last' : 'hanako'},
              {'first' : 'yoshida', 'last' : 'ziro'}
]
with open('namelist.csv', 'w') as f:
    c = csv.DictWriter(f, ['first', 'last'])
    c.writeheader()
    c.writerows(namelist)
```

namelist.csv というファイル名の CSV ファイルが生成される。中身は以下のようになる。

| first   | last   |
| ------- | ------ |
| yamada  | taro   |
| sato    | hanako |
| yoshida | ziro   |

### Pandas

構造化データのためのライブラリ Pandas を使って CSV の読み出しができる。

```python
import pandas
date = pandas.read_csv('namelist.csv')
print(date)

#      first    last
# 0   yamada    taro
# 1     sato  hanako
# 2  yoshida    ziro
```


csv モジュールは、CSV ファイルを読み込みパースする標準ライブラリである。csv モジュールを使うと CSV ファイルの読み込みや書き出し、追記ができる。

Python: csv モジュールの使い方（reader、writer、DictReader など）


## TL;DR

Python の最新のコードは、リポジトリである PyPI（パイパイ）で探し、Python パッケージのインストールは標準的に pip と venv というツールを使う。Python バージョン切り替えは pyenv を使う。

最初に、Python コードを見つける場所を説明する。

### PyPI（パッケージ一覧）

[PyPI](https://pypi.org/)（パイパイ） は ソフトウェアのリポジトリ。Python のパッケージ一覧が集められている。パッケージとは、Python のコードをまとめ再配布にしたライブラリのことである。パッケージを活用することで開発期間を短縮することができる。

以前は、モンティ・パイソン（Monty Python）にちなんで、チーズショップ（Python Cheese Shop）と呼ばれていた。[Wiki](https://ja.wikipedia.org/wiki/Python_Package_Index)によるとモンティ・パイソンは、イギリスの代表的なコメディグループ。「チーズ・ショップ」は、モンティ・パイソンがテレビシリーズ『空飛ぶモンティ・パイソン』で放送したスケッチだそうだ。私は見たことがない。

PyPI は、Python コミュニティによって開発・共有されている。全てオープンソースだ。ソフトウェア検索とインストールに役立つ。PyPI のトップページには、最新のトレンドとリリースが取り上げられている。

Python のトレンドコードを見つけるサイト

- [GitHub 今日のトレンド](https://github.com/trending?1=python)
- [ActiveState Code](https://code.activestate.com/recipes/langs/python/)

### venv（仮想環境作成）

venv は、Python の仮想環境作成ツール。仮想環境を管理するための標準モジュールである。環境変数とは、OS 環境をカスタマイズするためのシステム変数だ。venv は、環境変数（$PATH） を書き換える仕組みで仮想環境を実現している。

使い方は「仮想環境にしたいディレクトリ名」を記述して実行する。新規作成のコマンドは次のとおりである。コマンドを叩くことで、指定したディレクトリの中にファイルが配置される。

```
# 新規作成
python3 -m venv 仮想環境にしたいディレクトリ名

# ディレクトリに移動
cd 仮想環境にしたいディレクトリ名

# 可動
source bin/activate

# 仮想環境を終了する
deactivate
```

### pip（パッケージ管理）

Python のパッケージ管理ツール。パッケージをインストールするときは pip install コマンドを使う。pip は PyPI にパッケージを探しに行く。バージョンを指定しない場合、最新バージョンがインストールされる。アンインストールした場合、依存関係にあるパッケージは残されてしまうので、その仮想環境ごと破棄するとよい。

##### パッケージの操作方法一覧

```
# インストール
pip install パッケージ名

# 特定のバージョンをインストールする
pip install flask==0.9.0

# 最低限のバージョンをインストールする
pip install 'flask>=0.9.0'

# ライブラリの最新版アップデート
pip install -U pip

# インストールされたバージョン一覧
pip list

# バージョン表示
pip -V

# パッケージをアップグレード
pip install --upgrade パッケージ名

# アンインストール
pip uninstall プロジェクト名
```

##### 複数のパッケージをインストールする

requirements.txt ファイルを使って、複数のパッケージを指定することができる。requirements.txt を指定すると、そのファイルに書かれたパッケージがインストールされる。requirements.lock を指定し実行すると、実行環境が再現される。

freez を指定すると、これまでにインストールしたライブラリが一覧で出力される。

```
# インストール
pip install -r requirements.txt

# 書き込み
pip freeze > requirements.txt

# 環境を再現
pip install -r requirements.lock
```

[pip documentation v21.3.1](https://pip.pypa.io/en/stable/)

### Pipenv（pip に似たもの）

Pipenv は pip を使いやすくしたもの。pip と venv を結合したようなモジュールである。pip と混在させても問題ないが、pip に不自由を感じなければインストールする必要はないと思う。

公式では、次のように記されている。

> Pipenv は、手動でパッケージのインストールおよびアンインストールを行うのと同じように Pipfile に対してパッケージの追加および削除を行うのに加え、自動でプロジェクト用の仮想環境を作成し管理します。また Pipenv は、いかなるときも重要な Pipfile.lock を生成し、これを利用しビルドが常に同じ結果になるようにします。

[Pipenv](https://pipenv-ja.readthedocs.io/ja/translate-ja/)

インストール

```
brew install pipenv
```

パッケージ インストール

```
pipenv install パッケージ名
```

### pyenv（環境切り替え）

pyenv は、1 台のパソコンで複数バージョンの python 環境を簡単に切り替えることができる。

[pyenv](https://github.com/pyenv/pyenv)

特徴は次のとおり

- ユーザーに応じてグローバル Python バージョン変更
- Python バージョンを環境変数で上書きできるように変更する
- プロジェクトごとの Python バージョンのサポートを提供
- 一度に複数のバージョンの Python からコマンドを検索
- Python 自体に依存する
- virtualenv を管理する

インストール

```
brew update
brew install pyenv

# Python3 に切り替え
pyenv global 3.9.6
```

スムーズに適用されない場合があるので、バージョンを適用させるときの方法を、次の別ページで詳しく解説した。

参考：[pyenv - Python をインストールした後でバージョンが適用されない場合の対処法](https://commte.net/7259)


Python の最新のコードは、リポジトリである PyPI（パイパイ）で探し、Python パッケージのインストールは標準的に pip と venv というツー

Python: 環境開発の方法（パッケージのインストール、venv、pip、pyenv など）


## TL;DR

並行処理は、プログラムの実行時のパフォーマンスを向上させる。Python で並行処理を実現する方法として、マルチスレッドやマルチプロセスがある。どの方法がベストであるかの判断は、CPU バウンド（数値処理）か I/O バウンド（入出力操作）かによる。

### プロセスとスレッド

プログラムが実行されるとき、プロセスが作られ、システムリソース（メモリや CPU）やカーネルのデータ構造が割り当てられる。各プロセスの中には、スレッドが作られ処理が行われる。

##### プロセスとメモリのイメージ

```
メモリ
　　プロセスA
　　　　スレッド１→ CPUへ命令
　　　　スレッド２→ CPUへ命令
　　　　スレッド３→ CPUへ命令

　　プロセスB
　　　　スレッド１→ CPUへ命令
　　　　スレッド２→ CPUへ命令
　　　　スレッド３→ CPUへ命令

```

##### 処理の分類

並行性と並列性は、お互いに独立した概念である。

| Python 処理 | 意味                     | コア数       | スレッド数       |
| ----------- | ------------------------ | ------------ | ---------------- |
| 逐次処理    | 一つずつ順番に実行       | シングルコア | シングルスレッド |
| 並行処理    | 複数の処理を少しずつ実行 | シングルコア | マルチスレッド   |
| 並列処理    | 複数の処理を同時に実行   | マルチコア   | マルチプロセス   |

マルチとは複数を示す。

プロセスとは実行中のプログラムのことである。

スレッドとは、OS が CPU に割り当てている最小の実行単位である。プロセスの中に存在し、メモリを共有している。

マルチコアとは、デュアルコア CPU のように、1 チップの CPU 上に複数のコアが存在するもの。人間でいうところの脳が複数あるイメージ。

3 つの処理の違いを簡略化したイメージは次のようになる。右横に進むほど時間が経過する。

```
逐次処理
１　→　２　→　３

並行処理
１　→　２　→　３
        １　→　２　→　３

並列処理
１　→　２　→　３
１　→　２　→　３
１　→　２　→　３

```

#### 並行処理

「一つの処理を待たずに複数の処理を実行したい」

しかし、一つの CPU しかない場合、どのように複数の処理をすればよいのか？

この問題を解決するために生まれたのが並行処理である。

「我々人間が感知できないような短い間隔で、複数の処理を切り替えながら実行することによって、あたかも、人間が見ると複数の処理が並行しているように見える。」

これが並行処理の考え方である。

Python のプログラムでは、基本的には、並行処理を実装しな限り、常に逐次（ちくじ）処理となる。

マルチプロセス・マルチスレッドを利用する場合は「並行処理」、マルチコアでマルチプロセスを利用する場合は「並列処理」が該当する。

#### I/O バウンド と CPU バウンド

コンピューターが待機する理由として、次の 2 つがある。

| 状態         | 発生タイミング | 具体例                             |
| ------------ | -------------- | ---------------------------------- |
| CPU バウンド | 数値処理       | 化学計算、暗号化                   |
| I/O バウンド | 入出力操作     | Web API、DB 接続、ネットワーク通信 |

CPU バウンドな処理であればマルチプロセス、I/O バウンドであればマルチプロセス・マルチスレッドなどが有効である。

#### 同期処理と非同期処理

並行処理に関する用語に、同期処理と非同期処理がある。

簡単に説明すると同期的とは順番に続くこと、非同期とはタスクが独立していることである。

##### 同期処理

同期処理は処理の完了まで次に進めない。例えば、Python の場合、関数を呼び出したとき、呼び出し先の処理が全て完了するまで、呼び出し元は次の処理に進めない。

##### 非同期処理

一方、非同期処理は、呼び出し先の処理が実行中であっても、呼び出し元は次の処理に進める。呼び出した先の結果が返る前であっても呼び出し元は先に進んでいるので、結果はコールバック関数（関数に渡される関数）を利用して、呼び出し元に伝えられる。このとき、並行処理である。

Python においてスレッドやマルチプロセスを扱う場合は、細部に注意が必要だ。この作業を単純化するために、Python 公式ドキュメントでは、コードの並行実行のサポートを提供している。並行処理を扱うものでは、concurrent.futures モジュールがある。このモジュールの詳細については、別のページで解説する。

[並行実行のライブラリ一覧 — Python 3.10.0b2 ドキュメント](https://docs.python.org/ja/3/library/concurrency.html)

#### 並列処理

複数のコアを使って同時に複数の計算を行うことを、並列処理という。物理的に同時に処理が行われている。

様々な処理が、物理的に同時進行しているパラレルワールドをイメージするとよい。

並列処理は、マルチコア（複数のコア）でマルチプロセス（複数のプロセス）を利用する場合である。マルチコアでは、同時に複数の計算ができる。各コアは独立しているから、それぞれのコアは他のコアに影響されることなく動作する。

CPU コアが 1 つだけの場合、並列処理というのはありえないということになる。デュアルコアの場合は、一つの CPU に 2 個のコアが存在するので並列処理が可能である。


並行処理は、プログラムの実行時のパフォーマンスを向上させる。Python で並行処理を実現する方法として、マルチスレッドやマルチプロセスがある。どの方法がベスト

Python: 並列処理と並列処理、プロセスとスレッドなど


## TL;DR

組み込み関数 open()は、指定したモードとエンコーディングでファイルを開きファイルオブジェクト（ファイルを読み書きするオブジェクト）を返す。既存のファイルの読み出し、新しいファイルへの書き込み、既存ファイルへの追記、既存のファイルへの上書きを行う。

### 組み込み関数 open()のポイント

- 指定したファイルを開き、ファイルオブジェクトを返す
- 通常は、with 文と合わせて使う
- モードを省略すると読み取りでテキストとして開く
- モードは、ファイルのタイプやファイルをどのように操作したいかシステムに知らせる

### with によるファイルの自動クローズ

```python
with open('ファイルパス', 'モード', encoding='エンコード') as f:
    ファイル処理
```

第一引数に指定するパスは、拡張子まで記入したファイルを絶対パスか相対パスで指定する。相対パスはカレントディレクトリからのパスである。なお、拡張子は、txt でも md でも、テキストファイルであれば書き込み可能である。

as の後は、任意の名前をつける。encodeing のデフォルトは、プラットフォームに依存する。

モードのデフォルトは、`r` なので、読み込みを行う場合は省略可能である。

with を使わずに処理を行えるのだが、with 文を使うと close を省略してくれるので、close の書き忘れを防ぐことができる。したがって with を使うのがよい。

```python
with open('test.md', 'w') as f:
    f.write('hello')

with open('test.md', 'r') as f:
    a = f.read()

print(a)

# hello
# test.md に書かれた結果が表示される
```

with 文に対応したオブジェクトは、コンテキストマネージャーと呼ぶ。ファイルや DB 接続などで使う。with 文は「ある処理の前後の処理をまとめて再利用可能」にしてくれる。コードブロックをラップするために使われる。

関連記事：[コンテキストマネージャは with 文の前後で処理を実行する](https://commte.net/7472)

通常、open 関数は with 文と組み合わせて使う。as の後ろに指定した変数にファイルオブジェクトが格納される。

次に示すコードは、コンテキストマネージャを使ったファイル処理。組み込み関数 open()を使ってファイルの書き込みを行う処理を行っている。

```python
with open('test.txt', 'w') as f:
    f.write('add text')
# test.txt に「add text」と書き込まれる

f.closed
# True
```

通常、プログラム言語では、外部ファイルにアクセスする場合、利用後に close 処理を行う。Python においては、with 文を使うと close が省略される。これにより close の書き忘れを防ぐことができる。

with 文のブロックを抜けると、ファイルはクローズされる。次のコードは、書き込みモード内にも関わらず、意図的に書き込みモードを使って例外を発生させている。例外発生時も、ファイルはクローズされる。

```python
with open('test.txt', 'w') as f:
    f.read()
# UnsupportedOperation
# 書き込みモードを使うと例外が発生する
```

ファイルを開いた際は例外発生時であってもファイルはクローズされる。これは、ファイルの破損を防止するためである。

### モードの種類

モードを省略すると「読み取り」でテキストとして開く。テキストを読み書きしたい場合は「r」といったように指定する。

| モード | 意味                                             |
| ------ | ------------------------------------------------ |
| r      | 読み込み用に開く（デフォルト）                   |
| w      | 書き込み用に開く。ファイルを切り詰める           |
| r+     | 読み書き用に開く                                 |
| a      | 追記用に開く。ファイルが存在する場合は末尾に追記 |
| a+     | 読み込みと追記用に開く                           |
| b      | バイナリモード                                   |
| t      | テキストモード（デフォルト）                     |

「w」は書き込み用としてファイルを開く。ファイルが存在しない場合は新たにファイルが作成される。すでにファイルが存在する場合は、ファイルの中身は消去され、追記されずに上書き保存される。

「x」は、ファイルが存在しない場合は書き込まれ、ファイルが存在する場合は失敗する。

「a」は、ファイルが存在する場合、現在の末尾の後ろへ追記される。

モードの第 2 文字目は、ファイルのタイプを示す。「t」はテキスト、「b」はバイナリという意味である。

次のコードは、ファイルである「test.txt」を開き、何も書き込まずに閉じたので、空ファイルが作られる。

```python
f = open('test.txt', 'w')
f.close()
```

次に先程作った空ファイルに上書きしてみよう。print によって文字列「hello world」が書き込まれる。

```python
f = open('test.txt', 'w')
print('hello world', file=f)
f.close()
```

次は、print を使わずに write 関数を使って書き込む。先程書かれた「hello world」の文字は削除され、新たに「this text」という文字がファイルに上書きされた。

```python
f = open('test.txt', 'w')
f.write('this text')
f.close()
```

x モードを使えば上書きによってファイルを壊すことを防ぐことができる。

```python
f = open('test.txt', 'x')
f.write('xモードで書く')
f.close()
# FileExistsError
```

例外ハンドラと組み合わせて使うケース。

```python
try:
    f = open('test.txt', 'x')
    f.write('add text')
except FileExistsError:
    print('already exists!')
# already exists!
```

ファイルの中に書かれている文字数を数えるコード。イテレータを使った例。

```python
txt = ''
f = open('test.txt', 'r')
for i in f:
    txt += i

f.close()
len(txt)

# 8
# test.txt には、「add text」と書かれている
```

### ファイルオブジェクトのメソッド

テキストファイルを読むには、以下のメソッドがある。

| メソッド      | 戻り値                   |
| ------------- | ------------------------ |
| f.read()      | ファイル全体のデータ     |
| f.readlines() | １行ずつ分割されたリスト |
| f.readline()  | １行ごとのデータ         |

read()メソッドは、開いたファイル全体のデータを取得できる。

readlines()メソッドは、次のコードのように行ごとに分割されたリストを返す。返される要素には `\n` が含まれる。

```python
with open('test.txt') as f:
    a = f.readlines()
    print(a)
# ['１行目です\n', '２行目です\n', '最終行です']
```

readline()でなく、for 文を使うと、改行コードを含まない文字列が１行ずつ表示される。

```python
with open('test.txt') as f:
    for i in f:
        print(i)

# １行目です

# ２行目です

# 最終行です
```

ファイルに書き込むメソッド

| メソッド       | 戻り値                                 |
| -------------- | -------------------------------------- |
| f.write()      | 指定した文字列を書き込む               |
| f.writelines() | 指定した文字列リストを一つずつ書き込む |

例えば、writelines メソッドは、ファイルに対し、リストの内容を一つづつ書き込む。要素間にセパレータは入らず、詰めて連結される。

```python
f_list = ["A", "B", "CCC"]
with open('test.txt', 'w') as f:
    f.writelines(f_list)
# test.txt に　ABCCC と書き込まれた
```


組み込み関数 open()は、指定したモードとエンコーディングでファイルを開きファイルオブジェクト（ファイルを読み書きするオブジェクト）を返す。既存のファイルの

Python : ファイル入出力の基本操作編（with open など）


## TL;DR

datetime モジュールは、日時データを処理するクラスを提供する。日時や時間を扱う型が用意されている。datetime 型は、属性を指定して日付や時間を参照できる。

日付や時間の型には次のようなものがある。

| 型        | 役割                                   |
| --------- | -------------------------------------- |
| datetime  | 日時を扱う。日付と時刻を対象とする。   |
| date      | 日付を扱う。年月日を対象とする         |
| time      | 時間を扱う。時分秒と端数を対象とする。 |
| timedelta | 日付、時間の計算を扱う。               |

### datetime

#### datetime のポイント

- 変更不可能（イミュータブル）である
- 日付、時間、曜日の計算を行う
- 引数に日付や時間を指定する
- フォーマット文字列の変換が可能である
- ハッシュ可能である

datetime モジュールは、日時データ（日付と時刻を含む）を処理する。date オブジェクトは、年月日を指定し、その値を属性として取り出すことができる。

主な属性

| 属性        | 意味       |
| ----------- | ---------- |
| year        | 年         |
| month       | 月         |
| day         | 日         |
| hour        | 時         |
| minute      | 分         |
| second      | 秒         |
| microsecond | マイクロ秒 |

datetime クラス の構文は次のようになる。引数で指定した年月日時、分秒、マイクロ秒の datetime 型を生成する。次のコードは、分かりやすいように改行している。

```python
datetime(year, month, day, hour=0,
minute=0, second=0, microsecond=0)
```

数値を入力してみよう。時刻も対象となっている。この例は 2021 年 12 月 24 日午前 3 時 30 分 20 秒を示している。

```python
from datetime import datetime
xmas = datetime(2021, 12, 24, 3, 30, 20)

xmas.hour
# 3

xmas.minute
# 30

xmas.second
# 20
```

detetime オブジェクトには、isoformat() メソッドがある。中央の T は日付と時刻を分割している。

```python
from datetime import datetime
xmas = datetime(2021, 12, 24, 3, 30, 20)
xmas.isoformat()
# 2021-12-24T03:30:20
```

#### now()

datetime の now()メソッドは、現在の日付と時刻を取得できる。

```python
from datetime import datetime
now = datetime.now()
now
# datetime.datetime(2021, 10, 25, 4, 17, 42, 641682)

now.year
# 2021

now.month
# 10

now.day
# 25

now.hour
# 4

now.minute
# 20

now.second
# 13

now.microsecond
# 150095
```

#### combine()

combine()は、date オブジェクトと time オブジェクトを結合して、datetime オブジェクトを作ることができる。

```python
from datetime import date, datetime, time
noon = time(12)
this_day = date.today()
noon_today = datetime.combine(this_day, noon)
noon_today
# datetime.datetime(2021, 10, 25, 12, 0)
```

#### strptime()

日時データは、strptime()メソッドを使えば、文字列と datetime 型は相互に変換できる。

```python
datetime.strptime("日付文字列", "フォーマット文字")
```

文字列から datetime 型を生成する。

```python
from datetime import datetime

d = datetime.strptime("2021/10/23 12:01:11", "%Y/%m/%d %H:%M:%S")
print(d)
# 2021-10-23 12:01:11
```

**strptime() の書式指定子一覧表**

| 書式指定子 | 単位            | 範囲     | 例      |
| ---------- | --------------- | -------- | ------- |
| %Y         | 年 西暦 4 桁    | 1900-    | 2021    |
| %y         | 西暦 2 桁       | 19-      | 21      |
| %m         | 月 10 進表記    | 01-12    | 10      |
| %B         | 月名            | January, | Octobar |
| %b         | 月名 略称       | Jan,     | Oct     |
| %d         | 日 10 進表記    | 01-31    | 25      |
| %A         | 曜日            | Sunday,  | Monday  |
| %a         | 曜日 略称       | Sun,     | Mon     |
| %H         | 時間（24 時間） | 00-23    | 18      |
| %I         | 時間（12 時間） | 00-12    | 06      |
| %p         | 午前、午後      | AM, PM   | AM      |
| %M         | 分 10 進表記    | 00-59    | 05      |
| %S         | 秒 10 進表記    | 00-59    | 48      |

#### 現在の日時を取得する

現在の日時等を取得するには datetime.now() を使う。これは現在日時の datetime 型を生成して返すメソッドである。

```python
datetime.now()
```

現在の日付を取得してフォーマットする。

```python
import datetime
now = datetime.datetime.now()
now.strftime("%Y/%m/%d %H:%M:%S")

# 2021/10/25 06:05:08
```

リテラルを使う方法。

```python
f"{now:%Y/%m/%d - %H:%M:%S}"

# 2021/10/25 - 06:05:08
```

[time --- 時刻データへのアクセスと変換 — Python 3.10.0b2 ドキュメント](https://docs.python.org/ja/3/library/time.html#time.strftime)

### date

date 型は、日付を扱うことができる。

```python
date(year, month, day)
```

引数で指定する年月日の date 型を生成する。

```python
from datetime import date
xmas = date(2021, 12, 24)
xmas
# datetime.date(2021, 12, 24)

xmas.day
# 24

xmas.month
# 12

xmas.year
# 2021
```

次のようにフォーマットすると、日付の部分が整形され、時刻は深夜 0 時 0 分になる。

```python
from datetime import date
s = date(2023, 11, 1)
fmt = "%A, %B, %d, %Y, %I:%M:%S"
s.strftime(fmt)

# Wednesday, November, 01, 2023, 12:00:00
```

現在の日付を取得する場合、date.today() メソッドを使う。

```python
from datetime import datetime, date
d = date.today()
s = d.strftime("%Y/%m/%d")
print(s)

# 2021/10/26
```

### timedelta 型

timedelata 型は、日時の計算を行う。次に示すコードは、10 日後の日付を計算したものである。

```python
from datetime import datetime, date, time, timedelta
d = date.today()
y = d + timedelta(days=10)
print(y)

# 2021-11-05
```


datetime モジュールは、日時データを処理するクラスを提供する。日時や時間を扱う型が用意されている。datetime 型は、属性を指定して日付や時間を参照

2021-11-26

Python: Requests-HTML の使い方

2021-11-25

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

2021-11-24

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

2021-11-22

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

2021-11-19

Python: JSON とは何か？（loads、dumps など）

2021-11-18

Python: csv モジュールの使い方（reader、writer、DictReader など）

2021-11-17

Python: 環境開発の方法（パッケージのインストール、venv、pip、pyenv など）

2021-11-15

Python: 並列処理と並列処理、プロセスとスレッドなど

2021-11-8

Python : ファイル入出力の基本操作編（with open など）

2021-10-26

Python : 日付の基本操作編（datetime 型、date 型、strptime など）