Python基础

布满荆棘的人生 2021-09-20 23:32 486阅读 0赞

# python基础 #

# python入门 #

Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。

Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。

*  **Python 是一种解释型语言：** 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
 *  **Python 是交互式语言：** 这意味着，您可以在一个 Python 提示符 **>>>** 后直接执行代码。
 *  **Python 是面向对象语言:** 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
 *  \*\*Python 是初学者的语言：\*\*Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。

## Python 发展历史 ##

Python 是由 Guido van Rossum 在八十年代末和九十年代初，在荷兰国家数学和计算机科学研究所设计出来的。

Python 本身也是由诸多其他语言发展而来的,这包括 ABC、Modula-3、C、C++、Algol-68、SmallTalk、Unix shell 和其他的脚本语言等等。

像 Perl 语言一样，Python 源代码同样遵循 GPL(GNU General Public License)协议。

现在 Python 是由一个核心开发团队在维护，Guido van Rossum 仍然占据着至关重要的作用，指导其进展。

Python 2.0 于 2000 年 10 月 16 日发布，增加了实现完整的垃圾回收，并且支持 Unicode。

Python 3.0 于 2008 年 12 月 3 日发布，此版不完全兼容之前的 Python 源代码。不过，很多新特性后来也被移植到旧的Python 2.6/2.7版本。

Python 3.0 版本，常被称为 Python 3000，或简称 Py3k。相对于 Python 的早期版本，这是一个较大的升级。

Python 2.7 被确定为最后一个 Python 2.x 版本，它除了支持 Python 2.x 语法外，还支持部分 Python 3.1 语法。

## Python 特点 ##

**优点**

*  \*\*1.易于学习：\*\*Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
 *  \*\*2.易于阅读：\*\*Python代码定义的更清晰。
 *  \*\*3.易于维护：\*\*Python的成功在于它的源代码是相当容易维护的。
 *  \*\*4.一个广泛的标准库：\*\*Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
 *  \*\*5.互动模式：\*\*互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
 *  \*\*6.可移植：\*\*基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
 *  \*\*7.可扩展：\*\*如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
 *  \*\*8.数据库：\*\*Python提供所有主要的商业数据库的接口。ORACLE,MYSQL,SQLSERVER
 *  \*\*9.GUI编程：\*\*Python支持GUI可以创建和移植到许多系统调用。(Graphical User Interface)
 *  **10.可嵌入:** 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。

**缺点**

*  运行速度，有速度要求的话，用 C++ 改写关键部分吧。
 *  国内市场较小（国内以 Python 来做主要开发的，目前只有一些 web2.0 公司）。但时间推移，目前很多国内软件公司，尤其是游戏公司，也开始规模使用他。
 *  中文资料匮乏（好的 Python 中文资料屈指可数，现在应该变多了）。托社区的福，有几本优秀的教材已经被翻译了，但入门级教材多，高级内容还是只能看英语版。
 *  构架选择太多（没有像 C\# 这样的官方 .net 构架，也没有像 ruby 由于历史较短，构架开发的相对集中。Ruby on Rails 构架开发中小型web程序天下无敌）。不过这也从另一个侧面说明，python比较优秀，吸引的人才多，项目也多。

## Python 应用 ##

*  Youtube - 视频社交网站
 *  Google - 全球最大的[搜索引擎][Link 1]公司
 *  Facebook -社交网站
 *  Reddit - 社交分享网站
 *  Dropbox - 文件分享服务
 *  豆瓣网 - 图书、唱片、电影等文化产品的资料数据库网站
 *  知乎 - 一个问答网站
 *  果壳 - 一个泛科技主题网站
 *  Bottle - Python微Web框架
 *  EVE - 网络游戏EVE大量使用Python进行开发
 *  Blender - 使用Python作为建模工具与GUI语言的开源3D绘图软件
 *  Inkscape - 一个开源的SVG矢量图形编辑器。

## Python简介及应用领域 ##

Python是一种解释型脚本语言，可以应用于以下领域：

*  Web 和 Internet开发
 *  科学计算和统计
 *  人工智能
 *  教育
 *  桌面界面开发
 *  软件开发
 *  后端开发
    
    ## 如何用 ##

