python組み込み関数解説①

## 本記事で解説する関数たち
- abs
- aiter
- all
- anext
- any
- ascii
- bin
- bool
- breakpoint
- bytearray
- bytes

## 注意
Python3.12.4 現在の内容です
また、
```python
print("Hello World")
> Hello World
```
と書いた時、上の部分が実行するコード、その下の`>`に続く部分はshellへの出力とする

## 関数解説
### abs
入力値の絶対値を返す
数値系の方でなくてはならない
abs関数の実行時に、`object.__abs__(self)`が呼び出される
```python
print(abs(1-44))
> 43

print(abs(43))
> 43

print(abs(-1*1/3))
> 0.3333333333333333

# 複素数の場合は...
print(abs(3 + 4j))
> 5.0
```

### aiter
`async - awairt` に関する関数のため、まずは非同期処理について知るべきである
以下のブログがわかりやすい

https://iuk.hateblo.jp/entry/2017/01/27/173449

非同期イテラブルオブジェクトから非同期イテレータを取得するための関数である。async for ループと共に使用される。

```python
import asyncio

class AsyncIterable:
    def __init__(self, n):
        self.n = n

    def __aiter__(self):
        self.i = 0
        return self

    async def __anext__(self):
        if self.i < self.n:
            await asyncio.sleep(1)
            self.i += 1
            return self.i
        else:
            raise StopAsyncIteration

async def main():
    async_iterable = AsyncIterable(5)
    async_iterator = aiter(async_iterable)
    async for value in async_iterator:
        print(value)

asyncio.run(main())

> 1
> 2
> 3
> 4
> 5
```
この例では、AsyncIterable クラスを定義し、`__aiter__` メソッドで非同期イテレータを返し、`__anext__` メソッドで非同期に次の値を返している。
main 関数内で aiter 関数を使用し、async for ループでそれを消費する。

### all

イテラブルの全ての要素が真であるかをチェックする関数である。全ての要素が真であれば True を返し、1つでも偽があれば False を返す。空のイテラブルに対しては True を返す。

#### 真と偽の判定基準
all 関数は、各要素が以下の条件に該当するかどうかで判定を行う
- 真（True）：非ゼロの数値、イテラブルの要素が非空、非空の辞書、True など
- 偽（False）：ゼロ (0)、イテラブルの要素が空、空の辞書、False、None など

```python
print(all([1, 2, 3]))
> True

print(all([1, 0, 3]))
> False

print(all([]))
> True

print(all([True, True, True]))
> True

print(all([True, False, True]))
> False
```
```def_all.py
# 以下は、all関数の簡易的な実装例である
def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True
```

### anext
`awaitable anext(async_iterator)`
`anext` は、Python 3.10で追加された、非同期イテレータ (asynchronous iterator) の次の値を取得するための関数である。これは、組み込みの `next()` 関数の非同期版であり、同じように動作する。

`anext` 関数には2つのシグネチャがある
1. `await anext(async_iterator)`
1. `await anext(async_iterator, default)`


`anext` 関数は、非同期イテレータの `__anext__()` メソッドを呼び出し、その結果として待ち受け可能オブジェクト (awaitable) を返す。これにより、イテレータの次の値を取得できる。

```python
import asyncio

class AsyncIterable:
    def __init__(self, n):
        self.n = n

    def __aiter__(self):
        self.i = 0
        return self

    async def __anext__(self):
        if self.i < self.n:
            await asyncio.sleep(1)  # 非同期処理をシミュレート
            self.i += 1
            return self.i
        else:
            raise StopAsyncIteration

async def main():
    async_iterable = AsyncIterable(5)
    async_iterator = aiter(async_iterable)

    try:
        while True:
            value = await anext(async_iterator)
            print(value)
    except StopAsyncIteration:
        print("Iteration finished")

asyncio.run(main())

> 1
> 2
> 3
> 4
> 5
> Iteration finished
```
この例では、AsyncIterable クラスを定義し、非同期に次の値を返すように `__anext__` メソッドを実装している
main 関数では、aiter を使って非同期イテレータを取得し、anext を使って次の値を非同期に取得している

default 引数の使用
anext 関数に default 引数を渡すと、イテレータが枯渇したときに StopAsyncIteration ではなく、default の値が返される

```python
async def main_with_default():
    async_iterable = AsyncIterable(3)
    async_iterator = aiter(async_iterable)

    while True:
        value = await anext(async_iterator, default='Done')
        if value == 'Done':
            break
        print(value)

asyncio.run(main_with_default())

> 1
> 2
> 3
> Done
```
この例では、イテレータが枯渇したときに default 値である `Done` が返されるため、`StopAsyncIteration` が発生せずにループを終了することができる

### any
イテラブル内の要素のうち、少なくとも1つが真であれば `True` を返し、すべてが偽であれば `False` を返す組み込み関数である

```python
print(any([False, False, True]))
> True

print(any([False, False, False]))
> False

print(any([]))
> False

print(any([0, 1, 2]))
> True

print(any([0, None, False]))
> False
```
```def_any.py
# 以下は、any関数の簡易的な実装例である
def any(iterable):
    for element in iterable:
        if element:
            return True
    return False
```
#### 特殊ケース
空のイテラブル：
- 空のイテラブルに対しては、False を返す
    ```python
    print(any([]))
    > False
    ```
