Object-oriented-python-quick-guide

提供：Dev Guides
移動先:案内、検索

オブジェクト指向Python-はじめに

プログラミング言語は絶えず出現しており、さまざまな方法論が存在します。オブジェクト指向プログラミングは、このような方法論の1つであり、過去数年で非常に普及しています。

この章では、Pythonプログラミング言語をオブジェクト指向プログラミング言語にする機能について説明します。

言語プログラミング分類スキーム

Pythonは、オブジェクト指向プログラミングの方法論の下で特徴付けることができます。 次の図は、さまざまなプログラミング言語の特性を示しています。 Pythonをオブジェクト指向にする機能を観察してください。

言語学クラス

カテゴリー

ランゲージ

プログラミングのパラダイム

手続き型

C、C ++、C＃、Objective-C、java、Go

スクリプティング

CoffeeScript、JavaScript、Python、Perl、Php、Ruby

機能的

Clojure、Eralang、Haskell、Scala

コンパイルクラス

静的

C、C ++、C＃、Objective-C、java、Go、Haskell、Scala

動的

CoffeeScript、JavaScript、Python、Perl、Php、Ruby、Clojure、Erlang

型クラス

強い

C＃、java、Go、Python、Ruby、Clojure、Erlang、Haskell、Scala

Weak

C、C ++、C＃、Objective-C、CoffeeScript、JavaScript、Perl、Php

メモリクラス

マネージド

その他

管理対象外

C、C ++、C＃、Objective-C

オブジェクト指向プログラミングとは

  • オブジェクト指向*は、オブジェクトに向けられていることを意味します。 言い換えると、機能的にオブジェクトのモデリングに向けられていることを意味します。 これは、データと動作を介して相互作用するオブジェクトのコレクションを記述することにより、複雑なシステムのモデリングに使用される多くの手法の1つです。

Pythonは、オブジェクト指向プログラミング（OOP）であり、オブジェクトとクラスを使用してアプリケーションを設計および構築することに焦点を当てたプログラミング方法です。 オブジェクト指向プログラミング（OOP）の主要な柱は、継承、ポリモーフィズム、抽象化、 *カプセル化*です。

オブジェクト指向分析（OOA）は、問題、システム、またはタスクを検査し、オブジェクトとそれらの間の相互作用を識別するプロセスです。

オブジェクト指向プログラミングを選択する理由

Pythonはオブジェクト指向のアプローチで設計されました。 OOPには次の利点があります-

  • 明確なプログラム構造を提供します。これにより、実際の問題とその解決策を簡単にマップできます。
  • 既存のコードの簡単なメンテナンスと変更を容易にします。
  • 各オブジェクトが独立して存在し、既存の機能を乱すことなく新しい機能を簡単に追加できるため、プログラムのモジュール性が向上します。
  • 提供されたコンポーネントをプログラマーが簡単に調整および変更できるコードライブラリの優れたフレームワークを提供します。
  • コードの再利用性を与える

手続き型と オブジェクト指向プログラミング

手続きベースのプログラミングは、 functions/procedure/routines の概念に基づいた構造プログラミングから派生しています。 手続き指向プログラミングでは、データに簡単にアクセスして変更できます。 一方、オブジェクト指向プログラミング（OOP）では、問題を*オブジェクト*と呼ばれる多数のユニットに分解し、これらのオブジェクトを中心にデータと機能を構築できます。 プロシージャや関数よりもデータに重点​​を置いています。 また、OOPでは、データは非表示であり、外部プロシージャからアクセスできません。

次の図の表は、POPアプローチとOOPアプローチの主な違いを示しています。

手続き指向プログラミング（POP）との違い。 オブジェクト指向プログラミング（OOP）。

Procedural Oriented Programming ObjectOriented Programming
Based On In Pop,entire focus is on data and functions Oops is based on a real world scenario.Whole program is divided into small parts called object
Reusability Limited Code reuse Code reuse
Approach Top down Approach Object focused Design
Access specifiers Not any Public, private and Protected
Data movement Data can move freely from functions to function in the system In Oops, data can move and communicate with each other through member functions
Data Access In pop, most functions uses global data for sharing that can be accessed freely from function to function in the system In Oops,data cannot move freely from method to method,it can be kept in public or private so we can control the access of data
Data Hiding In pop, so specific way to hide data, so little bit less secure It provides data hiding, so much more secure
Overloading Not possible Functions and Operator Overloading
Example-Languages C, VB, Fortran, Pascal C++, Python, Java, C#
Abstraction Uses abstraction at procedure level Uses abstraction at class and object Level

オブジェクト指向プログラミングの原理

オブジェクト指向プログラミング（OOP）は、アクションではなく*オブジェクト*の概念に基づいており、ロジックではなく*データ*に基づいています。 プログラミング言語がオブジェクト指向であるためには、クラスとオブジェクト、および基本的なオブジェクト指向の原則と概念、つまり継承、抽象化、カプセル化、ポリモーフィズムの実装と使用を可能にするメカニズムが必要です。

エラー

オブジェクト指向プログラミングの各柱を簡単に理解しましょう-

カプセル化

このプロパティは、不必要な詳細を隠し、プログラム構造の管理を容易にします。 各オブジェクトの実装と状態は、明確に定義された境界の後ろに隠れており、それらを操作するためのクリーンでシンプルなインターフェースを提供します。 これを実現する1つの方法は、データをプライベートにすることです。

継承

一般化とも呼ばれる継承により、クラスとオブジェクト間の階層関係をキャプチャできます。 たとえば、「果物」は「オレンジ」の一般化です。 継承は、コードの再利用の観点から非常に役立ちます。

抽象化

このプロパティを使用すると、詳細を非表示にして、コンセプトまたはオブジェクトの本質的な機能のみを公開できます。 たとえば、スクーターを運転している人は、クラクションを押すと音が出ることを知っていますが、クラクションを押すと実際に音がどのように発生するかについてはわかりません。

多型

ポリモーフィズムは多くの形態を意味します。 つまり、モノやアクションはさまざまな形や方法で存在します。 多態性の良い例の1つは、クラスでのコンストラクタのオーバーロードです。

オブジェクト指向Python

Pythonプログラミングの中心は*オブジェクト*と OOP ですが、コードをクラスに整理することでOOPの使用を制限する必要はありません。 OOPは、Pythonの設計哲学全体に追加され、プログラミングへのクリーンで実用的な方法を奨励します。 OOPは、より大きく複雑なプログラムの作成も可能にします。

モジュールと クラスとオブジェクト

モジュールは「辞書」のようなものです

モジュールで作業する場合、次の点に注意してください-

  • Pythonモジュールは、再利用可能なコードをカプセル化するパッケージです。
  • モジュールは、 init。py ファイルのあるフォルダーにあります。
  • モジュールには関数とクラスが含まれます。
  • モジュールは import キーワードを使用してインポートされます。

辞書は*キーと値*のペアであることを思い出してください。 つまり、キー EmployeID を持つ辞書があり、それを取得したい場合は、次のコード行を使用する必要があります- 

employee = {“EmployeID”: “Employee Unique Identity!”}
print (employee [‘EmployeID])

あなたは、次のプロセスでモジュールで作業する必要があります-

  • モジュールは、いくつかの関数または変数を含むPythonファイルです。

  • 必要なファイルをインポートします。

  • これで、「。」*（ドット）*演算子を使用して、そのモジュールの関数または変数にアクセスできます。

    *employee* という名前の関数を持つ *employee.py* という名前のモジュールを考えてみましょう。 関数のコードは以下のとおりです-
# this goes in employee.py
def EmployeID():
   print (“Employee Unique Identity!”)

ここでモジュールをインポートし、関数 EmployeID にアクセスします- 

import employee
employee. EmployeID()

次のように、 Age という名前の変数を挿入できます- 

def EmployeID():
   print (“Employee Unique Identity!”)
# just a variable
Age = “Employee age is **”

今、次の方法でその変数にアクセスします- 

import employee
employee.EmployeID()
print(employee.Age)

さて、これを辞書と比較しましょう- 

Employee[‘EmployeID’] # get EmployeID from employee
Employee.employeID() # get employeID from the module
Employee.Age # get access to variable

Pythonには一般的なパターンがあることに注意してください-

  • key = value スタイルのコンテナを取る
  • キーの名前で何かを引き出す

モジュールを辞書と比較するとき、以下を除いて、両方は似ています-

  • dictionary の場合、キーは文字列であり、構文は[key]です。
  • *モジュール*の場合、キーは識別子であり、構文は.keyです。

クラスはモジュールのようなものです

モジュールは、Pythonコードを保存できる特殊な辞書であるため、「。」演算子を使用してアクセスできます。 クラスは、関数とデータのグループを取得してコンテナ内に配置する方法であり、「。」演算子を使用してそれらにアクセスできます。

あなたが従業員モジュールに似たクラスを作成する必要がある場合は、次のコードを使用してそれを行うことができます- 

class employee(object):
   def __init__(self):
      self. Age = “Employee Age is ##”
   def EmployeID(self):
      print (“This is just employee unique identity”)

注意-クラスは、モジュールよりも優先されます。クラスをそのまま再利用できるため、多くの干渉がありません。 モジュールでは、プログラム全体で1つしかありません。

オブジェクトはミニインポートのようなものです

クラスは*ミニモジュール*のようなものであり、 instantiate という概念を使用して、クラスの場合と同様の方法でインポートできます。 クラスをインスタンス化すると、*オブジェクト*を取得することに注意してください。

あなたが示すように、関数のようなクラスを呼び出すことに似て、オブジェクトをインスタンス化することができます- 

this_obj = employee() # Instantiatethis_obj.EmployeID() # get EmployeId from the class
print(this_obj.Age) # get variable Age

次の3つの方法のいずれかでこれを行うことができます- 

# dictionary style
Employee[‘EmployeID’]
# module style
Employee.EmployeID()
Print(employee.Age)
# Class style
this_obj = employee()
this_obj.employeID()
Print(this_obj.Age)

オブジェクト指向Python-環境設定

この章では、ローカルコンピューターでのPython環境のセットアップについて詳しく説明します。

前提条件とツールキット

Pythonでさらに学習を進める前に、次の前提条件が満たされているかどうかを確認することをお勧めします-

  • Pythonの最新バージョンがコンピューターにインストールされています
  • IDEまたはテキストエディターがインストールされている
  • Pythonで記述およびデバッグするための基本的な知識があります。つまり、 Pythonで次の-
  • Pythonプログラムを作成および実行できます。
  • プログラムをデバッグし、エラーを診断します。
  • 基本的なデータ型を操作します。
  • for ループ、 while ループ、 if ステートメントを記述する
  • コード*関数*

プログラミング言語の経験がない場合は、Pythonで多くの初心者向けチュートリアルを見つけることができます。

https://www.finddevguides.com [https://www.tutorialpoints.com/]

Pythonをインストールする

次の手順は、ローカルコンピューターにPythonをインストールする方法を詳細に示しています-

ステップ1 *-Pythonの公式Webサイトhttps://www.python.org/にアクセスし、 *Downloads メニューをクリックして、最新バージョンまたは任意の安定バージョンを選択します。

Pythonウェブサイト

  • ステップ2 *-ダウンロードするPythonインストーラーexeファイルを保存し、ダウンロードしたら開きます。 [実行]をクリックして、デフォルトで[次へ]オプションを選択し、インストールを完了します。

Pythonインストーラー

  • ステップ3 *-インストール後、次の画像に示すようにPythonメニューが表示されます。 IDLE（Python GUI）を選択してプログラムを開始します。

IDLE

これにより、Pythonシェルが起動します。 簡単なコマンドを入力して、インストールを確認します。

Python Shell

IDEの選択

統合開発環境は、ソフトウェア開発向けのテキストエディターです。 Pythonで作業する場合、プログラミングのフローを制御し、プロジェクトをグループ化するためにIDEをインストールする必要があります。 以下は、オンラインで入手可能なIDEの一部です。 都合の良いときに選択できます。

  • Pycharm IDE
  • コモドIDE
  • エリックパイソンIDE

注-Eclipse IDEは主にJavaで使用されますが、Pythonプラグインがあります。

ピチャーム

Pycharm

クロスプラットフォームIDEであるPycharmは、現在利用可能な最も人気のあるIDEの1つです。 コード補完、プロジェクトとコードのナビゲーション、統合された単体テスト、バージョン管理の統合、デバッグなどのコーディング支援と分析を提供します

ダウンロードリンク

https://www.jetbrains.com/pycharm/download/#section=windows

サポートされる言語-Python、HTML、CSS、JavaScript、Coffee Script、TypeScript、Cython、AngularJS、Node.js、テンプレート言語。

スクリーンショット

スクリーンショット

選ぶ理由

PyCharmはユーザーに次の機能と利点を提供します-

  • Windows、Linux、Mac OSと互換性のあるクロスプラットフォームIDE
  • Django IDEに加えて、CSSおよびJavaScriptのサポートが含まれています
  • 数千のプラグイン、統合されたターミナル、バージョン管理を含む
  • Git、SVN、Mercurialと統合
  • Python用のインテリジェントな編集ツールを提供します
  • Virtualenv、Docker、Vagrantとの簡単な統合
  • シンプルなナビゲーションおよび検索機能
  • コード分​​析とリファクタリング
  • 設定可能な注入
  • 多数のPythonライブラリをサポート
  • テンプレートとJavaScriptデバッガーが含まれています
  • Python/Djangoデバッガーが含まれています
  • Google App Engine、追加のフレームワークおよびライブラリで動作します。
  • カスタマイズ可能なUI、VIMエミュレーションが利用可能

コモドIDE

Komode

これは、100以上の言語をサポートし、基本的にPython、PHP、Rubyなどの動的言語用の多言語IDEです。 これは、完全な機能を備えた21日間の無料トライアルで利用可能な商用IDEです。 ActiveStateは、Komodo IDEの開発を管理するソフトウェア会社です。 また、シンプルなプログラミングタスク用に、Komodo Editとして知られるKomodoのトリミングバージョンも提供しています。

このIDEには、最も基本的なレベルから高度なレベルまでのすべての種類の機能が含まれています。 学生またはフリーランサーの場合、実際の価格のほぼ半分で購入できます。 ただし、公認の機関や大学の教師や教授は完全に無料です。

すべての言語とフレームワークのサポートを含む、Webおよびモバイル開発に必要なすべての機能を備えています。

ダウンロードリンク

Komodo Edit（無料版）とKomodo IDE（有料版）のダウンロードリンクはここにあります-

コモド編集（無料）

https://www.activestate.com/komodo-edit

  • Komodo IDE（有料）*

https://www.activestate.com/komodo-ide/downloads/ide

スクリーンショット

Komodo IDE

選ぶ理由

  • Perl、PHP、Python、Rubyなどをサポートする強力なIDE。
  • クロスプラットフォームIDE。

