概述

虽然官方 Python 实现差不多得到最广泛的欢迎，但也有一些其他实现对特定领域的用户来说更具吸引力。

知名的实现包括:

• CPython

  这是最早出现并持续维护的 Python 实现，以 C 语言编写。新的语言特性通常在此率先添加。

• Jython

  以 Java 语言编写的 Python 实现。此实现可以作为 Java 应用的一个脚本语言，或者可以用来创建需要 Java 类库支持的应用。想了解更多信息可访问 Jython 网站。

• Python for .NET

  此实现实际上使用了 CPython 实现，但是属于 .NET 托管应用并且可以引入 .NET 类库。它的创造者是 Brian Lloyd。想了解详情可访问 Python for .NET 主页。

• IronPython

  另一个 .NET 的 Python 实现，与 Python.NET 不同点在于它是生成 IL 的完全 Python 实现，并且将 Python 代码直接编译为 .NET 程序集。它的创造者就是当初创造 Jython 的 Jim Hugunin。想了解详情可访问 IronPython 网站。

• PyPy

  完全使用 Python 语言编写的 Python 实现。它支持多个其他实现所没有的高级特性，例如非栈式支持和 JIT 编译器等。此项目的目标之一是通过允许方便地修改解释器 (因为它是用 Python 编写的)，鼓励该对语言本身进行试验。想了解详情可访问 PyPy 项目主页。

关键字

以下标识符为保留字，或称 关键字，不可用于普通标识符。关键字的拼写必须与这里列出的完全一致：

False      await      else       import     passNone       break      except     in         raiseTrue       class      finally    is         returnand        continue   for        lambda     tryas         def        from       nonlocal   whileassert     del        global     not        withasync      elif       if         or         yield

标准数据类型

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。

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（集合）。

Number

Python3 支持 int、float、bool、complex（复数）。

在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

内置的 type() 函数可以用来查询变量所指的对象类型。

a, b, c = 10, 20.2, Trueprint(a, b, c)print(type(a), type(b), type(c))10 20.2 True<class \'int\'> <class \'float\'> <class \'bool\'>

此外还可以用 isinstance 来判断

# 此外还可以用 isinstance 来判断a = 111print(a)print(isinstance(a, int))111True

isinstance 和 type 的区别在于：

• type()不会认为子类是一种父类类型。
• isinstance()会认为子类是一种父类类型。

注意：Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True==1、False==0 会返回 True，但可以通过 is 来判断类型。在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。

class A:passclass B(A):passprint(isinstance(A(), A))print(type(A()) == A)print(isinstance(B(), A))print(type(B()) == A)TrueTrueTrueFalse

数值类型实例

Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

String

Python中的字符串用单引号 \’ 或双引号 " 括起来，同时使用反斜杠 ** 转义特殊字符。

字符串的截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

• 加号 + 是字符串的连接符， 星号 ***** 表示复制当前字符串，与之结合的数字为复制的次数。

• Python 使用反斜杠 \\ 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串。

• 反斜杠 \\ 可以作为续行符，表示下一行是上一行的延续。也可以使用 … 或者 \’\’\’…\’\’\’ 跨越多行。注意，Python 没有单独的字符类型，一个字符就是长度为1的字符串。

• 与 C 字符串不同的是，Python 字符串不能被改变。

str = \'lijiatu\'print(str)  # 输出字符串print(str[0:-1])  # 输出第一个到倒数第二个的所有字符print(str[0])  # 输出字符串第一个字符print(str[2:5])  # 输出从第三个开始到第五个的字符print(str[2:])  # 输出从第三个开始的后的所有字符print(str * 2)  # 输出字符串两次，也可以写成 print (2 * str)print(str + "TEST")  # 连接字符串print(\'=======================\')print(\'li\\njiatu\')print(r\'li\\njiatu\')print(\'=======================\')word = \'Python\'print(word[0], word[5])print(word[-1], word[-6])print(\'=======================\')lijiatulijiatljiajiatulijiatulijiatulijiatuTEST=======================lijiatuli\\njiatu=======================P nn P=======================

注意：

• 1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
• 2、字符串可以用+运算符连接在一起，用*运算符重复。
• 3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
• 4、Python中的字符串不能改变。

List

List（列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

注意：

• 1、List写在方括号之间，元素用逗号隔开。
• 2、和字符串一样，list可以被索引和切片。
• 3、List可以使用+操作符进行拼接。
• 4、List中的元素是可以改变的。

Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串。 如果第三个参数为负数表示逆向读取

Tuple

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。

其实，可以把字符串看作一种特殊的元组。

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

string、list 和 tuple 都属于 sequence（序列）。

注意：

• 1、与字符串一样，元组的元素不能修改。
• 2、元组也可以被索引和切片，方法一样。
• 3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
• 4、元组也可以使用+操作符进行拼接。

Set

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 ，因为 是用来创建一个空字典。

创建格式：

parame = {value01,value02,...}或者set(value)

Dictionary

字典（dictionary）是Python中另一个非常有用的内置数据类型。

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用 标识，它是一个无序的 键(key) : 值(value) 的集合。

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。

