python基礎

# print(文字を出力する方法)

```csharp:php
print('Hellow World');
```
# ＃（コメント)

```csharp:php
#コメントアウト
```
# 変数の定義
+ PHPのように、$などはいらない。
+ 変数名の付け方は、`user_name`のように、単語2文字以上のときは、アンダーバーで繋げる。

```csharp:php
name = 'Naoki';
name = 12;
```
+ 変数の中の値を取り出すときは↓
+ クオテーションをつけると、文字列として認識されてしまうので、クオテーションはつけない。

```csharp:php
print(name); //Naoki
```
# 変数の更新

```csharp:php
x = x + 10//x + = 10と同じ　、x　% = 10など
```
# 文字列の連結

+ +記号は、文字列の連結もすることができる。
+ PHPの場合は、'Hello'.'World'→ドットで繋げていた。

```csharp:php
print('Hello' + 'World');
name = 'John';
print('Hello' + name);
```

# 型変換(str,int)

**異なる型同士の連結はできない**

```csharp:php
price = 100;
print('りんごの値段は' + price + 'です。');//文字列型と数値型であるため、エラーが起きてしまう。
```
解決するには、`str(変数名)`とする。文字列同士なので、エラーが起きずに連結することができる。

```csharp:php
price = 100;
print('りんごの値段は' + str(price) + 'です。');
```
反対に、文字列を数値に変えたいときは、`int`を使う。

# if文（条件分岐）

**if文の中身は、インデントで字下げを行うことによって処理をすることができる。**

```csharp:ph
score = 100;
+ if score == 100://if ()→括弧なし、文末にコロンを付与する。
　　　　　print('よくできました');
print('はみでっちゃっています');//インデントされていないので、常に実行されてしまう。
```

+ 真偽値はTrue、Falseと頭文字は大文字

```csharp:php
score = 100
if score == 100:
  print('よくできました')
else :
  print('残念')
```
+ PHPはelseifだったが、pythonでは、elifとなっている。

```csharp:php
score = 30
if score >= 35:
   print('よくできました')
elif score == 30:
   print('まずまずですね')
else:
  print('たいへんよくできました')
```
# and、or、not
+ PHPの場合は、&&(かつ)や、|(または)であったが、pythonでは、`and`で繋げる。
+ andの場合、条件式が1つでもfalseであれば`false`、orの場合、条件式が1つでもTrueであれば`True`

```csharp:php
time = 9
if not time == 24:
  print('時間が間違っています。')
```

# 入力を受け取る（input）

`input関数`を使うと、キーボードを使って文字列データを入力できる。
+ 文字列として返ってくる

```csharp:php
apple_price = 200

input_count = input('購入するりんごの個数を入力してください：')

# input_count を数値として代入してください
count = int(input_count)
total_price = apple_price * count

print('購入するりんごの個数は' + str(count) + '個です')
print('支払い金額は' + str(total_price) + '円です')
```
# リスト

+ 複数のデータをまとめて管理したいとき→`リスト`
+ 中身の値を`要素`という
+ リストの各要素は`リスト[インデックス番号]`で取得できる

```csharp:php
# 文字列と数値のリスト
['apple', `sushi`, 100, 200]
```
+ 取得の仕方

```csharp:php
foods = ['sushi', 'curry']
print('好きな食べ物は' + foods[1] + 'です')//好きな食べ物はcurryです
foods[0] = 'mentaiko'//更新
```
+ リストの追加
+ `append`→リストの末尾に追加することふができる

```csharp:php
foods.append('piza')
```
# for文
`for 変数名 in リスト`→リストの要素の数だけ処理を繰り返すことができる。

```csharp:php
fruits = ['apple', 'banana', 'grape']
for fruit in fruits://コロンを忘れずに！！
   print('好きな果物は' + fruit + 'です')
```
# 辞書

+ PHPでいう連想配列同じ→キーと値で1セット
+ リストは[]だったが、辞書は{}で囲む
+ `{キー1:値、キー2：値、キー3：値}`
+ 辞書の要素の順番は定義したものと異なる。
+ 値を取り出したい時は、`辞書名['キー名']`→キー名の前後にクオテーションを忘れずに！

