快速指南

Object Oriented Python - Introduction

编程语言不断涌现，不同的方法也在不断涌现。面向对象的编程就是这样一种方法，在过去的几年里变得非常流行。

本章讨论Python编程语言的特性，使其成为面向对象的编程语言。

语言规划分类方案

Python可以在面向对象的编程方法中进行表征。下图显示了各种编程语言的特征。观察使其面向对象的Python的功能。

Langauage课程	分类	Langauages
编程范式	Procedural	C, C++, C#, Objective-C, java, Go
	Scripting	CoffeeScript, JavaScript, Python, Perl, Php, Ruby
	Functional	Clojure, Eralang, Haskell, Scala
编译类	Static	C, C++, C#, Objective-C, java, Go, Haskell, Scala
编译类	Dynamic	CoffeeScript, JavaScript, Python, Perl, Php, Ruby, Clojure, Erlang
类型类	Strong	C#, java, Go, Python, Ruby, Clojure, Erlang, Haskell, Scala
类型类	Weak	C, C++, C#, Objective-C, CoffeeScript, JavaScript, Perl, Php
Memory Class	Managed	Others
Unmanaged	C, C++, C#, Objective-C

什么是面向对象编程？

Object Oriented意味着针对对象。换句话说，它意味着在功能上指向建模对象。这是用于通过其数据和行为描述交互对象的集合来对复杂系统进行建模的众多技术之一。

Python是一种面向对象编程（OOP），是一种编程方式，专注于使用对象和类来设计和构建应用程序。面向对象编程（OOP）的主要支柱是Inheritance, Polymorphism, Abstraction,广告Encapsulation 。

面向对象分析（OOA）是检查问题，系统或任务以及识别对象和它们之间的交互的过程。

为什么选择面向对象的编程？

Python采用面向对象的方法设计。 OOP具有以下优势 -

提供清晰的程序结构，可以轻松映射现实世界的问题及其解决方案。
便于维护和修改现有代码。
增强程序模块性，因为每个对象都是独立存在的，并且可以轻松添加新功能而不会干扰现有功能。
为代码库提供了一个很好的框架，程序员可以很容易地调整和修改所提供的组件。
赋予代码可重用性

程序与面向对象的编程

基于程序的编程源自基于functions/procedure/routines的概念的结构编程。在面向过程的编程中很容易访问和更改数据。另一方面，面向对象编程（OOP）允许将问题分解为多个称为objects的单元，然后围绕这些对象构建数据和函数。它更强调数据而不是程序或功能。同样在OOP中，数据被隐藏，外部程序无法访问。

下图中的表格显示了POP和OOP方法之间的主要差异。

程序导向编程（POP）与。面向对象编程（OOP）。

	程序导向编程	面向对象的编程
Based On	在Pop中，整个重点是数据和功能	糟糕的是基于现实世界的场景。整个程序被分成称为对象的小部分
Reusability	有限代码重用	代码重用
Approach	Top down Approach	面向对象的设计
Access specifiers	Not any	公共，私人和受保护
数据移动	数据可以自由地从功能移动到系统中的功能	在Oops中，数据可以通过成员函数相互移动和通信
数据访问	在pop中，大多数函数使用全局数据进行共享，可以在系统中从函数到函数自由访问	在Oops中，数据不能在一个方法之间自由移动，它可以保存在公共或私有中，因此我们可以控制数据的访问
数据隐藏	在pop中，如此具体的隐藏数据方式，所以安全性稍差一点	它提供了数据隐藏，更加安全
Overloading	不可能	Functions and Operator Overloading
Example-Languages	C, VB, Fortran, Pascal	C++, Python, Java, C#
Abstraction	在程序级别使用抽象	在类和对象级别使用抽象

面向对象程序设计原理

面向对象编程（OOP）基于objects的概念而不是动作，而不是逻辑。为了使编程语言面向对象，它应该具有一种机制，使得能够使用类和对象以及基本的面向对象原则和概念的实现和使用，即继承，抽象，封装和多态。

让我们简单了解面向对象编程的每个支柱 -

封装 (Encapsulation)

此属性隐藏了不必要的详细信息，使管理程序结构变得更加容易。每个对象的实现和状态都隐藏在明确定义的边界之后，并提供了一个干净简单的界面来处理它们。实现此目的的一种方法是将数据设为私有。

继承(Inheritance)

继承，也称为泛化，允许我们捕获类和对象之间的层级关系。例如，“水果”是“橙色”的概括。从代码重用的角度来看，继承非常有用。

抽象(Abstraction)

此属性允许我们隐藏细节并仅显示概念或对象的基本特征。例如，驾驶踏板车的人知道在按下喇叭时发出声音，但他不知道在按下喇叭时声音是如何实际产生的。

多态性(Polymorphism)

多态性意味着多种形式。也就是说，事物或行为以不同的形式或方式存在。多态的一个很好的例子是类中的构造函数重载。

Object-Oriented Python

Python编程的核心是object和OOP ，但是您不必通过将代码组织到类中来限制自己使用OOP。 OOP增加了Python的整体设计理念，并鼓励一种干净，实用的编程方式。 OOP还可以编写更大更复杂的程序。

模块与类和对象

模块就像“字典”

在使用模块时，请注意以下几点 -

Python模块是一个封装可重用代码的包。
模块驻留在一个带有__init__.py文件的文件夹中。
模块包含函数和类。
使用import关键字导入模块。

回想一下，字典是key-value对。这意味着如果你有一个带有密钥EmployeID的字典，并且你想要检索它，那么你将不得不使用以下代码行 -

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

您必须使用以下过程处理模块 -

模块是一个Python文件，其中包含一些函数或变量。
导入所需的文件。
现在，您可以使用'。'访问该模块中的函数或变量。 (dot)运算符。

考虑一个名为employee.py的模块，其中包含一个名为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]。
在module的情况下，密钥是标识符，语法是.key。

类就像模块

Module是一个专门的字典，可以存储Python代码，因此您可以使用'。'来实现它。运算符。类是一种对函数和数据进行分组并将它们放在容器中的方法，因此您可以使用“。”操作符访问它们。

如果必须创建类似于雇员模块的类，则可以使用以下代码执行此操作 -

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

Note - 类比模块更受欢迎，因为您可以按原样重用它们，而不会受到太多干扰。使用模块时，您只有一个与整个程序。

对象就像迷你进口

类就像一个mini-module ，您可以使用名为instantiate的概念以类似于类的方式导入。请注意，在实例化类时，会得到一个object 。