另外，字典类型也有一些内置的函数，例如 clear()、keys()、values() 等。

注意：

• 1、字典是一种映射类型，它的元素是键值对。
• 2、字典的关键字必须为不可变类型，且不能重复。
• 3、创建空字典使用 。

删除对象

您也可以使用del语句删除一些对象引用。

del语句的语法是：

del var1[,var2[,var3[....,varN]]]

数据类型转换

数据类型的转换，你只需要将数据类型作为函数名即可

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

Python 数据类型转换可以分为两种：

• 隐式类型转换 – 自动完成
• 显式类型转换 – 需要使用类型函数来转换

推导式

列表推导式格式为：

[表达式 for 变量 in 列表]或者[表达式 for 变量 in 列表 if 条件]

字典推导基本格式：

{ key_expr: value_expr for value in collection }或{ key_expr: value_expr for value in collection if condition }

集合推导式基本格式：

{ expression for item in Sequence }或{ expression for item in Sequence if conditional }

元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。

元组推导式基本格式：

(expression for item in Sequence )或(expression for item in Sequence if conditional )

元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []，另外元组推导式返回的结果是一个生成器对象。

运算符

算数运算符

>>> 9//2 4 >>> -9//2 -5

比较运算符

赋值运算符

if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)")

位运算符

逻辑运算符

成员运算符

身份运算符

运算符优先级

迭代器与生成器

迭代器

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next()。

import sys  # 引入 sys 模块list = [1, 2, 3, 4]it = iter(list)  # 创建迭代器对象while True:try:print(next(it))  # 输出迭代器的下一个元素except StopIteration:sys.exit()

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

调用一个生成器函数，返回的是一个迭代器对象。

例子：

import sysdef fibonacci(n):  # 生成器函数 - 斐波那契a, b, counter = 0, 1, 0while True:if (counter > n):returnyield aa, b = b, a + bcounter += 1f = fibonacci(10)  # f 是一个迭代器，由生成器返回生成while True:try:print(next(f), end=" ")except StopIteration:sys.exit()

函数

参数传递

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

• **不可变数据（3 个）：**Number（数字）、String（字符串）、Tuple（元组）；

  变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。

  类似 C++ 的值传递，如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。

• **可变数据（3 个）：**List（列表）、Dictionary（字典）、Set（集合）。

  变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

  类似 C++ 的引用传递，如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响

Python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

参数

以下是调用函数时可使用的正式参数类型：

• 必需参数， 必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
• 关键字参数， 使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
• 默认参数
• 不定长参数

def printinfo(arg1, *vartuple):"打印任何传入的参数"print("输出: ")print(arg1)print(vartuple)# 调用printinfo 函数printinfo(70, 60, 50)输出:70(60, 50)

• 独出现星号 ***** 后的参数必须用关键字传入
• 两个星号 ** 的参数会以字典的形式导入

def printinfo(arg1, **vardict):"打印任何传入的参数"print("输出: ")print(arg1)print(vardict)# 调用printinfo 函数printinfo(1, a=2, b=3)输出:1{\'a\': 2, \'b\': 3}

匿名函数

Python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

• lambda 只是一个表达式，函数体比 def 简单很多。
• lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
• lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
• 虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

lambda 函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

x = lambda a : a + 10print(x(5))

强制位置参数

Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。

def f(a, b, /, c, d, *, e, f):print(a, b, c, d, e, f)# 形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参f(10, 20, 30, d=40, e=50, f=60)# f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用关键字参数的形式# f(10, 20, 30, 40, 50, f=60)           # e 必须使用关键字参数的形式

模块

from……import语句

_ _ name _ _ 属性

一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用 _ _ name _ _ 属性来使该程序块仅在该模块自身运行时执行。

dir() 函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回。

输入输出

读取键盘

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