```csharp:php
sports = {'soocer':'サッカー', 'baseball':'野球'}
print('好きなスポーツは' + fruits['soccer'] + 'です')
```
+ 追加する場合は、`辞書名[新しいキー名] = '値'
+ 末尾につ追加は、append()

+ for文で繰り返し出力する時↓

```csharp:php
sports = {'soocer':'サッカー', 'baseball':'野球'}
for sport_key in sports//sport_keyに、キー名が1つずつ代入される

print(sport_key 'は' + sports[sport_key] + 'という意味です')
```
# while文

+ 値の更新やインデントを忘れて無限ループが起きないように気をつける

```csharp:php
x = 1
while 条件式:
　　　　　　　　print(x)
    x += 1
```
# break

`break`を用いると繰り返し処理を終了することができる。

```csharp:php
numbers = [1,2,3,4,5,6]
for number in numberes:
    print(number)
    if number == 3:
       break
```
# continue

+ `continue`は、その周の処理だけをスキップする。

```csharp:php
numbers = [1,2,3,4,5,6,7,8,9]
for number in numbers:
    if number % 3 == 0:
      continue
      print(number)
```
# 関数
+ ある処理をまとめたプログラムの塊
+ 例えば、電子レンジは、❶あたためたいものを中に入れる。❷あたたる。❸時間になったら温めるのをやめる。というように、電子レンジには複数の処理があるので、電子レンジをいわば`関数`という。

```csharp:php
def 関数名()://コロンを忘れずに！！
   実行する処理//インデントを忘れずに！！

関数名（）で呼び出すことができる。
```
# 引数
関数に値を渡すことができる。
関数の中でその値を使うことができる

```csharp:php
def hello(name):
   print('Hello' + name)

hello('naoki')//Hello naoki
```
# 引数の初期値

```csharp:php
def test_score(name, score = 100)//第2引数が省略されれば、100となる。
print(name + 'さんのスコアは' + score + '点です')

//出力
test_score('naoki', 87)//naokiさんのスコアは87点です
```
# コードを分ける（モジュール）

+ 関数を定義しているファイル（util.ps）と、処理を書いている（script.py）の2つに分ける。
+ `モジュール`とは→パイソンのコードが書かれたファイルのこと。

# Pythonにおけるモジュール、パッケージ、ライブラリ

+ `.pyファイル`のことをモジュールという。
+ `import`を使うことで、モジュールを読み込むことができる。→import モジュール名 //.pyは除く
+ モジュールをいくつか集めてまとめたものが`パッケージ`
+ いくつかのパッケージを集めてインストールできるようにしたものが、`ライブラリ`

**pythonには、すぐに使える組み込み関数と、importで読み込む必要のある標準ライブラリがある。**

+ `モジュール名.関数名()`でモジュール先の関数を使うことができる。
+ 例えば
```csharp:php
import random
computer_hand = random.randint(0,2)→//0から2までをランダムに表示できる。
```
# クラスとインスタンス

`クラス`→設計図のようなもの
`インスタンス`→設計図をもとにしてできたモノ
一つのメニューには、値段と商品名のような情報がいくつかある。
+ 1つ設計図（クラス）を作ってしまば、そこから何個でもインスタンスをつくることができる。

:::note
❶設計図（クラス）から、空のインスタンスを生成する。
❷空のインスタンスに情報を加えていく。
:::

①クラスの作り方

```csharp:php
class SportItem://アッパーキャメルケース
　　　//処理（設計図の内容を記述する）
  pass//何も処理がないことを表すもの
```

②インスタンスの作り方（から）

```csharp:php
item = SportItem()//クラス名（）でインスタンスを生成することができる。
```
③空のインスタンスに情報を加えていく

下記のnameを`インスタンス変数`という。
`インスタンス.インスタンス変数名`で値を取得することができる。

```csharp:php
item = SportItem()
item.name = 'サッカー道具'
item.price = 1000
print(item.name)
```
# クラスの中に処理を追加する

クラスの中の関数を　`メソッド`という

```csharp:php
class SportItem
   def info(self)://メソッド
     print('スポーツ用品の名前と値段が表示されます')