您可以实例化一个对象，类似于像函数一样调用类，如图所示 -

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

您可以通过以下三种方式之一完成此操作 -

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

Object Oriented Python - Environment Setup

本章将详细介绍如何在本地计算机上设置Python环境。

先决条件和工具包

在继续深入学习Python之前，我们建议您检查是否满足以下先决条件 -

您的计算机上安装了最新版本的Python
安装了IDE或文本编辑器
您对Python的编写和调试基本熟悉，也就是说您可以在Python中执行以下操作 -
- 能够编写和运行Python程序。
- 调试程序并诊断错误。
- 使用基本数据类型。
- 写入for循环， while循环和if语句
- 代码functions

如果您没有任何编程语言经验，可以在Python上找到许多初学者教程

https://www.tutorialpoints.com/

安装Python (Installing Python)

以下步骤详细说明了如何在本地计算机上安装Python -

Step 1 - 访问官方Python网站https://www.python.org/ ，单击“ Downloads菜单，选择您选择的最新版本或任何稳定版本。

Step 2 - 保存您正在下载的Python安装程序exe文件，一旦下载它，打开它。单击“ Run Next ，默认选择“ Next ，完成安装。

Step 3 - 安装完成后，您现在应该看到Python菜单，如下图所示。选择IDLE（Python GUI）启动程序。

这将启动Python shell。键入简单命令以检查安装。

选择IDE

集成开发环境是一个面向软件开发的文本编辑器。在使用Python时，您必须安装IDE来控制编程流程并将项目组合在一起。以下是一些在线可用的IDE。您可以在方便时选择一个。

Pycharm IDE
Komodo IDE
Eric Python IDE

Note - Eclipse IDE主要用于Java，但它有一个Python插件。

Pycharm

Pycharm，跨平台IDE是目前最流行的IDE之一。它提供编码辅助和分析，包括代码完成，项目和代码导航，集成单元测试，版本控制集成，调试等等

下载链接

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

Languages Supported - Python，HTML，CSS，JavaScript，Coffee Script，TypeScript，Cython，AngularJS，Node.js，模板语言。

截图 (Screenshot)

为什么选择？

PyCharm为其用户提供以下功能和优势 -

跨平台IDE与Windows，Linux和Mac OS兼容
包括Django IDE，以及CSS和JavaScript支持
包括数千个插件，集成终端和版本控制
与Git，SVN和Mercurial集成
为Python提供智能编辑工具
与Virtualenv，Docker和Vagrant轻松集成
简单的导航和搜索功能
代码分析和重构
可配置的注射
支持大量的Python库
包含模板和JavaScript调试程序
包括Python/Django调试器
适用于Google App Engine，其他框架和库。
具有可自定义的UI，VIM仿真可用

科莫多IDE

它是一个多语言IDE，支持100多种语言，基本上用于动态语言，如Python，PHP和Ruby。它是一个商业IDE，提供21天免费试用，功能齐全。 ActiveState是管理Komodo IDE开发的软件公司。它还提供修剪版的Komodo，称为Komodo Edit，用于简单的编程任务。

此IDE包含从最基本级到高级级的所有类型的功能。如果您是学生或自由职业者，那么您几乎可以购买实际价格的一半。但是，对于来自公认机构和大学的教师和教授来说，它是完全免费的。

它具有Web和移动开发所需的所有功能，包括对所有语言和框架的支持。

下载链接

Komodo Edit（免费版）和Komodo IDE（付费版）的下载链接如下所示 -

Komodo Edit (free)

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

Komodo IDE (paid)

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

截图 (Screenshot)

为什么选择？

功能强大的IDE，支持Perl，PHP，Python，Ruby等等。
跨平台IDE。

它包括基本功能，如集成调试器支持，自动完成，文档对象模型（DOM）查看器，代码浏览器，交互式shell，断点配置，代码分析，集成单元测试。简而言之，它是一个专业的IDE，具有许多提高生产力的功能。

Eric Python IDE

它是Python和Ruby的开源IDE。 Eric是一个全功能的编辑器和IDE，用Python编写。它基于跨平台Qt GUI工具包，集成了高度灵活的Scintilla编辑器控件。 IDE非常易于配置，可以选择使用什么和不使用什么。您可以从以下链接下载Eric IDE:

https://eric-ide.python-projects.org/eric-download.html

为什么选择

很好的缩进，错误突出显示。
代码帮助
代码完成
使用PyLint进行代码清理
Quick search
集成的Python调试器。

截图 (Screenshot)

选择文本编辑器

您可能并不总是需要IDE。对于学习使用Python或Arduino进行编码的任务，或者在shell脚本中使用快速脚本来帮助您自动执行某些任务时，可以使用简单且轻量级的以代码为中心的文本编辑器。此外，许多文本编辑器提供语法突出显示和程序内脚本执行等功能，类似于IDE。这里给出了一些文本编辑器 -

Atom
崇高文本
Notepad++

Atom文本编辑器

Atom是由GitHub团队构建的可破解文本编辑器。它是一个免费的开源文本和代码编辑器，这意味着所有代码都可供您阅读，修改以供您自己使用，甚至可以进行改进。它是一个兼容macOS，Linux和Microsoft Windows的跨平台文本编辑器，支持用Node.js和嵌入式Git Control编写的插件。

下载链接

https://atom.io/

截图 (Screenshot)

语言支持

C/C ++，C＃，CSS，CoffeeScript，HTML，JavaScript，Java，JSON，Julia，Objective-C，PHP，Perl，Python，Ruby on Rails，Ruby，Shell脚本，Scala，SQL，XML，YAML等等。

Sublime文本编辑器

Sublime文本是一个专有软件，它为您提供免费试用版，以便在购买之前对其进行测试。据stackoverflow.com ，它是第四大最受欢迎的开发环境。

它提供的一些优势是其令人难以置信的速度，易用性和社区支持。它还支持许多编程语言和标记语言，用户可以使用插件添加功能，通常是社区构建的，并在免费软件许可下维护。

截图 (Screenshot)

语言支持

Python，Ruby，JavaScript等

为什么选择？

自定义键绑定，菜单，代码段，宏，完成等。
自动完成功能
使用片段，字段标记和占位符快速插入带有崇高文本片段的文本和代码
快速打开
跨平台支持Mac，Linux和Windows。
将光标跳到您想去的地方
选择多行，单词和列

Notepad ++