統合デバッガーサポート、オートコンプリート、ドキュメントオブジェクトモデル（DOM）ビューアー、コードブラウザー、インタラクティブシェル、ブレークポイント構成、コードプロファイリング、統合ユニットテストなどの基本機能が含まれています。 一言で言えば、それは生産性向上機能を備えたプロフェッショナルなIDEです。

エリックパイソンIDE

eric

PythonおよびRuby用のオープンソースIDEです。 Ericは、Pythonで書かれたフル機能のエディターおよびIDEです。 クロスプラットフォームQt GUIツールキットに基づいており、柔軟性の高いScintillaエディターコントロールを統合しています。 IDEは非常に構成可能であり、使用するものと使用しないものを選択できます。 以下のリンクからEric IDEをダウンロードできます。

https://eric-ide.python-projects.org/eric-downloadl

選ぶ理由

  • 大きなインデント、エラーの強調表示。
  • コード支援
  • コード補完
  • PyLintを使用したコードのクリーンアップ
  • クイック検索
  • 統合されたPythonデバッガー。

スクリーンショット

選択の理由

テキストエディターの選択

必ずしもIDEが必要とは限りません。 PythonやArduinoを使用したコーディングの学習などのタスク、またはいくつかのタスクの自動化に役立つシェルスクリプトのクイックスクリプトで作業する場合、シンプルで軽量なコード中心のテキストエディターが実行します。 また、多くのテキストエディタは、IDEと同様に、構文の強調表示やプログラム内のスクリプト実行などの機能を提供します。 テキストエディタのいくつかはここに与えられています-

  • Atom
  • 崇高なテキスト
  • メモ帳

Atom Text Editor

Atom

Atomは、GitHubのチームによって作成されたハッキン​​グ可能なテキストエディターです。 これは無料でオープンソースのテキストおよびコードエディターであるため、すべてのコードを読んだり、自分の用途に合わせて変更したり、改善に貢献することもできます。 これは、macOS、Linux、およびMicrosoft Windowsと互換性のあるクロスプラットフォームテキストエディターであり、Node.jsで記述されたプラグインと埋め込みGitコントロールをサポートしています。

ダウンロードリンク

https://atom.io/

スクリーンショット

ダウンロードリンク

サポートされる言語

C/C ++、C＃、CSS、CoffeeScript、HTML、JavaScript、Java、JSON、Julia、Objective-C、PHP、Perl、Python、Ruby on Rails、Ruby、シェルスクリプト、Scala、SQL、XML、YAMLなど

崇高なテキストエディター

Sublime

崇高なテキストはプロプライエタリなソフトウェアであり、購入前にテストするための無料の試用版を提供します。 stackoverflow.comによると、4番目に人気のある開発環境です。

それが提供する利点のいくつかは、その信じられないほどの速度、使いやすさ、コミュニティのサポートです。 また、多くのプログラミング言語とマークアップ言語をサポートしており、ユーザーがプラグインを使用して機能を追加できます。プラグインは、通常、コミュニティが構築し、フリーソフトウェアライセンスで管理します。

スクリーンショット

フリーソフトウェアライセンス

サポートされる言語

  • Python、Ruby、JavaScriptなど

選ぶ理由

  • キーバインディング、メニュー、スニペット、マクロ、補完などをカスタマイズします。
  • 自動補完機能
  • スニペット、フィールドを使用して、崇高なテキストスニペットでテキストとコードをすばやく挿入 マーカーとプレースホルダー
  • すばやく開く
  • Mac、Linux、およびWindowsのクロスプラットフォームサポート。
  • カーソルを目的の場所にジャンプします
  • 複数の行、単語、列を選択する

メモ帳

メモ帳

これは、AssemblyからXMLまで、Pythonを含む複数の言語をサポートする無料のソースコードエディターおよびメモ帳の代替品です。 MS Windows環境で実行する場合、その使用はGPLライセンスによって管理されます。 構文の強調表示に加えて、Notepad ++にはコーダーに特に役立ついくつかの機能があります。

スクリーンショット

Notepad Plus Plus

主な機能

  • 構文の強調表示と構文の折りたたみ
  • PCRE（Perl互換の正規表現）検索/置換
  • 完全にカスタマイズ可能なGUI
  • S自動補完
  • タブ編集
  • マルチビュー
  • 多言語環境
  • 異なる引数で起動可能

サポートされる言語

  • Python、C、C ++、C＃、Javaなど、ほぼすべての言語（60以上の言語）

オブジェクト指向Python-データ構造

Pythonデータ構造は、構文の観点から非常に直感的であり、多くの操作を選択できます。 Pythonのデータ構造は、データの内容、変更が必要な場合、または固定データであるか、開始/終了/ランダムなどのアクセスタイプが必要かによって選択する必要があります。

リスト

リストは、Pythonで最も用途の広いタイプのデータ構造を表します。 リストは、角括弧の間にコンマ区切りの値（アイテムまたは要素）を保持するコンテナです。 リストは、複数の関連する値を処理する場合に役立ちます。 リストはデータをまとめて保持するため、複数の値に対して同じメソッドと操作を一度に実行できます。 リストのインデックスはゼロから始まり、文字列とは異なり、リストは可変です。

データ構造-リスト

>>>
>>> # Any Empty List
>>> empty_list = []
>>>
>>> # A list of String
>>> str_list = ['Life', 'Is', 'Beautiful']
>>> # A list of Integers
>>> int_list = [1, 4, 5, 9, 18]
>>>
>>> #Mixed items list
>>> mixed_list = ['This', 9, 'is', 18, 45.9, 'a', 54, 'mixed', 99, 'list']
>>> # To print the list
>>>
>>> print(empty_list)
[]
>>> print(str_list)
['Life', 'Is', 'Beautiful']
>>> print(type(str_list))
<class 'list'>
>>> print(int_list)
[1, 4, 5, 9, 18]
>>> print(mixed_list)
['This', 9, 'is', 18, 45.9, 'a', 54, 'mixed', 99, 'list']

Pythonリストのアイテムへのアクセス

リストの各項目には番号が割り当てられます。つまり、その番号のインデックスまたは位置です。インデックス付けは常にゼロから始まり、2番目のインデックスは1などです。 リスト内のアイテムにアクセスするには、角括弧内のこれらのインデックス番号を使用できます。 例のために次のコードを観察します- 

>>> mixed_list = ['This', 9, 'is', 18, 45.9, 'a', 54, 'mixed', 99, 'list']
>>>
>>> # To access the First Item of the list
>>> mixed_list[0]
'This'
>>> # To access the 4th item
>>> mixed_list[3]
18
>>> # To access the last item of the list
>>> mixed_list[-1]
'list'

空のオブジェクト

空のオブジェクトは、最も単純で最も基本的なPython組み込み型です。 気付かずにそれらを複数回使用し、作成したすべてのクラスに拡張しました。 空のクラスを作成する主な目的は、一時的に何かをブロックし、後で拡張して動作を追加することです。

クラスに動作を追加するということは、データ構造をオブジェクトに置き換え、その参照をすべて変更することを意味します。 そのため、データを作成する前に、それが変装したオブジェクトであるかどうかを確認することが重要です。 理解を深めるために、次のコードを確認してください。 

>>> #Empty objects
>>>
>>> obj = object()
>>> obj.x = 9
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
obj.x = 9
AttributeError: 'object' object has no attribute 'x'

したがって、上から、直接インスタンス化されたオブジェクトに属性を設定することは不可能であることがわかります。 Pythonがオブジェクトに任意の属性を持たせる場合、属性名とその値の両方を保存するために、各オブジェクトが持っている属性を追跡するために一定量のシステムメモリが必要です。 属性が保存されていない場合でも、潜在的な新しい属性に一定量のメモリが割り当てられます。

そのため、Pythonはデフォルトでオブジェクトおよびその他のいくつかのビルトインの任意のプロパティを無効にします。 

>>> # Empty Objects
>>>
>>> class EmpObject:
    pass
>>> obj = EmpObject()
>>> obj.x = 'Hello, World!'
>>> obj.x
'Hello, World!'

したがって、プロパティをグループ化する場合は、上記のコードに示すように、空のオブジェクトにプロパティを保存できます。 ただし、この方法は常に推奨されるわけではありません。 クラスとオブジェクトは、データと動作の両方を指定する場合にのみ使用してください。

タプル

タプルはリストに似ており、要素を保存できます。 ただし、これらは不変であるため、オブジェクトを追加、削除、または置換することはできません。 タプルが不変であるために提供される主な利点は、辞書で、またはオブジェクトがハッシュ値を必要とする他の場所でキーとして使用できることです。

タプルはデータを保存するために使用され、動作ではありません。 タプルを操作する動作が必要な場合は、アクションを実行する関数（または別のオブジェクトのメソッド）にタプルを渡す必要があります。

タプルはディクショナリキーとして機能できるため、格納されている値は互いに異なります。 値をコンマで区切ってタプルを作成できます。 タプルは括弧で囲まれていますが、必須ではありません。 次のコードは、2つの同一の割り当てを示しています。 

>>> stock1 = 'MSFT', 95.00, 97.45, 92.45
>>> stock2 = ('MSFT', 95.00, 97.45, 92.45)
>>> type (stock1)
<class 'tuple'>
>>> type(stock2)
<class 'tuple'>
>>> stock1 == stock2
True
>>>

タプルの定義

タプルはリストと非常に似ていますが、要素のセット全体が角括弧ではなく括弧で囲まれている点が異なります。

リストをスライスするときに新しいリストを取得し、タプルをスライスするときに新しいタプルを取得するように。 

>>> tupl = ('Tuple','is', 'an','IMMUTABLE', 'list')
>>> tupl
('Tuple', 'is', 'an', 'IMMUTABLE', 'list')
>>> tupl[0]
'Tuple'
>>> tupl[-1]
'list'
>>> tupl[1:3]
('is', 'an')

Pythonタプルメソッド

次のコードは、Pythonタプルのメソッドを示しています- 

>>> tupl
('Tuple', 'is', 'an', 'IMMUTABLE', 'list')
>>> tupl.append('new')
Traceback (most recent call last):
   File "<pyshell#148>", line 1, in <module>
      tupl.append('new')
AttributeError: 'tuple' object has no attribute 'append'
>>> tupl.remove('is')
Traceback (most recent call last):
   File "<pyshell#149>", line 1, in <module>
      tupl.remove('is')
AttributeError: 'tuple' object has no attribute 'remove'
>>> tupl.index('list')
4
>>> tupl.index('new')
Traceback (most recent call last):
   File "<pyshell#151>", line 1, in <module>
      tupl.index('new')
ValueError: tuple.index(x): x not in tuple
>>> "is" in tupl
True
>>> tupl.count('is')
1

上記のコードから、タプルは不変であり、したがって-

  • タプルに要素を追加することはできません。
  • メソッドを追加または拡張することはできません。
  • タプルから要素を削除することはできません。
  • タプルには、removeまたはpopメソッドがありません。
  • カウントとインデックスは、タプルで使用できるメソッドです。

辞書

辞書はPythonの組み込みデータ型の1つであり、キーと値の間の1対1の関係を定義します。

辞書の定義

辞書の定義について理解するために、次のコードを観察します- 

>>> # empty dictionary
>>> my_dict = {}
>>>
>>> # dictionary with integer keys
>>> my_dict = { 1:'msft', 2: 'IT'}
>>>
>>> # dictionary with mixed keys
>>> my_dict = {'name': 'Aarav', 1: [ 2, 4, 10]}
>>>
>>> # using built-in function dict()
>>> my_dict = dict({1:'msft', 2:'IT'})
>>>
>>> # From sequence having each item as a pair
>>> my_dict = dict([(1,'msft'), (2,'IT')])
>>>
>>> # Accessing elements of a dictionary
>>> my_dict[1]
'msft'
>>> my_dict[2]
'IT'
>>> my_dict['IT']
Traceback (most recent call last):
   File "<pyshell#177>", line 1, in <module>
   my_dict['IT']
KeyError: 'IT'
>>>

上記のコードから、次のことがわかります。

  • まず、2つの要素を持つ辞書を作成し、変数に割り当てます my_dict 。 各要素はキーと値のペアであり、要素のセット全体が中括弧で囲まれています。
  • 番号 1 はキーで、 msft はその値です。 同様に、 2 がキーで、 IT はそのキーです 値。
  • キーで値を取得できますが、その逆はできません。 したがって、 my_dict [‘IT’] を試してみると、 IT はキーではないため、例外が発生します。

辞書の変更

辞書の変更について理解するために、次のコードを観察します- 

>>> # Modifying a Dictionary
>>>
>>> my_dict
{1: 'msft', 2: 'IT'}
>>> my_dict[2] = 'Software'
>>> my_dict
{1: 'msft', 2: 'Software'}
>>>
>>> my_dict[3] = 'Microsoft Technologies'
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies'}

上記のコードから、次のことがわかります-

  • 辞書に重複したキーを含めることはできません。 既存のキーの値を変更すると、古い値が削除されます。
  • 新しいキーと値のペアはいつでも追加できます。
  • 辞書には、要素間の順序の概念はありません。 それらは単純な順序付けられていないコレクションです。

辞書でのデータ型の混合

辞書内のデータ型の混合について理解するために、次のコードを観察します- 

>>> # Mixing Data Types in a Dictionary
>>>
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies'}
>>> my_dict[4] = 'Operating System'
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System'}
>>> my_dict['Bill Gates'] = 'Owner'
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System',
'Bill Gates': 'Owner'}

上記のコードから、次のことがわかります-

  • 文字列だけでなく、ディクショナリ値は、ディクショナリ自体を含む文字列、整数を含む任意のデータ型にすることができます。
  • ディクショナリ値とは異なり、ディクショナリキーはより制限されていますが、文字列、整数などの任意のタイプにすることができます。

辞書からアイテムを削除する

辞書からアイテムを削除することを理解するために、次のコードを観察します- 

>>> # Deleting Items from a Dictionary
>>>
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System',
'Bill Gates': 'Owner'}
>>>
>>> del my_dict['Bill Gates']
>>> my_dict
{1: 'msft', 2: 'Software', 3: 'Microsoft Technologies', 4: 'Operating System'}
>>>
>>> my_dict.clear()
>>> my_dict
{}

上記のコードから、次のことがわかります-

  • del -キーから辞書から個々のアイテムを削除できます。
  • clear -辞書からすべてのアイテムを削除します。

Sets

Set（）は、要素が重複していない順序付けられていないコレクションです。 個々のアイテムは不変ですが、セット自体は可変です。つまり、セットに要素/アイテムを追加または削除できます。 ユニオン、インターセクションなどの数学演算を実行できます。 セットで。

一般にセットはツリーを使用して実装できますが、Pythonのセットはハッシュテーブルを使用して実装できます。 これにより、特定の要素がセットに含まれているかどうかを確認するための高度に最適化された方法が可能になります