sport_item1 = SportItem()//インスタンス生成
  sport_item1.info()//インスタンスメソッド
```
# インスタンスメソッドのselfの正体

+ selfには、そのメソッドを呼び出したインスタンス自身が入っている。

```csharp:php
class SportItem
   def info(self)://メソッド
     print('スポーツ用品の名前と値段が表示されます')
     print(self.name)//サッカー道具

sport_item1 = SportItem()//インスタンス生成
  sport_item1.info()//インスタンスメソッド
  sport_item1.name = 'サッカー道具'
```
+ インスタンスは、情報として`インスタンス変数`、処理として`インスタンスメソッド`を持っている。

```csharp:php
class SportItem:
    def info(self):
        return self.name + ': ¥' + str(self.price)

        def get_total_price(self, count):
          total_price = self.price * count
          return total_price

sport_item1 = SportItem()
sport_item1.name = 'サッカーボール'
sport_item1.price = 500

print(menu_item1.info())

result = sport_item1.get_total_price(4)

print('合計は' + str(result) + '円です')
```
# __init__メソッド

`__initメソッド`は、クラス名（）でインスタンスを生成した直後に自動で呼び出される。

```csharp:php
def __init__(self):
   print('SportItemインスタンスが生成されました。')
　
sport_item1 = SportItem()
 //インスタンスが生成された直後に__init__メソッド内の処理が呼び出される。
```

+ __init__メソッドでインスタンス変数を扱う

__init__メソッドの役割は、インスタンス生成直後にインスタンス変数に値を代入することができる。


```csharp:php
def __init__(self):
  self.name = 'サッカーボール'//インスタンス生成直後に、インスタンス変数に値を代入する。

sport_item1 = SportItem()
   print(menu_item1.name)
```
+ __init__メソッドに引数を渡す
 

```csharp:php
class SportItem
   def __init__(self, name, price)
     self.name = name
     self.price = price

sport_item1 = SportItem('サッカーボール', 1000)//これにより、__init__メソッドの引数に値を渡すことができる。インスタンス変数に値を代入
```
# クラスを直接読み込む

+ 下記の構文で別ファイルのクラスを直接使うことができる。

```csharp:php
from モジュール名 import クラス名
```
# 商品一覧の作成

```csharp:php
from menu_item import MenuItem//別ファイルからモジュールをインポート

sport_item1 = SportItem('サッカーボール', 500)
sport_item2 = SportItem('野球ボール', 400)
sport_item3 = SportItem('バレーボール', 300)
sport_item4 = SportItem('バスケットボール', 200)


sport_items = [sport_item1, sport_item2, sport_item3, sport_item4]

for item in sport_items:
  print(item.info())

```
# 繰り返し処理で番号をつける

```csharp:php
foods = ['ラーメン', 'やきそば', 'おにぎり', 'うどん']
index = 0
for food in foods
  print(str(index) + '.' + food)
  index += 1
```
+ 4個以上購入で割引できるようにする（1割引）

```csharp:php
class MenuItem:
    
   　　def get_total_price(self, count):
        total_price = self.price * count
        
        if count >= 4:
          total_price *=  0.9
        
      return round(total_price)//round関数で四捨五入

```
# クラスの継承

+ 食べ物と飲み物を別々で注文できるようにする。
+ `食べ物クラス`　`飲み物クラス`を作成する。
+ 情報として、名前、値段などのインスタンス変数を加える。
+ 1からクラスを作成するのではなく、すでにあるクラスから作成できる。→**共通部分を効率的に使うことができる**→`継承`

```csharp:php
class food(FoodItem)//FoodItemクラスを継承することができる→foodが子クラス、FoodItemが親クラスという
```
**継承することによって,親クラスのメソッドをそのまま使うことができる。**__init__やget_total_priceを子クラスでも使うことができる。
+ インスタンスメソッドを追加できる。→子クラスには、親クラスから継承されたインスタンスメソッドと、子クラスで定義された独自のメソッドを使うことができる。
+ 子クラスで定義されたメソッドは親クラスでは使えない。

# メソッドの上書き

+ 親クラスで定義されいているメソッドを子クラスでも使うと、メソッドが上書きされる→`オーバーライド`
+ メソッドを呼び出すときは、親クラスで定義されたメソッドではなく、子クラスで定義されたメソッドとなる。
+ **同名のメソッドがある場合、子クラスのメソッドが優先される。**

```csharp:php
from food_item import FoodItem