它是一个免费的源代码编辑器和Notepad替代品，支持从汇编到XML和包括Python的多种语言。在MS Windows环境中运行，其使用受GPL许可证管理。除语法高亮外，Notepad ++还有一些对编码器特别有用的功能。

截图 (Screenshot)

主要特点

语法高亮和语法折叠
PCRE（Perl兼容正则表达式）搜索/替换
完全可定制的GUI
SAuto completion
选项卡式编辑
Multi-View
多语言环境
Launchable with different arguments

语言支持

几乎所有语言（60多种语言），如Python，C，C ++，C＃，Java等。

Object Oriented Python - Data Structures

从语法的角度来看，Python数据结构非常直观，并且它们提供了大量的操作选择。您需要选择Python数据结构，具体取决于数据涉及的内容，是否需要修改，或者是否是固定数据以及需要哪种访问类型，例如在开头/结尾/随机等。

Lists

List表示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列表中的项目

列表的每个项目都分配了一个数字 - 即该数字的索引或位置。索引始终从零开始，第二个索引是一个，依此类推。要访问列表中的项目，我们可以在方括号内使用这些索引号。例如，请注意以下代码 -

>>> 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!'

因此，如果我们想要将属性组合在一起，我们可以将它们存储在空对象中，如上面的代码所示。但是，并不总是建议使用此方法。请记住，只有在要指定数据和行为时才应使用类和对象。

Tuples

元组与列表类似，可以存储元素。但是，它们是不可变的，因此我们无法添加，删除或替换对象。元组提供的主要好处是因为它的不变性是我们可以将它们用作字典中的键，或者在对象需要哈希值的其他位置。

元组用于存储数据，而不是行为。如果您需要行为来操作元组，则需要将元组传递给执行操作的函数（或另一个对象上的方法）。

由于元组可以充当字典键，因此存储的值彼此不同。我们可以通过用逗号分隔值来创建元组。元组用括号括起来但不是强制性的。以下代码显示了两个相同的分配。

>>> 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 Tuple Methods

以下代码显示了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

从上面显示的代码中，我们可以理解元组是不可变的，因此 -

您cannot将元素添加到元组。
您cannot追加或扩展方法。
您cannot从元组中删除元素。
元组no删除或弹出方法。
Count和index是元组中可用的方法。

字典(Dictionary)

Dictionary是Python的内置数据类型之一，它定义了键和值之间的一对一关系。

定义词典

请注意以下代码以了解有关定义字典的信息 -

>>> # 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'
>>>

从上面的代码我们可以看到:

首先，我们创建一个包含两个元素的字典，并将其分配给变量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()来创建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()

Object Oriented Python - Building Blocks

在本章中，我们将详细讨论面向对象的术语和编程概念.Class只是一个实例的工厂。该工厂包含描述如何制作实例的蓝图。从类构造实例或对象。在大多数情况下，我们可以有一个以上的类实例。每个实例都有一组属性，这些属性在类中定义，因此特定类的每个实例都应具有相同的属性。

类捆绑:行为和状态

类可以让您将对象的行为和状态捆绑在一起。请注意以下图表以便更好地理解 -

在讨论课程包时，以下几点值得注意 -

单词behavior与function相同 - 它是执行某些操作（或实现行为）的一段代码
单词state与variables相同 - 它是一个在类中存储值的地方。
当我们一起断言一个类行为和状态时，它意味着一个类打包函数和变量。

类具有方法和属性

在Python中，创建方法定义了一个类行为。 word方法是给定在类中定义的函数的OOP名称。总结一下 -

Class functions - 是methods同义词
Class variables - 是name attributes.同义词name attributes.
Class - 具有确切行为的实例的蓝图。
Object - 类的一个实例，执行类中定义的功能。
Type - 表示实例所属的类
Attribute - 任何对象值:object.attribute
Method - 类中定义的“可调用属性”

例如，请注意以下代码 -

var = “Hello, John”
print( type (var)) # < type ‘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.实例MyClass. 十六进制代码指的是存储对象的地址。另一个例子指向另一个地址。

现在让我们在类MyClass()定义一个变量，并从该类的实例中获取变量，如下面的代码所示 -

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)

输出 (Output)

执行上面给出的代码时，您可以观察到以下输出 -

9
9

由于实例知道它实例化了哪个类，因此当从实例请求属性时，实例会查找属性和类。这称为attribute lookup.

实例方法

类中定义的函数称为method. 实例方法需要一个实例才能调用它并且不需要装饰器。创建实例方法时，第一个参数始终为self. 虽然我们可以通过任何其他名称来调用它（self），但建议使用self，因为它是一个命名约定。

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

输出 (Output)

执行上面给出的代码时，您可以观察到以下输出 -

9
hello, World

请注意，在上面的程序中，我们定义了一个以self作为参数的方法。但我们不能调用该方法，因为我们没有声明任何参数。

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

输出 (Output)

执行上面给出的代码时，您可以观察到以下输出 -

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

封装(Encapsulation)

封装是OOP的基础之一。 OOP使我们能够隐藏对象内部工作的复杂性，这对开发人员有以下几种方式的好处 -

在不知道内部结构的情况下简化并易于理解使用对象。
任何变化都可以轻松管理。

面向对象的编程在很大程度上依赖于封装。术语封装和抽象（也称为数据隐藏）通常用作同义词。它们几乎是同义词，因为抽象是通过封装实现的。

封装为我们提供了限制对某些对象组件的访问的机制，这意味着无法从对象定义的外部看到对象的内部表示。通常通过特殊方法（ Getters和Setters.来访问此数据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())

输出 (Output)

执行上面给出的代码时，您可以观察到以下输出 -

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。

实例化操作（即calling a class object ）创建一个空对象。许多类喜欢创建具有针对特定初始状态定制的实例的对象。因此，一个类可以定义一个名为'__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)

输出 (Output)

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

输出 (Output)

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

简而言之，类属性对于类的所有实例都是相同的，而实例属性对于每个实例都是特定的。对于两个不同的实例，我们将有两个不同的实例属性。

class myClass:
   class_attribute = 99
   def class_method(self):
      self.instance_attribute = 'I am instance attribute'
print (myClass.__dict__)

输出 (Output)

执行上面给出的代码时，您可以观察到以下输出 -

{'__module__': '__main__', 'class_attribute': 99, 'class_method': <function myClass.class_method at 0x04128D68>, '__dict__': <attribute '__dict__' of 'myClass' objects>, '__weakref__': <attribute '__weakref__' of 'myClass' objects>, '__doc__': None}

