【Pythonの超基本】基礎の基礎を勉強したので簡単にまとめてみた

#概要

Pythonをちょっとだけ勉強したので、簡単にまとめておきます。

自分用のメモなのであしからず。




#目次

- [print](#print)
    - [文字列の出力](#文字列の出力)
    - [数値の出力](#数値の出力)
    - [数値の計算](#数値の計算)
    - [文字列と数値](#文字列と数値)
- [変数](#変数)
- [データ型](#データ型)
- [文字列の連結](#文字列の連結)
- [型変換](#型変換)
    - [数値型　→　文字列型](#数値型　→　文字列型)
    - [文字列型　→　数値型](#文字列型　→　数値型)
- [条件分岐](#条件分岐)
    - [真偽値](#真偽値)
    - [比較演算子](#比較演算子)
    - [if文](#if文)
    - [else](#else)
    - [elif](#elif)
    - [条件の組み合わせ](#条件の組み合わせ)
        - [and](#and)
        - [or](#or)
        - [not](#not)
- [リスト](#リスト)
    - [リストの要素の更新](#リストの要素の更新)
    - [リストの要素の追加](#リストの要素の追加)
- [辞書](#辞書)
    - [辞書の要素の更新](#辞書の要素の更新)
    - [辞書の要素の追加](#辞書の要素の追加)
- [繰り返し処理](#繰り返し処理)
    - [for文](#for文)
    - [while文](#while文)
        - [無限ループ](#無限ループ)
    - [breakとcontinue](#breakとcontinue)
        - [break](#break)
        - [continue](#continue)
- [まとめ](#まとめ)




#print

`print`を用いると、コンソールに文字を出力することができます。

```example.py
print('Hello World')
# 出力結果 -> Hello World
```

出力したい文字を`()`の中に記述します。




##文字列の出力

**文字列**とは、上の部分で言う`Hello World`という文字のことです。

文字列は`'`、`"`で囲む必要があります。
どちらを用いた場合でも出力に差は生じません。

```example.py
#シングルクォーテーションで囲んだ場合
print('Hello World')
# 出力結果 -> Hello World

#ダブルクォーテーションで囲んだ場合
print("Hello World")
# 出力結果 -> Hello World
```




##数値の出力

文字列と同様に**数値**も扱うことができます。

数値を出力する場合は、**クォーテーションで囲む必要がありません**。

クォーテーションで囲んだ場合は、文字列として出力されます。

```example.py
#数字を数値として出力
print(14)
# 出力結果 -> 14　（数値）

#数字を文字列として出力
print('7')
# 出力結果 -> 7　（文字列）
```

> 追記
ご指摘いただいたので、訂正いたします。
>> print関数は、与えられた引数をstr関数を呼び出して文字列化し、クォートを外した結果を出力します。
引用 : *この記事のコメント欄参照*

>つまり、printによって出力された値は全て文字列型であるということなんですね。全然知りませんでした。




##数値の計算

数値は、`+`、`-`を用いて、足し算や引き算が可能です。
注意点としては、**数値や記号はすべて半角で記述**しなければいけません。

計算記号について抑えておきましょう。

| 記号 | 処理 |
|:-:|:-:|
|+|足し算|
|-|引き算|
|*|かけ算|
|/|割り算|
|%|割り算の余りを表示|

```example.py
#足し算
print(5 + 3)
# 出力結果 -> 8

#引き算
print(10 - 8)
# 出力結果 -> 2

#かけ算
print(2 * 5)
# 出力結果 -> 10

#割り算
print(6 / 2)
# 出力結果 -> 3

#余りの計算
print(10 % 3)
# 出力結果 -> 1
```




##文字列と数値

計算結果を出力する際は、クォーテーションの有無に気をつけなければいけません。

```example.py
print(2 + 4)
# 出力結果 -> 6

print('2 + 4')
# 出力結果 -> 2 + 4
```

クォーテーションで囲まない場合は、計算結果が出力されます。
一方、クォーテーションで囲んだ場合は、`2 + 4`は文字列として解釈されそのまま出力されます。




#変数

**変数**には、データを代入することができます。

変数は`変数名 = 値`で定義します。変数名は`'`や`"`で囲む必要はありません。

Pythonにおいて`=`は、右辺を左辺に代入するという意味になります。

変数の名前の付け方には、いくつか注意点があります。

- 変数名は数字から始めることはできない
- 2語以上の変数名を使う場合には、`_`で区切ぎる

```example.py
#文字列の代入
name = 'ふくもとたいち'

#数値の代入
age = 22

#変数名が2語以上の場合
first_name = 'たいち'
```

上の例では、`name`に`たいち`が、`age`に`22を代入しています。

では、上の例で定義した変数を取り出してみましょう。

変数名を使って値を出力するときは、`print(変数名)`とします。変数名は`'`で囲む必要はありません。

```example.py
name = 'ふくもとたいち'

#変数の出力
print(name)
# 出力結果 -> ふくもとたいち
```

このように、変数に代入した値が出力されました。

変数を使うことで、扱っているデータの中身が何を表しているのかはっきりします。そのため、コードが読みやすくなります。
また、同じデータを繰り返し使えたり、数値などの修正をする場合に修正箇所が少なくったりというメリットもあります。

変数の値は更新することができます。
`変数名 = 新しい値`をすることで変数の値を上書きできます。

```example.py
age = 22
print(age)
# 出力結果 -> 22

#ageの値を更新
age = 30
print(age)
# 出力結果 -> 30
```

すでに定義された数値を足したり、引いたりすることで値を更新することもできます。

```example.py
age = 22
print(age)
# 出力結果 -> 22

age = age + 8
print(age)
# 出力結果 -> 30
```

数値を更新する際には、省略形が存在します。以下に省略形をまとめます。

|　標準　|　省略形　|
|:-:|:-:|:-:|
|x = x + 1|x += 1|
|x = x – 1|x -= 1|
|x = x * 1|x *= 1|
|x = x / 1|x /= 1|
|x = x %1|x %= 1|




#データ型

扱うデータには種類が存在します。

ここでは「**文字列型**」と「**数値型**」を学びます。

今まで`'`で囲んで表示していたものが**文字列型**です。

一方、`2`や`14`といった数字を**数値型**といいます。

```example.py
print(100)
# 出力結果 -> 100

print('100')
# 出力結果 -> 100
```

出力の結果は目ではわかりませんが、一つ目は数値型、二つ目は文字列型として出力されています。




#文字列の連結

ここからは文字列の連結について学んでいきます。

`+`を用いることで、文字列を連結することができます。

```example.py
first_name = 'たいち'
last_name = 'ふくもと'

#文字列を連結して出力する
print('私のフルネームは' + last_name + first_name + 'です')
# 出力結果 -> 私のフルネームはふくもとたいちです
```

上の例のように書くことで、文字列同士、文字列と変数、あるいは変数同士といった組み合わせで連結することができます。

ここで注意が必要なのは、**変数は文字列型でなければいけない**点です。

つまり、**同じデータ型でしか連結することができない**ということです。

次の例を見てみましょう。

```example.py
print(3 + 7)
# 出力結果 -> 10

print('3' + '7')
# 出力結果 -> 37

print('3' + 7)
# 出力結果 -> Type Error
```

1行目のコードは数値型で書かれているため、計算式の結果が出力されます。
2行目のコードは文字列型で書かれているため、`３`という文字列と`７`という文字列が連結された`37`が出力されます
3行目のコードは文字列型と数値列型を用いているため、エラーが発生していまいます。

連結は文字列型同士でしか行えないことを学びました。




#型変換

##数値型　→　文字列型

では、数値型を代入してある変数を文字列として連結するにはどうすればいいのでしょうか。

```example.py
name = 'たいち'
age = 22
```

これらの変数を用いて、`たいちは22歳です`と出力する方法学びます。

数値型の変数を文字列として連結するときには型変換を行います。

数値型を文字列型に変換するには`str`を用います。
`str(数値型)`とすることで数値型に変換することができます。

```example.py
name = 'たいち'
age = 22

print(name + 'は' + str(age) + '歳です。')
# 出力結果 -> たいちは22歳です
```

`str`によって変数`age`が文字列型に変換されたため、エラーが起きることなく出力が行われました。




##文字列型　→　数値型

先ほどの例とは反対に文字列型を数値型に変換するには、`int`を用います。
`str`と同じように、`int(文字列型)`とすることで数値型に変換することができます。

例をみていきましょう。

```example.py
count = '5'
price = 200

total_price = price * int(count)

print(total_price)
# 出力結果 -> 1000
```

`count`には`５`が文字列型で代入されていますので、数値型に変換して計算することでエラーを起こすことなく処理が実行されます。




#条件分岐

ある条件に当てはまる場合だけに処理を行う条件分岐について学んでいきます。

条件分岐の構文を学ぶ前に、「**真偽値**」と「**比較演算子**」について学びましょう。




##真偽値

まず、**真偽値**というものについて学んでいきます。

以下のようなコードを実行します。

```example.py
age = 20
print(age == 20)
# 出力結果 -> True
```

`==`は両辺が等しいかどうかを比較する比較演算子になります。比較演算子については、まとめて説明します。

では、このとき出力された`True`とは一体なんなのでしょうか。

この`True`が真偽値と呼ばれるものになります。
真偽値を扱うデータ型は「**真偽値型**」に分類され、`True`と`False`の2種類が存在します。
比較演算子を用いた条件式の部分が成り立つときは`True`、成り立たないときは`False`となります。




##比較演算子

ここで先ほど出てきた「**比較演算子**」についてみていきます。

**比較演算子**とは、**値の等しさや大小を比較するときに用いる記号**のことです。

比較演算子には以下のものが存在します。

|　演算子　|　意味　|
|:-:|:-:|
|a == b|aがbと等しいときTrue|
|a != b|aがbと等しくないときTrue|
|a > b|aがbより大きいときTrue|
|a < b|aがbより小さいときTrue|
|a >= b|aがb以上のときTrue|
|a <= b|aがb以下のときTrue|

この比較演算子は、条件分岐の際の条件文で出てきますので、しっかり抑えておきましょう。



##if文

それでは、条件分岐のコードについてみていきます。

**`if`**を用いると、**ある条件の場合にだけ処理を行うことが可能**になります。

構文をみてみましょう。

```Python
if 条件式:
    処理
```

`if`のあとに`条件式`を指定し、その条件が成り立つときに実行する`処理`を次の行に書きます。
**処理はインデントにより字下げを行わなければいけない**点に注意してください。

例をみていきましょう。

```example.py
age = 22

if age >= 20:
    print('お酒が飲めます')

# 出力結果 -> お酒が飲めます
```

上の例では、`age >= 20`の部分が条件式になります。

上の条件式では、「**ageの値が20以上だった場合**」に`True`となります。

`age`には`22`が代入されていて条件式は`True`になるので、その後の処理である`print(‘お酒が飲めます’)`が実行されます。
次の例をみてみましょう。

```example.py
age = 19

if age >= 20:
print('お酒が飲めます')

# 出力結果 -> お酒が飲めます
```

上の例では処理の部分にインデントがありません。
その結果、本来実行されないはずの処理が行われてしまっています。

インデントには気をつけましょう。



##else

if文に**`else`**を組み合わせることで「**if文の条件に当てはまらなかった場合に別の処理を実行する**」ことができます。

構文は以下の通りです。

```Python
if 条件式:
    処理
else:
    処理
```

`if`の処理の後に、`else:`と書いて、次の行に`処理`を書きます。
`else`のあとには`：`が必要なので忘れないようにしましょう。また、if文と同様にインデントにも注意しましょう。

具体例をみてみます。

```example.py
age = 19

if age >= 20:
    print('お酒が飲めます')

else:
    print('お酒は二十歳になってから')

# 出力結果 -> お酒は二十歳になってから
```

具体例では、`age`に`19`が代入されているため`if`ブロックの条件を満たしていません。

よって`else`の中に書かれている処理が実行されます。



##elif

if文で成り立たなかった場合の**条件式を複数定義したい場合**は、**`elif`**を用います。
構文は以下の通りです。

```Python
if 条件式:
    処理
elif 条件式:
    処理
else:
    処理
```

`if`と`else`の間に、`elif`ブロックを追加します。
書き方は、`if`の場合と同じで、`elif'の後ろに`条件式:`を書いて、次の行に処理を書きます。

`elif`はいくつでも書くことができます。
しかし、**上から順に条件が成り立つか判断され、最初に条件を満たしている部分の処理だけ**が行われます。

`elif`を用いて条件を書いていく場合には条件の順番にも注意が必要です。

具体例を見てみましょう。

```example.py
number = 0

if number > 0:
    print('正です')

elif number == 0:
    print('0です')

else:
    print('負です')

# 出力結果 -> 0です
```

`number`には`0`が代入されているため、`elif`の条件分である`number == 0`を満たします。

よって、`elif`の中に書かれている処理が実行されます。

`elif`の処理が実行されたので、ここで処理は終了となります。

##条件の組み合わせ

###and

`and`を使い複数の条件式を組み合わせることで、「**条件１も条件２も成り立つ**」場合に処理を実行させることができます。

```Python
if 条件式1 and 条件式2:
　　処理
```

`and`を用いた場合は、すべての条件式が`True`のとき全体が`True`となり、処理が実行されます。




###or

`or`を使い複数の条件式を組み合わせると、「**条件１と条件２のどちらかが成り立つ**」場合に処理を実行させることができます。

```Python
if 条件式1 or 条件式2:
　　処理
```

`or`を用いた場合は、複数の条件式のうち一つでも`True`であれば全体が`True`となり処理が実行されます。




###not

`not`を用いると、**条件の否定**をすることができます。

条件式が`True`じゃない時に処理が実行されます。
つまり、`not 条件式`のようにすると、**条件式が`True`であれば全体が`False`になります**。

```Python
if not 条件式:
　　処理
```





#リスト

複数のデータを扱うには「**リスト**」を用います。

リストは、`[〇〇, △△, … ]`のように`[]`を用いて作ります。リストに入っているそれぞれの値を「**要素**」といいます。

また、リストも1つの値なので、**変数に代入することができます**。

```example.py
names = ['山田', '田中', '鈴木']

print(names)
# 出力結果 -> ['山田', '田中', '鈴木']
```

出力すると、リストがそのまま出力されます。
また、変数には複数形を使うことが一般的です。

リストの要素には、前から順に「**0, 1, 2, …**」と番号が割り振られています。これを「**インデックス番号**」といいます。

上の例でいうと、`’山田’`がインデックス番号`0`の要素です。

リストの各要素はリスト`リスト名[インデックス番号]`とすることで取得することができます。

```example.py
names = ['山田', '田中', '鈴木']

print('彼は' + names[0] + 'さんです。')
# 出力結果 -> 彼は山田さんです。
```

`names[0]`では、要素のインデックス番号0の要素を取り出しているので、`山田`が入ります。




##リストの要素の更新

リストの要素の更新は、**`リスト[インデックス番号] = 値`**とすることで行うことができます。

更新したい場所を指定して、代入をやり直すという感じですね。

具体例をみてみます。

```example.py
names = ['山田', '田中', '鈴木']
names[2] = '佐藤'

print(names)
# 出力結果 -> ['山田', '田中', '佐藤']
```

インデックス番号2の要素を更新しています。出力したリストは、値が更新されていることがわかります。




##リストの要素の追加

次に、リストに値を追加してみましょう。

**`リスト.append(値)`**とすることで、**すでに定義されているリストに新たな要素を追加することが可能**です。

具体例をみてみましょう。

```example.py
names = ['山田', '田中', '鈴木']
names.append('佐藤')

print(names)
# 出力結果 -> ['山田', '田中', '鈴木', '佐藤']
```

要素は、**リストの末尾**に追加されます。

具体例でもリストの末尾に`佐藤`が追加されたリストが出力されていることがわかります。




#辞書

「**辞書**」も、複数のデータをまとめて管理するのに使われます。

辞書はリストと違い、インデックス番号をではなく「**キー**」と呼ばれる名前をつけて管理します。

辞書は**`{キー1: 値1, キー2: 値2, …}`**のように定義します。

一般にキーには文字列が使われます。

```example.py
names = {'山田': 22, '田中': 40, '鈴木': 33}

print(names)
# 出力結果 -> {'山田': 22, '田中': 40, '鈴木': 33}
```

辞書の要素には順序がないため、出力すると要素の順番が定義したときと変わっていることがあります。

辞書の要素は、取り出したいキーを用いて、`辞書名['キー']`とすることで取り出すことができます。

```example.py
names = {'山田': 22, '田中': 40, '鈴木': 33}

print('彼は' + str(names['田中']) + '歳です。')
# 出力結果 -> 彼は40歳です。
```




##辞書の要素の更新

基本的にはリストの更新と同じです。

インデックス番号の代わりに**キー**を用います。

```example.py
names = {'山田': 22, '田中': 40, '鈴木': 33}

#値を更新
names['田中'] = 50

print('彼は' + str(names['田中']) + '歳です。')
# 出力結果 -> 彼は50歳です。
```

値が更新されていることが確認できました。




##辞書の要素の追加

辞書に要素を追加するときは、`辞書名['新しいキー'] = 値`のように新しいキーを設定してそこに値を代入します。

```example.py
names = {'山田': 22, '田中': 40, '鈴木': 33}
names['佐藤'] = 15

#辞書を出力
print(names)
# 出力結果 -> {'山田': 22, '田中': 40, '鈴木': 33, '佐藤': 15}

#新しく追加した要素を出力
print('彼は' + str(names['佐藤']) + '歳です。')
# 出力結果 ->  彼は15歳です。
```

要素が追加され、指定して取り出すこともできています。




#繰り返し処理

Pythonの繰り返し処理である「**for文**」と「**while文**」について学んでいきます。




##for文

リストのすべての要素を一つひとつ取り出したい場合、1つずつインデックス番号を指定するのは非常に面倒です。

「**for文**」を使うことで、「**繰り返し処理**」を行うことができます。

for文は、**`for 変数名 in リスト名:`**のように記述します。

変数名にリストの要素が先頭から順に1つずつ入っていき、その上でfor文の中の処理が実行されます。

具体例をみてみましょう。

```example.py
names = ['山田', '田中', '鈴木']

for name in names:
    print('彼は' + name + 'さんです。')

# 出力結果 ->
彼は山田さんです。
彼は田中さんです。
彼は鈴木さんです。
```

このように、for文中の出力の処理がリストの先頭から順に行われていきます。
また、変数名は一般的にリスト名の単数形にします。

同じように、辞書もfor文を用いることで、要素を1つずつ取り出し、繰り返し処理を実行することができます。

辞書の場合、for文は、**`for 〇〇_key in 辞書名:`**のように記述します。

具体例をみてみましょう。

```example.py
names = {'山田': 22, '田中': 40, '鈴木': 33}

for name_key in names:
    print(name_key + 'さんは' + str(names[name_key]) + '歳です。')

# 出力結果 ->
山田さんは22歳です。
田中さんは40歳です。
鈴木さんは33歳です。
```

このように辞書の要素もfor文で取り出すことができました。




##while文

もう一つの繰り返し処理が、「**while文**」です。

while文を用いると「**ある条件に当てはまる間、処理を繰り返す**」ことができます。

構文を見てみましょう。

```example.py
while 条件式:
    値の更新を含む処理    
```

`while 条件式:`のように書き、その後にインデントして処理を書きます。
処理の部分には、必ず値を更新する処理を含めます。

具体例をみてみましょう。

```example.py
x = 1

while x <= 5:
    print(x)
    x += 1
# 出力結果 ->
1
2
3
4
5
```

例を見てみると、条件式の部分は「**`x`が`5`以下のとき**」となってます。while文の中の処理は、まず「**`x`の値を出力**」し、そのあと「**`x`に`1`を足す**」というものになってます。

`5`が出力された後、`1`が足され、`x`の値は`6`になり条件を満たさなくなるので処理は終了します。

よって、`x`が`5`になるまで処理は繰り返されます。




###無限ループ

while文では、処理の最後に変数の値を更新し忘れたり、インデントが間違っていたりすると条件式が常に`True`となってしまい、**無限に繰り返し処理が行われてしまいます**。

気をつけましょう。




##breakとcontinue

###break

`break`を用いることで、繰り返し処理を「**強制的に終了**」させることができます。

`break`はif文などの条件分岐を組み合わせて使います。

具体例をみてみましょう。

```example.py
numbers = [1, 2, 3, 4, 5]

for number in numbers:
    print(number)
    if number == 4:
        break

# 出力結果 ->
1
2
3
4
```

コードを見てみましょう。

if文の条件式が「4になったとき」となっています。`if`ブロックの中には、`break`が書いてあり条件を満たした場合に実行されます。

よって、`5`の出力は行われることなく処理が終了しています。




###continue

**`continue`**を用いると、**条件を満たしている場合の処理をスキップする**ことができます。

`break`と同様に条件分岐と組み合わせて使います。

```example.py
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for number in numbers:
    if number % 2 == 0:
        continue
    print(number)

# 出力結果 ->
1
3
5
7
9
```

`if`の条件式の部分は、「**numberが2で割り切れるとき**」となっているため、**偶数の処理はスキップされ、奇数だけが出力**されています。


 


#まとめ

一気にまとめてみました。
Pythonはコードがシンプルで読みやすいですね。

最後まで読んでいただきありがとうございました。