有些系统自带python,如果没有自行官网下载https://www.python.org/

## 风格 ##

Python在设计上坚持了清晰划一的风格，这使得Python成为一门易读、易维护，并且被大量用户所欢迎的、用途广泛的[语言][Link 2]。

设计者开发时总的指导思想是，对于一个特定的问题，只要有一种最好的方法来解决就好了。

Python的作者有意的设计限制性很强的语法，使得不好的编程习惯（例如[if语句][if]的下一行不向右缩进）都不能通过编译。其中很重要的一项就是Python的[缩进][Link 3]规则。

## 与MATLAB的对比 ##

说起科学计算，首先会被提到的可能是[MATLAB][]。然而除了MATLAB的一些专业性很强的工具箱还无法被替代之外，[MATLAB][MATLAB 1]的大部分常用功能都可以在Python世界中找到相应的扩展库。和MATLAB相比，用Python做科学计算有如下优点：

● 首先，[MATLAB][MATLAB 1]是一款商用软件，并且价格不菲。而Python完全免费，众多开源的[科学][Link 4]计算库都提供了Python的调用接口。用户可以在任何计算机上免费安装Python及其绝大多数扩展库。

● 其次，与[MATLAB][MATLAB 1]相比，Python是一门更易学、更严谨的程序设计语言。它能让用户编写出更易读、易维护的代码。

● 最后，[MATLAB][MATLAB 1]主要专注于工程和科学计算。然而即使在计算领域，也经常会遇到文件管理、[界面设计][Link 5]、[网络通信][Link 6]等各种需求。而Python有着丰富的扩展库，可以轻易完成各种高级任务，开发者可以用Python实现完整应用程序所需的各种功能。

注:MATLAB \[1\] 是美国[MathWorks][]公司出品的商业[数学软件][Link 7]，用于算法开发、数据可视化、数据分析以及[数值计算][Link 8]的高级技术计算语言和交互式环境，主要包括MATLAB和Simulink两大部分。

## 设计定位 ##

Python的设计哲学是“优雅”、“明确”、“简单”。

准则:在Python[解释器][Link 9]内运行import this可以获得完整的列表。Python开发人员尽量避开不成熟或者不重要的优化。所以很多人认为Python很慢。Python设计师倾向于使用[JIT][]技术，或者用使用C/C++语言改写这部分程序。可用的JIT技术是[PyPy][]。

## 控制语句 ##

if语句，当条件成立时运行语句块。经常与else, elif(相当于else if) 配合使用。

for语句，遍历列表、字符串、字典、集合等[迭代器][Link 10]，依次处理迭代器中的每个元素。

while语句，当条件为真时，循环运行语句块。

try语句，与except,finally配合使用处理在程序运行中出现的异常情况。

class语句，用于定义[类型][Link 11]。

def语句，用于定义函数和类型的方法。

pass语句，表示此行为空，不运行任何操作。

assert语句，用于程序调试阶段时测试运行条件是否满足。

with语句，Python2.6以后定义的语法，在一个场景中运行语句块。比如，运行语句块前加密，然后在语句块运行退出后解密。

yield语句，在迭代器函数内使用，用于返回一个元素。自从Python 2.5版本以后。这个语句变成一个运算符。

raise语句，制造一个错误。

import语句，导入一个模块或包。

from import语句，从包导入模块或从模块导入某个对象。

import as语句，将导入的对象赋值给一个变量。

in语句，判断一个对象是否在一个字符串/列表/元组里。

## 特点 ##

### 优点 ###

简单、易学、速度快、免费、开源、高层语言(用Python语言编写程序的时候无需考虑诸如如何管理你的程序使用的内存一类的底层细节。)、可移植性、解释性(在计算机内部，Python[解释器][Link 9]把源代码转换成称为[字节码][Link 12]的中间形式，然后再把它翻译成计算机使用的[机器语言][Link 13]并运行。这使得使用Python更加简单。也使得Python程序更加易于移植。)、面向对象、可拓展性、可嵌入性、丰富的库、规范的代码

### 缺点 ###