实例属性myClass.__dict__如图所示 -

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

Object Oriented Shortcuts

本章详细讲述了Python中的各种内置函数，文件I/O操作和重载概念。

Python Built-in Functions

Python解释器有许多称为内置函数的函数，可以随时使用。在其最新版本中，Python包含68个内置函数，如下表所示 -

内置功能
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()
delattr()	hash()	memoryview()	set()

本节简要讨论了一些重要的功能 -

len() function

len（）函数获取字符串，列表或集合的长度。它返回对象的项目长度或数量，其中object可以是字符串，列表或集合。

>>> 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__。
它易于维护。
它支持向后兼容性。

Reversed(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循环打印正常列表的反转列表，以及两个自定义序列的实例。输出显示__reversed__ reversed()适用于它们中的所有三个，但是当我们定义__reversed__时，结果会有很大不同。

输出 (Output)

执行上面给出的代码时，您可以观察到以下输出 -

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

枚举(Enumerate)

enumerate ()方法向iterable添加一个计数器并返回枚举对象。

enumerate（）的语法是 -

enumerate(iterable, start = 0)

这里第二个参数start是可选的，默认情况下，index以零（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,它接受两个或多个序列并返回一个新的元组序列，其中每个元组包含每个序列的单个值。

File I/O

文件的概念与术语面向对象编程相关联。 Python已经包含了抽象中提供的操作系统接口，允许我们使用文件对象。

open()内置函数用于打开文件并返回文件对象。它是最常用的有两个参数的函数 -

open(filename, mode)

open（）函数调用两个参数，第一个是文件名，第二个是模式。这里模式可以是'r'表示只读模式，'w'表示只写（现有的同名文件将被删除），'a'打开文件进行追加，任何写入文件的数据都会自动添加到最后。 'r +'打开文件进行读写。默认模式是只读的。

在窗口上，附加到模式的'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方法将文件的全部内容作为str或bytes对象返回，具体取决于第二个参数是否为“b”。

为了便于阅读，并且为了避免一次性读取大文件，通常最好直接在文件对象上使用for循环。对于文本文件，它将一次读取每一行，我们可以在循环体内处理它。但是对于二进制文件，最好使用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（）方法的更好方法，但从技术上讲，这将在脚本存在时自动发生。

方法重载的替代方法

方法重载是指具有多个接受不同参数集的同名方法。

给定单个方法或函数，我们可以指定自己的参数数量。根据函数定义，可以使用零个，一个，两个或更多参数调用它。

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')

输出 (Output)

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)

在上面的代码中，我们可以将两个不同的函数作为参数传递给我们的第三个函数，并为每个函数获取不同的输出 -

The description: A silly function
The name: my_func
The class: <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: <class>
Now I'll call the function passed in
Second function was called
</class></class>

可调用的对象

就像函数是可以在其上设置属性的对象一样，可以创建一个可以被调用的对象，就像它是一个函数一样。

在Python中，可以使用函数调用语法调用具有__call __（）方法的任何对象。

Inheritance and Polymorphism

继承和多态 - 这是Python中一个非常重要的概念。如果你想学习，你必须更好地理解它。

继承 (Inheritance)

面向对象编程的一个主要优点是重用。继承是实现同样的机制之一。继承允许程序员首先创建通用类或基类，然后将其扩展到更专业的类。它允许程序员编写更好的代码。

使用继承，您可以使用或继承基类中可用的所有数据字段和方法。稍后您可以添加自己的方法和数据字段，因此继承提供了一种组织代码的方法，而不是从头开始重写代码。

在面向对象的术语中，当类X扩展类Y时，则Y称为超级/父/基类，X称为子类/子/派生类。这里要注意的一点是，子类只能访问非私有的数据字段和方法。私有数据字段和方法只能在类中访问。

创建派生类的语法是 -

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

继承属性

现在看下面的例子 -

输出 (Output)

我们首先创建了一个名为Date的类，并将该对象作为参数传递，here-object是Python提供的内置类。后来我们创建了另一个名为time的类，并将Date类称为参数。通过此调用，我们可以访问Date类的所有数据和属性到Time类中。因此，当我们尝试从我们之前创建的Time类对象tm获取get_date方法时，可能。

Object.Attribute查找层次结构

实例
class
此类继承的任何类

继承示例

让我们看看继承示例的闭包 -

让我们创建几个类来参与示例 -

动物 - 类模拟动物
猫 - 动物的子类
狗 - 动物的子类

在Python中，类的构造函数用于创建对象（实例），并为属性赋值。

子类的构造函数总是调用父类的构造函数来初始化父类中的属性的值，然后它开始为其属性赋值。

输出 (Output)

在上面的示例中，我们看到了我们在父类中放置的命令属性或方法，以便所有子类或子类将从父类继承该属性。

如果一个子类尝试从另一个子类继承方法或数据，那么它将通过一个错误，就像我们看到当Dog类尝试从该cat类调用swatstring（）方法时，它会抛出一个错误（就像我们的情况下的AttributeError）。

Polymorphism (“MANY SHAPES”)

多态性是Python中类定义的一个重要特性，当您跨类或子类使用通常命名的方法时，可以使用它。这允许函数在不同时间使用不同类型的实体。因此，它提供了灵活性和松散耦合，因此可以随着时间的推移扩展和轻松维护代码。

这允许函数使用任何这些多态类的对象，而无需了解类之间的区别。

多态可以通过继承来执行，子类使用基类方法或覆盖它们。

让我们用我们之前的继承示例理解多态的概念，并在两个子类中添加一个名为show_affection的常用方法 -

从我们可以看到的示例中，它指的是一种设计，其中不同类型的对象可以以相同的方式处理，或者更具体地，使用相同名称或公共接口的方法处理两个或更多个类，因为相同的方法（以下示例中的show_affection）用任何类型的对象调用。

输出 (Output)

因此，所有动物都表现出情感（show_affection），但它们的表现却不同。因此，“show_affection”行为是多态的，因为它根据动物的不同而有所不同。因此，抽象的“动物”概念实际上并不是“show_affection”，而是特定的动物（如狗和猫）具有动作“show_affection”的具体实现。

Python本身具有多态的类。例如，len（）函数可以与多个对象一起使用，并且所有对象都根据输入参数返回正确的输出。

Overriding

在Python中，当子类包含覆盖超类方法的方法时，您还可以通过调用调用超类方法