Boolean型の要素：
- 少なくとも1つの要素が True の場合は True を返す
    ```python
    print(any([True, False, False]))
    > True
    
    print(any([False, False, False]))
    > False
    ```

数値型の要素：

- 非ゼロの数値が含まれていれば True を返す
    ```python
    print(any([0, 1, 2]))
    > True

    print(any([0, 0, 0]))
    > False
    ```

### ascii
与えられたオブジェクトの ASCII 表現を返す組み込み関数である
この関数は、オブジェクトの `__repr__()` メソッドを呼び出して得られた文字列を返す
ただし、返される文字列はASCII文字のみを含み、非ASCII文字はエスケープされる


```python
print(ascii('Hello, こんにちは'))
> 'Hello, \u3053\u3093\u306b\u3061\u306f'

print(ascii(123))
> 123

print(ascii([1, 2, 'あいう']))
> [1, 2, '\u3042\u3044\u3046']
```

**注意点**
ascii 関数は、与えられたオブジェクトの `__repr__()` メソッドを呼び出してASCII表現を生成する
返される文字列には、非ASCII文字がエスケープされて含まれる
ASCII表現は、主にデバッグやログ出力で使用され、可読性を確保するために非ASCII文字をエスケープする

### bin
整数を先頭に "0b" が付いた2進文字列に変換する
結果はPythonの式としても使える形式になる
もし `x` が Python の `int` オブジェクトでない場合、`x` は整数に変換可能な `__index__()` メソッドを持っていなければなりません

```python
print(bin(3))
> 0b11

print(bin(-10))
> -0b1010

# 先頭に "0b" を付けたくない場合
print(format(14, '#b'), format(14, 'b'))
> 0b1110 1110

# f-string を使う方法
print(f'{14:#b}', f'{14:b}')
> 0b1110 1110
```

### bool
`bool` クラスは、真理値 (Boolean) を表すためのクラスであり、その値は `True` または `False` のいずれかである
引数は標準の真理値テスト手順を用いて変換される
引数が偽であるか省略されている場合、`False` を返し、それ以外の場合は `True` を返す
`bool` クラスは `int` のサブクラスであり、さらにその派生クラスを作成することはできない
唯一のインスタンスは `False` と `True` である

> バージョン 3.7 で変更 : The parameter is now positional-only.

- `bool` クラスは、Python の真偽値を表すために使用される
    条件式や制御フローでしばしば使用される
- `False` と `True` は予約語であり、それぞれ偽と真を表す
- `bool` クラスのインスタンスは、条件式や論理演算の結果として返される

```python
print(bool())
> False

print(bool(0))
> False

print(bool(1))
> True

print(bool([]))
> False

print(bool([1, 2, 3]))
> True

# 冗長だが以下のような書き方もできる
a = 42
b = 32
if (a//b==1)==True: # つまりは、`if a//b==1:`である
    print(True)
> True
```

### breakpoint
`breakpoint()` は、Python 3.7 で追加されたデバッグ用の組み込み関数である
この関数を呼び出すと、デバッガが起動し、その場でプログラムの実行を停止させる
```python
def example_function():
    for i in range(5):
        print(i)
        if i == 2:
            breakpoint()  # デバッガを起動するポイント
        print("continue...")

example_function()
```
**動作**
breakpoint() を呼び出すと、Python のデフォルトのデバッガが起動する
デバッガが起動すると、プログラムの実行が停止し、対話型のデバッグモードに入る
デバッグモードでは、変数の値を調べたり、スタックトレースを表示したりすることができる

> breakpoint() を使うには、Python のバージョンが 3.7 以上である必要がある

それ以前のバージョンでは、import pdb; pdb.set_trace() を使うことが一般的だった

### bytearray
`bytearray` は、可変長のバイト列を表現する組み込み型である。バイト列は0〜255の整数のシーケンスで構成され、バイナリデータの操作に便利である。

```python
# 初期化方法
b = bytearray()
print(b)
# bytearray(b'')

b = bytearray(5)
print(b)
# bytearray(b'\x00\x00\x00\x00\x00')

b = bytearray(b'hello')
print(b)
# bytearray(b'hello')

b = bytearray([104, 101, 108, 108, 111])
print(b)
# bytearray(b'hello')

# 操作方法
b[0] = 72
print(b)
# bytearray(b'Hello')

b.append(33)
print(b)
# bytearray(b'Hello!')

# スライス操作
b[1:5] = b'ELLO'
print(b)
# bytearray(b'HELLO!')
```

### bytes
bytes は不変であるため、内容を変更することはできない。しかし、スライスや結合などの操作は可能である。
```python
# 初期化方法
b = bytes()
print(b)
# b''

b = bytes(5)
print(b)
# b'\x00\x00\x00\x00\x00'

b = bytes(b'hello')
print(b)
# b'hello'

b = bytes([104, 101, 108, 108, 111])
print(b)
# b'hello'
```

**詳細**
- 不変性：bytes は不変シーケンスであり、内容を変更することはできない。変更が必要な場合は、bytearray を使用する
- 整数の範囲：bytes に格納される各値は0〜255の範囲の整数である
- エンコーディングとデコーディング：文字列との相互変換が可能であり、文字列をバイト列にエンコードしたり、バイト列を文字列にデコードしたりすることができる

***
下記サイトをもとに作成した

https://docs.python.org/ja/3/library/functions.html#func-bytes

<!-- 
/*続編 : [python組み込み関数解説②]() */
--!>