**单行语句和命令行输出问题**：很多时候不能将程序连写成一行，如import sys;for i in sys.path:print i。而perl和awk就无此限制，可以较为方便的在shell下完成简单程序，不需要如Python一样，必须将程序写入一个.py文件。

##### 运行速度慢：这里是指与C和C++相比。 #####

## Python pip 安装与使用 ##

pip 是 Python 包管理工具，该工具提供了对Python 包的查找、下载、安装、卸载的功能。

### pip 最常用命令 ###

**显示版本和路径**

pip --version

**获取帮助**

pip --help

**升级 pip**

pip install -U pip

> 如果这个升级命令出现问题 ，可以使用以下命令：
> 
>     sudo easy_install --upgrade pip

**安装包**

pip install SomePackage              # 最新版本
    pip install SomePackage==1.0.4       # 指定版本
    pip install 'SomePackage>=1.0.4'     # 最小版本

比如我要安装 Django。用以下的一条命令就可以，方便快捷。

pip install Django==1.7

**升级包**

pip install --upgrade SomePackage

升级指定的包，通过使用==, >=, <=, >, < 来指定一个版本号。

**卸载包**

pip uninstall SomePackage

**搜索包**

pip search SomePackage

**显示安装包信息**

pip show

**查看指定包的详细信息**

pip show -f SomePackage

**列出已安装的包**

pip list

**查看可升级的包**

pip list -o

## 编码 ##

默认情况下，Python 3 源码文件以 **UTF-8** 编码，所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码：

# -*- coding: cp-1252 -*-

## 注释 ##

Python中单行注释以 **\#** 开头，实例如下：  
多行注释可以用多个 **\#** 号，还有 **‘’’** 和 **“”"**：

## 行与缩进 ##

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 **\{\}** 。

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。实例如下：

if True:  
print (“True”)  
else:  
print (“False”)

## 多行语句 ##

Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠()来实现多行语句，例如：

total = item_one + \
            item_two + \
            item_three

在 \[\], \{\}, 或 () 中的多行语句，不需要使用反斜杠()，例如：

total = ['item_one', 'item_two', 'item_three',
            'item_four', 'item_five']

## 数字(Number)类型 ##

python中数字有四种类型：整数、布尔型、浮点数和复数。

*  **int** (整数), 如 1, 只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
 *  **bool** (布尔), 如 True。
 *  **float** (浮点数), 如 1.23、3E-2
 *  **complex** (复数), 如 1 + 2j、 1.1 + 2.2j

## 字符串(String) ##