Super（Subclass，self）.method而不是self.method。

例子 (Example)

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并在那里找到并在那里调用它。因此，当我们的类设计变得复杂时，我们可能希望初始化一个实例，首先通过父类构造函数然后通过子类构造函数处理它。

输出 (Output)

在上面的例子中 - 所有动物都有一个名字，所有的狗都是特定的品种。我们用super调用了父类构造函数。所以狗有自己的__init__但是第一件事就是我们称之为超级。 Super内置于函数中，旨在将类与其超类或其父类相关联。

在这种情况下，我们说获取超类狗并将狗实例传递给我们在这里所说的构造函数__init__。换句话说，我们用dog对象调用父类Animal __init__。你可能会问为什么我们不会只用dog实例说动物__init__，我们可以这样做但是如果动物类的名字要改变，将来某个时候。如果我们想重新安排类层次结构，那么狗会从另一个类继承。在这种情况下使用super可以让我们保持模块化，易于更改和维护。

因此，在此示例中，我们能够将常规__init__功能与更具体的功能相结合。这使我们有机会将通用功能与特定功能分开，这些功能可以消除代码重复，并以反映系统整体设计的方式将类相互关联。

结论 (Conclusion)

__init__与任何其他方法一样; 它可以继承
如果一个类没有__init__构造函数，Python将检查其父类以查看它是否可以找到它。
一找到它，Python就会调用它并停止查找
我们可以使用super（）函数来调用父类中的方法。
我们可能想要在父级和我们自己的类中初始化。

多重继承和查找树

正如其名称所示，多重继承是Python，当一个类继承自多个类时。

例如，一个孩子继承父母双方（母亲和父亲）的人格特质。

Python Multiple Inheritance Syntax

为了使类继承自多个父类，我们在定义它时将括号中的这些类的名称写入派生类。我们用逗号分隔这些名称。

以下是一个例子 -

>>> class Mother:
   pass
>>> class Father:
   pass
>>> class Child(Mother, Father):
   pass
>>> issubclass(Child, Mother) and issubclass(Child, Father)
True

多重继承是指从两个或两个以上的类继承的能力。当孩子从父母继承而父母继承祖父母阶级时，就会出现复杂性。 Python爬上继承树，查找要求从对象读取的属性。它将检查实例，在类中然后在父类中检查，最后从祖父类中检查。现在问题出现了类的搜索顺序 - 先呼吸或深度优先。默认情况下，Python采用深度优先。

这就是为什么在下图中Python首先在A类中搜索dothis（）方法。所以下面例子中的方法解析顺序将是

Mro- D→B→A→C

看下面的多重继承图 -

让我们通过一个例子来理解Python的“mro”特性。

输出 (Output)

例子3 (Example 3)

让我们再看一个“钻石形状”多重继承的例子。

上图将被视为含糊不清。从我们之前的例子中了解“方法解析顺序”.ie mro将是D→B→A→C→A，但事实并非如此。在从C获得第二个A时，Python将忽略之前的A.因此在这种情况下mro将是D→B→C→A。

让我们根据上图创建一个示例 -

输出 (Output)

理解上述输出的简单规则是 - 如果在方法分辨率顺序中出现相同的类，则将从方法分辨率顺序中删除此类的早期外观。

总之 -

任何类都可以从多个类继承
在搜索继承类时，Python通常使用“深度优先”顺序。
但是当两个类继承自同一个类时，Python会从mro中删除该类的首次出现。

装饰器，静态和类方法

函数（或方法）由def语句创建。

虽然方法的工作方式与函数完全相同，但方法第一个参数是实例对象的一点除外。

我们可以根据它们的行为方式对方法进行分类，例如

Simple method - 在类之外定义。此函数可以通过提供实例参数来访问类属性:

def outside_func(():

Instance method -

def func(self,)

Class method - 如果我们需要使用类属性

   @classmethod
def cfunc(cls,)

Static method - 没有关于该类的任何信息

      @staticmethod
def sfoo()

直到现在我们已经看到了实例方法，现在是时候了解其他两种方法，

类方法 (Class Method)

@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）参数，但它可以自由地接受任意数量的其他参数。

syntax

class C(object):
   @staticmethod
   def fun(arg1, arg2, ...):
   ...
returns: a static method for function funself.

静态方法既不能修改对象状态也不能修改类状态。
他们受限于他们可以访问的数据。

什么时候用

我们通常使用类方法来创建工厂方法。 Factory方法为不同的用例返回类对象（类似于构造函数）。
我们通常使用静态方法来创建实用程序函数。

Python Design Pattern

概述 (Overview)

现代软件开发需要满足复杂的业务需求。它还需要考虑未来可扩展性和可维护性等因素。良好的软件系统设计对于实现这些目标至关重要。设计模式在这样的系统中起着重要作用。

要了解设计模式，让我们考虑以下示例 -

每辆车的设计都遵循基本的设计模式，四个车轮，方向盘，核心驱动系统，如加速器 - 断开 - 离合器等。

因此，所有重复建造/生产的东西，都必然会遵循其设计模式......汽车，自行车，披萨，自动取款机，无论是什么......甚至是沙发床。

几乎成为在软件中编码某些逻辑/机制/技术的标准方法的设计，因此被称为或研究为软件设计模式。

为什么设计模式很重要？

使用设计模式的好处是 -

通过成熟的方法帮助您解决常见的设计问题。
理解中没有含糊不清的内容。
缩短整体开发时间。
帮助您更轻松地处理未来的扩展和修改。
可以减少系统中的错误，因为它们是常见问题的成熟解决方案。

设计模式的分类

GoF（Gang of Four）设计模式分为三类，即创造，结构和行为。

创作模式

创建设计模式将对象创建逻辑与系统的其余部分分开。创建模式不是为您创建对象，而是为您创建它们。创作模式包括抽象工厂，建造者，工厂方法，原型和单身人士。

由于语言的动态特性，Creational Patterns在Python中并不常用。语言本身也为我们提供了我们需要以足够优雅的方式创建的所有灵活性，我们很少需要在顶层实现任何东西，如singleton或Factory。

此外，这些模式提供了一种在隐藏创建逻辑的同时创建对象的方法，而不是使用新运算符直接实例化对象。

结构模式

有时候，您需要使用现有的一组类来构建更大的结构，而不是从头开始。这就是结构类模式使用继承来构建新结构的地方。结构对象模式使用组合/聚合来获得新功能。适配器，桥梁，复合材料，装饰器，外墙，飞重和代理是结构模式。它们提供了组织类层次结构的最佳方法。

行为模式

行为模式提供了处理对象之间通信的最佳方式。模式属于这一类别:访客，责任链，命令，口译员，迭代器，调解员，纪念品，观察员，状态，战略和模板方法是行为模式。

因为它们代表系统的行为，所以它们通常用于描述软件系统的功能。

常用的设计模式

单身人士(Singleton)

它是所有设计模式中最具争议和最着名的一个。它用于过度面向对象的语言，是传统的面向对象编程的重要组成部分。

Singleton模式用于，

需要执行日志记录时。记录器实例由系统的所有组件共享。
配置文件正在使用它，因为信息缓存需要由系统中的所有各种组件维护和共享。
管理与数据库的连接。

这是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

在此示例中，Logger是Singleton。

当调用__new__时，它通常构造该类的新实例。当我们覆盖它时，我们首先检查我们的单例实例是否已经创建。如果没有，我们使用超级电话创建它。因此，每当我们在Logger上调用构造函数时，我们总是得到完全相同的实例。

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

Object Oriented Python - Advanced Features

在本文中，我们将介绍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__添加到我们自己的类中，我们也可以这样做。我们试着这样做。

我们有一个名为Sumlist的类，它有一个构造函数__init__，它将list作为一个名为my_list的参数。

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])