class Food(MenuItem):
   
    def info(self)://メソッドのオーバーライド
      return self.name + ': ¥' + str(self.price) + ' (' + str(self.calorie) + 'kcal)'
    
    
    def calorie_info(self):
        print(str(self.calorie) + 'kcalです')

--------------------------------------------------------------

food1 = Food('ラーメン', 600)
food1.calorie = 330

print(food1.info())

```
# メソッド内の処理の重複

+ `super().メソッド名`で親クラスのメソッド内の処理を小クラスでも使うことができる。

```csharp:php
class LuncheItem
  def __init__(self, name, price):
    self.name = name
    self.price = price
```

+ 子クラスに継承し、同じ処理は`super()`で読み込む

```csharp:php
class Rice(LuncheItem)
   def __init__(self, name. price, calorie)
     super().__init__(name, price)//親クラスのメソッド内の同じ処理を読み込む
     self.calorie = calorie
```

# type関数

type関数で型がわかる。

```csharp:main.py
num = 1
name = 'Mike'
is_ok = True

print(num, type(num))
print(name, type(name))
print(is_ok, type(is_ok))
```
# 型変換

```csharp:main.py
# 型変換

name = '1'
new_num = int(name)

print(new_num, type(new_num))
```
# sep end

+ `sep`→文字の区切り文字を設定できる。
+ `end`→'文字の最後に文字などを代入できる'

```csharp:main.py
print('Hi', 'Mike', sep=',', end='.\n')//デフォルトでendには、バックスラッシュが入っている。endを空にすることによって改行されなくなる。
```
+ 対話型シェルをうまく使っていく

```csharp:main.py
type=(1.5)//<class float>

・17/3→5.666666666666667
17 // 3 → 5
小数点以下を除いたものだけ求めることができる
```
+ べき乗もできる

```csharp:main.py
5 * 5 * 5 * 5 * 5//めんどくさい
5 ** 5//5を5回かけるという意味
```
+ round関数で処理でできる

```csharp:main.py
pie = 3.1415
print(round(pie,2))//小数点2桁まで表示するという意味
```
+ 便利な数学関数がある。

```csharp:main.py
import math
result = math.sqrt(25)
print(result)//5(平方根)

print(help(math))//mathのドキュメントを表示できる。
```
# 文字列について
クオテーションがかぶる時は、その前にバックスラッシュをつける。

```csharp:main.py
print("say \"I don't know\"")
```
+ 改行→`\n` \nameのようなパスがあった場合は、先頭にrをつけることによって改行されなくなる。

```csharp:main.py
print(r'\name\name')
```
+ 複数改行したい時

```csharp:main.py
print("""
line1
line2l
line3
kine4
line5
""")
```
+ 文字列を演算子でも表示できる

```csharp:main.py
print('こんにちは' * 4)//こんにちはこんにちはこんにちはこんにちは
print('こんにちは'*4 + 'なおきさん')//こんにちはこんにちはこんにちはこんにちは尚樹さん
```
```csharp:main.py
print('py' + 'thon'))//python
print('py''thon')//python
```
+ プラスなしの時はどんな時か

```csharp:main.py
print('sssssssssssssssss'
       'fffffffffffffff')