*  python中单引号和双引号使用完全相同。
 *  使用三引号(’’'或""")可以指定一个多行字符串。
 *  转义符 ‘’
 *  反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。 如 r"this is a line with \\n" 则\\n会显示，并不是换行。
 *  按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
 *  字符串可以用 + 运算符连接在一起，用 \* 运算符重复。
 *  Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
 *  Python中的字符串不能改变。
 *  Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
 *  字符串的截取的语法格式如下：**变量\[头下标:尾下标:步长\]**

word = '字符串'
    sentence = "这是一个句子。"
    paragraph = """这是一个段落，
    可以由多行组成"""

### 多个变量赋值 ###

Python允许你同时为多个变量赋值。例如：

a = b = c = 1

以上实例，创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值。

您也可以为多个对象指定多个变量。例如：

a, b, c = 1, 2, "runoob"

## 标准数据类型 ##

Python3 中有六个标准的数据类型：

*  Number（数字）
 *  String（字符串）
 *  List（列表）
 *  Tuple（元组）
 *  Set（集合）
 *  Dictionary（字典）

Python3 的六个标准数据类型中：

*  \*\*不可变数据（3 个）：\*\*Number（数字）、String（字符串）、Tuple（元组）；
 *  \*\*可变数据（3 个）：\*\*List（列表）、Dictionary（字典）、Set（集合）。
    
    ## dos使用 ##
 *  如果我们要在cmd窗口调用test.py文件，只需要将**cmd路径目录转入test.py所在的文件夹，然后输入命令即可**
 *  假设我们的test.py文件放在D盘，路径为：D:\\Python27\\Mytest\\test.py 那么要在cmd窗口调用这个文件，我们需要将目录路径切换到D:\\Python27\\Mytest。使用**cd命令**即可做到。  
    ![img][]

## Python身份运算符 ##

身份运算符用于比较两个对象的存储单元

<table> 
 <thead> 
  <tr> 
   <th align="left">运算符</th> 
   <th align="left">描述</th> 
   <th align="left">实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">is</td> 
   <td align="left">is 是判断两个标识符是不是引用自一个对象</td> 
   <td align="left"><strong>x is y</strong>, 类似 <strong>id(x) == id(y)</strong> , 如果引用的是同一个对象则返回 True，否则返回 False</td> 
  </tr> 
  <tr> 
   <td align="left">is not</td> 
   <td align="left">is not 是判断两个标识符是不是引用自不同对象</td> 
   <td align="left"><strong>x is not y</strong> ， 类似 <strong>id(a) != id(b)</strong>。如果引用的不是同一个对象则返回结果 True，否则返回 False。</td> 
  </tr> 
 </tbody> 
</table>

**注：** [id()][id] 函数用于获取对象内存地址。

以下实例演示了Python所有身份运算符的操作：

\#!/usr/bin/python3  
a = 20  
b = 20  
if ( a is b ):  
print (“1 - a 和 b 有相同的标识”)  
else:  
print (“1 - a 和 b 没有相同的标识”)  
if ( id(a) == id(b) ):  
print (“2 - a 和 b 有相同的标识”)  
else:  
print (“2 - a 和 b 没有相同的标识”)

\#修改变量 b 的值

b = 30  
if ( a is b ):  
print (“3 - a 和 b 有相同的标识”)  
else:  
print (“3 - a 和 b 没有相同的标识”)  
if ( a is not b ):  
print (“4 - a 和 b 没有相同的标识”)  
else:  
print (“4 - a 和 b 有相同的标识”)

\*\*注意：\*\*Pyhton3 已不支持 <> 运算符，可以使用 != 代替，如果你一定要使用这种比较运算符，可以使用以下的方式：>>> from **future** import barry\_as\_FLUFL

> > >     >>> from __future__ import barry_as_FLUFL
> > >     >>> 1 <> 2
> > >     True

# Python3 数字(Number) #

Python 数字数据类型用于存储数值。

数据类型是不允许改变的,这就意味着如果改变数字数据类型的值，将重新分配内存空间。

以下实例在变量赋值时 Number 对象将被创建：

var1 = 1
    var2 = 10

你也可以使用del语句删除一些数字对象的引用。

del语句的语法是

del var
    del var_a, var_b

## Python 数字类型转换 ##

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

*  **int(x)** 将x转换为一个整数。
 *  **float(x)** 将x转换到一个浮点数。
 *  **complex(x)** 将x转换到一个复数，实数部分为 x，虚数部分为 0。
 *  **complex(x, y)** 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

以下实例将浮点数变量 a 转换为整数：

>>> a = 1.0
    >>> int(a)
    1

# Python3 字符串 #

字符串是 Python 中最常用的数据类型。我们可以使用引号( **’** 或 **"** )来创建字符串。

创建字符串很简单，只要为变量分配一个值即可。例如：

var1 = ‘Hello World!’  
var2 = “Runoob”

## Python 访问字符串中的值 ##

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

Python 访问子字符串，可以使用方括号来截取字符串，如下实例：

var1 = ‘Hello World!’  
var2 = “Runoob”  
print ("var1\[0\]: ", var1\[0\])  
print ("var2\[1:5\]: ", var2\[1:5\])

## Python 字符串更新 ##

你可以截取字符串的一部分并与其他字段拼接，如下实例：

var1 = ‘Hello World!’  
print ("已更新字符串 : ", var1\[:6\] + ‘Runoob!’)

## Python字符串格式化 ##

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。

print (“我叫 %s 今年 %d 岁!” % (‘小明’, 10))

# Python 列表(List) #

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

Python有6个序列的内置类型，但最常见的是列表和元组。

list1 = \[‘physics’, ‘chemistry’, 1997, 2000\]  
list2 = \[1, 2, 3, 4, 5 \]  
list3 = \[“a”, “b”, “c”, “d”\]

## 访问列表中的值 ##

使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示：

list1 = \[‘physics’, ‘chemistry’, 1997, 2000\]  
list2 = \[1, 2, 3, 4, 5, 6, 7 \]  
print "list1\[0\]: ", list1\[0\]  
print "list2\[1:5\]: ", list2\[1:5\]

## 更新列表 ##

你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项，如下所示：

list = \[\] \#\# 空列表  
list.append(‘Google’) \#\# 使用 append() 添加元素  
list.append(‘Runoob’)  
print list

# Python 元组 #

Python的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

tup1 = (‘physics’, ‘chemistry’, 1997, 2000)  
tup2 = (1, 2, 3, 4, 5 )  
tup3 = “a”, “b”, “c”, “d”

# Python 字典(Dictionary) #

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 **key=>value** 对用冒号 **:** 分割，每个键值对之间用逗号 **,** 分割，整个字典包括在花括号 **\{\}** 中 ,格式如下所示：

dict = \{‘Alice’: ‘2341’, ‘Beth’: ‘9102’, ‘Cecil’: ‘3258’\}

## 访问字典里的值 ##

把相应的键放入熟悉的方括弧，如下实例:

dict = \{‘Name’: ‘Zara’, ‘Age’: 7, ‘Class’: ‘First’\}  
print "dict\[‘Name’\]: ", dict\[‘Name’\]  
print "dict\[‘Age’\]: ", dict\[‘Age’\]

## 修改字典 ##

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:

dict = \{‘Name’: ‘Zara’, ‘Age’: 7, ‘Class’: ‘First’\}  
dict\[‘Age’\] = 8 \# 更新  
dict\[‘School’\] = “RUNOOB” \# 添加  
print "dict\[‘Age’\]: ", dict\[‘Age’\]  
print "dict\[‘School’\]: ", dict\[‘School’\]

# Python 日期和时间 #

Python 程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。

Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。

时间间隔是以秒为单位的浮点小数。

每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。

Python 的 time 模块下有很多函数可以转换常见日期格式。如函数time.time()用于获取当前时间戳, 如下实例:

import time; \# 引入time模块  
ticks = time.time()  
print “当前时间戳为:”, ticks

# Python 函数 #

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

## 定义一个函数 ##

你可以定义一个由自己想要功能的函数，以下是简单的规则：

*  函数代码块以 **def** 关键词开头，后接函数标识符名称和圆括号\*\*()\*\*。
 *  任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
 *  函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
 *  函数内容以冒号起始，并且缩进。
 *  **return \[表达式\]** 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

### 可更改(mutable)与不可更改(immutable)对象 ###

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

*  \*\*不可变类型：\*\*变量赋值 **a=5** 后再赋值 **a=10**，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
 *  \*\*可变类型：\*\*变量赋值 **la=\[1,2,3,4\]** 后再赋值 **la\[2\]=5** 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

# Python 模块 #

Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。

模块让你能够有逻辑地组织你的 Python 代码段。

把相关的代码分配到一个模块里能让你的代码更好用，更易懂。

模块能定义函数，类和变量，模块里也能包含可执行的代码。

**例子**

下例是个简单的模块 support.py：

# Python 文件I/O #

本章只讲述所有基本的 I/O 函数，更多函数请参考Python标准文档。

## 读取键盘输入 ##

Python提供了内置函数从标准输入读入一行文本，默认的标准输入是键盘。如下：

### input函数 ###

**input(\[prompt\])** 函数可以接收一个Python表达式作为输入，并将运算结果返回。

## 打开和关闭文件 ##

现在，您已经可以向标准输入和输出进行读写。现在，来看看怎么读写实际的数据文件。

Python 提供了必要的函数和方法进行默认情况下的文件基本操作。你可以用 **file** 对象做大部分的文件操作。

### open 函数 ###

你必须先用Python内置的open()函数打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。

语法：

### close()方法 ###

File 对象的 close（）方法刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。

当一个文件对象的引用被重新指定给另一个文件时，Python 会关闭之前的文件。用 close（）方法关闭文件是一个很好的习惯。

语法：

# 打开一个文件
    fo = open("foo.txt", "w")
    print "文件名: ", fo.name
     
    # 关闭打开的文件
    fo.close()

### read()方法 ###

read（）方法从一个打开的文件中读取一个字符串。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。

语法：

# 打开一个文件
    fo = open("foo.txt", "r+")
    str = fo.read(10)
    print "读取的字符串是 : ", str
    # 关闭打开的文件
    fo.close()

# Python3 错误和异常 #

作为 Python 初学者，在刚学习 Python 编程时，经常会看到一些报错信息，在前面我们没有提及，这章节我们会专门介绍。

Python 有两种错误很容易辨认：语法错误和异常。

Python assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常。

while True print('Hello world')

## 异常 ##

即便 Python 程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常。

大多数的异常都不会被程序处理，都以错误信息的形式展现在这里:

10 \* (1/0) \# 0 不能作为除数，触发异常

## 用户自定义异常 ##

你可以通过创建一个新的异常类来拥有自己的异常。异常类继承自 Exception 类，可以直接继承，或者间接继承，例如:

**class** MyError(Exception):  
**def** **init**(self, value):  
self.value = value  
**def** **str**(self):  
**return** repr(self.value)

**try**:  
**raise** MyError(2\*2)  
**except** MyError **as** e:  
**print**(‘My exception occurred, value:’, e.value)

# Python3 面向对象 #

Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。

如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于你更容易的学习Python的面向对象编程。

接下来我们先来简单的了解下面向对象的一些基本特征。

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

## 面向对象技术简介 ##

*  **类(Class):** 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
 *  \*\*方法：\*\*类中定义的函数。
 *  \*\*类变量：\*\*类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
 *  \*\*数据成员：\*\*类变量或者实例变量用于处理类及其实例对象的相关的数据。
 *  \*\*方法重写：\*\*如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
 *  \*\*局部变量：\*\*定义在方法中的变量，只作用于当前实例的类。
 *  \*\*实例变量：\*\*在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。
 *  \*\*继承：\*\*即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
 *  \*\*实例化：\*\*创建一个类的实例，类的具体对象。
 *  \*\*对象：\*\*通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。

Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。

对象可以包含任意数量和类型的数据。

### self代表类的实例，而非类 ###

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的**第一个参数名称**, 按照惯例它的名称是 self。

class Test:
        def prt(self):
            print(self)
            print(self.__class__)
    
    t = Test()
    t.prt()

## 类的方法 ##

在类的内部，使用 **def** 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

#类定义
    **class** people:
        #定义基本属性
        name = ''
        age = 0
        #定义私有属性,私有属性在类外部无法直接进行访问
        __weight = 0
        #定义构造方法
        **def** __init__(self,n,a,w):
            self.name = n
            self.age = a
            self.__weight = w
        **def** speak(self):
            **print**("%s 说: 我 %d 岁。" %(self.name,self.age))
    
    # 实例化类
    p = people('runoob',10,30)
    p.speak()

## 继承 ##

Python 同样支持类的继承，如果一种语言不支持继承，类就没有什么意义。派生类的定义如下所示:

#类定义
    class people:
        #定义基本属性
        name = ''
        age = 0
        #定义私有属性,私有属性在类外部无法直接进行访问
        __weight = 0
        #定义构造方法
        def __init__(self,n,a,w):
            self.name = n
            self.age = a
            self.__weight = w
        def speak(self):
            print("%s 说: 我 %d 岁。" %(self.name,self.age))
    
    #单继承示例
    class student(people):
        grade = ''
        def __init__(self,n,a,w,g):
            #调用父类的构函
            people.__init__(self,n,a,w)
            self.grade = g
        #覆写父类的方法
        def speak(self):
            print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
    
    
    
    s = student('ken',10,60,3)
    s.speak()

## 方法重写 ##

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法，实例如下：

class Parent:        # 定义父类
       def myMethod(self):
          print ('调用父类方法')
     
    class Child(Parent): # 定义子类
       def myMethod(self):
          print ('调用子类方法')
     
    c = Child()          # 子类实例
    c.myMethod()         # 子类调用重写方法
    super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

## 类属性与方法 ##

### 类的私有属性 ###

**\_\_private\_attrs**：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 **self.\_\_private\_attrs**。

### 类的方法 ###

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 **self**，且为第一个参数，**self** 代表的是类的实例。

**self** 的名字并不是规定死的，也可以使用 **this**，但是最好还是按照约定是用 **self**。

### 类的私有方法 ###

**\_\_private\_method**：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。**self.\_\_private\_methods**。

### 实例 ###

类的私有属性实例如下：

class JustCounter:
        __secretCount = 0  # 私有变量
        publicCount = 0    # 公开变量
    
        def count(self):
            self.__secretCount += 1
            self.publicCount += 1
            print (self.__secretCount)
    
    counter = JustCounter()
    counter.count()
    counter.count()
    print (counter.publicCount)
    print (counter.__secretCount)  # 报错，实例不能访问私有变量

### 类的专有方法： ###

*  **init :** 构造函数，在生成对象时调用
 *  **del :** 析构函数，释放对象时使用
 *  **repr :** 打印，转换
 *  **setitem :** 按照索引赋值
 *  **getitem:** 按照索引获取值
 *  **len:** 获得长度
 *  **cmp:** 比较运算
 *  **call:** 函数调用
 *  **add:** 加运算
 *  **sub:** 减运算
 *  **mul:** 乘运算
 *  **truediv:** 除运算
 *  **mod:** 求余运算
 *  **pow:** 乘方

## 彩蛋:配置清华镜像: ##

https://blog.csdn.net/tanzuozhev/article/details/76022189  
（1）“pip install pip -U”是用于执行升级pip的命令；  
（2）若pip为10.0.0以上版本，则可以进行升级；  
（3）查看pip版本的命令：pip -V  
pip

AI 案例

https://magi.com/search?q=magi

excel处理数据案例

https://new.qq.com/omn/20191106/20191106A0IFBL00.html

### 资料 ###

菜鸟教程、b站、慕课

[Link 1]: https://baike.baidu.com/item/%E6%90%9C%E7%B4%A2%E5%BC%95%E6%93%8E/104812
[Link 2]: https://baike.baidu.com/item/%E8%AF%AD%E8%A8%80/2291095
[if]: https://baike.baidu.com/item/if%E8%AF%AD%E5%8F%A5
[Link 3]: https://baike.baidu.com/item/%E7%BC%A9%E8%BF%9B/7337492
[MATLAB]: https://baike.baidu.com/item/MATLAB
[MATLAB 1]: https://baike.baidu.com/item/MATLAB/263035
[Link 4]: https://baike.baidu.com/item/%E7%A7%91%E5%AD%A6/10406
[Link 5]: https://baike.baidu.com/item/%E7%95%8C%E9%9D%A2%E8%AE%BE%E8%AE%A1
[Link 6]: https://baike.baidu.com/item/%E7%BD%91%E7%BB%9C%E9%80%9A%E4%BF%A1
[MathWorks]: https://baike.baidu.com/item/MathWorks
[Link 7]: https://baike.baidu.com/item/%E6%95%B0%E5%AD%A6%E8%BD%AF%E4%BB%B6
[Link 8]: https://baike.baidu.com/item/%E6%95%B0%E5%80%BC%E8%AE%A1%E7%AE%97/3729797
[Link 9]: https://baike.baidu.com/item/%E8%A7%A3%E9%87%8A%E5%99%A8
[JIT]: https://baike.baidu.com/item/JIT
[PyPy]: https://baike.baidu.com/item/PyPy
[Link 10]: https://baike.baidu.com/item/%E8%BF%AD%E4%BB%A3%E5%99%A8
[Link 11]: https://baike.baidu.com/item/%E7%B1%BB%E5%9E%8B/6737759
[Link 12]: https://baike.baidu.com/item/%E5%AD%97%E8%8A%82%E7%A0%81
[Link 13]: https://baike.baidu.com/item/%E6%9C%BA%E5%99%A8%E8%AF%AD%E8%A8%80
[img]: /images/20210920/f695daf155a9477aabb83088f5dadeda.png
[id]: https://www.runoob.com/python/python-func-id.html