输出 (Output)

[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__。当我们在字典中设置键和值时，会调用此（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]))

输出 (Output)

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

让我们扩展前面的例子，下面我们在处理列表索引时调用了两个名为__getitem__和__setitem__的魔术方法。

# 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!

输出 (Output)

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

在上面的例子中，我们在Mylist中设置了一个三项列表，并且隐式调用__init__方法，当我们打印元素x时，我们得到三个项目列表（['a'，'b'，'c']）。然后我们将另一个元素附加到此列表中。稍后我们要求索引1和索引4.但是如果你看到输出，我们从（index-1）得到我们要求的元素。我们知道列表索引从0开始，但这里的索引从1开始（这就是为什么我们得到列表的第一项）。

命名约定

在这里，我们将研究我们将用于变量的名称，尤其是全球Python程序员使用的私有变量和约定。虽然变量被指定为私有，但Python中没有隐私，这是设计的。与任何其他记录良好的语言一样，Python具有它所推广的命名和样式约定，尽管它不会强制执行它们。由Guido van Rossum” the originator of Python, that describe the best practices and use of name and is called PEP8. Here is the link for this, “ Guido van Rossum” the originator of Python, that describe the best practices and use of name and is called PEP8. Here is the link for this,编写的风格指南Guido van Rossum” the originator of Python, that describe the best practices and use of name and is called PEP8. Here is the link for this, Guido van Rossum” the originator of Python, that describe the best practices and use of name and is called PEP8. Here is the link for this, https://www.python.org/dev/peps/pep-0008/

PEP代表Python增强提议，是一系列文档，分布在Python社区中以讨论提议的更改。例如，建议全部，

模块名称 - all_lower_case
类名和异常名称 - CamelCase
全局和本地名称 - 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)

输出 (Output)

setting the "var" attribute
10
no privacy!

Object Oriented Python - Files and Strings

Strings

字符串是每种编程语言中使用的最流行的数据类型。为什么？因为我们比数字更好地理解文本，所以在写作和谈话中我们使用文本和单词，类似于编程我们也使用字符串。在字符串中，我们解析文本，分析文本语义，并进行数据挖掘 - 所有这些数据都是人类消费的文本.Python中的字符串是不可变的。

字符串操作

在Python中，字符串可以用多种方式标记，在多行字符串的情况下使用单引号（'），双引号（“）或甚至三引号（'''）。

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

字符串操作非常有用，并且在每种语言中都被广泛使用。通常，程序员需要打破字符串并仔细检查它们。

字符串可以迭代（逐个字符），切片或连接。语法与列表相同。

str类有很多方法可以使操作字符串更容易。 dir和help命令在Python解释器中提供了如何使用它们的指导。

下面是我们使用的一些常用字符串方法。

Sr.No.	方法和描述
1	isalpha() 检查所有字符是否都是字母
2	isdigit() 检查数字字符
3	isdecimal() 检查十进制字符
4	isnumeric() 检查数字字符
5	find() 返回子串的最高索引
6	istitle() 检查Titlecased字符串
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（）方法或格式字符串中的％符号（旧样式）来完成。

该字符串可以包含由大括号{}分隔的文字文本或替换字段，每个替换字段可以包含位置参数的数字索引或关键字参数的名称。

句法

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字符的集合。 Unicode字符串提供了创建可在任何地方工作的软件或程序的机会，因为Unicode字符串可以表示任何可能的字符，而不仅仅是ASCII字符。

许多IO操作只知道如何处理字节，即使bytes对象引用文本数据。因此，了解如何在字节和Unicode之间进行交换非常重要。

Converting text to bytes

将字符串转换为字节对象称为编码。有许多形式的编码，最常见的是:PNG; JPEG，MP3，WAV，ASCII，UTF-8等。此（编码）也是一种以字节为单位表示音频，图像，文本等的格式。

这种转换可以通过encode（）实现。它采用编码技术作为参数。默认情况下，我们使用'UTF-8'技术。

>>> # Python Code to demonstrate string encoding 
>>> 
>>> # Initialising a String 
>>> x = 'IoWiki' 
>>> 
>>> #Initialising a byte object 
>>> y = b'IoWiki'
>>> 
>>> # 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!

Converting bytes to text

将字节转换为文本称为解码。这是通过decode（）实现的。如果我们知道使用哪种编码对字符串进行编码，我们可以将字节字符串转换为字符串。

因此编码和解码是逆过程。

>>> 
>>> # Python code to demonstrate Byte Decoding 
>>> 
>>> #Initialise a String 
>>> x = 'IoWiki' 
>>> 
>>> #Initialising a byte object 
>>> y = b'IoWiki' 
>>> 
>>> #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! 
>>>

File I/O

操作系统将文件表示为字节序列，而不是文本。

文件是磁盘上用于存储相关信息的命名位置。它用于永久存储磁盘中的数据。

在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'

要从文件中读取文本，我们只需要将文件名传递给函数。将打开该文件以进行读取，并使用平台默认编码将字节转换为文本。

Exception and Exception Classes