```
# 文字列のインデックスとスライス

```csharp:main.py
tango = 'python'
print(tango[1])//y
print(tango[-4])//後ろから4番目を表示
print(tango[2:5])//スライス　直前まで表示される//tho
print(tango[:2])//0から2まで
print(tango[2:])#2から最後まで
tango = 'j' + tango[1:]
print(tango)
print(tango[:])# すべてのワードのコピーとなる
n = len(tango)# 関数lengs
print(n)//6
```
+ 文字列のメソッド

```csharp:main.py
s = 'my name is naoki. Hi mayuko'
print(s)
s.
//ドットをつけることによって、メソッドを使うことができる。
is_start = s.startswith('my')//myではじまっていえるかチェック
print(is_start)//True

print(s.find('mayuko'))
print(s.count('mayuko'))//1→数を数える
print(s.capitalize())//先頭のみ大文字
print(s.title())//先頭の文字を全て大文字
print(s.upper())//全部大文字
print(s.lower())//全て小文字
print(s.replace('mayuko', 'kazuya'))//変更できる
```
# 文字列の代入

```csharp:main.py
'a is {}'.format('naoki')//a is naoki
'naoki {}'.format('Ishikawa')
'a is {} {} {}'.format('1','2','3')//a is 1 2 3
'my name is {name} {family}. watasi ha {family} {name}'.format(name='naoki', family='ishikawa')
//型変換もできる
x=str(123)
print(type(x))
//<class str>
```
# リストについて

+ s=[1,2,3,4,5,6]

```csharp:main.py
s[1:]//インデックス1から最後まで
s[2:4]//インデックス2から4の手前まで。3、4
s[:]//すべて表示
len(s)//リストの個数表示
 list('sknkdnkdnknknsk')//文字列をリストにする。list型
['s', 'k', 'n', 'k', 'd', 'n', 'k', 'd', 'n', 'k', 'n', 'k', 'n', 's', 'k']
n[::2]→1、3、5
n[::-1]//6,5,4,3,2,1
s=[1,2,3,4]
n=[a,b,c,d,]
l=[s,n]
[[1,2,3,4][a,b,c,d]]//入れ子構造になっている
l[1][2]//二つ目のリストのcを表示
l[0]//[1,2,3,4]を表示
```
+ リストの操作

```csharp:main.py
s = [1,2,3,4,5,6,7]
s[:] = []//[]にする
s[1:4] = 'なおき'//2,3,4をなおきにする [1,'なおき',5,6,7]
//リストのメソッド
n = [1,2,3,4,5,6,7,8]
n.append(100)//最後に100を代入
n.insert(0,200)//インデックス番号（第一引き数）に第2引数を挿入
n.pop()//最後を取り出す。インデックス番号を指定して削除
n.pop(0)//200を取り出す
del n[0]//インデックス番号の部分を削除
n.remove(1)//1番最初の1を削除
```
+ リストの結合

```csharp:main.py
a = [1,2,3,4,5]
b = [6,7,8,9,10]
a + b = [1,2,3,4,5,6,7,8,9,10]
a += bでも上記と同じ結果となる。
a.extend(b)でも上記と同じ結果となる。
b.extend(a)//6,7,8,9,10,1,2,3,4,5
>>> l = list(range(10))
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> l.extend([10,11,12,13,14,15,16,17])
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17]
>>> 

```
+ リストのメソッド

```csharp:main.py
n = [1,2,3,4,5,6,7,8,1,2,3,4]
print(n.index('2'))//2のインデックス番号を表示してくれる
n.sort()//番号順に並べてくれる
n.sort(reverse=True)//番号逆順に表示
r.reverse()
name2 = 'my name is naoki'
to_split2 = name2.split(' ')//スペースで分けてリストに入れてくれる。
print(to_split2)//['my name is naoki']

arm = 'buki arm ibu'
print(arm)
split = arm.split(' ')//['buki', 'arm', 'ibu']→スペース開けてリストにしてくれる。
print(split)
c = ' #### '.join(split)//joinで空白部分を＃＃＃で繋げるようにする。
print(c)
```
+ リストのコピー(リストなどは`参照渡し`)

```csharp:main.py
x = [1,2,3,4,5]
y = x.copy()//xをコピーしてあげる。バグにならないように気をつける。
y[0] = 100
print('y=', y)
print('x=',x)