セットを作成する

セットを作成するには、すべてのアイテム（要素）を中括弧 \ {} 内に配置し、コンマで区切るか、組み込み関数* set（）*を使用します。 次のコード行を確認してください- 

>>> #set of integers
>>> my_set = {1,2,4,8}
>>> print(my_set)
{8, 1, 2, 4}
>>>
>>> #set of mixed datatypes
>>> my_set = {1.0, "Hello World!", (2, 4, 6)}
>>> print(my_set)
{1.0, (2, 4, 6), 'Hello World!'}
>>>

セットのメソッド

セットのメソッドについて理解するために、次のコードを観察します- 

>>> >>> #METHODS FOR SETS
>>>
>>> #add(x) Method
>>> topics = {'Python', 'Java', 'C#'}
>>> topics.add('C++')
>>> topics
{'C#', 'C++', 'Java', 'Python'}
>>>
>>> #union(s) Method, returns a union of two set.
>>> topics
{'C#', 'C++', 'Java', 'Python'}
>>> team = {'Developer', 'Content Writer', 'Editor','Tester'}
>>> group = topics.union(team)
>>> group
{'Tester', 'C#', 'Python', 'Editor', 'Developer', 'C++', 'Java', 'Content
Writer'}
>>> # intersets(s) method, returns an intersection of two sets
>>> inters = topics.intersection(team)
>>> inters
set()
>>>
>>> # difference(s) Method, returns a set containing all the elements of
invoking set but not of the second set.
>>>
>>> safe = topics.difference(team)
>>> safe
{'Python', 'C++', 'Java', 'C#'}
>>>
>>> diff = topics.difference(group)
>>> diff
set()
>>> #clear() Method, Empties the whole set.
>>> group.clear()
>>> group
set()
>>>

セットの演算子

セットの演算子について理解するために、次のコードを観察します- 

>>> # PYTHON SET OPERATIONS
>>>
>>> #Creating two sets
>>> set1 = set()
>>> set2 = set()
>>>
>>> # Adding elements to set
>>> for i in range(1,5):
   set1.add(i)
>>> for j in range(4,9):
   set2.add(j)
>>> set1
{1, 2, 3, 4}
>>> set2
{4, 5, 6, 7, 8}
>>>
>>> #Union of set1 and set2
>>> set3 = set1 | set2 # same as set1.union(set2)
>>> print('Union of set1 & set2: set3 = ', set3)
Union of set1 & set2: set3 = {1, 2, 3, 4, 5, 6, 7, 8}
>>>
>>> #Intersection of set1 & set2
>>> set4 = set1 & set2 # same as set1.intersection(set2)
>>> print('Intersection of set1 and set2: set4 = ', set4)
Intersection of set1 and set2: set4 = {4}
>>>
>>> # Checking relation between set3 and set4
>>> if set3 > set4: # set3.issuperset(set4)
   print('Set3 is superset of set4')
elif set3 < set4: #set3.issubset(set4)
   print('Set3 is subset of set4')
else: #set3 == set4
   print('Set 3 is same as set4')
Set3 is superset of set4
>>>
>>> # Difference between set3 and set4
>>> set5 = set3 - set4
>>> print('Elements in set3 and not in set4: set5 = ', set5)
Elements in set3 and not in set4: set5 = {1, 2, 3, 5, 6, 7, 8}
>>>
>>> # Check if set4 and set5 are disjoint sets
>>> if set4.isdisjoint(set5):
   print('Set4 and set5 have nothing in common\n')
Set4 and set5 have nothing in common
>>> # Removing all the values of set5
>>> set5.clear()
>>> set5 set()

オブジェクト指向Python-ビルディングブロック

この章では、オブジェクト指向の用語とプログラミングの概念について詳しく説明します。クラスはインスタンスの単なるファクトリです。 このファクトリには、インスタンスの作成方法を説明する設計図が含まれています。 インスタンスまたはオブジェクトは、クラスから構築されます。 ほとんどの場合、1つのクラスのインスタンスを複数持つことができます。 すべてのインスタンスには属性のセットがあり、これらの属性はクラスで定義されるため、特定のクラスのすべてのインスタンスは同じ属性を持つことが期待されます。

クラスバンドル：動作と状態

クラスを使用すると、オブジェクトの動作と状態をまとめることができます。 より良い理解のために次の図を観察してください-

バンドル

クラスバンドルを議論するとき、次の点は注目に値する-

  • *動作*という言葉は*機能*と同じです–それは何かをする（または動作を実装する）コードの一部です
  • state という単語は variables と同じです。クラス内の値を保存する場所です。
  • クラスの動作と状態を一緒にアサートすると、クラスが関数と変数をパッケージ化することを意味します。

クラスにはメソッドと属性があります

Pythonでは、メソッドを作成するとクラスの動作が定義されます。 メソッドという語は、クラス内で定義される関数に与えられるOOP名です。 まとめると-

  • クラス関数-メソッドの同義語です
  • クラス変数-名前属性の同義語です
  • クラス-正確な動作を持つインスタンスの青写真。
  • Object -クラスのインスタンスの1つで、クラスで定義された機能を実行します。
  • タイプ-インスタンスが属するクラスを示します
  • 属性-任意のオブジェクト値：object.attribute
  • メソッド-クラスで定義された「呼び出し可能な属性」

たとえば、次のコードの一部を観察します- 

var = “Hello, John”
print( type (var)) # ‘str’> or <class 'str'>
print(var.upper()) # upper() method is called, HELLO, JOHN

作成とインスタンス化

次のコードは、最初のクラスを作成してからそのインスタンスを作成する方法を示しています。 

class MyClass(object):
   pass
# Create first instance of MyClass
this_obj = MyClass()
print(this_obj)
# Another instance of MyClass
that_obj = MyClass()
print (that_obj)

ここでは、 MyClass というクラスを作成しましたが、これはタスクを実行しません。 MyClass クラスの引数 object にはクラスの継承が含まれ、後の章で説明します。 上記のコードの pass は、このブロックが空、つまり空のクラス定義であることを示しています。

  • MyClass（）クラスのインスタンス *this_obj を作成し、次のように出力します。
<__main__.MyClass object at 0x03B08E10>
<__main__.MyClass object at 0x0369D390>

ここでは、* MyClass。*のインスタンスを作成しました。16進コードは、オブジェクトが保存されているアドレスを参照します。 別のインスタンスが別のアドレスを指している。

ここで、クラス* MyClass（）*内に1つの変数を定義し、次のコードに示すように、そのクラスのインスタンスから変数を取得しましょう- 

class MyClass(object):
   var = 9

# Create first instance of MyClass
this_obj = MyClass()
print(this_obj.var)

# Another instance of MyClass

that_obj = MyClass()
print (that_obj.var)

出力

上記のコードを実行すると、次の出力を確認できます- 

9
9

インスタンスはインスタンス化されるクラスを知っているため、インスタンスの属性を要求すると、インスタンスは属性とクラスを探します。 これは*属性ルックアップ*と呼ばれます。

インスタンスメソッド

クラスで定義された関数は method と呼ばれます。インスタンスメソッドは、呼び出すためにインスタンスを必要とし、デコレータを必要としません。 インスタンスメソッドを作成する場合、最初のパラメーターは常に* self。*です。他の名前で（self）を呼び出すこともできますが、命名規則なのでselfを使用することをお勧めします。 

class MyClass(object):
   var = 9
   def firstM(self):
      print("hello, World")
obj = MyClass()
print(obj.var)
obj.firstM()

出力

上記のコードを実行すると、次の出力を確認できます- 

9
hello, World

上記のプログラムでは、引数としてselfを使用してメソッドを定義していることに注意してください。 ただし、メソッドに引数を宣言していないため、メソッドを呼び出すことはできません。 

class MyClass(object):
   def firstM(self):
      print("hello, World")
      print(self)
obj = MyClass()
obj.firstM()
print(obj)

出力

上記のコードを実行すると、次の出力を確認できます- 

hello, World
<__main__.MyClass object at 0x036A8E10>
<__main__.MyClass object at 0x036A8E10>

カプセル化

カプセル化は、OOPの基本の1つです。 OOPを使用すると、オブジェクトの内部作業の複雑さを隠すことができます。これは、次の方法で開発者に有利です-

  • 内部を知らなくてもオブジェクトを使用することを単純化し、理解しやすくします。
  • 変更は簡単に管理できます。

オブジェクト指向プログラミングは、カプセル化に大きく依存しています。 カプセル化と抽象化（データ隠蔽とも呼ばれます）という用語は、同義語としてよく使用されます。 カプセル化によって抽象化が実現されるため、これらはほぼ同義語です。

カプセル化は、オブジェクトの一部のコンポーネントへのアクセスを制限するメカニズムを提供します。これは、オブジェクトの内部表現がオブジェクト定義の外部から見えないことを意味します。 このデータへのアクセスは通常、 Getters および Setters という特別な方法で実現されます。

このデータはインスタンス属性に保存され、クラス外のどこからでも操作できます。 セキュリティで保護するには、インスタンスメソッドを使用してのみそのデータにアクセスする必要があります。 直接アクセスを許可しないでください。 

class MyClass(object):
   def setAge(self, num):
      self.age = num

   def getAge(self):
      return self.age

zack = MyClass()
zack.setAge(45)
print(zack.getAge())

zack.setAge("Fourty Five")
print(zack.getAge())

出力

上記のコードを実行すると、次の出力を確認できます- 

45
Fourty Five

データは、例外処理構造を使用して、正しく有効な場合にのみ保存する必要があります。 上記のように、setAge（）メソッドへのユーザー入力に制限はありません。 文字列、数字、リストのいずれかです。 そのため、上記のコードをチェックして、保存されていることを確認する必要があります。 

class MyClass(object):
   def setAge(self, num):
      self.age = num

   def getAge(self):
      return self.age
zack = MyClass()
zack.setAge(45)
print(zack.getAge())
zack.setAge("Fourty Five")
print(zack.getAge())

Initコンストラクター

initメソッドは、クラスのオブジェクトがインスタンス化されるとすぐに暗黙的に呼び出されます。これにより、オブジェクトが初期化されます。 

x = MyClass()

上記のコード行は、新しいインスタンスを作成し、このオブジェクトをローカル変数xに割り当てます。

インスタンス化操作、つまり*クラスオブジェクトの呼び出し*は、空のオブジェクトを作成します。 多くのクラスは、特定の初期状態にカスタマイズされたインスタンスを持つオブジェクトを作成するのが好きです。 したがって、クラスは、示されているように「init（）」という名前の特別なメソッドを定義できます- 

def __init__(self):
   self.data = []

Pythonは、インスタンス化中にinitを呼び出して、クラスのインスタンス化時に発生する追加属性を定義します。この属性は、オブジェクトの開始値を設定したり、インスタンス化に必要なルーチンを実行したりします。 したがって、この例では、新しい初期化されたインスタンスを取得することができます- 

x = MyClass()

init（）メソッドは、柔軟性を高めるために単一または複数の引数を持つことができます。 initは、インスタンスの属性を初期化するため、初期化の略です。 クラスのコンストラクターと呼ばれます。 

class myclass(object):
   def __init__(self,aaa, bbb):
      self.a = aaa
      self.b = bbb

x = myclass(4.5, 3)
print(x.a, x.b)

出力

4.5 3

クラス属性

クラスで定義された属性は「クラス属性」と呼ばれ、関数で定義された属性は「インスタンス属性」と呼ばれます。 これらの属性はクラスのプロパティであり、特定のインスタンスのプロパティではないため、定義中、これらの属性にはselfのプレフィックスが付きません。

クラスの属性（className.attributeName）およびクラスのインスタンス（inst.attributeName）からクラス属性にアクセスできます。 そのため、インスタンスは、インスタンス属性とクラス属性の両方にアクセスできます。 

>>> class myclass():
   age = 21
>>> myclass.age
21
>>> x = myclass()
>>> x.age
21
>>>

クラス属性は、カプセル化を解除するのに適したメソッドではありませんが、インスタンス内でオーバーライドできます。

Pythonには属性のルックアップパスがあります。 最初はクラス内で定義されたメソッドであり、次にその上のクラスです。 

>>> class myclass(object):
   classy = 'class value'
>>> dd = myclass()
>>> print (dd.classy) # This should return the string 'class value'
class value
>>>
>>> dd.classy = "Instance Value"
>>> print(dd.classy) # Return the string "Instance Value"
Instance Value
>>>
>>> # This will delete the value set for 'dd.classy' in the instance.
>>> del dd.classy
>>> >>> # Since the overriding attribute was deleted, this will print 'class
value'.

>>> print(dd.classy)
class value
>>>

インスタンスddの「classy」クラス属性をオーバーライドしています。 オーバーライドされると、Pythonインタープリターはオーバーライドされた値を読み取ります。 しかし、新しい値が「del」で削除されると、オーバーライドされた値はインスタンスに存在しなくなるため、ルックアップは上記のレベルを超えてクラスから取得します。

クラスおよびインスタンスデータの操作

このセクションでは、クラスデータがインスタンスデータにどのように関連するかを理解しましょう。 クラスまたはインスタンスにデータを保存できます。 クラスを設計するとき、どのデータがインスタンスに属し、どのデータをクラス全体に格納するかを決定します。

インスタンスはクラスデータにアクセスできます。 複数のインスタンスを作成した場合、これらのインスタンスは個々の属性値とクラスデータ全体にアクセスできます。

したがって、クラスデータは、すべてのインスタンス間で共有されるデータです。 より良いアンダーサンディングのために以下のコードを観察してください- 

class InstanceCounter(object):
   count = 0 # class attribute, will be accessible to all instances
   def __init__(self, val):
      self.val = val
      InstanceCounter.count +=1 # Increment the value of class attribute, accessible through class name
# In above line, class ('InstanceCounter') act as an object
   def set_val(self, newval):
      self.val = newval

   def get_val(self):
      return self.val

   def get_count(self):
      return InstanceCounter.count
a = InstanceCounter(9)
b = InstanceCounter(18)
c = InstanceCounter(27)

for obj in (a, b, c):
   print ('val of obj: %s' %(obj.get_val())) # Initialized value ( 9, 18, 27)
   print ('count: %s' %(obj.get_count())) # always 3

出力

val of obj: 9
count: 3
val of obj: 18
count: 3
val of obj: 27
count: 3

つまり、クラス属性はクラスのすべてのインスタンスで同じですが、インスタンス属性は各インスタンスに固有です。 2つの異なるインスタンスに対して、2つの異なるインスタンス属性があります。 

class myClass:
   class_attribute = 99

   def class_method(self):
      self.instance_attribute = 'I am instance attribute'

print (myClass.__dict__)

出力

上記のコードを実行すると、次の出力を確認できます- 

{'__module__': '__main__', 'class_attribute': 99, 'class_method': , '__dict__': , '__weakref__': , '__doc__': None}

インスタンス属性 myClass .dict のように- 

>>> a = myClass()
>>> a.class_method()
>>> print(a.__dict__)
{'instance_attribute': 'I am instance attribute'}

オブジェクト指向のショートカット

この章では、Pythonのさまざまな組み込み関数、ファイルI/O操作、オーバーロードの概念について詳しく説明します。

Python組み込み関数

Pythonインタープリターには、すぐに使用できる組み込み関数と呼ばれる多くの関数があります。 その最新バージョンでは、Pythonには以下の表にリストされている68個の組み込み関数が含まれています-

組み込み関数

abs（）

dict（）

助けて（）

min（）

setattr（）

すべて（）

dir（）

hex（）

次（）

スライス（）

どれか（）

divmod（）

id()

object（）

ソート済み（）

ascii（）

enumerate（）

入力（）

oct（）

staticmethod（）

bin（）

eval（）

int（）

開いた（）

str（）

bool（）

exec（）

isinstance（）

ord（）

和（）

bytearray（）

フィルタ（）

issubclass（）

捕虜（）

スーパー（）

bytes（）

浮く（）

iter（）

print（）

tuple（）

callable（）

フォーマット（）

len（）

property（）

タイプ（）

chr（）

frozenset（）

リスト（）

範囲（）

vars（）

classmethod（）

getattr（）

locals（）

repr（）

zip（）

コンパイル（）

globals（）

地図（）

reverse（）

インポート（）

complex（）

hasattr（）

max（）

円形（）

delattr（）

ハッシュ（）

memoryview（）

セット（）

このセクションでは、いくつかの重要な機能について簡単に説明します-

len（）関数

len（）関数は、文字列、リスト、またはコレクションの長さを取得します。 オブジェクトのアイテムの長さまたは数を返します。オブジェクトには文字列、リスト、またはコレクションを指定できます。 

>>> len(['hello', 9 , 45.0, 24])
4

len（）関数は、* list .len（）または tuple .len（）*のように内部的に機能します。 したがって、len（）は* len（）*メソッドを持つオブジェクトでのみ機能することに注意してください。 

>>> set1
{1, 2, 3, 4}
>>> set1.__len__()
4

ただし、実際には、次の理由により、* len（）関数の代わりに len（）*を好みます-

  • もっと効率的です。 また、lenなどの特別なメソッドへのアクセスを拒否するために特定のメソッドを記述する必要はありません。
  • 保守が簡単です。
  • 下位互換性をサポートします。

逆転（seq）

逆反復子を返します。 seqは、reversed（）メソッドを持つか、シーケンスプロトコル（len（）メソッドとgetitem（）メソッド）をサポートするオブジェクトでなければなりません。 通常、アイテムを後ろから前にループする場合の for ループで使用されます。 

>>> normal_list = [2, 4, 5, 7, 9]
>>>
>>> class CustomSequence():
   def __len__(self):
      return 5
   def __getitem__(self,index):
      return "x{0}".format(index)
>>> class funkyback():
   def __reversed__(self):
      return 'backwards!'
>>> for seq in normal_list, CustomSequence(), funkyback():
      print('\n{}: '.format(seq.__class__.__name__), end="")
      for item in reversed(seq):
         print(item, end=", ")

最後のforループは、通常のリストの逆のリストと、2つのカスタムシーケンスのインスタンスを出力します。 出力は、これら3つすべてで* reversed（）が機能することを示していますが、 *reversed を定義すると、結果が大きく異なります。

出力

上記のコードを実行すると、次の出力を確認できます- 

list: 9, 7, 5, 4, 2,
CustomSequence: x4, x3, x2, x1, x0,
funkyback: b, a, c, k, w, a, r, d, s, !,

列挙する

  • enumerate（）*メソッドは、反復可能オブジェクトにカウンターを追加し、列挙オブジェクトを返します。

enumerate（）の構文は- 

enumerate(iterable, start = 0)

ここで、2番目の引数 start はオプションであり、デフォルトではインデックスはゼロ（0）で始まります。 

>>> # Enumerate
>>> names = ['Rajesh', 'Rahul', 'Aarav', 'Sahil', 'Trevor']
>>> enumerate(names)
<enumerate object at 0x031D9F80>
>>> list(enumerate(names))
[(0, 'Rajesh'), (1, 'Rahul'), (2, 'Aarav'), (3, 'Sahil'), (4, 'Trevor')]
>>>

したがって、* enumerate（）*は、渡されたシーケンス内の要素のカウントを保持するタプルを生成する反復子を返します。 戻り値はイテレータなので、直接アクセスすることはあまり役に立ちません。 enumerate（）のより良いアプローチは、forループ内でカウントを維持することです。 

>>> for i, n in enumerate(names):
   print('Names number: ' + str(i))
   print(n)
Names number: 0
Rajesh
Names number: 1
Rahul
Names number: 2
Aarav
Names number: 3
Sahil
Names number: 4
Trevor

標準ライブラリには他の多くの関数があり、ここにいくつかのより広く使用される関数の別のリストがあります-

  • hasattr、getattr、setattr 、および delattr 。オブジェクトの属性を文字列名で操作できます。
  • all および* any、反復可能なオブジェクトを受け入れ、すべてまたは一部のアイテムがtrueと評価された場合に *True を返します。
  • * nzip、*は、2つ以上のシーケンスを取り、タプルの新しいシーケンスを返します。各タプルには、各シーケンスからの単一の値が含まれます。

ファイル入出力

ファイルの概念は、オブジェクト指向プログラミングという用語に関連付けられています。 Pythonは、オペレーティングシステムが抽象的に提供するインターフェイスをラップして、ファイルオブジェクトを操作できるようにしました。

  • open（）*組み込み関数は、ファイルを開いてファイルオブジェクトを返すために使用されます。 それは2つの引数を持つ最も一般的に使用される関数です-
open(filename, mode)

open（）関数は2つの引数を呼び出します。1つ目はファイル名で、2つ目はモードです。 ここで、モードは読み取り専用モードの場合は 'r'、書き込み専用の場合は 'w'（同じ名前の既存のファイルは消去されます）、および 'a’は追加のためにファイルを開き、ファイルに書き込まれたデータは自動的に追加されます最後まで。 「r +」は、読み取りと書き込みの両方のためにファイルを開きます。 デフォルトのモードは読み取り専用です。

Windowsでは、モードに「b」を追加すると、ファイルがバイナリモードで開かれるため、「rb」、「wb」、「r + b」などのモードもあります。 

>>> text = 'This is the first line'
>>> file = open('datawork','w')
>>> file.write(text)
22
>>> file.close()

場合によっては、既存のファイルを完全に上書きするのではなく、ファイルの最後に追加するために、値 'a’をモード引数として指定できるため、既存のファイルを上書きするのではなく、単に追加したいだけです。内容。 

>>> f = open('datawork','a')
>>> text1 = ' This is second line'
>>> f.write(text1)
20
>>> f.close()

ファイルを読み取り用に開いたら、read、readline、またはreadlinesメソッドを呼び出してファイルの内容を取得できます。 readメソッドは、2番目の引数が「b」であるかどうかに応じて、ファイルのコンテンツ全体をstrまたはbytesオブジェクトとして返します。

読みやすくするため、また一度に大きなファイルを読み取らないようにするために、ファイルオブジェクトで直接forループを使用することをお勧めします。 テキストファイルの場合、各行を一度に1つずつ読み取り、ループ本文内で処理できます。 ただし、バイナリファイルの場合は、read（）メソッドを使用して固定サイズのデータ​​チャンクを読み取り、読み取る最大バイト数のパラメーターを渡すことをお勧めします。 

>>> f = open('fileone','r+')
>>> f.readline()
'This is the first line. \n'
>>> f.readline()
'This is the second line. \n'

ファイルオブジェクトのwriteメソッドを使用してファイルに書き込むと、文字列（バイナリデータのバイト）オブジェクトがファイルに書き込まれます。 writelinesメソッドは一連の文字列を受け入れ、各反復値をファイルに書き込みます。 writelinesメソッドは、シーケンス内の各アイテムの後に新しい行を追加しません。

最後に、ファイルの読み取りまたは書き込みが終了したときにclose（）メソッドを呼び出して、バッファリングされた書き込みがディスクに書き込まれ、ファイルが適切にクリーンアップされ、ファイルに関連付けられたすべてのリソースが解放されるようにしますオペレーティングシステム。 close（）メソッドを呼び出す方が適切ですが、技術的には、スクリプトが存在するときに自動的に行われます。

メソッドのオーバーロードの代替

メソッドのオーバーロードとは、異なる引数セットを受け入れる同じ名前の複数のメソッドを持つことを指します。

単一のメソッドまたは関数を指定すると、パラメーターの数を自分で指定できます。 関数の定義に応じて、0、1、2、またはそれ以上のパラメーターで呼び出すことができます。 

class Human:
   def sayHello(self, name = None):
      if name is not None:
         print('Hello ' + name)
      else:
         print('Hello ')

#Create Instance
obj = Human()

#Call the method, else part will be executed
obj.sayHello()

#Call the method with a parameter, if part will be executed
obj.sayHello('Rahul')

出力

Hello
Hello Rahul

デフォルトの引数

関数もオブジェクトです

呼び出し可能オブジェクトとは、オブジェクトがいくつかの引数を受け入れることができ、場合によってはオブジェクトを返すことです。 関数はPythonで最も単純な呼び出し可能なオブジェクトですが、クラスや特定のクラスインスタンスのようなものもあります。

Pythonのすべての関数はオブジェクトです。 オブジェクトにはメソッドまたは関数を含めることができますが、オブジェクトは関数である必要はありません。 

def my_func():
   print('My function was called')
my_func.description = 'A silly function'
def second_func():

   print('Second function was called')

   second_func.description = 'One more sillier function'

def another_func(func):
   print("The description:", end=" ")
   print(func.description)
   print('The name: ', end=' ')
   print(func.__name__)
   print('The class:', end=' ')
   print(func.__class__)
   print("Now I'll call the function passed in")
   func()

another_func(my_func)
another_func(second_func)

上記のコードでは、2つの異なる関数を3番目の関数に引数として渡し、それぞれに対して異なる出力を取得できます- 

The description: A silly function
The name: my_func
The class:
Now I'll call the function passed in
My function was called
The description: One more sillier function
The name: second_func
The class:
Now I'll call the function passed in
Second function was called

呼び出し可能オブジェクト

関数が属性を設定できるオブジェクトであるように、関数であるかのように呼び出すことができるオブジェクトを作成することができます。

Pythonでは、call（）メソッドを持つオブジェクトは、関数呼び出し構文を使用して呼び出すことができます。

継承とポリモーフィズム

継承とポリモーフィズム-これはPythonで非常に重要な概念です。 あなたが学びたいなら、あなたはそれをよりよく理解しなければなりません。

継承

オブジェクト指向プログラミングの主な利点の1つは再利用です。 継承は、同じことを達成するメカニズムの1つです。 継承により、プログラマーは最初に一般クラスまたは基本クラスを作成し、後でそれをより専門的なクラスに拡張できます。 プログラマーはより良いコードを書くことができます。

継承を使用すると、基本クラスで使用可能なすべてのデータフィールドとメソッドを使用または継承できます。 後で独自のメソッドとデータフィールドを追加できるため、継承はコードを最初から書き直すのではなく、コードを整理する方法を提供します。

クラスXがクラスYを拡張するオブジェクト指向の用語では、Yはスーパー/親/ベースクラスと呼ばれ、Xはサブクラス/子/派生クラスと呼ばれます。 ここで注意すべき点は、プライベートではないデータフィールドとメソッドのみが子クラスからアクセスできることです。 プライベートデータフィールドとメソッドは、クラス内でのみアクセス可能です。

派生クラスを作成する構文は- 

class BaseClass:
   Body of base class
class DerivedClass(BaseClass):
   Body of derived class

属性を継承する

今、以下の例を見てください-

属性の継承

出力

属性出力の継承

最初にDateというクラスを作成し、オブジェクトを引数として渡します。here-objectはPythonが提供する組み込みクラスです。 その後、timeという別のクラスを作成し、Dateクラスを引数として呼び出しました。 この呼び出しを通じて、Dateクラスのすべてのデータと属性にアクセスし、Timeクラスにアクセスします。 そのため、以前に作成したTimeクラスオブジェクトtmからget_dateメソッドを取得しようとしています。

Object.Attribute Lookup Hierarchy

  • インスタンス
  • クラス
  • このクラスが継承するすべてのクラス

継承の例

継承の例を見てみましょう-

継承の例

いくつかのクラスを作成して、例に参加しましょう-

  • Animal-クラスは動物をシミュレートします
  • 猫-動物のサブクラス
  • 犬-動物のサブクラス

Pythonでは、オブジェクト（インスタンス）を作成し、属性の値を割り当てるために使用されるクラスのコンストラクター。

サブクラスのコンストラクターは常に親クラスのコンストラクターに呼び出され、親クラスの属性の値を初期化してから、属性の値の割り当てを開始します。

Pythonコンストラクター

出力

Pythonコンストラクターの出力

上記の例では、すべてのサブクラスまたは子クラスが親クラスからそのプロパティを継承するように、親クラスに配置したコマンド属性またはメソッドが表示されます。

サブクラスが別のサブクラスからメソッドまたはデータを継承しようとすると、Dogクラスがそのcatクラスからswatstring（）メソッドを呼び出そうとすると、エラーが発生します（この場合はAttributeErrorなど）。

ポリモーフィズム（「多くの形状」）

ポリモーフィズムはPythonのクラス定義の重要な機能であり、クラスまたはサブクラス全体で一般的に名前の付いたメソッドがある場合に利用されます。 これにより、関数は異なるタイプのエンティティを異なる時間に使用できます。 そのため、柔軟性と疎結合を提供するため、コードを拡張し、長期間にわたって簡単に維持できます。

これにより、クラス全体の違いを意識する必要なく、関数はこれらの多態性クラスのオブジェクトを使用できます。

ポリモーフィズムは、サブクラスが基本クラスのメソッドを使用するかオーバーライドすることにより、継承を通じて実行できます。

私たちの以前の継承の例でポリモーフィズムの概念を理解し、両方のサブクラスでshow_affectionと呼ばれる1つの一般的なメソッドを追加しましょう-

私たちが見ることができる例から、それは異なるタイプのオブジェクトが同じ方法で、またはより具体的には同じメソッドまたは同じメソッド（以下の例のshow_affection）いずれかのタイプのオブジェクトで呼び出されます。

ポリモーフィズム

出力

多態性出力

そのため、すべての動物は愛情（show_affection）を示しますが、それらは異なっています。 したがって、「show_affection」ビヘイビアは、動物によって異なる動作をするという意味で多形的です。 したがって、抽象的な「動物」の概念は実際には「show_affection」ではありませんが、特定の動物（犬や猫など）にはアクション「show_affection」の具体的な実装があります。

Python自体には、ポリモーフィックなクラスがあります。 たとえば、len（）関数は複数のオブジェクトで使用でき、すべてが入力パラメーターに基づいて正しい出力を返します。

ポリモーフィック

オーバーライド

Pythonでは、サブクラスにスーパークラスのメソッドをオーバーライドするメソッドが含まれている場合、次を呼び出すことでスーパークラスメソッドを呼び出すこともできます。

self.methodの代わりにSuper（Subclass、self）.method。

例

class Thought(object):
   def __init__(self):
      pass
   def message(self):
      print("Thought, always come and go")

class Advice(Thought):
   def __init__(self):
      super(Advice, self).__init__()
   def message(self):
      print('Warning: Risk is always involved when you are dealing with market!')

コンストラクターの継承

前の継承の例からわかるように、initはupの親クラスにあり、「子クラスdogまたはcatはinitメソッドを持っていなかったためです」 Pythonは、継承属性ルックアップを使用して、動物クラスでinitを見つけました。 子クラスを作成すると、最初にdogクラスのinitメソッドが検索されますが、それが見つからなかった後、親クラスAnimalが検索され、そこで検索されて呼び出されました。 クラスの設計が複雑になったため、最初に親クラスコンストラクターで処理し、次に子クラスコンストラクターで処理するインスタンスを初期化することができます。

コンストラクター

出力

コンストラクター出力

上記の例では、すべての動物には名前があり、すべての犬には特定の品種があります。 superで親クラスコンストラクターを呼び出しました。 したがって、dogには独自のinitがありますが、最初に起こるのはsuperと呼ぶことです。 スーパーは組み込み関数であり、クラスをそのスーパークラスまたはその親クラスに関連付けるように設計されています。

この場合、犬のスーパークラスを取得し、犬のインスタンスをここで言うコンストラクタinitのメソッドに渡すと言います。 つまり、別の言い方をすると、dogオブジェクトを使用して親クラスAnimal initを呼び出しています。 犬のインスタンスでどうしてAnimal initと言わないのか、と尋ねることができますが、これを行うことはできますが、動物のクラスの名前が変更される場合は、将来的になります。 クラス階層を再配置したい場合、犬は別のクラスから継承します。 この場合にsuperを使用すると、物事をモジュール式に保ち、変更と保守を簡単に行うことができます。

したがって、この例では、一般的なinit機能をより具体的な機能と組み合わせることができます。 これにより、コードの重複を排除し、システム全体の設計を反映するようにクラスを相互に関連付けることができる特定の機能から共通の機能を分離することができます。

結論

  • initは他のメソッドと同様です。継承できる
  • クラスにinitコンストラクターがない場合、Pythonは親クラスをチェックして、クラスを見つけることができるかどうかを確認します。
  • Pythonはそれを見つけるとすぐにそれを呼び出し、検索を停止します
  • super（）関数を使用して、親クラスのメソッドを呼び出すことができます。
  • 独自のクラスと同様に親で初期化することもできます。

多重継承とルックアップツリー

名前が示すように、多重継承はPythonがクラスが複数のクラスから継承する場合です。

たとえば、子は両方の親（母と父）から性格特性を継承します。

Python多重継承構文

クラスが複数の親クラスを継承するように、これらのクラスの名前をかっこ内に派生クラスに定義し、それを定義します。 これらの名前はコンマで区切ります。

以下はその例です- 

>>> class Mother:
   pass

>>> class Father:
   pass

>>> class Child(Mother, Father):
   pass

>>> issubclass(Child, Mother) and issubclass(Child, Father)
True

多重継承とは、2つまたは3つ以上のクラスから継承する機能のことです。 子は親から継承し、親は祖父母クラスから継承するため、複雑さが生じます。 Pythonは、オブジェクトからの読み取りが要求されている属性を検索する継承ツリーを登ります。 インスタンス内、クラス内、親クラス、最後に祖父母クラスからチェックします。 ここで、クラスが検索される順序（呼吸優先または深さ優先）で問題が発生します。 デフォルトでは、Pythonは深さ優先になります。

それが、下の図でPythonがクラスAで最初にdothis（）メソッドを検索する理由です。 したがって、以下の例のメソッド解決順序は次のようになります 

*Mro-D→B→A→C*

以下の多重継承図を見てください-

複数の継承

Pythonの「mro」機能を理解するための例を見てみましょう。

出力

Python mro機能の出力

実施例３

「ダイヤモンド形状」多重継承の別の例を見てみましょう。

Diamond Shape Multiple Inheritance

上記の図は曖昧と見なされます。 「メソッド解決順序」を理解する前の例から。 mroはD→B→A→C→Aになりますが、そうではありません。 Cから2番目のAを取得すると、Pythonは前のAを無視します。 この場合、mroはD→B→C→Aになります。

上記の図に基づいて例を作成しましょう-

メソッド解決順序

出力

メソッド解決順序出力

上記の出力を理解するための簡単なルールは、同じクラスがメソッド解決順序に現れる場合、このクラスの以前の外観はメソッド解決順序から削除されます。

結論として-

  • どのクラスも複数のクラスから継承できます
  • Pythonは通常、継承クラスを検索するときに「深さ優先」の順序を使用します。
  • しかし、2つのクラスが同じクラスを継承する場合、Pythonはmroからそのクラスの最初の外観を削除します。

デコレータ、静的およびクラスメソッド

関数（またはメソッド）はdefステートメントによって作成されます。

メソッドは、メソッドの最初の引数がインスタンスオブジェクトである1点を除いて、関数とまったく同じように機能しますが。

次のように、振る舞いに基づいてメソッドを分類できます。

  • シンプルメソッド-クラスの外部で定義されています。 この関数は、インスタンス引数を渡すことでクラス属性にアクセスできます。
def outside_func(():
  • インスタンスメソッド-
def func(self,)
  • クラスメソッド-クラス属性を使用する必要がある場合
   @classmethod
def cfunc(cls,)
  • 静的メソッド-クラスに関する情報がありません
      @staticmethod
def sfoo()

これまでインスタンスメソッドを見てきましたが、今が他の2つのメソッドについての洞察を得るときです。

クラスメソッド

@classmethodデコレータは、呼び出されたクラスまたは最初の引数として呼び出されたインスタンスのクラスを渡す組み込み関数デコレータです。 その評価の結果は、関数定義を隠します。

構文

class C(object):
   @classmethod
   def fun(cls, arg1, arg2, ...):
      ....
fun: function that needs to be converted into a class method
returns: a class method for function

彼らはこのcls引数にアクセスできます。オブジェクトインスタンスの状態を変更することはできません。 それは自己へのアクセスを必要とするでしょう。

  • クラスのオブジェクトではなく、クラスにバインドされます。
  • クラスメソッドは、クラスのすべてのインスタンスに適用されるクラス状態を引き続き変更できます。

静的メソッド

静的メソッドはselfもcls（class）パラメーターも受け取りませんが、任意の数の他のパラメーターを自由に受け入れることができます。

構文 

class C(object):
   @staticmethod
   def fun(arg1, arg2, ...):
   ...
returns: a static method for function funself.
  • 静的メソッドは、オブジェクトの状態もクラスの状態も変更できません。
  • アクセスできるデータが制限されています。

何を使用するか

  • 通常、クラスメソッドを使用してファクトリメソッドを作成します。 ファクトリメソッドは、さまざまなユースケースのクラスオブジェクト（コンストラクタに類似）を返します。
  • 通常、静的メソッドを使用してユーティリティ関数を作成します。

Pythonデザインパターン

概要

最新のソフトウェア開発では、複雑なビジネス要件に対処する必要があります。 また、将来の拡張性や保守性などの要因を考慮する必要があります。 これらの目標を達成するには、ソフトウェアシステムの適切な設計が不可欠です。 このようなシステムでは、設計パターンが重要な役割を果たします。

設計パターンを理解するために、以下の例を検討してみましょう-

  • すべての車のデザインは、基本的なデザインパターン、4つの車輪、ステアリングホイール、アクセルブレーククラッチなどのコアドライブシステムなどに従っています。

したがって、繰り返し構築/生産されるすべてのものは、必然的にそのデザインのパターンに従うものとします。 車、自転車、ピザ、ATM、その他何でも…ソファーベッドも。

ソフトウェアのロジック/メカニズム/テクニックをコーディングする標準的な方法になりつつあるデザインは、ソフトウェアデザインパターンとして知られるか、研究されるようになりました。

デザインパターンが重要な理由

デザインパターンを使用する利点は次のとおりです-

  • 実証済みのアプローチにより、一般的な設計上の問題を解決できます。
  • よく文書化されているため、理解にあいまいさはありません。
  • 全体的な開発時間を短縮します。
  • 他の方法よりも簡単に、将来の拡張や修正に対処できます。
  • 一般的な問題の解決策であることが証明されているため、システムのエラーを減らすことができます。

設計パターンの分類

GoF（Gang of Four）デザインパターンは、創造的、構造的、および行動的な3つのカテゴリに分類されます。

創造パターン

創造的な設計パターンは、オブジェクト作成ロジックをシステムの他の部分から分離します。 オブジェクトを作成する代わりに、作成パターンがオブジェクトを作成します。 作成パターンには、Abstract Factory、Builder、Factory Method、Prototype、Singletonが含まれます。

創造的なパターンは、言語の動的な性質のため、Pythonでは一般的に使用されません。 また、言語自体は、十分にエレガントな方法で作成するために必要なすべての柔軟性を提供します。シングルトンやファクトリーなど、上に何かを実装する必要はほとんどありません。

また、これらのパターンは、新しい演算子を使用してオブジェクトを直接インスタンス化するのではなく、作成ロジックを非表示にしながらオブジェクトを作成する方法を提供します。

構造パターン

ゼロから始めるのではなく、既存のクラスのセットを使用してより大きな構造を構築する必要がある場合があります。 そこで構造クラスパターンが継承を使用して新しい構造を構築します。 構造オブジェクトパターンは、構成/集計を使用して新しい機能を取得します。 アダプタ、ブリッジ、コンポジット、デコレータ、ファサード、フライウェイト、プロキシは構造パターンです。 クラス階層を整理する最良の方法を提供します。

行動パターン

動作パターンは、オブジェクト間の通信を処理する最良の方法を提供します。 パターンは、このカテゴリに分類されます。ビジター、責任の連鎖、コマンド、インタープリター、イテレーター、メディエーター、メメント、オブザーバー、ステート、ストラテジー、およびテンプレートメソッドは行動パターンです。

これらはシステムの動作を表すため、一般的にソフトウェアシステムの機能を説明するために使用されます。

一般的に使用されるデザインパターン

シングルトン

これは、すべてのデザインパターンの中で最も物議をかもし、有名なものの1つです。 過度にオブジェクト指向の言語で使用され、従来のオブジェクト指向プログラミングの重要な部分です。

シングルトンパターンは、

  • ロギングを実装する必要がある場合。 ロガーインスタンスは、システムのすべてのコンポーネントで共有されます。
  • システム内のさまざまなコンポーネントすべてで情報のキャッシュを維持および共有する必要があるため、構成ファイルはこれを使用しています。 *データベースへの接続の管理。

これがUML図です。

UML図 

class Logger(object):
   def __new__(cls,* args, **kwargs):
      if not hasattr(cls, '_logger'):
      cls._logger = super(Logger, cls).__new__(cls, *args, **kwargs)
return cls._logger

この例では、ロガーはシングルトンです。

newが呼び出されると、通常、そのクラスの新しいインスタンスが構築されます。 オーバーライドする場合、まずシングルトンインスタンスが作成されたかどうかを確認します。 そうでない場合は、スーパーコールを使用して作成します。 したがって、Loggerでコンストラクターを呼び出すと、常にまったく同じインスタンスが取得されます。 

>>>
>>> obj1 = Logger()
>>> obj2 = Logger()
>>> obj1 == obj2
True
>>>
>>> obj1
<__main__.Logger object at 0x03224090>
>>> obj2
<__main__.Logger object at 0x03224090>

オブジェクト指向Python-高度な機能

ここでは、Pythonが提供する高度な機能のいくつかを見ていきます。

クラス設計のコア構文

この記事では、Pythonがクラス内の演算子をどのように活用できるかについて説明します。 Pythonは主にオブジェクトであり、メソッドはオブジェクトを呼び出します。これは、便利な構文で隠されている場合でも続きます。 

>>> var1 = 'Hello'
>>> var2 = ' World!'
>>> var1 + var2
'Hello World!'
>>>
>>> var1.__add__(var2)
'Hello World!'
>>> num1 = 45
>>> num2 = 60
>>> num1.__add__(num2)
105
>>> var3 = ['a', 'b']
>>> var4 = ['hello', ' John']
>>> var3.__add__(var4)
['a', 'b', 'hello', ' John']

したがって、マジックメソッドaddを独自のクラスに追加する必要がある場合は、それを行うこともできます。 それを試してみましょう。

mylistという引数としてlistを取るコンストラクタinitを持つSumlistというクラスがあります。 

class SumList(object):
   def __init__(self, my_list):
      self.mylist = my_list
   def __add__(self, other):
     new_list = [ x + y for x, y in zip(self.mylist, other.mylist)]

     return SumList(new_list)

   def __repr__(self):
      return str(self.mylist)

aa = SumList([3,6, 9, 12, 15])

bb = SumList([100, 200, 300, 400, 500])
cc = aa + bb # aa.__add__(bb)
print(cc) # should gives us a list ([103, 206, 309, 412, 515])

出力

[103, 206, 309, 412, 515]

しかし、他の魔法のメソッドによって内部的に管理される多くのメソッドがあります。 以下はその一部です、 

'abc' in var # var.__contains__('abc')
var == 'abc' # var.__eq__('abc')
var[1] # var.__getitem__(1)
var[1:3] # var.__getslice__(1, 3)
len(var) # var.__len__()
print(var) # var.__repr__()

組み込み型からの継承

クラスは組み込み型から継承することもできます。つまり、組み込み型から継承し、そこにあるすべての機能を利用できます。

以下の例では、辞書から継承していますが、メソッドsetitemの1つを実装しています。 この（setitem）は、辞書にキーと値を設定するときに呼び出されます。 これは魔法のメソッドなので、暗黙的に呼び出されます。 

class MyDict(dict):

   def __setitem__(self, key, val):
      print('setting a key and value!')
      dict.__setitem__(self, key, val)

dd = MyDict()
dd['a'] = 10
dd['b'] = 20

for key in dd.keys():
   print('{0} = {1}'.format(key, dd[key]))

出力

setting a key and value!
setting a key and value!
a = 10
b = 20

前の例を拡張してみましょう。以下では、リストインデックスを処理するときに呼び出されるgetitemおよびsetitemという2つのマジックメソッドを呼び出します。 

# Mylist inherits from 'list' object but indexes from 1 instead for 0!
class Mylist(list): # inherits from list
   def __getitem__(self, index):
      if index == 0:
         raise IndexError
      if index > 0:
         index = index - 1
         return list.__getitem__(self, index) # this method is called when

# we access a value with subscript like x[1]
   def __setitem__(self, index, value):
      if index == 0:
         raise IndexError
      if index > 0:
      index = index - 1
      list.__setitem__(self, index, value)

x = Mylist(['a', 'b', 'c']) # __init__() inherited from builtin list

print(x) # __repr__() inherited from builtin list

x.append('HELLO'); # append() inherited from builtin list

print(x[1]) # 'a' (Mylist.__getitem__ cutomizes list superclass
               # method. index is 1, but reflects 0!

print (x[4]) # 'HELLO' (index is 4 but reflects 3!

出力

['a', 'b', 'c']
a
HELLO

上記の例では、Mylistに3つのアイテムリストを設定し、暗黙的にinitメソッドが呼び出され、要素xを印刷すると、3つのアイテムリスト（['a'、 'b'、 'c']）を取得します。 次に、このリストに別の要素を追加します。 後でインデックス1とインデックス4を要求します。 しかし、出力が表示された場合、要求された（index-1）から要素を取得しています。 リストのインデックス作成は0から始まりますが、ここではインデックス作成は1から始まります（そのため、リストの最初のアイテムが取得されます）。

命名規則

この記事では、変数に使用する名前、特に世界中のPythonプログラマーが使用するプライベート変数と規約を調べます。 変数はプライベートとして指定されていますが、Pythonにはプライバシーがありません。これは設計上です。 よく文書化されている他の言語と同様、Pythonには命名規則とスタイル規則がありますが、それらは強制されていません。 Pythonの創始者である「* Guido van Rossum」によって書かれたスタイルガイドがあります。これは、ベストプラクティスと名前の使用を説明し、PEP8と呼ばれています。 このリンクはこちらです*。https://www.python.org/dev/peps/pep-0008/

PEPはPython拡張提案の略であり、提案された変更について議論するためにPythonコミュニティに配布された一連のドキュメントです。 たとえば、すべてをお勧めします、

  • モジュール名-all_lower_case
  • クラス名と例外名-キャメルケース
  • グローバル名とローカル名-all_lower_case
  • 関数とメソッド名-all_lower_case
  • 定数-ALL_UPPER_CASE

これらは単なる推奨事項であり、必要に応じて変更できます。 しかし、ほとんどの開発者はこれらの推奨事項に従っているので、コードが読みにくくなるかもしれません。

なぜ慣例に従うのですか？

PEPの推奨事項に従うことができます。

  • 大多数の開発者にとってより身近なもの
  • コードのほとんどの読者にとって明確です。
  • 同じコードベースで作業する他の貢献者のスタイルと一致します。
  • プロのソフトウェア開発者のマーク
  • 誰もがあなたを受け入れます。

変数の命名-「パブリック」と「プライベート」

Pythonでは、モジュールとクラスを扱うときに、一部の変数または属性をプライベートとして指定します。 Pythonには、オブジェクトの内部を除いてアクセスできない「プライベート」インスタンス変数は存在しません。 プライベートとは、単にコードのユーザーが使用することを意図したものではなく、内部で使用することを意図したものです。 一般に、ほとんどのPython開発者は慣習に従っています。 たとえば、アンダースコアが前に付いた名前。 _attrval（以下の例）は、関数、メソッド、データメンバーのいずれであっても、APIまたはPythonコードの非公開部分として扱う必要があります。 以下は、私たちが従う命名規則です。

  • パブリック属性または変数（このモジュールのインポーターまたはこのクラスのユーザーが使用することを意図）-* regular_lower_case *
  • プライベート属性または変数（モジュールまたはクラスによる内部使用）-* _ single_leading_underscore *
  • サブクラス化すべきでないプライベート属性-* __ double_leading_underscore *
  • マジックアトリビュート-* double_underscores *（使用して、作成しないでください）
class GetSet(object):

   instance_count = 0 # public

   __mangled_name = 'no privacy!' # special variable

   def __init__(self, value):
      self._attrval = value # _attrval is for internal use only
      GetSet.instance_count += 1

   @property
   def var(self):
      print('Getting the "var" attribute')
      return self._attrval

   @var.setter
   def var(self, value):
      print('setting the "var" attribute')
      self._attrval = value

   @var.deleter
   def var(self):
      print('deleting the "var" attribute')
      self._attrval = None

cc = GetSet(5)
cc.var = 10 # public name
print(cc._attrval)
print(cc._GetSet__mangled_name)

出力

setting the "var" attribute
10
no privacy!

オブジェクト指向Python-ファイルと文字列

文字列

文字列は、すべてのプログラミング言語で使用される最も一般的なデータ型です。 Why? 私たちは数字よりもテキストをよく理解しているので、文章や会話ではテキストと単語を使用します。プログラミングでも文字列を使用します。 文字列では、テキストを解析し、テキストのセマンティクスを分析し、データマイニングを行います。このデータはすべて、人間が消費するテキストです。Pythonの文字列は不変です。

文字列操作

Pythonでは、複数行の文字列の場合、一重引用符（ ）、二重引用符（“）、さらには三重引用符（ ）を使用して、文字列を複数の方法でマークできます。 

>>> # String Examples
>>> a = "hello"
>>> b = ''' A Multi line string,
Simple!'''
>>> e = ('Multiple' 'strings' 'togethers')

文字列操作は非常に便利で、すべての言語で非常に広く使用されています。 多くの場合、プログラマーは文字列を分解し、それらを綿密に調べる必要があります。

文字列は（文字ごとに）繰り返し、スライス、または連結できます。 構文はリストの場合と同じです。

strクラスには、文字列の操作を簡単にするための多数のメソッドがあります。 dirコマンドとhelpコマンドは、Pythonインタープリターの使用方法に関するガイダンスを提供します。

以下は、一般的に使用される文字列メソッドの一部です。

Sr.No. Method & Description
1

isalpha()

すべての文字がアルファベットかどうかを確認します

2

isdigit()

数字をチェックします

3

isdecimal()

小数文字をチェックします

4

isnumeric()

数字をチェックします

5

find()

部分文字列の最高インデックスを返します

6

istitle()

タイトルケース文字列をチェックします

7

join()

連結された文字列を返します

8

lower()

小文字の文字列を返します

9

upper()

大文字の文字列を返します

10

partion()

タプルを返します

11

bytearray()

指定されたバイトサイズの配列を返します

12

enumerate()

列挙オブジェクトを返します

13

isprintable()

印刷可能文字をチェックします

いくつかの文字列メソッドを実行してみましょう。 

>>> str1 = 'Hello World!'
>>> str1.startswith('h')
False
>>> str1.startswith('H')
True
>>> str1.endswith('d')
False
>>> str1.endswith('d!')
True
>>> str1.find('o')
4
>>> #Above returns the index of the first occurence of the character/substring.
>>> str1.find('lo')
3
>>> str1.upper()
'HELLO WORLD!'
>>> str1.lower()
'hello world!'
>>> str1.index('b')
Traceback (most recent call last):
   File "<pyshell#19>", line 1, in <module>
      str1.index('b')
ValueError: substring not found
>>> s = ('hello How Are You')
>>> s.split(' ')
['hello', 'How', 'Are', 'You']
>>> s1 = s.split(' ')
>>> '*'.join(s1)
'hello*How*Are*You'
>>> s.partition(' ')
('hello', ' ', 'How Are You')
>>>

文字列のフォーマット

Python 3.xでは、文字列のフォーマットが変更され、より論理的で柔軟になりました。 フォーマットは、format（）メソッドまたはフォーマット文字列の％sign（old style）を使用して実行できます。

文字列には、リテラルテキストまたは中括弧\ {}で区切られた置換フィールドを含めることができ、各置換フィールドには、位置引数の数値インデックスまたはキーワード引数の名前を含めることができます。

構文

str.format(*args, **kwargs)

基本的なフォーマット

>>> '{} {}'.format('Example', 'One')
'Example One'
>>> '{} {}'.format('pie', '3.1415926')
'pie 3.1415926'

以下の例では、引数を変更せずに表示の順序を変更できます。 

>>> '{1} {0}'.format('pie', '3.1415926')
'3.1415926 pie'

文字列のパディングと整列

値は特定の長さにパディングできます。 

>>> #Padding Character, can be space or special character
>>> '{:12}'.format('PYTHON')
'PYTHON '
>>> '{:>12}'.format('PYTHON')
' PYTHON'
>>> '{:<{}s}'.format('PYTHON',12)
'PYTHON '
>>> '{:*<12}'.format('PYTHON')
'PYTHON******'
>>> '{:*^12}'.format('PYTHON')
'***PYTHON***'
>>> '{:.15}'.format('PYTHON OBJECT ORIENTED PROGRAMMING')
'PYTHON OBJECT O'
>>> #Above, truncated 15 characters from the left side of a specified string
>>> '{:.{}}'.format('PYTHON OBJECT ORIENTED',15)
'PYTHON OBJECT O'
>>> #Named Placeholders
>>> data = {'Name':'Raghu', 'Place':'Bangalore'}
>>> '{Name} {Place}'.format(**data)
'Raghu Bangalore'
>>> #Datetime
>>> from datetime import datetime
>>> '{:%Y/%m/%d.%H:%M}'.format(datetime(2018,3,26,9,57))
'2018/03/26.09:57'

文字列はユニコードです

不変のUnicode文字のコレクションとしての文字列。 Unicode文字列は、ASCII文字だけでなくあらゆる文字を表現できるため、どこでも動作するソフトウェアまたはプログラムを作成する機会を提供します。

バイトオブジェクトがテキストデータを参照している場合でも、多くのIO操作はバイトの処理方法のみを知っています。 したがって、バイトとユニコードを交換する方法を知ることは非常に重要です。

テキストをバイトに変換する

文字列をバイトオブジェクトに変換することをエンコーディングと呼びます。 エンコードには多くの形式があり、最も一般的な形式は次のとおりです。 JPEG、MP3、WAV、ASCII、UTF-8など また、this（encoding）は、音声、画像、テキストなどを表す形式です。 バイト単位

この変換は、encode（）を介して可能です。 引数としてエンコード手法を使用します。 デフォルトでは、「UTF-8」テクニックを使用します。 

>>> # Python Code to demonstrate string encoding
>>>
>>> # Initialising a String
>>> x = 'finddevguides'
>>>
>>> #Initialising a byte object
>>> y = b'finddevguides'
>>>
>>> # Using encode() to encode the String >>> # encoded version of x is stored in z using ASCII mapping
>>> z = x.encode('ASCII')
>>>
>>> # Check if x is converted to bytes or not
>>>
>>> if(z==y):
   print('Encoding Successful!')
else:
   print('Encoding Unsuccessful!')
Encoding Successful!

バイトをテキストに変換

バイトをテキストに変換することをデコードと呼びます。 これはdecode（）を通じて実装されます。 エンコードに使用されるエンコードがわかっている場合は、バイト文字列を文字列に変換できます。

したがって、エンコードとデコードは逆のプロセスです。 

>>>
>>> # Python code to demonstrate Byte Decoding
>>>
>>> #Initialise a String
>>> x = 'finddevguides'
>>>
>>> #Initialising a byte object
>>> y = b'finddevguides'
>>>
>>> #using decode() to decode the Byte object
>>> # decoded version of y is stored in z using ASCII mapping
>>> z = y.decode('ASCII')
>>> #Check if y is converted to String or not
>>> if (z == x):
   print('Decoding Successful!')
else:
   print('Decoding Unsuccessful!') Decoding Successful!
>>>

ファイル入出力

オペレーティングシステムは、ファイルをテキストではなくバイトシーケンスとして表します。

ファイルは、関連情報を保存するためのディスク上の名前付きの場所です。 ディスクにデータを永続的に保存するために使用されます。

Pythonでは、ファイル操作は次の順序で行われます。

  • ファイルを開く
  • ファイルの読み取りまたは書き込み（操作）ファイルを開く
  • ファイルを閉じます。

Pythonは、着信（または発信）バイトストリームを適切なデコード（またはエンコード）呼び出しでラップし、strオブジェクトを直接処理できるようにします。

ファイルを開く

Pythonには、ファイルを開くための組み込み関数open（）があります。 これにより、ファイルの読み取りまたは変更に使用されるため、ハンドルとも呼ばれるファイルオブジェクトが生成されます。 

>>> f = open(r'c:\users\rajesh\Desktop\index.webm','rb')
>>> f
<_io.BufferedReader name='c:\\users\\rajesh\\Desktop\\index.webm'>
>>> f.mode
'rb'
>>> f.name
'c:\\users\\rajesh\\Desktop\\index.webm'

ファイルからテキストを読み取るには、ファイル名を関数に渡すだけです。 ファイルは読み取り用に開かれ、バイトはプラットフォームのデフォルトのエンコーディングを使用してテキストに変換されます。

例外と例外クラス

一般的に、例外は異常な状態です。 例外は通常エラーを示しますが、プロシージャを早期に終了したり、リソース不足から回復したりする場合など、意図的にプログラムに入れます。 組み込みの例外がいくつかあります。これらの例外は、ファイルの終わりを超えて読み取る、またはゼロで除算するなどの条件を示します。 カスタム例外と呼ばれる独自の例外を定義できます。

例外処理を使用すると、エラーを適切に処理し、意味のあることを実行できます。 例外処理には、「スロー」と「キャッチ」の2つのコンポーネントがあります。

例外の特定（エラー）

Pythonで発生するすべてのエラーは、エラーの種類によって識別されるエラー状態になる例外を発生させます。 

>>> #Exception
>>> 1/0
Traceback (most recent call last):
   File "<pyshell#2>", line 1, in <module>
      1/0
ZeroDivisionError: division by zero
>>>
>>> var = 20
>>> print(ver)
Traceback (most recent call last):
   File "<pyshell#5>", line 1, in <module>
      print(ver)
NameError: name 'ver' is not defined
>>> #Above as we have misspelled a variable name so we get an NameError.
>>>
>>> print('hello)

SyntaxError: EOL while scanning string literal
>>> #Above we have not closed the quote in a string, so we get SyntaxError.
>>>
>>> #Below we are asking for a key, that doen't exists.
>>> mydict = {}
>>> mydict['x']
Traceback (most recent call last):
   File "<pyshell#15>", line 1, in <module>
      mydict['x']
KeyError: 'x'
>>> #Above keyError
>>>
>>> #Below asking for a index that didn't exist in a list.
>>> mylist = [1,2,3,4]
>>> mylist[5]
Traceback (most recent call last):
   File "<pyshell#20>", line 1, in <module>
      mylist[5]
IndexError: list index out of range
>>> #Above, index out of range, raised IndexError.

キャッチ/トラッピングの例外

プログラムで異常が発生し、例外メカニズムを使用してそれを処理する場合、「例外をスロー」します。 キーワードtryおよびexceptは、例外をキャッチするために使用されます。 tryブロック内でエラーが発生するたびに、Pythonはそれを処理するために一致する以外のブロックを探します。 ある場合、実行はそこでジャンプします。

構文

try:
   #write some code
   #that might throw some exception
except <ExceptionType>:
   # Exception handler, alert the user

try句内のコードは、ステートメントごとに実行されます。

例外が発生した場合、残りのtryブロックはスキップされ、except句が実行されます。 

try:
   some statement here
except:
   exception handling

プログラムでエラー処理メカニズムを使用しない場合に何が起こるかを確認するために、いくつかのコードを書きましょう。 

number = int(input('Please enter the number between 1 & 10: '))
print('You have entered number',number)

上記のプログラムは、ユーザーが数字を入力する限り正しく動作しますが、ユーザーが他のデータ型（文字列やリストなど）を入力しようとするとどうなりますか。 

Please enter the number between 1 > 10: 'Hi'
Traceback (most recent call last):
   File "C:/Python/Python361/exception2.py", line 1, in <module>
      number = int(input('Please enter the number between 1 & 10: '))
ValueError: invalid literal for int() with base 10: "'Hi'"

現在、ValueErrorは例外タイプです。 上記のコードを例外処理で書き直してみましょう。 

import sys

print('Previous code with exception handling')

try:
   number = int(input('Enter number between 1 > 10: '))

except(ValueError):
   print('Error..numbers only')
   sys.exit()

print('You have entered number: ',number)

プログラムを実行し、（数値ではなく）文字列を入力すると、異なる結果が得られることがわかります。 

Previous code with exception handling
Enter number between 1 > 10: 'Hi'
Error..numbers only

例外を発生させる

独自のメソッドから例外を発生させるには、次のようなraiseキーワードを使用する必要があります 

raise ExceptionClass(‘Some Text Here’)

例を見てみましょう 

def enterAge(age):
   if age<0:
      raise ValueError('Only positive integers are allowed')
   if age % 2 ==0:
      print('Entered Age is even')
   else:
      print('Entered Age is odd')

try:
   num = int(input('Enter your age: '))
   enterAge(num)
except ValueError:
   print('Only positive integers are allowed')

プログラムを実行し、正の整数を入力します。

期待される出力

Enter your age: 12
Entered Age is even

しかし、負の数を入力しようとすると、

期待される出力

Enter your age: -2
Only positive integers are allowed

カスタム例外クラスの作成

BaseExceptionクラスまたはBaseExceptionのサブクラスを拡張することにより、カスタム例外クラスを作成できます。

カスタム例外クラス

上記の図から、Pythonのほとんどの例外クラスがBaseExceptionクラスから拡張されていることがわかります。 BaseExceptionクラスまたはそのサブクラスから独自の例外クラスを派生できます。

NegativeNumberException.pyという新しいファイルを作成し、次のコードを記述します。 

class NegativeNumberException(RuntimeError):
   def __init__(self, age):
      super().__init__()
      self.age = age

上記のコードは、NegativeNumberExceptionという名前の新しい例外クラスを作成します。これは、super（）init（）を使用して親クラスコンストラクターを呼び出し、年齢を設定するコンストラクターのみで構成されます。

次に、独自のカスタム例外クラスを作成するために、いくつかのコードを記述し、新しい例外クラスをインポートします。 

from NegativeNumberException import NegativeNumberException
def enterage(age):
   if age < 0:
      raise NegativeNumberException('Only positive integers are allowed')

   if age % 2 == 0:
      print('Age is Even')

   else:
      print('Age is Odd')

try:
   num = int(input('Enter your age: '))
   enterage(num)
except NegativeNumberException:
   print('Only positive integers are allowed')
except:
   print('Something is wrong')

出力

Enter your age: -2
Only positive integers are allowed

カスタム例外クラスを作成する別の方法。 

class customException(Exception):
   def __init__(self, value):
      self.parameter = value

   def __str__(self):
      return repr(self.parameter)
try:
   raise customException('My Useful Error Message!')
except customException as instance:
   print('Caught: ' + instance.parameter)

出力

Caught: My Useful Error Message!

例外階層

組み込み例外のクラス階層は次のとおりです- 

+-- SystemExit
+-- KeyboardInterrupt
+-- GeneratorExit
+-- Exception
+-- StopIteration
+-- StopAsyncIteration
+-- ArithmeticError
| +-- FloatingPointError
| +-- OverflowError
| +-- ZeroDivisionError
+-- AssertionError
+-- AttributeError
+-- BufferError
+-- EOFError
+-- ImportError
+-- LookupError
| +-- IndexError
| +-- KeyError
+-- MemoryError
+-- NameError
| +-- UnboundLocalError
+-- OSError
| +-- BlockingIOError
| +-- ChildProcessError
| +-- ConnectionError
| | +-- BrokenPipeError
| | +-- ConnectionAbortedError
| | +-- ConnectionRefusedError
| | +-- ConnectionResetError
| +-- FileExistsError
| +-- FileNotFoundError
| +-- InterruptedError
| +-- IsADirectoryError
| +-- NotADirectoryError
| +-- PermissionError
| +-- ProcessLookupError
| +-- TimeoutError
+-- ReferenceError
+-- RuntimeError
| +-- NotImplementedError
| +-- RecursionError
+-- SyntaxError
| +-- IndentationError
| +-- TabError
+-- SystemError
+-- TypeError
+-- ValueError
| +-- UnicodeError
| +-- UnicodeDecodeError
| +-- UnicodeEncodeError
| +-- UnicodeTranslateError
+-- Warning
+-- DeprecationWarning
+-- PendingDeprecationWarning
+-- RuntimeWarning
+-- SyntaxWarning
+-- UserWarning
+-- FutureWarning
+-- ImportWarning
+-- UnicodeWarning
+-- BytesWarning
+-- ResourceWarning

オブジェクト指向Python-オブジェクトのシリアル化

データストレージのコンテキストでは、シリアル化とは、データ構造またはオブジェクトの状態を、ファイルやメモリバッファーに格納できる形式に変換したり、後で送信および再構築したりするプロセスです。

シリアル化では、オブジェクトを保存可能な形式に変換して、後でシリアル化を解除し、シリアル化された形式から元のオブジェクトを再作成できるようにします。

ピクルス

酸洗とは、Pythonオブジェクト階層をバイトストリーム（通常は人間が読み取れない形式）に変換してファイルに書き込むプロセスです。これは、シリアル化とも呼ばれます。 ピックル解除は逆の操作であり、バイトストリームは変換されて動作するPythonオブジェクト階層に戻ります。

Pickleは、オブジェクトを保存する操作上最も簡単な方法です。 Python Pickleモジュールは、オブジェクトを特別なストレージ形式で直接保存するオブジェクト指向の方法です。

何ができますか？

  • Pickleは、辞書とリストを非常に簡単に保存および再現できます。
  • オブジェクトの属性を保存し、同じ状態に復元します。

ピクルスにできないことは何ですか？

  • オブジェクトコードは保存されません。 属性値のみです。
  • ファイルハンドルまたは接続ソケットを保存できません。

要するに、pickleは、変数がリストやクラスなどである可能性のあるファイルにデータ変数を保存したり、ファイルからデータ変数を取得したりする方法です。

何かをピクルスするには、あなたがする必要があります-

  • 輸入ピクルス
  • 次のような変数をファイルに書き込みます
pickle.dump(mystring, outfile, protocol),

3番目の引数のプロトコルはオプションです。

インポートピクルス

次のような変数をファイルに書き込みます 

myString = pickle.load(inputfile)

方法

pickleインターフェースには4つの異なる方法があります。

  • * dump（）*-dump（）メソッドは、開いているファイル（ファイルのようなオブジェクト）にシリアル化します。
  • * dumps（）*-文字列にシリアル化
  • * load（）*-オープンライクなオブジェクトからデシリアライズします。
  • * loads（）*-文字列から逆シリアル化します。

上記の手順に基づいて、以下は「酸洗い」の例です。

Pickling

出力

My Cat pussy is White and has 4 legs
Would you like to see her pickled? Here she is!
b'\x80\x03c__main__\nCat\nq\x00)\x81q\x01}q\x02(X\x0e\x00\x00\x00number_of_legsq\x03K\x04X\x05\x00\x00\x00colorq\x04X\x05\x00\x00\x00Whiteq\x05ub.'

したがって、上記の例では、Catクラスのインスタンスを作成し、それをピクルスして、「Cat」インスタンスを単純なバイト配列に変換しました。

これにより、バイト配列をバイナリファイルまたはデータベースフィールドに簡単に保存し、後でストレージサポートから元の形式に復元することができます。

また、pickleオブジェクトを使用してファイルを作成する場合は、（dumps *（）*メソッドの代わりに）dump（）メソッドを使用して、開いているバイナリファイルも渡すことができ、pickleの結果はファイルに自動的に保存されます。 

[….]
binary_file = open(my_pickled_Pussy.bin', mode='wb')
my_pickled_Pussy = pickle.dump(Pussy, binary_file)
binary_file.close()

ピックル解除

バイナリ配列を受け取り、それをオブジェクト階層に変換するプロセスは、ピッキング解除と呼ばれます。

ピクル解除プロセスは、pickleモジュールのload（）関数を使用して行われ、単純なバイト配列から完全なオブジェクト階層を返します。

前の例で関数loadを使用してみましょう。

Unpicking

出力

MeOw is black
Pussy is white

JSON

JSON（JavaScript Object Notation）は、Python標準ライブラリの一部であり、軽量のデータ交換形式です。 人間にとって読み書きは簡単です。 解析と生成は簡単です。

JSONはシンプルであるため、JSONはデータを保存および交換する方法であり、JSON構文を介して実現され、多くのWebアプリケーションで使用されています。 人間が読める形式であるため、APIを使用する際の有効性に加えて、これがデータ転送で使用する理由の1つである可能性があります。

JSON形式のデータの例は次のとおりです- 

{"EmployID": 40203, "Name": "Zack", "Age":54, "isEmployed": True}

Pythonを使用すると、Jsonファイルを簡単に操作できます。 この目的で使用されるモジュールはJSONモジュールです。 このモジュールは、Pythonインストールに含まれる（組み込まれる）必要があります。

Python辞書をJSONに変換してテキストファイルに書き込む方法を見てみましょう。

JSONからPython

JSONの読み取りとは、JSONをPython値（オブジェクト）に変換することを意味します。 jsonライブラリは、JSONをPythonの辞書またはリストに解析します。 それを行うには、次のように、loads（）関数（文字列からの読み込み）を使用します-

Json to Python

出力

JsonからPythonへの出力

以下はjsonファイルのサンプルです。 

data1.json
{"menu": {
   "id": "file",
   "value": "File",
   "popup": {
      "menuitem": [
         {"value": "New", "onclick": "CreateNewDoc()"},
         {"value": "Open", "onclick": "OpenDoc()"},
         {"value": "Close", "onclick": "CloseDoc()"}
      ]
   }
}}

上記のコンテンツ（Data1.json）は、従来の辞書のように見えます。 pickleを使用してこのファイルを保存できますが、その出力は人間が読める形式ではありません。

JSON（Java Script Object Notification）は非常にシンプルな形式であり、それが人気の理由の1つです。 それでは、以下のプログラムを通してjsonの出力を見てみましょう。

Java Script Object Notification

出力

Javaスクリプトオブジェクト通知出力

上記では、読み取り用にjsonファイル（data1.json）を開き、ファイルハンドラーを取得し、json.loadに渡してオブジェクトを取得します。 jsonファイルと同じ、オブジェクトの出力を印刷しようとしています。 オブジェクトのタイプは辞書ですが、Pythonオブジェクトとして出力されます。 このピクルスを見たように、jsonへの書き込みは簡単です。 上記でjsonファイルをロードし、別のキーと値のペアを追加して、同じjsonファイルに書き戻します。 data1.jsonを見ると、見た目が異なります。 以前と同じ形式ではありません。

出力が同じように見えるように（人間が読める形式）、プログラムの最後の行にいくつかの引数を追加し、 

json.dump(conf, fh, indent = 4, separators = (‘,’, ‘: ‘))

同様に、pickleのように、ダンプを使用して文字列を出力し、ロードを使用してロードできます。 以下はその例です。

ダンプ付き文字列

YAML

YAMLは、すべてのプログラミング言語にとって最も人間に優しいデータシリアル化標準である可能性があります。

Python yamlモジュールはpyamlと呼ばれます

YAMLはJSONの代替です-

  • 人間が読めるコード-YAMLは最も人間が読める形式なので、そのトップページのコンテンツでさえYAMLで表示されるため、この点がわかります。
  • コンパクトコード-YAMLでは、空白インデントを使用して括弧ではなく構造を示します。
  • リレーショナルデータの構文-内部参照には、アンカー（＆）とエイリアス（*）を使用します。
  • 広く使用されている領域の1つは、データ構造の表示/編集用です-例えば、設定ファイル、デバッグ中のダンプ、ドキュメントヘッダー。

YAMLのインストール

yamlは組み込みモジュールではないため、手動でインストールする必要があります。 Windowsマシンにyamlをインストールする最良の方法は、pipを使用することです。 Windowsターミナルで以下のコマンドを実行して、yamlをインストールします。 

pip install pyaml (Windows machine)
sudo pip install pyaml (*nix and Mac)

上記のコマンドを実行すると、現在の最新バージョンに基づいて、画面に次のようなものが表示されます。 

Collecting pyaml
Using cached pyaml-17.12.1-py2.py3-none-any.whl
Collecting PyYAML (from pyaml)
Using cached PyYAML-3.12.tar.gz
Installing collected packages: PyYAML, pyaml
Running setup.py install for PyYAML ... done
Successfully installed PyYAML-3.12 pyaml-17.12.1

テストするには、Pythonシェルに移動してyamlモジュールをインポートし、yamlをインポートします。エラーが見つからない場合は、インストールが成功したと言えます。

pyamlをインストールした後、以下のコードを見てみましょう。 

script_yaml1.py

Yaml

上記では、3つの異なるデータ構造、辞書、リスト、およびタプルを作成しました。 各構造で、yaml.dumpを実行します。 重要なポイントは、出力が画面にどのように表示されるかです。

出力

Yaml Output

辞書の出力はきれいに見えます。 キー：値。

異なるオブジェクトを分離するための空白。

リストはダッシュ（-）で表記されます

タプルは、最初に!! Python/tupleで示され、次にリストと同じ形式で示されます。

yamlファイルをロードする

だから、私は1つのyamlファイルを持っているとしましょう 

---
# An employee record
name: Raagvendra Joshi
job: Developer
skill: Oracle
employed: True
foods:
   - Apple
   - Orange
   - Strawberry
   - Mango
languages:
   Oracle: Elite
   power_builder: Elite
   Full Stack Developer: Lame
education:
   4 GCSEs
   3 A-Levels
   MCA in something called com

では、yaml.load関数を使用してこのyamlファイルを読み込むコードを作成しましょう。 以下は同じコードです。

Yaml Load Function

出力はそれほど読みにくいように見えるため、最後にjsonを使用して出力を説明します。 取得した出力と実際のyamlファイルを比較します。

出力

Yaml3

ソフトウェア開発の最も重要な側面の1つは、デバッグです。 このセクションでは、ビルトインデバッガーまたはサードパーティのデバッガーを使用したPythonデバッグのさまざまな方法について説明します。

PDB – Pythonデバッガー

モジュールPDBは、ブレークポイントの設定をサポートしています。 ブレークポイントは、プログラムの意図的な一時停止であり、プログラムの状態に関する詳細情報を取得できます。

ブレークポイントを設定するには、次の行を挿入します 

pdb.set_trace()

例

pdb_example1.py
import pdb
x = 9
y = 7
pdb.set_trace()
total = x + y
pdb.set_trace()

このプログラムにいくつかのブレークポイントを挿入しました。 プログラムは各ブレークポイントで停止します（pdb.set_trace（））。 変数の内容を表示するには、変数名を入力するだけです。 

c:\Python\Python361>Python pdb_example1.py
> c:\Python\Python361\pdb_example1.py(8)<module>()
-> total = x + y
(Pdb) x
9
(Pdb) y
7
(Pdb) total
*** NameError: name 'total' is not defined
(Pdb)

cを押すか、次のブレークポイントまでプログラムの実行を続けます。 

(Pdb) c
--Return--
> c:\Python\Python361\pdb_example1.py(8)<module>()->None
-> total = x + y
(Pdb) total
16

最終的には、はるかに大きなプログラム（サブルーチンを使用するプログラム）をデバッグする必要があります。 そして、時々、あなたが見つけようとしている問題はサブルーチンの中にあるでしょう。 次のプログラムを考えてください。 

import pdb
def squar(x, y):
   out_squared = x^2 + y^2
   return out_squared
if __name__ == "__main__":
   #pdb.set_trace()
   print (squar(4, 5))

上記のプログラムを実行すると、 

c:\Python\Python361>Python pdb_example2.py
> c:\Python\Python361\pdb_example2.py(10)<module>()
-> print (squar(4, 5))
(Pdb)

？*を使用してヘルプを取得できますが、矢印は実行しようとしている行を示しています。 この時点で、sを押して *s を押すと、その行にステップインできます。 

(Pdb) s
--Call--
>c:\Python\Python361\pdb_example2.py(3)squar()
-> def squar(x, y):

これは関数の呼び出しです。 あなたがあなたのコードのどこにいるかの概要が必要な場合は、lを試してください- 

(Pdb) l
1 import pdb
2
3 def squar(x, y):
4 -> out_squared = x^2 + y^2
5
6 return out_squared
7
8 if __name__ == "__main__":
9 pdb.set_trace()
10 print (squar(4, 5))
[EOF]
(Pdb)

nを押すと、次の行に進むことができます。 この時点で、out_squaredメソッド内にあり、関数.i.e内で宣言された変数にアクセスできます。 xとy 

(Pdb) x
4
(Pdb) y
5
(Pdb) x^2
6
(Pdb) y^2
7
(Pdb) x**2
16
(Pdb) y**2
25
(Pdb)

そのため、^演算子は望んだものではなく、代わりに**演算子を使用して平方を行う必要があることがわかります。

これにより、関数/メソッド内でプログラムをデバッグできます。

ロギング

ロギングモジュールは、Pythonバージョン2.3以降、Pythonの標準ライブラリの一部となっています。 組み込みモジュールなので、すべてのPythonモジュールがロギングに参加できるため、アプリケーションログには、サードパーティモジュールからのメッセージと統合された独自のメッセージを含めることができます。 多くの柔軟性と機能を提供します。

ロギングの利点

  • 診断ログ-アプリケーションの操作に関連するイベントを記録します。
  • 監査ログ-ビジネス分析のためにイベントを記録します。

メッセージは「重大度」レベルで書き込まれ、ログに記録されます＆minu

  • * DEBUG（debug（））*-開発用の診断メッセージ。
  • * INFO（info（））*-標準の「進捗」メッセージ。
  • 警告（warning（））-重大ではない問題を検出しました。
  • * ERROR（error（））*-重大なエラーが発生しました。
  • * CRITICAL（critical（））*-通常、致命的なエラー（プログラムが停止します）。

以下の簡単なプログラムを見てみましょう。 

import logging

logging.basicConfig(level=logging.INFO)

logging.debug('this message will be ignored') # This will not print
logging.info('This should be logged') # it'll print
logging.warning('And this, too') # It'll print

上記では、重大度レベルでメッセージを記録しています。 最初にモジュールをインポートし、basicConfigを呼び出してログレベルを設定します。 上記で設定したレベルはINFOです。 次に、デバッグステートメント、情報ステートメント、警告ステートメントの3つの異なるステートメントがあります。

logging1.pyの出力

INFO:root:This should be logged
WARNING:root:And this, too

infoステートメントはdebugステートメントの下にあるため、デバッグメッセージを表示できません。 Outputターミナルでもデバッグステートメントを取得するには、basicConfigレベルのみを変更する必要があります。 

logging.basicConfig(level = logging.DEBUG)

そして、出力で見ることができます、 

DEBUG:root:this message will be ignored
INFO:root:This should be logged
WARNING:root:And this, too

また、デフォルトの動作では、ログレベルを設定しない場合は警告になります。 上記のプログラムの2行目をコメントアウトして、コードを実行します。 

#logging.basicConfig(level = logging.DEBUG)

出力

WARNING:root:And this, too

ロギングレベルに組み込まれたPythonは、実際には整数です。 

>>> import logging
>>>
>>> logging.DEBUG
10
>>> logging.CRITICAL
50
>>> logging.WARNING
30
>>> logging.INFO
20
>>> logging.ERROR
40
>>>

ログメッセージをファイルに保存することもできます。 

logging.basicConfig(level = logging.DEBUG, filename = 'logging.log')

これで、すべてのログメッセージは、画面ではなく現在の作業ディレクトリのファイル（logging.log）に送信されます。 これは、受け取ったメッセージの事後分析を行うことができるため、はるかに優れたアプローチです。

ログメッセージで日付スタンプを設定することもできます。 

logging.basicConfig(level=logging.DEBUG, format = '%(asctime)s %(levelname)s:%(message)s')

出力は次のようになります。 

2018-03-08 19:30:00,066 DEBUG:this message will be ignored
2018-03-08 19:30:00,176 INFO:This should be logged
2018-03-08 19:30:00,201 WARNING:And this, too

ベンチマーク

ベンチマークまたはプロファイリングは、基本的に、コードの実行速度とボトルネックの場所をテストすることです。 これを行う主な理由は、最適化のためです。

計時

Pythonには、timeitと呼ばれる組み込みモジュールが付属しています。 これを使用して、小さなコードスニペットを計測できます。 timeitモジュールはプラットフォーム固有の時間関数を使用するため、可能な限り最も正確なタイミングを取得できます。

そのため、それぞれのコードの2つの出荷を比較し、スクリプトを最適化してパフォーマンスを向上させることができます。

timeitモジュールにはコマンドラインインターフェイスがありますが、インポートすることもできます。

スクリプトを呼び出すには2つの方法があります。 最初にスクリプトを使用してみましょう。そのためには以下のコードを実行し、出力を確認します。 

import timeit
print ( 'by index: ', timeit.timeit(stmt = "mydict['c']", setup = "mydict = {'a':5, 'b':10, 'c':15}", number = 1000000))
print ( 'by get: ', timeit.timeit(stmt = 'mydict.get("c")', setup = 'mydict = {"a":5, "b":10, "c":15}', number = 1000000))

出力

by index: 0.1809192126703489
by get: 0.6088525265034692

上記では、2つの異なる方法を使用しています。 添え字によって、辞書のキー値にアクセスします。 非常に小さなデータに対しては速すぎるため、ステートメントを100万回実行します。 これで、getよりもはるかに高速にインデックスアクセスを確認できます。 コードを複数回実行することができ、理解を深めるために実行時間にわずかなばらつきがあります。

別の方法は、コマンドラインで上記のテストを実行することです。 やってみましょう、 

c:\Python\Python361>Python -m timeit -n 1000000 -s "mydict = {'a': 5, 'b':10, 'c':15}" "mydict['c']"
1000000 loops, best of 3: 0.187 usec per loop

c:\Python\Python361>Python -m timeit -n 1000000 -s "mydict = {'a': 5, 'b':10, 'c':15}" "mydict.get('c')"
1000000 loops, best of 3: 0.659 usec per loop

上記の出力は、システムのハードウェアと、システムで現在実行されているすべてのアプリケーションによって異なります。

関数を呼び出す場合は、以下でtimeitモジュールを使用できます。 テストする関数内に複数のステートメントを追加できるため。 

import timeit

def testme(this_dict, key):
   return this_dict[key]

print (timeit.timeit("testme(mydict, key)", setup = "from __main__ import testme; mydict = {'a':9, 'b':18, 'c':27}; key = 'c'", number = 1000000))

出力

0.7713474590139164

オブジェクト指向Python-ライブラリ

リクエスト-Pythonリクエストモジュール

Requestsは、Python用のエレガントでシンプルなHTTPライブラリであるPythonモジュールです。 これにより、あらゆる種類のHTTPリクエストを送信できます。 このライブラリを使用して、ヘッダー、フォームデータ、マルチパートファイルおよびパラメーターを追加し、応答データにアクセスできます。

Requestsは組み込みモジュールではないため、最初にインストールする必要があります。

あなたは、ターミナルで次のコマンドを実行することでそれをインストールすることができます- 

pip install requests

モジュールをインストールしたら、Pythonシェルで以下のコマンドを入力して、インストールが成功したかどうかを確認できます。 

import requests

インストールが成功した場合、エラーメッセージは表示されません。

GETリクエストを行う

例として、「pokeapi」を使用します

Pokeapi

出力-

Pokeapi出力

POSTリクエストを行う

現在使用中のすべてのHTTP動詞の要求ライブラリメソッド。 あなたがAPIエンドポイントに簡単なPOSTリクエストをしたいなら、あなたはそのようにすることができます- 

req = requests.post(‘http://api/user’, data = None, json = None)

これは、以前のGETリクエストとまったく同じように機能しますが、2つの追加のキーワードパラメータを備えています-

  • POSTリクエストのHTTPボディで渡される辞書、ファイル、またはバイトなどを入力できるデータ。
  • HTTPリクエストの本文でも渡されるjsonオブジェクトを設定できるjson。

パンダ：Pythonライブラリパンダ

Pandasは、強力なデータ構造を使用して高性能のデータ操作および分析ツールを提供するオープンソースのPythonライブラリです。 パンダは、データサイエンスで最も広く使用されているPythonライブラリの1つです。 これは主にデータの改ざんに使用されますが、それには正当な理由があります。強力で柔軟な機能グループ。

Numpyパッケージ上に構築され、主要なデータ構造はDataFrameと呼ばれます。 これらのデータフレームにより、観測の行と変数の列に表形式のデータを保存および操作できます。

DataFrameを作成するにはいくつかの方法があります。 1つの方法は、辞書を使用することです。 たとえば-

DataFrame

出力

データフレーム出力

出力から、新しいbrics DataFrameを確認できます。Pandasは、各国に0〜4の数値としてキーを割り当てています。

0から4までのインデックス値を提供する代わりに、2文字の国コードなど、異なるインデックス値を使用したい場合、同様に簡単に行うことができます

上記のコードの1行下に追加すると、

brics.index = ['BR'、 'RU'、 'IN'、 'C​​H'、 'SA']

出力

Dataframe brics.index

データフレームのインデックス作成

インデックス付けデータフレーム

出力

DataFrames出力のインデックス作成

パイガメ

Pygameは、ゲームを含むマルチメディアアプリケーションを作成するためのオープンソースおよびクロスプラットフォームライブラリです。 Pythonプログラミング言語で使用するように設計されたコンピューターグラフィックスとサウンドライブラリが含まれています。 Pygameで多くのクールなゲームを開発できます。」

概要

Pygameはさまざまなモジュールで構成され、各モジュールは特定のタスクセットを処理します。 たとえば、表示モジュールは表示ウィンドウと画面を処理し、描画モジュールは形状を描画する機能を提供し、キーモジュールはキーボードで動作します。 これらは、ライブラリのモジュールの一部にすぎません。

Pygameライブラリーのホームはhttps://www.pygame.org/newsにあります

Pygameアプリケーションを作成するには、次の手順に従います-

Pygameライブラリをインポートする 

import pygame

Pygameライブラリーを初期化する 

pygame.init()

ウィンドウを作成します。 

screen = Pygame.display.set_mode((560,480))
Pygame.display.set_caption(‘First Pygame Game’)

ゲームオブジェクトの初期化

このステップでは、画像のロード、サウンドのロード、オブジェクトの配置、状態変数の設定などを行います。

ゲームループを開始します。

イベントを継続的に処理し、入力をチェックし、オブジェクトを移動し、描画するループです。 ループの各反復はフレームと呼ばれます。

上記のロジックをすべて以下のプログラムに入れましょう。 

*Pygame_script.py*

Pygame Script

出力

Pygameスクリプト出力

美しいスープ：美しいスープを使用したWebスクレイピング

Webスクレイピングの背後にある一般的な考え方は、Webサイトに存在するデータを取得し、分析に使用できる形式に変換することです。

HTMLまたはXMLファイルからデータを引き出すためのPythonライブラリです。 お気に入りのパーサーを使用して、構文解析ツリーをナビゲート、検索、および変更する慣用的な方法を提供します。

BeautifulSoupは組み込みライブラリではないため、使用する前にインストールする必要があります。 BeautifulSoupをインストールするには、以下のコマンドを実行します 

$ apt-get install Python-bs4 # For Linux and Python2
$ apt-get install Python3-bs4 # for Linux based system and Python3.

$ easy_install beautifulsoup4 # For windows machine,
Or
$ pip instal beatifulsoup4 # For window machine

インストールが完了すると、いくつかの例を実行する準備が整い、Beautifulsoupを詳細に探索し、

詳細の美しいスープ

出力

詳細出力の美しいスープ

以下は、そのデータ構造をナビゲートするいくつかの簡単な方法です-

データ構造

一般的なタスクの1つは、ページの<a>タグ内にあるすべてのURLを抽出することです-

URL

別の一般的なタスクは、ページからすべてのテキストを抽出することです-

ページからのテキスト

「https://www.finddevguides.com/index.php?title=Object-oriented-python-quick-guide&oldid=79158」から取得
Powered by MediaWiki