通常，例外是任何异常情况。例外通常表示错误，但有时他们故意放入程序，例如提前终止程序或从资源短缺中恢复。有许多内置异常，表示读取文件末尾或除以零等条件。我们可以定义自己的异常，称为自定义异常。

异常处理使您可以优雅地处理错误并对其执行有意义的操作。异常处理有两个组成部分:“抛出”和“捕获”。

Identifying Exception (Errors)

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.

Catching/Trapping Exception

当程序中出现异常并且您希望使用异常机制处理它时，您会“抛出异常”。关键字try和except用于捕获异常。每当try块中发生错误时，Python都会查找匹配的except块来处理它。如果有，执行跳转到那里。

句法

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')

输出 (Output)

Enter your age: -2
Only positive integers are allowed

另一种创建自定义Exception类的方法。

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)

输出 (Output)

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

Object Oriented Python - Object Serialization

在数据存储的上下文中，序列化是将数据结构或对象状态转换为可以存储（例如，在文件或存储缓冲器中）或稍后传输和重构的格式的过程。

在序列化中，对象被转换为可以存储的格式，以便以后能够对其进行反序列化并从序列化格式重新创建原始对象。

Pickle

Pickling是将Python对象层次结构转换为要写入文件的字节流（通常不是人类可读的）的过程，这也称为序列化。取消是反向操作，将字节流转换回工作的Python对象层次结构。

Pickle是操作上最简单的存储对象的方法。 Python Pickle模块是一种面向对象的方式，可以直接以特殊的存储格式存储对象。

它能做什么？

Pickle可以非常轻松地存储和复制字典和列表。
存储对象属性并将它们还原到同一个状态。

什么泡菜不能做？

它不保存对象代码。只有它的属性值。
它无法存储文件句柄或连接套接字。

简而言之，我们可以说，酸洗是一种在文件中存储和检索数据变量的方法，其中变量可以是列表，类等。

要腌制你必须的东西 -

import pickle
将变量写入文件，例如

pickle.dump(mystring, outfile, protocol),

其中第三个参数协议是可选的要取消你必须的东西 -

进口泡菜

将变量写入文件，例如

myString = pickle.load(inputfile)

方法 (Methods)

pickle界面提供四种不同的方法。

dump() - dump（）方法序列化为打开的文件（类文件对象）。
dumps() - 序列化为字符串
load() - 从类似开放的对象反序列化。
loads() - 从字符串反序列化。

基于以上程序，下面是“酸洗”的一个例子。

输出 (Output)

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对象的文件，可以使用dump（）方法（而不是dumps *（）* one）同时传递打开的二进制文件，并且pickling结果将自动存储在文件中。

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

Unpickling (Unpickling)

采用二进制数组并将其转换为对象层次结构的过程称为unpickling。

通过使用pickle模块的load（）函数完成unpickling过程，并从简单的字节数组返回一个完整的对象层次结构。

我们在前面的例子中使用load函数。

输出 (Output)

MeOw is black
Pussy is white

JSON

JSON（JavaScript Object Notation）已经成为Python标准库的一部分，是一种轻量级的数据交换格式。人类很容易读写。它很容易解析和生成。

由于其简单性，JSON是我们存储和交换数据的一种方式，它通过其JSON语法实现，并在许多Web应用程序中使用。因为它是人类可读的格式，这可能是在数据传输中使用它的原因之一，除了它在使用API时的有效性。

JSON格式数据的示例如下 -

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

Python使得使用Json文件变得简单。为此目的而使用的模块是JSON模块。应该在Python安装中包含（内置）此模块。

那么让我们看看如何将Python字典转换为JSON并将其写入文本文件。

JSON到Python

读JSON意味着将JSON转换为Python值（对象）。 json库将JSON解析为Python中的字典或列表。为了做到这一点，我们使用loads（）函数（从字符串加载），如下所示 -

输出 (Output)

下面是一个示例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脚本对象通知）是一种非常简单的格式，这也是它受欢迎的原因之一。现在让我们通过以下程序查看json输出。

输出 (Output)

上面我们打开json文件（data1.json）进行读取，获取文件处理程序并传递给json.load并获取对象。当我们尝试打印对象的输出时，它与json文件相同。虽然对象的类型是字典，但它作为Python对象出现。当我们看到这个泡菜时，写入json很简单。上面我们加载json文件，添加另一个键值对并将其写回到同一个json文件中。现在，如果我们看到data1.json，它看起来不同.ie的格式与我们之前看不到的相同。

为了使我们的输出看起来相同（人类可读的格式），将几个参数添加到我们程序的最后一行，

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

与pickle类似，我们可以使用转储打印字符串并使用load加载。以下是一个例子，

YAML

YAML可能是所有编程语言中最人性化的数据序列化标准。

Python yaml模块称为pyaml

YAML是JSON的替代品 -

Human readable code - YAML是人类可读的格式，因此即使其首页内容也显示在YAML中以表明这一点。
Compact code - 在YAML中，我们使用空格缩进来表示结构而不是括号。
Syntax for relational data - 对于内部引用，我们使用锚点（＆）和别名（*）。
One of the area where it is used widely is for viewing/editing of data structures - 例如配置文件，调试期间的转储和文档头。

安装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 shell并导入yaml模块，导入yaml，如果没有找到错误，那么我们可以说安装成功。

安装pyaml后，让我们看下面的代码，

script_yaml1.py

上面我们创建了三种不同的数据结构，字典，列表和元组。在每个结构上，我们做yaml.dump。重要的一点是输出如何在屏幕上显示。

输出 (Output)

字典输出看起来很干净.ie。核心价值。

用于分隔不同对象的空白区域。

列表标有破折号（ - ）

元组首先用!! Python /元组表示，然后以与列表相同的格式表示。

加载yaml文件

所以，假设我有一个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文件。下面是相同的代码。

由于输出看起来不那么可读，我最后通过使用json来美化它。比较我们得到的输出和我们拥有的实际yaml文件。

输出 (Output)

软件开发最重要的一个方面是调试。在本节中，我们将看到使用内置调试器或第三方调试器进行Python调试的不同方法。

PDB - Python调试器

模块PDB支持设置断点。断点是程序的故意暂停，您可以在其中获取有关程序状态的更多信息。

要设置断点，请插入该行

pdb.set_trace()

例子 (Example)

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方法内，并且您可以访问函数.ie 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)

所以我们可以看到^运算符不是我们想要的，而是我们需要使用**运算符来做正方形。

这样我们就可以在函数/方法中调试我们的程序。