str = input(\'input:\')print(str)

读和写文件

open() 将会返回一个 file 对象，基本语法格式如下:

open(filename, mode)

• filename：包含了你要访问的文件名称的字符串值。
• mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。

不同模式打开文件的完全列表：

序列化

Python的pickle模块实现了基本的数据序列和反序列化。

通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。

通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。

基本接口：

pickle.dump(obj, file, [,protocol])

有了 pickle 这个对象, 就能对 file 以读取的形式打开:

x = pickle.load(file)

**注解：**从 file 中读取一个字符串，并将它重构为原来的python对象。

file: 类文件对象，有read()和readline()接口。

import pprint, pickle# 使用pickle模块将数据对象保存到文件data1 = {\'a\': [1, 2.0, 3, 4 + 6j],\'b\': (\'string\', u\'Unicode string\'),\'c\': None}selfref_list = [1, 2, 3]selfref_list.append(selfref_list)output = open(\'data.pkl\', \'wb\')pickle.dump(data1, output)pickle.dump(selfref_list, output, -1)output.close()# 使用pickle模块从文件中重构python对象pkl_file = open(\'data.pkl\', \'rb\')data1 = pickle.load(pkl_file)print(\'data1:\', data1)pprint.pprint(data1)print(\'data2:\', data1)data2 = pickle.load(pkl_file)pprint.pprint(data2)pkl_file.close()data1: {\'a\': [1, 2.0, 3, (4+6j)], \'b\': (\'string\', \'Unicode string\'), \'c\': None}{\'a\': [1, 2.0, 3, (4+6j)], \'b\': (\'string\', \'Unicode string\'), \'c\': None}data2: {\'a\': [1, 2.0, 3, (4+6j)], \'b\': (\'string\', \'Unicode string\'), \'c\': None}[1, 2, 3, <Recursion on list with id=2269454737856>]

文件

open() 方法

Python open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。

**注意：**使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。

open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。

open(file, mode=\'r\')

完整的语法格式为：

open(file, mode=\'r\', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数说明:

• file: 必需，文件路径（相对或者绝对路径）。
• mode: 可选，文件打开模式
• buffering: 设置缓冲
• encoding: 一般使用utf8
• errors: 报错级别
• newline: 区分换行符
• closefd: 传入的file参数类型
• opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。

mode 参数有：

默认为文本模式，如果要以二进制模式打开，加上 b 。

file 对象

file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：

错误和异常

x = 10if x > 5:raise Exception(\'x 不能大于 5。x 的值为: {}\'.format(x))

用户自定义异常

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

class MyError(Exception):def __init__(self, value):self.value = valuedef __str__(self):return repr(self.value)try:raise MyError(2 * 2)except MyError as e:print(\'My exception occurred, value:\', e.value)raise MyError(\'oops!\')

定义清理行为

try 语句还有另外一个可选的子句，它定义了无论在任何情况下都会执行的清理行为。

try:raise KeyboardInterruptfinally:print(\'Goodbye, world!\')

预定义的清理行为

一些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执行。

for line in open("myfile.txt"):print(line, end="")with open("myfile.txt") as f:for line in f:print(line, end="")

面向对象

类的方法&继承

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

#!/usr/bin/python3# 类定义class people:# 定义基本属性name = \'\'age = 0# 定义私有属性,私有属性在类外部无法直接进行访问__weight = 0# 定义构造方法def __init__(self, n, a, w):self.name = nself.age = aself.__weight = wdef speak(self):print("%s 说: 我 %d 岁。" % (self.name, self.age))# 实例化类p = people(\'runoob\', 10, 30)p.speak()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 speaker():topic = \'\'name = \'\'def __init__(self, n, t):self.name = nself.topic = tdef speak(self):print("我叫 %s，我是一个演说家，我演讲的主题是 %s" % (self.name, self.topic))# 多重继承class sample(speaker, student):a = \'\'def __init__(self, n, a, w, g, t):student.__init__(self, n, a, w, g)speaker.__init__(self, n, t)test = sample("Tim", 25, 80, 4, "Python")test.speak()  # 方法名同，默认调用的是在括号中参数位置排前父类的方法runoob 说: 我 10 岁。ken 说: 我 10 岁了，我在读 3 年级我叫 Tim，我是一个演说家，我演讲的主题是 Python

方法重写

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。

类的专有方法

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

命名空间&作用域

命名空间

命名空间(Namespace)是从名称到对象的映射，大部分的命名空间都是通过 Python 字典来实现的。

命名空间提供了在项目中避免名字冲突的一种方法。各个命名空间是独立的，没有任何关系的，所以一个命名空间中不能有重名，但不同的命名空间是可以重名而没有任何影响。

一般有三种命名空间：

• 内置名称（built-in names）， Python 语言内置的名称，比如函数名 abs、char 和异常名称 BaseException、Exception 等等。
• 全局名称（global names），模块中定义的名称，记录了模块的变量，包括函数、类、其它导入的模块、模块级的变量和常量。
• 局部名称（local names），函数中定义的名称，记录了函数的变量，包括函数的参数和局部定义的变量。（类中定义的也是）

作用域

作用域就是一个 Python 程序可以直接访问命名空间的正文区域。

在一个 python 程序中，直接访问一个变量，会从内到外依次访问所有的作用域直到找到，否则会报未定义的错误。

Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python 的作用域一共有4种，分别是：

有四种作用域：

• L（Local）：最内层，包含局部变量，比如一个函数/方法内部。
• E（Enclosing）：包含了非局部(non-local)也非全局(non-global)的变量。比如两个嵌套函数，一个函数（或类） A 里面又包含了一个函数 B ，那么对于 B 中的名称来说 A 中的作用域就为 nonlocal。
• G（Global）：当前脚本的最外层，比如当前模块的全局变量。
• B（Built-in）： 包含了内建的变量/关键字等，最后被搜索。

规则顺序： L –> E –> G –> B。

内置作用域是通过一个名为 builtin 的标准模块来实现的，但是这个变量名自身并没有放入内置作用域内，所以必须导入这个文件才能够使用它。在Python3.0中，可以使用以下的代码来查看到底预定义了哪些变量:

import builtinsprint(dir(builtins))

Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这些语句内定义的变量，外部也可以访问。

global 和 nonlocal关键字

当内部作用域想修改外部作用域的变量时，就要用到 global 和 nonlocal 关键字了。

Python3实例

https://www.runoob.com/python3/python3-examples.html