x = [1,2,3,4,5]
y = x
y[0] = 100
print('y=', y)
print('x=',x)
```
# タプル型

+ `タプル型`は値を変更できない、代入できない。
+ countメソッド、indesメソッドぐらいしか使えない。
+ 読み込み専用でよく使われる。

```csharp:main.py
t = (a,b,c,d,e,f,g)
help(tuple)//タプルのメソッドを全表示
```
+ カッコなくてもタプルになる
+ カンマがついている時点でタプルになる。

```csharp:main.py
t = 1,2,3
type(t)
type = ()//タプル
type = (1)//カンマなしだと、intとなる。
type = ('name')//カンマなしだと、この場合文字列となる。
new_tuple = (1) + (2,3,4,5)//intとtupleのため、計算できずエラーになる
new_tuple = (1,) + (2,3,4,5)//カンマをつけることによってtuple同士となる。
```
+ タプルのアンパッキング
+ 長い場合は、1つずつ書いていく

```csharp:main.py
num_tuple = (100,200)
x, y = num_tuple
x、y = 10,20//xに10を展開、yに20を展開
min, maz = 0, 300
print(min, max)
print(x, y)//100,200
```
+ 変数の値の入れ替え
+ 10と20を入れ替えたいとき

```csharp:main.py
i =10
j =20
tmp＝i
i = j
j =tmp
print(i, j)//20,10

//手間がかかるので、アンパッキングを使ってもっと簡単に入れ替える。
a =100
b =300
a, b = b, a 
print(a,b)//300,100
```
# dict(辞書型)

+ キーと値で構成

```csharp:main.py
n = {'x': 10, 'y' :20}//{}→カーリーブラケット
n['x'] = 100//{'x': 100, 'y' :20}
n['z'] = 309//{'x': 100, 'y' :20, 'z':309}//追加

//dict
dict(a=10,b=20)//これでも辞書が生成できる。
{'a':10, 'b': 20}

```
+ 辞書型のメソッド

```csharp:main.py
d ={'x':100, 'b':200}
d.keys()//dict_keys(['x', 'y'])//リスト型
d.values()//dict_values([10, 20])
d2 = {'x':1000, 'j':500}
//dのxの値を更新して、jという新しいキーとその値を入れる。
d.update(d2)
d//{'x': 1000, 'y': 20, 'j': 500}
d['y']もしくは、d.get('x')//20
d['y'] = 400//yの値を更新
del d['x']//xというキーとその値を削除
d.clear()//{}→中身全て削除
//判定
 d ={'a':100,'b':300}
>>> d
{'a': 100, 'b': 300}
>>> 'a' in d
True
>>> 'c' in d
False
>>> d
```

+ 辞書のコピー

```csharp:main.py
//参照渡し
x = {'x':1}
y = x
Y['x'] = 1000
print(x)//1000
print(y)//1000
//copyする
x ={'a':1}
y = x.copy()
y['a'] = 1000
print(x)//1
print(y)//1000
 ```
# 集合型

```csharp:main.py
a = {1,2,3,4,4,4,4,5,6}//集合
>> a//{1,2,3,4,5,6}//重複していた数字がユニークになる。
type(a)//<class 'set'>
b = {2,3,3,4,5,7}
>> b//{2,3,4,5,7}
a - b//{1,6}→aに入っているものからbを取り除く。
b - a//{7}
a & b//aにもあり、bにもあるもの
a | b//aまたはbにあるもの
a^b //aとbどちらかにあるもの、重複していないもの
```

+ 集合のメソッド

```csharp:main.py
n  = {1,2,3,4,5}
n[0]//集合はリストとは違ってインデックスがないため、エラーになる。
s.add(6)//{1,2,3,4,5,6}
s.add(6)//{1,2,3,4,5,6}集合のため、もう一回6を入れても意味はない。ユニークになるため。
s.remove(7)
s.clear()//set()
```

```csharp:main.py
fruits = ['apple', ''banana', 'apple']// 買ったフルーツのリスト
kind =set(fruits)//集合にする。
print(kind)//{'banana', 'apple'}
```
Python基礎❷に続く！！！！！！！！！！！