日志记录 (Logging)

自Python 2.3版以来，日志记录模块已成为Python标准库的一部分。由于它是一个内置模块，所有Python模块都可以参与日志记录，因此我们的应用程序日志可以包含您自己的消息，该消息与来自第三方模块的消息集成在一起。它提供了很多灵活性和功能。

记录的好处

Diagnostic logging - 它记录与应用程序操作相关的事件。
Audit logging - 它记录业务分析的事件。

消息以“严重性”和最小值的级别写入和记录

DEBUG (debug()) - 用于开发的诊断消息。
INFO (info()) - 标准的“进度”消息。
WARNING (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。然后我们有三个不同的语句:debug语句，info语句和警告语句。

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

此外，默认行为意味着如果我们不设置任何日志记录级别是警告。只需注释掉上面程序中的第二行并运行代码即可。

#logging.basicConfig(level = logging.DEBUG)

输出 (Output)

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

基准测试(Benchmarking)

基准测试或分析基本上是为了测试代码的执行速度和瓶颈在哪里？这样做的主要原因是为了优化。

timeit

Python附带了一个名为timeit的内置模块。您可以使用它来计算小代码片段的时间。 timeit模块使用特定于平台的时间函数，以便您可以获得最准确的时序。

因此，它允许我们比较每个代码的两个代码，然后优化脚本以获得更好的性能。

timeit模块具有命令行界面，但也可以导入。

调用脚本有两种方法。让我们先使用脚本，为此运行下面的代码并查看输出。

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))

输出 (Output)

by index: 0.1809192126703489
by get: 0.6088525265034692

上面我们使用两个不同的方法.ie by下标并获取访问字典键值。我们执行语句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))

输出 (Output)

0.7713474590139164

Object Oriented Python - Libraries

请求 - Python请求模块

Requests是一个Python模块，它是一个优雅而简单的Python HTTP库。有了它，您可以发送各种HTTP请求。使用此库，我们可以添加标题，表单数据，多部分文件和参数，并访问响应数据。

由于请求不是内置模块，因此我们需要先安装它。

您可以通过在终端中运行以下命令来安装它 -

pip install requests

安装模块后，可以通过在Python shell中键入以下命令来验证安装是否成功。

import requests

如果安装成功，您将看不到任何错误消息。

发出GET请求

作为一个例子，我们将使用“pokeapi”

输出 -

发出POST请求

请求当前正在使用的所有HTTP谓词的库方法。如果您想向API端点发出简单的POST请求，那么您可以这样做 -

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

这将与我们之前的GET请求完全相同，但它有两个额外的关键字参数 -

数据可以填充在一个字典，一个文件或字节，将在我们的POST请求的HTTP正文中传递。
json，可以使用json对象填充，该对象也将在我们的HTTP请求的主体中传递。

熊猫:Python图书馆熊猫

Pandas是一个开源Python库，使用其强大的数据结构提供高性能数据操作和分析工具。 Pandas是数据科学中使用最广泛的Python库之一。它主要用于数据调整，并有充分的理由:强大而灵活的功能组。

基于Numpy包，关键数据结构称为DataFrame。这些数据框允许我们在观察行和变量列中存储和操作表格数据。

有几种方法可以创建DataFrame。一种方法是使用字典。例如 -

输出 (Output)

从输出中我们可以看到新的brics DataFrame，Pandas已经为每个国家分配了一个键作为数值0到4。

如果不是从0到4给出索引值，我们希望有不同的索引值，比如两个字母的国家代码，你也可以轻松地做到这一点 -

在上面的代码中添加以下一行，给出

brics.index = ['BR'，'RU'，'IN'，'CH'，'SA']

输出 (Output)

索引DataFrames

输出 (Output)

Pygame

Pygame是一个开源和跨平台的库，用于制作包括游戏在内的多媒体应用程序。它包括计算机图形和声音库，旨在与Python编程语言一起使用。你可以用Pygame开发很多很酷的游戏。

概述 Overview

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’)

Initialize game objects

在这一步中，我们加载图像，加载声音，进行对象定位，设置一些状态变量等。

Start the game loop.

它只是一个循环，我们不断处理事件，检查输入，移动对象，并绘制它们。循环的每次迭代称为帧。

我们将以上所有逻辑放在一个程序下面，

Pygame_script.py

输出 (Output)

美丽的汤:网上刮美丽的汤

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，

输出 (Output)

以下是一些导航该数据结构的简单方法 -

一个常见的任务是提取页面的标签中找到的所有网址 -

另一个常见任务是从页面中提取所有文本 -

<上一篇.Python (库)Libraries

有用的资源.下一篇>

教程

介绍

环境设置(Environment Setup)

数据结构(Data Structures)

建筑模块(Building Blocks)

面向对象的快捷方式(Object Oriented Shortcuts)

继承与多态(Inheritance and Ploymorphism)

Python Design Pattern

高级功能(Advanced Features)

文件和字符串(Files and Strings)

异常和异常类(Exception and Exception Classes)

对象序列化(Object Serialization)

Python (库)Libraries

快速指南

有用的资源

讨论

快速指南

Object Oriented Python - Introduction

语言规划分类方案

什么是面向对象编程？

为什么选择面向对象的编程？

程序与面向对象的编程

面向对象程序设计原理

封装 (Encapsulation)

继承(Inheritance)

抽象(Abstraction)

多态性(Polymorphism)

Object-Oriented Python

模块与类和对象

模块就像“字典”

类就像模块

对象就像迷你进口

Object Oriented Python - Environment Setup

先决条件和工具包

安装Python (Installing Python)

选择IDE

Pycharm

下载链接

截图 (Screenshot)

为什么选择？

科莫多IDE

下载链接

截图 (Screenshot)

为什么选择？

Eric Python IDE

为什么选择

截图 (Screenshot)

选择文本编辑器

Atom文本编辑器

下载链接

截图 (Screenshot)

语言支持

Sublime文本编辑器

截图 (Screenshot)

语言支持

为什么选择？

Notepad ++

截图 (Screenshot)

主要特点

语言支持

Object Oriented Python - Data Structures

Lists

数据结构 - 列表

访问Python列表中的项目

空对象

Tuples

定义一个元组

Python Tuple Methods

字典(Dictionary)

定义词典

修改词典

混合字典中的数据类型

从词典中删除项目

Sets

创建一个集合

集的方法

集合的运算符

Object Oriented Python - Building Blocks

类捆绑:行为和状态

类具有方法和属性