1.Python 简介
Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。Python 的设计具有很强的可读性,相比其他语言经常使用英文关键字,其他语言的一些标点符号,它具有比其他语言更有特色语法结构。

  • Python 是一种解释型语言: 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
  • Python 是交互式语言: 这意味着,您可以在一个 Python 提示符 >>> 后直接执行代码。
  • Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
  • Python 是初学者的语言:Python 对初级程序员而言,是一种伟大的语言,它支持广泛的应用
    2.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.7 被确定为最后一个 Python 2.x 版本,它除了支持 Python 2.x 语法外,还支持部分 Python3.1 语法。
    程序开发,从简单的文字处理到 WWW 浏览器再到游戏。
    3.Python 特点
  • 1.易于学习:Python有相对较少的关键字,结构简单,和一个明确定义的语法,学习起来更加简单。
  • 2.易于阅读:Python代码定义的更清晰。
  • 3.易于维护:Python的成功在于它的源代码是相当容易维护的。
  • 4.一个广泛的标准库:Python的最大的优势之一是丰富的库,跨平台的,在UNIX,Windows和Macintosh兼容很好。
  • 5.互动模式:互动模式的支持,您可以从终端输入执行代码并获得结果的语言,互动的测试和调试代码片断。
  • 6.可移植:基于其开放源代码的特性,Python已经被移植(也就是使其工作)到许多平台。
  • 7.可扩展:如果你需要一段运行很快的关键代码,或者是想要编写一些不愿开放的算法,你可以使用C或C++完成那部分程序,然后从你的Python程序中调用。
  • 8.数据库:Python提供所有主要的商业数据库的接口。
  • 9.GUI编程:Python支持GUI可以创建和移植到许多系统调用。
  • 10.可嵌入: 你可以将Python嵌入到C/C++程序,让你的程序的用户获得”脚本化”的
    4.Python 环境搭建
    本章节我们将向大家介绍如何在本地搭建Python开发环境。
    Python可应用于多平台包括 Linux 和 Mac OS X。
    你可以通过终端窗口输入 “python” 命令来查看本地是否已经安装Python以及Python的安装版本。
  • Unix (Solaris, Linux, FreeBSD, AIX, HP/UX, SunOS, IRIX, 等等。)
  • Win 9x/NT/2000
  • Macintosh (Intel, PPC, 68K)
  • OS/2
  • DOS (多个DOS版本)
  • PalmOS
  • Nokia 移动手机
  • Windows CE
  • Acorn/RISC OS
  • BeOS
  • Amiga
  • VMS/OpenVMS
  • QNX
  • VxWorks
  • Psion
  • Python 同样可以移植到 Java 和 .NET 虚拟机上。
    5.Python 中文编码
    前面章节中我们已经学会了如何用 Python 输出 “Hello, World!”,英文没有问题,但是如果你输出中文字符 “你好,世界” 就有可能会碰到中文编码问题。
    Python 文件中如果未指定编码,在执行过程会出现报错:
#!/usr/bin/pythonprint ("你好,世界")

以上程序执行输出结果为:

 File "test.py", line 2SyntaxError: Non-ASCII character '\xe4' in file test.py on line 2, but no encoding declared; see http://www.python.org/peps/pep-0263.html for details

ython中默认的编码格式是 ASCII 格式,在没修改编码格式时无法正确打印汉字,所以在读取中文时会报错。

解决方法为只要在文件开头加入 # -*- coding: UTF-8 -*- 或者 # coding=utf-8 就行了。
注意:# coding=utf-8 的 = 号两边不要空格。

实例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*- print( "你好,世界" )

输出结果为:
你好,世界
所以如果大家在学习过程中,代码中包含中文,就需要在头部指定编码。
注意:Python3.X 源码文件默认使用utf-8编码,所以可以正常解析中文,无需指定 UTF-8 编码。
注意:如果你使用编辑器,同时需要设置 py 文件存储的格式为 UTF-8,否则会出现类似以下错误信息:

SyntaxError: (unicode error) ‘utf-8’ codec can’t decode byte 0xc4 in position 0:invalid continuation byte

6.Pycharm 设置步骤:
进入 file > Settings,在输入框搜索 encoding。
找到 Editor > File encodings,将 IDE Encoding 和 Project Encoding 设置为utf-8。

6.Python 基础语法

Python 语言与 Perl,C 和 Java 等语言有许多相似之处。但是,也存在一些差异。
在本章中我们将来学习 Python 的基础语法,让你快速学会 Python 编程。
第一个 Python 程序
交互式编程:
交互式编程不需要创建脚本文件,是通过 Python 解释器的交互模式进来编写代码。
linux上你只需要在命令行中输入 Python 命令即可启动交互式编程,提示窗口如下:

$ pythonPython 2.7.6 (default, Sep9 2014, 15:04:36)[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.39)] on darwinType "help", "copyright", "credits" or "license" for more information.>>>

Window 上在安装 Python 时已经安装了交互式编程客户端,提示窗口如下:

在 python 提示符中输入以下文本信息,然后按 Enter 键查看运行效果:

>>> print ("Hello, Python!")

在 Python 2.7.6 版本中,以上实例输出结果如下:

Hello, Python!

脚本式编程
通过脚本参数调用解释器开始执行脚本,直到脚本执行完毕。当脚本执行完成后,解释器不再有效。
让我们写一个简单的 Python 脚本程序。所有 Python 文件将以 .py 为扩展名。将以下的源代码拷贝至 test.py 文件中。

print ("Hello, Python!")

这里,假设你已经设置了 Python 解释器 PATH 变量。使用以下命令运行程序:
$ python test.py
输出结果:

Hello, Python!

让我们尝试另一种方式来执行 Python 脚本。修改 test.py 文件,如下所示:

#!/usr/bin/pythonprint ("Hello, Python!")

这里,假定您的Python解释器在/usr/bin目录中,使用以下命令执行脚本:

$ chmod +x test.py # 脚本文件添加可执行权限$ ./test.py

输出结果:Hello, Python!

Python2.x 中使用 Python3.x 的 print 函数

如果 Python2.x 版本想使用 Python3.x 的 print 函数,可以导入 future 包,该包禁用 Python2.x 的 print 语句,采用 Python3.x 的 print 函数:

>>> list =["a", "b", "c"]>>> print list# python2.x 的 print 语句['a', 'b', 'c']>>> from __future__ import print_function# 导入 __future__ 包>>> print list # Python2.x 的 print 语句被禁用,使用报错File "", line 1print list ^SyntaxError: invalid syntax>>> print (list) # 使用 Python3.x 的 print 函数['a', 'b', 'c']>>>

Python3.x 与 Python2.x 的许多兼容性设计的功能可以通过 future 这个包来导入。

Python 标识符

在 Python 里,标识符由字母、数字、下划线组成。
在 Python 中,所有标识符可以包括英文、数字以及下划线(_),但不能以数字开头。
Python 中的标识符是区分大小写的。
以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性,需通过类提供的接口进行访问,不能用 from xxx import * 而导入。
以双下划线开头的 __foo 代表类的私有成员,以双下划线开头和结尾的 foo 代表 Python 里特殊方法专用的标识,如 init() 代表类的构造函数。
Python 可以同一行显示多条语句,方法是用分号 ; 分开,如:

>>> print ('hello');print ('runoob');hellorunoob

Python 保留字符

下面的列表显示了在Python中的保留字,所有 Python 的关键字只包含小写字母。这些保留字不能用作常数或变数,或任何其他标识符名称

andexecnotassertfinallyorbreakforpassclassfromprintcontinueglobalraisedefifreturndelimporttryelifinwhileelseiswithexceptlambdayield

行和缩进

学习 Python 与其他语言最大的区别就是,Python 的代码块不使用大括号 {} 来控制类,函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。
缩进的空白数量是可变的,但是所有代码块语句必须包含相同的缩进空白数量,这个必须严格执行。
以下实例缩进为四个空格:

if True:print ("True")else:print ("False")

以下代码将会执行错误:

#!/usr/bin/python# -*- coding: UTF-8 -*-# 文件名:test.pyif True:print ("Answer")print ("True")else:print ("Answer")# 没有严格缩进,在执行时会报错print ("False")

执行以上代码,会出现如下错误提醒:

File "test.py", line 11print ("False")^IndentationError: unindent does not match any outer indentation level

IndentationError: unindent does not match any outer indentation level错误表明,你使用的缩进方式不一致,有的是 tab 键缩进,有的是空格缩进,改为一致即可。
如果是 IndentationError: unexpected indent 错误, 则 python 编译器是在告诉你”Hi,老兄,你的文件里格式不对了,可能是 tab 和空格没对齐的问题”,所以 python 对格式要求非常严格。
因此,在 Python 的代码块中必须使用相同数目的行首缩进空格数。
建议你在每个缩进层次使用 单个制表符 或 两个空格 或 四个空格 , 切记不能混用.

多行语句

Python语句中一般以新行作为语句的结束符。
但是我们可以使用斜杠( \)将一行的语句分为多行显示,如下所示:

total = item_one + \item_two + \item_three

语句中包含 [], {} 或 () 括号就不需要使用多行连接符。如下实例:

days = ['Monday', 'Tuesday', 'Wednesday','Thursday', 'Friday']

Python 引号

Python 可以使用引号( ’ )、双引号( ” )、三引号( ‘’’ 或 “”” ) 来表示字符串,引号的开始与结束必须是相同类型的。
其中三引号可以由多行组成,编写多行文本的快捷语法,常用于文档字符串,在文件的特定地点,被当做注释。

word = 'word'sentence = "这是一个句子。"paragraph = """这是一个段落。包含了多个语句"""

Python注释

python中单行注释采用 # 开头。

#!/usr/bin/python# -*- coding: UTF-8 -*-# 文件名:test.py# 第一个注释print ("Hello, Python!")# 第二个注释

输出结果:

Hello, Python!

注释可以在语句或表达式行末:

name = "Runoob" # 这里的内容是一个注释

python 中多行注释使用三个单引号 ‘’’ 或三个双引号 “””。

#!/usr/bin/python# -*- coding: UTF-8 -*-# 文件名:test.py'''这是多行注释,使用单引号。这是多行注释,使用单引号。这是多行注释,使用单引号。'''"""这是多行注释,使用双引号。这是多行注释,使用双引号。这是多行注释,使用双引号。"""

Python空行

函数之间或类的方法之间用空行分隔,表示一段新的代码的开始。类和函数入口之间也用一行空行分隔,以突出函数入口的开始。
空行与代码缩进不同,空行并不是Python语法的一部分。书写时不插入空行,Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码,便于日后代码的维护或重构。
记住:空行也是程序代码的一部分。

等待用户输入

下面的程序执行后就会等待用户输入,按回车键后就会退出:

#!/usr/bin/python# -*- coding: UTF-8 -*-raw_input("按下 enter 键退出,其他任意键显示...\n")

以上代码中 ,\n 实现换行。一旦用户按下 enter(回车) 键退出,其它键显示。

同一行显示多条语句

Python可以在同一行中使用多条语句,语句之间使用分号(;)分割,以下是一个简单的实例:

#!/usr/bin/pythonimport sys; x = 'runoob'; sys.stdout.write(x + '\n')

执行以上代码,输入结果为:

$ python test.pyrunoob

print 输出

print 默认输出是换行的,如果要实现不换行需要在变量末尾加上逗号 ,。

#!/usr/bin/python# -*- coding: UTF-8 -*-x="a"y="b"# 换行输出print xprint yprint '---------'# 不换行输出print x,print y,# 不换行输出print x,y

以上实例执行结果为:

ab---------a b a b

多个语句构成代码组

缩进相同的一组语句构成一个代码块,我们称之代码组。
像if、while、def和class这样的复合语句,首行以关键字开始,以冒号( : )结束,该行之后的一行或多行代码构成代码组。
我们将首行及后面的代码组称为一个子句(clause)。
如下实例:

if expression :suite elif expression : suiteelse : suite 

命令行参数

很多程序可以执行一些操作来查看一些基本信息,Python 可以使用 -h 参数查看各参数帮助信息:

$ python -h usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ... Options and arguments (and corresponding environment variables): -c cmd : program passed in as string (terminates option list) -d : debug output from parser (also PYTHONDEBUG=x) -E : ignore environment variables (such as PYTHONPATH) -h : print this help message and exit[ etc. ] 

我们在使用脚本形式执行 Python 时,可以接收命令行输入的参数,具体使用可以参照 Python 命令行参数。

Python 变量类型

变量是存储在内存中的值,这就意味着在创建变量时会在内存中开辟一个空间。
基于变量的数据类型,解释器会分配指定内存,并决定什么数据可以被存储在内存中。
因此,变量可以指定不同的数据类型,这些变量可以存储整数,小数或字符。

变量赋值

Python 中的变量赋值不需要类型声明。
每个变量在内存中创建,都包括变量的标识,名称和数据这些信息。
每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。
等号 = 用来给变量赋值。
等号 = 运算符左边是一个变量名,等号 = 运算符右边是存储在变量中的值。例如:

#!/usr/bin/python# -*- coding: UTF-8 -*- counter = 100 # 赋值整型变量miles = 1000.0 # 浮点型name = "John" # 字符串 print counterprint milesprint name

以上实例中,100,1000.0和”John”分别赋值给counter,miles,name变量。
执行以上程序会输出如下结果:

1001000.0John

多个变量赋值

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

a = b = c = 1

以上实例,创建一个整型对象,值为1,三个变量被分配到相同的内存空间上。
您也可以为多个对象指定多个变量。例如:

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

以上实例,两个整型对象 1 和 2 分别分配给变量 a 和 b,字符串对象 “john” 分配给变量 c。

标准数据类型

在内存中存储的数据可以有多种类型。
例如,一个人的年龄可以用数字来存储,他的名字可以用字符来存储。
Python 定义了一些标准类型,用于存储各种类型的数据。
Python有五个标准的数据类型:

  • Numbers(数字)
  • String(字符串)
  • List(列表)
  • Tuple(元组)
  • Dictionary(字典)

Python 数字

数字数据类型用于存储数值。
他们是不可改变的数据类型,这意味着改变数字数据类型会分配一个新的对象。
当你指定一个值时,Number 对象就会被创建:

var1 = 1var2 = 10

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

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

您可以通过使用del语句删除单个或多个对象的引用。例如:

del vardel var_a, var_b

Python支持四种不同的数字类型:

  • -int(有符号整型)
  • long(长整型,也可以代表八进制和十六进制)
  • float(浮点型)
  • complex(复数)
    长整型也可以使用小写 l,但是还是建议您使用大写 L,避免与数字 1 混淆。Python使用 L 来显示长整型。
    Python 还支持复数,复数由实数部分和虚数部分构成,可以用 a + bj,或者 complex(a,b) 表示, 复数的实部 a 和虚部 b 都是浮点型。
    注意:long 类型只存在于 Python2.X 版本中,在 2.2 以后的版本中,int 类型数据溢出后会自动转为long类型。在 Python3.X 版本中 long 类型被移除,使用 int 替代。

Python字符串

字符串或串(String)是由数字、字母、下划线组成的一串字符。
一般记为 :

s = "a1a2···an" # n>=0

它是编程语言中表示文本的数据类型。
python的字串列表有2种取值顺序:

  • 从左到右索引默认0开始的,最大范围是字符串长度少1
  • 从右到左索引默认-1开始的,最大范围是字符串开头

    如果你要实现从字符串中获取一段子字符串的话,可以使用 [头下标:尾下标] 来截取相应的字符串,其中下标是从 0 开始算起,可以是正数或负数,下标可以为空表示取到头或尾。
    [头下标:尾下标] 获取的子字符串包含头下标的字符,但不包含尾下标的字符。
    比如:
>>> s = 'abcdef'>>> s[1:5]'bcde'

当使用以冒号分隔的字符串,python 返回一个新的对象,结果包含了以这对偏移标识的连续的内容,左边的开始是包含了下边界。
上面的结果包含了 s[1] 的值 b,而取到的最大范围不包括尾下标,就是 s[5] 的值 f。

加号(+)是字符串连接运算符,星号(*)是重复操作。如下实例:

这里是(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*- str = 'Hello World!' print str # 输出完整字符串print str[0]# 输出字符串中的第一个字符print str[2:5]# 输出字符串中第三个至第六个之间的字符串print str[2:] # 输出从第三个字符开始的字符串print str * 2 # 输出字符串两次print str + "TEST"# 输出连接的字符串

以上实例输出结果:

Hello World!Hllollo World!Hello World!Hello World!Hello World!TEST

Python 列表截取可以接收第三个参数,参数作用是截取的步长,以下实例在索引 1 到索引 4 的位置并设置为步长为 2(间隔一个位置)来截取字符串:

Python列表

List(列表) 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。它支持字符,数字,字符串甚至可以包含列表(即嵌套)。
列表用 [ ] 标识,是 python 最通用的复合数据类型。
列表中值的切割也可以用到变量 [头下标:尾下标] ,就可以截取相应的列表,从左到右索引默认 0 开始,从右到左索引默认 -1 开始,下标可以为空表示取到头或尾。

加号 + 是列表连接运算符,星号 * 是重复操作。如下实例:

#!/usr/bin/python# -*- coding: UTF-8 -*- list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]tinylist = [123, 'john'] print list # 输出完整列表print list[0]# 输出列表的第一个元素print list[1:3]# 输出第二个至第三个元素 print list[2:] # 输出从第三个开始至列表末尾的所有元素print tinylist * 2 # 输出列表两次print list + tinylist# 打印组合的列表

以上实例输出结果:

['runoob', 786, 2.23, 'john', 70.2]runoob[786, 2.23][2.23, 'john', 70.2][123, 'john', 123, 'john']['runoob', 786, 2.23, 'john', 70.2, 123, 'john']

Python 元组

元组是另一个数据类型,类似于 List(列表)。
元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值,相当于只读列表。

#!/usr/bin/python# -*- coding: UTF-8 -*- tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )tinytuple = (123, 'john') print tuple # 输出完整元组print tuple[0]# 输出元组的第一个元素print tuple[1:3]# 输出第二个至第四个(不包含)的元素 print tuple[2:] # 输出从第三个开始至列表末尾的所有元素print tinytuple * 2 # 输出元组两次print tuple + tinytuple # 打印组合的元组

以上实例输出结果:

('runoob', 786, 2.23, 'john', 70.2)runoob(786, 2.23)(2.23, 'john', 70.2)(123, 'john', 123, 'john')('runoob', 786, 2.23, 'john', 70.2, 123, 'john')

以下对元组的操作是无效的,因为元组不允许更新,而列表是允许更新的:

#!/usr/bin/python# -*- coding: UTF-8 -*- tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]tuple[2] = 1000# 元组中是非法应用list[2] = 1000 # 列表中是合法应用元组是不允许更新的,所以以上代码执行错误,结果如下:Traceback (most recent call last):File "test.py", line 6, in <module>tuple[2] = 1000# 元组中是非法应用TypeError: 'tuple' object does not support item assignment

Python 字典

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合,字典是无序的对象集合。
两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。
字典用”{ }”标识。字典由索引(key)和它对应的值value组成。

#!/usr/bin/python# -*- coding: UTF-8 -*- dict = {}dict['one'] = "This is one"dict[2] = "This is two" tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}print dict['one']# 输出键为'one' 的值print dict[2]# 输出键为 2 的值print tinydict # 输出完整的字典print tinydict.keys()# 输出所有键print tinydict.values()# 输出所有值

输出结果为:

This is oneThis is two{'dept': 'sales', 'code': 6734, 'name': 'runoob'}['dept', 'code', 'name']['sales', 6734, 'runoob']

Python数据类型转换:
有时候,我们需要对数据内置的类型进行转换,数据类型的转换,你只需要将数据类型作为函数名即可。
以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象,表示转换的值。

函数描述int(x [,base])将x转换为一个整数long(x [,base] )将x转换为一个长整数float(x)将x转换到一个浮点数complex(real [,imag])创建一个复数str(x)将对象 x 转换为字符串repr(x)将对象 x 转换为表达式字符串eval(str)用来计算在字符串中的有效Python表达式,并返回一个对象tuple(s)将序列 s 转换为一个元组list(s)将序列 s 转换为一个列表set(s)转换为可变集合dict(d)创建一个字典。d 必须是一个序列 (key,value)元组。frozenset(s)转换为不可变集合chr(x)将一个整数转换为一个字符unichr(x)将一个整数转换为Unicode字符ord(x)将一个字符转换为它的整数值hex(x)将一个整数转换为一个十六进制字符串oct(x)将一个整数转换为一个八进制字符串

Python 面向对象

Python从设计之初就已经是一门面向对象的语言,正因为如此,在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。
如果你以前没有接触过面向对象的编程语言,那你可能需要先了解一些面向对象语言的一些基本特征,在头脑里头形成一个基本的面向对象的概念,这样有助于你更容易的学习Python的面向对象编程。
接下来我们先来简单的了解下面向对象的一些基本特征。

面向对象技术简介

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

Python 运算符

什么是运算符?
本章节主要说明Python的运算符。举个简单的例子 4 +5 = 9 。 例子中,4 和 5 被称为操作数,+ 称为运算符。
Python语言支持以下类型的运算符:

  • 算术运算符
  • 比较(关系)运算符
  • 赋值运算符
  • 逻辑运算符
  • 位运算符
  • 成员运算符
  • 身份运算符
  • 运算符优先级
    接下来让我们一个个来学习Python的运算符。

Python算术运算符

以下假设变量: a=10,b=20:

运算符描述实例+- 两个对象相加a + b 输出结果 30-- 得到负数或是一个数减去另一个数a - b 输出结果 -10*- 两个数相乘或是返回一个被重复若干次的字符串a * b 输出结果 200/- x除以yb / a 输出结果 2%取模 - 返回除法的余数b % a 输出结果 0**- 返回x的y次幂a**b 为1020次方, 输出结果 100000000000000000000//取整除 - 返回商的整数部分(向下取整)>>> 9//24>>> -9//2-5

以下实例演示了Python所有算术运算符的操作:

#!/usr/bin/python# -*- coding: UTF-8 -*- a = 21b = 10c = 0 c = a + bprint "1 - c 的值为:", c c = a - bprint "2 - c 的值为:", cc = a * bprint "3 - c 的值为:", cc = a / bprint "4 - c 的值为:", cc = a % bprint "5 - c 的值为:", c # 修改变量 a 、b 、ca = 2b = 3c = a**b print "6 - c 的值为:", c a = 10b = 5c = a//b print "7 - c 的值为:", c

以上实例输出结果:

1 - c 的值为: 312 - c 的值为: 113 - c 的值为: 2104 - c 的值为: 25 - c 的值为: 16 - c 的值为: 87 - c 的值为: 2

注意:Python2.x 里,整数除整数,只能得出整数。如果要得到小数部分,把其中一个数改成浮点数即可。

>>> 1/20>>> 1.0/20.5>>> 1/float(2)0.5

Python比较运算符

以下假设变量a为10,变量b为20:

运算符描述实例==等于 - 比较对象是否相等(a == b) 返回 False!=不等于 - 比较两个对象是否不相等(a != b) 返回 True不等于 - 比较两个对象是否不相等。python3 已废弃。(a  b) 返回 True。这个运算符类似 !=>大于 - 返回x是否大于y(a > b) 返回 False<小于 - 返回x是否小于y。所有比较运算符返回1表示真,返回0表示假。这分别与特殊的变量 TrueFalse 等价。(a < b) 返回 True>=大于等于 - 返回x是否大于等于y。(a >= b) 返回 False<=小于等于 - 返回x是否小于等于y。(a <= b) 返回 Tru

以下实例演示了Python所有比较运算符的操作:

#!/usr/bin/python# -*- coding: UTF-8 -*- a = 21b = 10c = 0 ifa == b : print "1 - a 等于 b"else: print "1 - a 不等于 b" ifa != b : print "2 - a 不等于 b"else: print "2 - a 等于 b" ifa  b : print "3 - a 不等于 b"else: print "3 - a 等于 b" ifa < b : print "4 - a 小于 b" else: print "4 - a 大于等于 b" ifa > b : print "5 - a 大于 b"else: print "5 - a 小于等于 b" # 修改变量 a 和 b 的值a = 5b = 20ifa <= b : print "6 - a 小于等于 b"else: print "6 - a 大于b" ifb >= a : print "7 - b 大于等于 a"else: print "7 - b 小于 a"

以上实例输出结果:

1 - a 不等于 b2 - a 不等于 b3 - a 不等于 b4 - a 大于等于 b5 - a 大于 b6 - a 小于等于 b7 - b 大于等于 a

Python赋值运算符

以下假设变量a为10,变量b为20:

运算符描述实例=简单的赋值运算符c = a + b 将 a + b 的运算结果赋值为 c+=加法赋值运算符c += a 等效于 c = c + a-=减法赋值运算符c -= a 等效于 c = c - a*=乘法赋值运算符c *= a 等效于 c = c * a/=除法赋值运算符c /= a 等效于 c = c / a%=取模赋值运算符c %= a 等效于 c = c % a**=幂赋值运算符c **= a 等效于 c = c ** a//=取整除赋值运算符c //= a 等效于 c = c // a

以下实例演示了Python所有赋值运算符的操作:

#!/usr/bin/python# -*- coding: UTF-8 -*- a = 21b = 10c = 0 c = a + bprint "1 - c 的值为:", c c += aprint "2 - c 的值为:", cc *= aprint "3 - c 的值为:", cc /= a print "4 - c 的值为:", cc = 2c %= aprint "5 - c 的值为:", c c **= aprint "6 - c 的值为:", c c //= aprint "7 - c 的值为:", c

以上实例输出结果:

1 - c 的值为: 312 - c 的值为: 523 - c 的值为: 10924 - c 的值为: 525 - c 的值为: 26 - c 的值为: 20971527 - c 的值为: 99864

Python位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下:
下表中变量 a 为 60,b 为 13,二进制格式如下:

a = 0011 1100b = 0000 1101-----------------a&b = 0000 1100a|b = 0011 1101a^b = 0011 0001~a= 1100 0011
运算符描述实例&按位与运算符:参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0(a & b) 输出结果 12 ,二进制解释: 0000 1100|按位或运算符:只要对应的二个二进位有一个为1时,结果位就为1(a | b) 输出结果 61 ,二进制解释: 0011 1101^按位异或运算符:当两对应的二进位相异时,结果为1(a ^ b) 输出结果 49 ,二进制解释: 0011 0001~按位取反运算符:对数据的每个二进制位取反,即把1变为0,0变为1~x 类似于 -x-1(~a ) 输出结果 -61 ,二进制解释: 1100 0011,在一个有符号二进制数的补码形式。<<左移动运算符:运算数的各二进位全部左移若干位,由 << 右边的数字指定了移动的位数,高位丢弃,低位补0。a << 2 输出结果 240 ,二进制解释: 1111 0000>>右移动运算符:把">>"左边的运算数的各二进位全部右移若干位,>> 右边的数字指定了移动的位数a >> 2 输出结果 15 ,二进制解释: 0000 111

以下实例演示了Python所有位运算符的操作:

#!/usr/bin/python# -*- coding: UTF-8 -*- a = 60# 60 = 0011 1100 b = 13# 13 = 0000 1101 c = 0 c = a & b;# 12 = 0000 1100print "1 - c 的值为:", c c = a | b;# 61 = 0011 1101 print "2 - c 的值为:", c c = a ^ b;# 49 = 0011 0001print "3 - c 的值为:", c c = ~a; # -61 = 1100 0011print "4 - c 的值为:", c c = a << 2; # 240 = 1111 0000print "5 - c 的值为:", c c = a >> 2; # 15 = 0000 1111print "6 - c 的值为:", c

以上实例输出结果:

1 - c 的值为: 122 - c 的值为: 613 - c 的值为: 494 - c 的值为: -615 - c 的值为: 2406 - c 的值为: 15

Python逻辑运算符

Python语言支持逻辑运算符,以下假设变量 a 为 10, b为 20:

运算符逻辑表达式描述实例andx and y布尔"与" - 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值。(a and b) 返回 20orx or y布尔"或" - 如果 x 是非 0,它返回 x 的计算值,否则它返回 y 的计算值。(a or b) 返回 10notnot x布尔"非" - 如果 x 为 True,返回 False 。如果 x 为 False,它返回 Truenot(a and b) 返回 False``以上实例输出结果:```python#!/usr/bin/python# -*- coding: UTF-8 -*- a = 10b = 20 ifa and b : print "1 - 变量 a 和 b 都为 True"else: print "1 - 变量 a 和 b 有一个不为 True" ifa or b : print "2 - 变量 a 和 b 都为 True,或其中一个变量为 True"else: print "2 - 变量 a 和 b 都不为 True" # 修改变量 a 的值a = 0ifa and b : print "3 - 变量 a 和 b 都为 True"else: print "3 - 变量 a 和 b 有一个不为 True" ifa or b : print "4 - 变量 a 和 b 都为 True,或其中一个变量为 True"else: print "4 - 变量 a 和 b 都不为 True" if not( a and b ): print "5 - 变量 a 和 b 都为 False,或其中一个变量为 False"else: print "5 - 变量 a 和 b 都为 True"

以上实例输出结果:

1 - 变量 a 和 b 都为 True2 - 变量 a 和 b 都为 True,或其中一个变量为 True3 - 变量 a 和 b 有一个不为 True4 - 变量 a 和 b 都为 True,或其中一个变量为 True5 - 变量 a 和 b 都为 False,或其中一个变量为 False

Python成员运算符

除了以上的一些运算符之外,Python还支持成员运算符,测试实例中包含了一系列的成员,包括字符串,列表或元组。

运算符描述实例in如果在指定的序列中找到值返回 True,否则返回 False。x 在 y 序列中 , 如果 x 在 y 序列中返回 Truenot in如果在指定的序列中没有找到值返回 True,否则返回 False。x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True

以下实例演示了Python所有成员运算符的操作:

#!/usr/bin/python# -*- coding: UTF-8 -*- a = 10b = 20list = [1, 2, 3, 4, 5 ]; if ( a in list ): print "1 - 变量 a 在给定的列表中 list 中"else: print "1 - 变量 a 不在给定的列表中 list 中" if ( b not in list ): print "2 - 变量 b 不在给定的列表中 list 中"else: print "2 - 变量 b 在给定的列表中 list 中" # 修改变量 a 的值a = 2if ( a in list ): print "3 - 变量 a 在给定的列表中 list 中"else: print "3 - 变量 a 不在给定的列表中 list 中"

以上实例输出结果:

1 - 变量 a 不在给定的列表中 list2 - 变量 b 不在给定的列表中 list3 - 变量 a 在给定的列表中 list

Python身份运算符

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

运算符描述实例isis 是判断两个标识符是不是引用自一个对象x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True,否则返回 Falseis notis not 是判断两个标识符是不是引用自不同对象x is not y , 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True,否则返回 False

注: id() 函数用于获取对象内存地址。
以下实例演示了Python所有身份运算符的操作

#!/usr/bin/python# -*- coding: UTF-8 -*- a = 20b = 20 if ( a is b ): print "1 - a 和 b 有相同的标识"else: print "1 - a 和 b 没有相同的标识" if ( a is not b ): print "2 - a 和 b 没有相同的标识"else: print "2 - a 和 b 有相同的标识" # 修改变量 b 的值b = 30if ( 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 有相同的标识"

以上实例输出结果:

1 - a 和 b 有相同的标识2 - a 和 b 有相同的标识3 - a 和 b 没有相同的标识4 - a 和 b 没有相同的标识

is 与 == 区别:
is 用于判断两个变量引用对象是否为同一个(同一块内存空间), == 用于判断引用变量的值是否相等。

>>> a = [1, 2, 3]>>> b = a>>> b is a True>>> b == aTrue>>> b = a[:]>>> b is aFalse>>> b == aTrue

Python运算符优先级

以下表格列出了从最高到最低优先级的所有运算符:

运算符描述**指数 (最高优先级)~ + -按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)* / % //乘,除,取模和取整除+ -加法减法>> <<右移,左移运算符&'AND'^ |位运算符<= < > >=比较运算符 == !=等于运算符= %= /= //= -= += *= **=赋值运算符is is not身份运算符in not in成员运算符not and or逻辑运算符

and 拥有更高优先级:

x = Truey = Falsez = False if x or y and z:print("yes")else:print("no")

以下实例演示了Python所有运算符优先级的操作:

yes

注意:Python3 已不支持 运算符,可以使用 != 代替,如果你一定要使用这种比较运算符,可以使用以下的方式:

>>> from __future__ import barry_as_FLUFL>>> 1  2True
#!/usr/bin/python# -*- coding: UTF-8 -*- a = 20b = 10c = 15d = 5e = 0 e = (a + b) * c / d #( 30 * 15 ) / 5print "(a + b) * c / d 运算结果为:",e e = ((a + b) * c) / d # (30 * 15 ) / 5print "((a + b) * c) / d 运算结果为:",e e = (a + b) * (c / d);# (30) * (15/5)print "(a + b) * (c / d) 运算结果为:",e e = a + (b * c) / d;#20 + (150/5)print "a + (b * c) / d 运算结果为:",e

以上实例输出结果:

(a + b) * c / d 运算结果为: 90((a + b) * c) / d 运算结果为: 90(a + b) * (c / d) 运算结果为: 90a + (b * c) / d 运算结果为: 50

Python3 数字(Number)

Python 数字数据类型用于存储数值。
数据类型是不允许改变的,这就意味着如果改变数字数据类型的值,将重新分配内存空间。
以下实例在变量赋值时 Number 对象将被创建:

var1 = 1var2 = 10

您也可以使用del语句删除一些数字对象的引用。
del语句的语法是:

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

您可以通过使用del语句删除单个或多个对象的引用,例如:

del vardel var_a, var_b

Python 支持三种不同的数值类型:

  • 整型(int) – 通常被称为是整型或整数,是正或负整数,不带小数点。Python3 整型是没有限制大小的,可以当作 Long 类型使用,所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。
  • 浮点型(float) – 浮点型由整数部分与小数部分组成,浮点型也可以使用科学计数法表示(2.5e2 = 2.5 x 102 = 250)
  • 复数( (complex)) – 复数由实数部分和虚数部分构成,可以用a + bj,或者complex(a,b)表示, 复数的实部a和虚部b都是浮点型。
```python我们可以使用十六进制和八进制来代表整数:>>> number = 0xA0F # 十六进制>>> number2575>>> number=0o37 # 八进制>>> number31
```pythonintfloatcomplex100.03.14j10015.2045.j-786-21.99.322e-36j08032.3e+18.876j-0490-90.-.6545+0J-0x260-32.54e1003e+26J0x6970.2E-124.53e-7j

我们可以使用十六进制和八进制来代表整数:

>>> number = 0xA0F # 十六进制>>> number2575>>> number=0o37 # 八进制>>> number31
intfloatcomplex100.03.14j10015.2045.j-786-21.99.322e-36j08032.3e+18.876j-0490-90.-.6545+0J-0x260-32.54e1003e+26J0x6970.2E-124.53e-7j
  • Python支持复数,复数由实数部分和虚数部分构成,可以用a + bj,或者complex(a,b)表示, 复数的实部a和虚部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

Python 数字运算

Python 解释器可以作为一个简单的计算器,您可以在解释器里输入一个表达式,它将输出表达式的值。
表达式的语法很直白: +, -, * 和 /, 和其它语言(如Pascal或C)里一样。例如:

>>> 2 + 24>>> 50 - 5*620>>> (50 - 5*6) / 45.0>>> 8 / 5# 总是返回一个浮点数1.6

注意:在不同的机器上浮点运算的结果可能会不一样。
在整数除法中,除法 / 总是返回一个浮点数,如果只想得到整数的结果,丢弃可能的分数部分,可以使用运算符 // :

在整数除法中,除法 / 总是返回一个浮点数,如果只想得到整数的结果,丢弃可能的分数部分,可以使用运算符 //

注意:// 得到的并不一定是整数类型的数,它与分母分子的数据类型有关系。

>>> 7//23>>> 7.0//23.0>>> 7//2.03.0>>> 

等号 = 用于给变量赋值。赋值之后,除了下一个提示符,解释器不会显示任何结果。

>>> width = 20>>> height = 5*9>>> width * height900

Python 可以使用 ** 操作来进行幂运算:

>>> 5 ** 2# 5 的平方25>>> 2 ** 7# 2的7次方128

变量在使用前必须先”定义”(即赋予变量一个值),否则会出现错误:

变量在使用前必须先"定义"(即赋予变量一个值),否则会出现错误:

不同类型的数混合运算时会将整数转换为浮点数:

>>> 3 * 3.75 / 1.57.5>>> 7.0 / 23.5

在交互模式中,最后被输出的表达式结果被赋值给变量 _ 。例如:

>>> tax = 12.5 / 100>>> price = 100.50>>> price * tax12.5625>>> price + _113.0625>>> round(_, 2)113.06

此处, _ 变量应被用户视为只读变量。

数学函数

函数返回值 ( 描述 )abs(x)返回数字的绝对值,如abs(-10) 返回 10ceil(x)返回数字的上入整数,如math.ceil(4.1) 返回 5cmp(x, y)如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃,使用 (x>y)-(x<y) 替换。exp(x)返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045fabs(x)返回数字的绝对值,如math.fabs(-10) 返回10.0floor(x)返回数字的下舍整数,如math.floor(4.9)返回 4log(x)如math.log(math.e)返回1.0,math.log(100,10)返回2.0log10(x)返回以10为基数的x的对数,如math.log10(100)返回 2.0max(x1, x2,...)返回给定参数的最大值,参数可以为序列。min(x1, x2,...)返回给定参数的最小值,参数可以为序列。modf(x)返回x的整数部分与小数部分,两部分的数值符号与x相同,整数部分以浮点型表示。pow(x, y)x**y 运算后的值。round(x [,n])返回浮点数 x 的四舍五入值,如给出 n 值,则代表舍入到小数点后的位数。其实准确的说是保留值将保留到离上一位更近的一端。sqrt(x)返回数字x的平方根。

随机数函数

随机数可以用于数学,游戏,安全等领域中,还经常被嵌入到算法中,用以提高算法效率,并提高程序的安全性。
Python包含以下常用随机数函数:

函数描述choice(seq)从序列的元素中随机挑选一个元素,比如random.choice(range(10)),从09中随机挑选一个整数。randrange ([start,] stop [,step])从指定范围内,按指定基数递增的集合中获取一个随机数,基数默认值为 1random()随机生成下一个实数,它在[0,1)范围内。seed([x])改变随机数生成器的种子seed。如果你不了解其原理,你不必特别去设定seed,Python会帮你选择seed。shuffle(lst)将序列的所有元素随机排序uniform(x, y)随机生成下一个实数,它在[x,y]范围内。

三角函数

Python包括以下三角函数:

函数描述acos(x)返回x的反余弦弧度值。asin(x)返回x的反正弦弧度值。atan(x)返回x的反正切弧度值。atan2(y, x)返回给定的 X 及 Y 坐标值的反正切值。cos(x)返回x的弧度的余弦值。hypot(x, y)返回欧几里德范数 sqrt(x*x + y*y)。sin(x)返回的x弧度的正弦值。tan(x)返回x弧度的正切值。degrees(x)将弧度转换为角度,如degrees(math.pi/2) , 返回90.0radians(x)将角度转换为弧度

数学常量

常量描述pi数学常量 pi(圆周率,一般以π来表示)e数学常量 e,e即自然常数(自然常数)。

Python3 字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号( ’ 或 ” )来创建字符串。
创建字符串很简单,只要为变量分配一个值即可。例如:

var1 = 'Hello World!'var2 = "Runoob"

Python 访问字符串中的值

Python 不支持单字符类型,单字符在 Python 中也是作为一个字符串使用。
Python 访问子字符串,可以使用方括号 [] 来截取字符串,字符串的截取的语法格式如下:

变量[头下标:尾下标]

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


如下实例:

#!/usr/bin/python3 var1 = 'Hello World!'var2 = "Runoob" print ("var1[0]: ", var1[0])print ("var2[1:5]: ", var2[1:5])

以上实例执行结果:

var1[0]:Hvar2[1:5]:unoo

Python 字符串更新

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

#!/usr/bin/python3var1 = 'Hello World!'print ("已更新字符串 : ", var1[:6] + 'Runoob!')

以上实例执行结果:

已更新字符串 :Hello Runoob!

Python转义字符

在需要在字符中使用特殊字符时,python 用反斜杠 \ 转义字符。如下表:

转义字符描述实例\(在行尾时)续行符>>> print("line1 \... line2 \... line3")line1 line2 line3>>> \\反斜杠符号>>> print("\\")\\'单引号>>> print('\'')'\"双引号>>> print("\"")"\a响铃>>> print("\a")执行后电脑有响声。\b退格(Backspace)>>> print("Hello \b World!")Hello World!\000>>> print("\000")>>> \n换行>>> print("\n")>>>\v纵向制表符>>> print("Hello \v World!")HelloWorld!>>>\t横向制表符>>> print("Hello \t World!")HelloWorld!>>>\r回车,将 \r 后面的内容移到字符串开头,并逐一替换开头部分的字符,直至将 \r 后面的内容完全替换完成。>>> print("Hello\rWorld!")World!>>> print('google runoob taobao\r123456')123456 runoob taobao\f换页>>> print("Hello \f World!")HelloWorld!>>> \yyy八进制数,y 代表 0~7 的字符,例如:\012 代表换行。>>> print("\110\145\154\154\157\40\127\157\162\154\144\41")Hello World!\xyy十六进制数,以 \x 开头,y 代表的字符,例如:\x0a 代表换行>>> print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21")Hello World!\other其它的字符以普通格式输出 

Python字符串运算符

下表实例变量 a 值为字符串 “Hello”,b 变量值为 “Python”:

操作符描述实例+字符串连接a + b 输出结果: HelloPython*重复输出字符串a*2 输出结果:HelloHello[]通过索引获取字符串中字符a[1] 输出结果 e[ : ]截取字符串中的一部分,遵循左闭右开原则,str[0:2] 是不包含第 3 个字符的。a[1:4] 输出结果 ellin成员运算符 - 如果字符串中包含给定的字符返回 True'H' in a 输出结果 Truenot in成员运算符 - 如果字符串中不包含给定的字符返回 True'M' not in a 输出结果 Truer/R原始字符串 - 原始字符串:所有的字符串都是直接按照字面的意思来使用,没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r(可以大小写)以外,与普通字符串有着几乎完全相同的语法。print( r'\n' )print( R'\n' )%格式字符串请看下一节内容。
#!/usr/bin/python3 a = "Hello"b = "Python" print("a + b 输出结果:", a + b)print("a * 2 输出结果:", a * 2)print("a[1] 输出结果:", a[1])print("a[1:4] 输出结果:", a[1:4]) if( "H" in a) :print("H 在变量 a 中")else :print("H 不在变量 a 中") if( "M" not in a) :print("M 不在变量 a 中")else :print("M 在变量 a 中") print (r'\n')print (R'\n')

以上实例输出结果为:

a + b 输出结果: HelloPythona * 2 输出结果: HelloHelloa[1] 输出结果: ea[1:4] 输出结果: ellH 在变量 a 中M 不在变量 a 中\n\n

Python 字符串格式化

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

#!/usr/bin/python3print ("我叫 %s 今年 %d 岁!" % ('小明', 10))

以上实例输出结果:

我叫 小明 今年 10 岁!

python字符串格式化符号:

 符 号描述%c 格式化字符及其ASCII码%s 格式化字符串%d 格式化整数%u 格式化无符号整型%o 格式化无符号八进制数%x 格式化无符号十六进制数%X 格式化无符号十六进制数(大写)%f 格式化浮点数字,可指定小数点后的精度%e 用科学计数法格式化浮点数%E 作用同%e,用科学计数法格式化浮点数%g %f和%e的简写%G %f 和 %E 的简写%p 用十六进制数格式化变量的地址

格式化操作符辅助指令:

符号功能*定义宽度或者小数点精度-用做左对齐+在正数前面显示加号( + )<sp>在正数前面显示空格#在八进制数前面显示零('0'),在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')0显示的数字前面填充'0'而不是默认的空格%'%%'输出一个单一的'%'(var)映射变量(字典参数)m.n.m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

Python2.6 开始,新增了一种格式化字符串的函数 str.format(),它增强了字符串格式化的功能。

Python三引号

python三引号允许一个字符串跨多行,字符串中可以包含换行符、制表符以及其他特殊字符。实例如下:

#!/usr/bin/python3 para_str = """这是一个多行字符串的实例多行字符串可以使用制表符TAB ( \t )。也可以使用换行符 [ \n ]。"""print (para_str)

以上实例执行结果为:

这是一个多行字符串的实例多行字符串可以使用制表符TAB ()。也可以使用换行符 []

三引号让程序员从引号和特殊字符串的泥潭里面解脱出来,自始至终保持一小块字符串的格式是所谓的WYSIWYG(所见即所得)格式的。
一个典型的用例是,当你需要一块HTML或者SQL时,这时用字符串组合,特殊字符串转义将会非常的繁琐。

errHTML = '''Friends CGI Demo

ERROR

%s

'''cursor.execute('''CREATE TABLE users (login VARCHAR(8), uid INTEGER,prid INTEGER)''')

f-string

f-string 是 python3.6 之后版本添加的,称之为字面量格式化字符串,是新的格式化字符串的语法。
之前我们习惯用百分号 (%):

>>> name = 'Runoob'>>> 'Hello %s' % name'Hello Runoob'

f-string 格式化字符串以 f 开头,后面跟着字符串,字符串中的表达式用大括号 {} 包起来,它会将变量或表达式计算后的值替换进去,实例如下:

>>> name = 'Runoob'>>> f'Hello {name}'# 替换变量'Hello Runoob'>>> f'{1+2}' # 使用表达式'3'>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}>>> f'{w["name"]}: {w["url"]}''Runoob: www.runoob.com'

用了这种方式明显更简单了,不用再去判断使用 %s,还是 %d。
在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果。

>>> x = 1>>> print(f'{x+1}') # Python 3.62>>> x = 1>>> print(f'{x+1=}') # Python 3.8x+1=2

Unicode 字符串

在Python2中,普通字符串是以8位ASCII码进行存储的,而Unicode字符串则存储为16位unicode字符串,这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。
在Python3中,所有的字符串都是Unicode字符串。

Python 的字符串内建函数

Python 的字符串常用内建函数如下:

序号方法及描述1capitalize()将字符串的第一个字符转换为大写2center(width, fillchar)返回一个指定的宽度 width 居中的字符串,fillchar 为填充的字符,默认为空格。3count(str, beg= 0,end=len(string))返回 str 在 string 里面出现的次数,如果 beg 或者 end 指定则返回指定范围内 str 出现的次数4bytes.decode(encoding="utf-8", errors="strict")Python3 中没有 decode 方法,但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象,这个 bytes 对象可以由 str.encode() 来编码返回。5encode(encoding='UTF-8',errors='strict')以 encoding 指定的编码格式编码字符串,如果出错默认报一个ValueError 的异常,除非 errors 指定的是'ignore'或者'replace'6endswith(suffix, beg=0, end=len(string))检查字符串是否以 suffix 结束,如果 beg 或者 end 指定则检查指定的范围内是否以 suffix 结束,如果是,返回 True,否则返回 False7expandtabs(tabsize=8)把字符串 string 中的 tab 符号转为空格,tab 符号默认的空格数是 88find(str, beg=0, end=len(string))检测 str 是否包含在字符串中,如果指定范围 beg 和 end ,则检查是否包含在指定范围内,如果包含返回开始的索引值,否则返回-19index(str, beg=0, end=len(string))跟find()方法一样,只不过如果str不在字符串中会报一个异常。10isalnum()如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False11isalpha()如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False12isdigit()如果字符串只包含数字则返回 True 否则返回 False..13islower()如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True,否则返回 False14isnumeric()如果字符串中只包含数字字符,则返回 True,否则返回 False15isspace()如果字符串中只包含空白,则返回 True,否则返回 False.16istitle()如果字符串是标题化的(见 title())则返回 True,否则返回 False17isupper()如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True,否则返回 False18join(seq)以指定字符串作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串19len(string)返回字符串长度20ljust(width[, fillchar])返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串,fillchar 默认为空格。21lower()转换字符串中所有大写字符为小写.22lstrip()截掉字符串左边的空格或指定字符。23maketrans()创建字符映射的转换表,对于接受两个参数的最简单的调用方式,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标。24max(str)返回字符串 str 中最大的字母。25min(str)返回字符串 str 中最小的字母。26replace(old, new [, max])把 将字符串中的 old 替换成 new,如果 max 指定,则替换不超过 max 次。27rfind(str, beg=0,end=len(string))类似于 find()函数,不过是从右边开始查找.28rindex( str, beg=0, end=len(string))类似于 index(),不过是从右边开始.29rjust(width,[, fillchar])返回一个原字符串右对齐,并使用fillchar(默认空格)填充至长度 width 的新字符串30rstrip()删除字符串末尾的空格或指定字符。31split(str="", num=string.count(str))str 为分隔符截取字符串,如果 num 有指定值,则仅截取 num+1 个子字符串32splitlines([keepends])按照行('\r', '\r\n', \n')分隔,返回一个包含各行作为元素的列表,如果参数 keepends 为 False,不包含换行符,如果为 True,则保留换行符。33startswith(substr, beg=0,end=len(string))检查字符串是否是以指定子字符串 substr 开头,是则返回 True,否则返回 False。如果beg 和 end 指定值,则在指定范围内检查。34strip([chars])在字符串上执行 lstrip()和 rstrip()35swapcase()将字符串中大写转换为小写,小写转换为大写36title()返回"标题化"的字符串,就是说所有单词都是以大写开始,其余字母均为小写(见 istitle())37translate(table, deletechars="")根据 table 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中38upper()转换字符串中的小写字母为大写39zfill (width)返回长度为 width 的字符串,原字符串右对齐,前面填充040isdecimal()检查字符串是否只包含十进制字符,如果是返回 true,否则返回 false。

Python3 列表

序列是 Python 中最基本的数据结构。
序列中的每个值都有对应的位置值,称之为索引,第一个索引是 0,第二个索引是 1,依此类推。
Python 有 6 个序列的内置类型,但最常见的是列表和元组。
列表都可以进行的操作包括索引,切片,加,乘,检查成员。
此外,Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的 Python 数据类型,它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表,只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示:

list1 = ['Google', 'Runoob', 1997, 2000]list2 = [1, 2, 3, 4, 5 ]list3 = ["a", "b", "c", "d"]list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

访问列表中的值

与字符串的索引一样,列表索引从 0 开始,第二个索引是 1,依此类推。
通过索引列表可以进行截取、组合等操作。

#!/usr/bin/python3list = ['red', 'green', 'blue', 'yellow', 'white', 'black']print( list[0] )print( list[1] )print( list[2] )

以上实例输出结果:

redgreenblue

索引也可以从尾部开始,最后一个元素的索引为 -1,往前一位为 -2,以此类推。

#!/usr/bin/python3list = ['red', 'green', 'blue', 'yellow', 'white', 'black']print( list[-1] )print( list[-2] )print( list[-3] )
以上实例输出结果:blackwhiteyellow

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

#!/usr/bin/python3nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]print(nums[0:4])

以上实例输出结果:[10, 20, 30, 40]
使用负数索引值截取:

#!/usr/bin/python3 list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"] # 读取第二位print ("list[1]: ", list[1])# 从第二位开始(包含)截取到倒数第二位(不包含)print ("list[1:-2]: ", list[1:-2])

以上实例输出结果:

list[1]:Runooblist[1:-2]:['Runoob', 'Zhihu']

更新列表

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

#!/usr/bin/python3 list = ['Google', 'Runoob', 1997, 2000] print ("第三个元素为 : ", list[2])list[2] = 2001print ("更新后的第三个元素为 : ", list[2]) list1 = ['Google', 'Runoob', 'Taobao']list1.append('Baidu')print ("更新后的列表 : ", list1)

注意:我们会在接下来的章节讨论 append() 方法的使用。
以上实例输出结果:

第三个元素为 :1997更新后的第三个元素为 :2001更新后的列表 :['Google', 'Runoob', 'Taobao', 'Baidu']

删除列表元素

可以使用 del 语句来删除列表的的元素,如下实例:

#!/usr/bin/python3list = ['Google', 'Runoob', 1997, 2000]print ("原始列表 : ", list)del list[2]print ("删除第三个元素 : ", list)

以上实例输出结果:

原始列表 :['Google', 'Runoob', 1997, 2000]删除第三个元素 :['Google', 'Runoob', 2000]

注意:我们会在接下来的章节讨论 remove() 方法的使用

Python列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表,* 号用于重复列表。
如下所示:

Python 表达式结果描述len([1, 2, 3])3长度[1, 2, 3] + [4, 5, 6][1, 2, 3, 4, 5, 6]组合['Hi!'] * 4['Hi!', 'Hi!', 'Hi!', 'Hi!']重复3 in [1, 2, 3]True元素是否存在于列表中for x in [1, 2, 3]: print(x, end=" ")1 2 3迭代

Python列表截取与拼接

Python的列表截取与字符串操作类型,如下所示:

L=['Google', 'Runoob', 'Taobao']

操作:

`Python 表达式结果描述L[2]'Taobao'读取第三个元素L[-2]'Runoob'从右侧开始读取倒数第二个元素: count from the rightL[1:]['Runoob', 'Taobao']输出从第二个元素开始后的所有元素`
>>>L=['Google', 'Runoob', 'Taobao']>>> L[2]'Taobao'>>> L[-2]'Runoob'>>> L[1:]['Runoob', 'Taobao']>>>

列表还支持拼接操作:

>>>squares = [1, 4, 9, 16, 25]>>> squares += [36, 49, 64, 81, 100]>>> squares[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]>>>

嵌套列表

使用嵌套列表即在列表里创建其它列表,例如:

>>>a = ['a', 'b', 'c']>>> n = [1, 2, 3]>>> x = [a, n]>>> x[['a', 'b', 'c'], [1, 2, 3]]>>> x[0]['a', 'b', 'c']>>> x[0][1]'b'

列表比较

列表比较需要引入 operator 模块的 eq 方法(详见:Python operator 模块)

# 导入 operator 模块import operatora = [1, 2]b = [2, 3]c = [2, 3]print("operator.eq(a,b): ", operator.eq(a,b))print("operator.eq(c,b): ", operator.eq(c,b))

以上代码输出结果为:

operator.eq(a,b):Falseoperator.eq(c,b):True

Python列表函数&方法

Python包含以下函数:

序号函数1len(list)列表元素个数2max(list)返回列表元素最大值3min(list)返回列表元素最小值4list(seq)将元组转换为列表

Python包含以下方法:

序号方法1list.append(obj)在列表末尾添加新的对象2list.count(obj)统计某个元素在列表中出现的次数3list.extend(seq)在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)4list.index(obj)从列表中找出某个值第一个匹配项的索引位置5list.insert(index, obj)将对象插入列表6list.pop([index=-1])移除列表中的一个元素(默认最后一个元素),并且返回该元素的值7list.remove(obj)移除列表中某个值的第一个匹配项8list.reverse()反向列表中元素9list.sort( key=None, reverse=False)对原列表进行排序10list.clear()清空列表11list.copy()复制列表

Python3 元组

Python 的元组与列表类似,不同之处在于元组的元素不能修改。
元组使用小括号 ( ),列表使用方括号 [ ]。
元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。

>>> tup1 = ('Google', 'Runoob', 1997, 2000)>>> tup2 = (1, 2, 3, 4, 5 )>>> tup3 = "a", "b", "c", "d" #不需要括号也可以>>> type(tup3)<class 'tuple'>

创建空元组

tup1 = ()

元组中只包含一个元素时,需要在元素后面添加逗号 , ,否则括号会被当作运算符使用:

>>> tup1 = (50)>>> type(tup1) # 不加逗号,类型为整型<class 'int'>>>> tup1 = (50,)>>> type(tup1) # 加上逗号,类型为元组<class 'tuple'>

元组与字符串类似,下标索引从 0 开始,可以进行截取,组合等。

访问元组

元组可以使用下标索引来访问元组中的值,如下实例:

#!/usr/bin/python3tup1 = ('Google', 'Runoob', 1997, 2000)tup2 = (1, 2, 3, 4, 5, 6, 7 )print ("tup1[0]: ", tup1[0])print ("tup2[1:5]: ", tup2[1:5])

以上实例输出结果:

tup1[0]:Googletup2[1:5]:(2, 3, 4, 5)

修改元组

元组中的元素值是不允许修改的,但我们可以对元组进行连接组合,如下实例:

#!/usr/bin/python3 tup1 = (12, 34.56)tup2 = ('abc', 'xyz') # 以下修改元组元素操作是非法的。# tup1[0] = 100 # 创建一个新的元组tup3 = tup1 + tup2print (tup3)

以上实例输出结果:

(12, 34.56, 'abc', 'xyz')

删除元组

元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组,如下实例:

#!/usr/bin/python3tup = ('Google', 'Runoob', 1997, 2000)print (tup)del tupprint ("删除后的元组 tup : ")print (tup)

以上实例元组被删除后,输出变量会有异常信息,输出如下所示:

删除后的元组 tup : Traceback (most recent call last):File "test.py", line 8, in <module>print (tup)NameError: name 'tup' is not defined

元组运算符

与字符串一样,元组之间可以使用 +、+=和 * 号进行运算。这就意味着他们可以组合和复制,运算后会生成一个新的元组。

元组索引,截取

因为元组也是一个序列,所以我们可以访问元组中的指定位置的元素,也可以截取索引中的一段元素,如下所示:

元组:tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')

Python 表达式结果描述tup[1]'Runoob'读取第二个元素tup[-2]'Weibo'反向读取,读取倒数第二个元素tup[1:]('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')截取元素,从第二个开始后的所有元素。tup[1:4]('Runoob', 'Taobao', 'Wiki')截取元素,从第二个开始到第四个元素(索引为 3)。

运行实例如下:

>>> tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')>>> tup[1]'Runoob'>>> tup[-2]'Weibo'>>> tup[1:]('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')>>> tup[1:4]('Runoob', 'Taobao', 'Wiki')>>>

元组内置函数

Python元组包含了以下内置函数

序号方法及描述实例1len(tuple)计算元组元素个数。>>> tuple1 = ('Google', 'Runoob', 'Taobao')>>> len(tuple1)3>>> 2max(tuple)返回元组中元素最大值。>>> tuple2 = ('5', '4', '8')>>> max(tuple2)'8'>>> 3min(tuple)返回元组中元素最小值。>>> tuple2 = ('5', '4', '8')>>> min(tuple2)'4'>>> 4tuple(iterable)将可迭代系列转换为元组。>>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu']>>> tuple1=tuple(list1)>>> tuple1('Google', 'Taobao', 'Runoob', 'Baidu')

关于元组是不可变的

所谓元组的不可变指的是元组所指向的内存中的内容不可变。

>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')>>> tup[0] = 'g' # 不支持修改元素Traceback (most recent call last):File "", line 1, in <module>TypeError: 'tuple' object does not support item assignment>>> id(tup) # 查看内存地址4440687904>>> tup = (1,2,3)>>> id(tup)4441088800# 内存地址不一样了

从以上实例可以看出,重新赋值的元组 tup,绑定到新的对象了,不是修改了原来的对象。

Python3 字典

字典是另一种可变容器模型,且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割,每个对之间用逗号(,)分割,整个字典包括在花括号 {} 中 ,格式如下所示:

d = {key1 : value1, key2 : value2, key3 : value3 }

注意:dict 作为 Python 的关键字和内置函数,变量名不建议命名为 dict。

键必须是唯一的,但值则不必。
值可以取任何数据类型,但键必须是不可变的,如字符串,数字。
一个简单的字典实例:

tinydict = {'name': 'runoob', 'likes': 123, 'url': 'www.runoob.com'}


也可如此创建字典:

tinydict1 = { 'abc': 456 }tinydict2 = { 'abc': 123, 98.6: 37 }

创建空字典

使用大括号 { } 创建空字典:

# 使用大括号 {} 来创建空字典emptyDict = {} # 打印字典print(emptyDict) # 查看字典的数量print("Length:", len(emptyDict)) # 查看类型print(type(emptyDict))

以上实例输出结果:

{}Length: 0<class 'dict'>

使用内建函数 dict() 创建字典:

emptyDict = dict() # 打印字典print(emptyDict) # 查看字典的数量print("Length:",len(emptyDict)) # 查看类型print(type(emptyDict))

以上实例输出结果:

{}Length: 0<class 'dict'>

访问字典里的值

把相应的键放入到方括号中,如下实例:

#!/usr/bin/python3tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}print ("tinydict['Name']: ", tinydict['Name'])print ("tinydict['Age']: ", tinydict['Age'])

以上实例输出结果:

tinydict['Name']:Runoobtinydict['Age']:7

如果用字典里没有的键访问数据,会输出错误如下:

#!/usr/bin/python3 tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} print ("tinydict['Alice']: ", tinydict['Alice'])

以上实例输出结果:

Traceback (most recent call last):File "test.py", line 5, in <module>print ("tinydict['Alice']: ", tinydict['Alice'])KeyError: 'Alice'

修改字典

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

#!/usr/bin/python3tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}tinydict['Age'] = 8 # 更新 Agetinydict['School'] = "菜鸟教程"# 添加信息print ("tinydict['Age']: ", tinydict['Age'])print ("tinydict['School']: ", tinydict['School'])

以上实例输出结果:

tinydict['Age']:8tinydict['School']:菜鸟教程

删除字典元素

能删单一的元素也能清空字典,清空只需一项操作。
显式删除一个字典用del命令,如下实例:

#!/usr/bin/python3tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}del tinydict['Name'] # 删除键 'Name'tinydict.clear() # 清空字典del tinydict # 删除字典 print ("tinydict['Age']: ", tinydict['Age'])print ("tinydict['School']: ", tinydict['School'])

但这会引发一个异常,因为用执行 del 操作后字典不再存在:

`Traceback (most recent call last):File "/runoob-test/test.py", line 9, in <module>print ("tinydict['Age']: ", tinydict['Age'])NameError: name 'tinydict' is not defined`

注:del() 方法后面也会讨论。

字典键的特性

字典值可以是任何的 python 对象,既可以是标准的对象,也可以是用户定义的,但键不行。
两个重要的点需要记住:
1.不允许同一个键出现两次。创建时如果同一个键被赋值两次,后一个值会被记住,如下实例:

#!/usr/bin/python3tinydict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟'}print ("tinydict['Name']: ", tinydict['Name'])

以上实例输出结果:

tinydict['Name']:小菜鸟

2.键必须不可变,所以可以用数字,字符串或元组充当,而用列表就不行,如下实例:

#!/usr/bin/python3tinydict = {['Name']: 'Runoob', 'Age': 7}print ("tinydict['Name']: ", tinydict['Name'])

以上实例输出结果:

Traceback (most recent call last):File "test.py", line 3, in <module>tinydict = {['Name']: 'Runoob', 'Age': 7}TypeError: unhashable type: 'list'

字典内置函数&方法

Python字典包含了以下内置函数:

序号函数及描述实例1len(dict)计算字典元素个数,即键的总数。>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> len(tinydict)32str(dict)输出字典,可以打印的字符串表示。>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> str(tinydict)"{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"3type(variable)返回输入的变量类型,如果变量是字典就返回字典类型。>>> tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}>>> type(tinydict)<class 'dict'>

Python字典包含了以下内置方法:

序号函数及描述1dict.clear()删除字典内所有元素2dict.copy()返回一个字典的浅复制3dict.fromkeys()创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值4dict.get(key, default=None)返回指定键的值,如果键不在字典中返回 default 设置的默认值5key in dict如果键在字典dict里返回true,否则返回false6dict.items()以列表返回一个视图对象7dict.keys()返回一个视图对象8dict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default9dict.update(dict2)把字典dict2的键/值对更新到dict10dict.values()返回一个视图对象11pop(key[,default])删除字典 key(键)所对应的值,返回被删除的值。12popitem()返回并删除字典中的最后一对键和值。

Python3 集合

集合(set)是一个无序的不重复元素序列。可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。创建格式:
parame = {value01,value02,...}或者set(value)
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}>>> print(basket)# 这里演示的是去重功能{'orange', 'banana', 'pear', 'apple'}>>> 'orange' in basket # 快速判断元素是否在集合内True>>> 'crabgrass' in basketFalse>>> # 下面展示两个集合间的运算....>>> a = set('abracadabra')>>> b = set('alacazam')>>> a{'a', 'r', 'b', 'c', 'd'}>>> a - b# 集合a中包含而集合b中不包含的元素{'r', 'd', 'b'}>>> a | b# 集合a或b中包含的所有元素{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}>>> a & b# 集合a和b中都包含了的元素{'a', 'c'}>>> a ^ b# 不同时包含于a和b的元素{'r', 'd', 'b', 'm', 'z', 'l'}

类似列表推导式,同样集合支持集合推导式(Set comprehension):

>>> a = {x for x in 'abracadabra' if x not in 'abc'}>>> a{'r', 'd'}

集合的基本操作

1、添加元素
语法格式如下:

s.add( x )

将元素 x 添加到集合 s 中,如果元素已存在,则不进行任何操作。

>>> thisset = set(("Google", "Runoob", "Taobao"))>>> thisset.add("Facebook")>>> print(thisset){'Taobao', 'Facebook', 'Google', 'Runoob'}

还有一个方法,也可以添加元素,且参数可以是列表,元组,字典等,语法格式如下:

s.update( x )

x 可以有多个,用逗号分开。

>>> thisset = set(("Google", "Runoob", "Taobao"))>>> thisset.update({1,3})>>> print(thisset){1, 3, 'Google', 'Taobao', 'Runoob'}>>> thisset.update([1,4],[5,6])>>> print(thisset){1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}>>>

2、移除元素
语法格式如下:s.remove( x )
将元素 x 从集合 s 中移除,如果元素不存在,则会发生错误。

>>> thisset = set(("Google", "Runoob", "Taobao"))>>> thisset.remove("Taobao")>>> print(thisset){'Google', 'Runoob'}>>> thisset.remove("Facebook") # 不存在会发生错误Traceback (most recent call last):File "", line 1, in <module>KeyError: 'Facebook'>>>

此外还有一个方法也是移除集合中的元素,且如果元素不存在,不会发生错误。格式如下所示:

s.discard( x )
>>> thisset = set(("Google", "Runoob", "Taobao"))>>> thisset.discard("Facebook")# 不存在不会发生错误>>> print(thisset){'Taobao', 'Google', 'Runoob'}

我们也可以设置随机删除集合中的一个元素,语法格式如下:

s.pop() 
thisset = set(("Google", "Runoob", "Taobao", "Facebook"))x = thisset.pop()print(x)输出结果:$ python3 test.py Runoob

多次执行测试结果都不一样。
set 集合的 pop 方法会对集合进行无序的排列,然后将这个无序排列集合的左面第一个元素进行删除。

3、计算集合元素个数

语法格式如下:

len(s)

计算集合 s 元素个数。

>>> thisset = set(("Google", "Runoob", "Taobao"))>>> len(thisset)3

4、清空集合

语法格式如下:

s.clear()

清空集合 s

>>> thisset = set(("Google", "Runoob", "Taobao"))>>> thisset.clear()>>> print(thisset)set()

5、判断元素是否在集合中存在
语法格式如下:
x in s判断元素 x 是否在集合 s 中,存在返回 True,不存在返回 False。

>>> thisset = set(("Google", "Runoob", "Taobao"))>>> "Runoob" in thissetTrue>>> "Facebook" in thissetFalse>>>

集合内置方法完整列表

方法描述add()为集合添加元素clear()移除集合中的所有元素copy()拷贝一个集合difference()返回多个集合的差集difference_update()移除集合中的元素,该元素在指定的集合也存在。discard()删除集合中指定的元素intersection()返回集合的交集intersection_update()返回集合的交集。isdisjoint()判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。issubset()判断指定集合是否为该方法参数集合的子集。issuperset()判断该方法的参数集合是否为指定集合的子集pop()随机移除元素remove()移除指定元素symmetric_difference()返回两个集合中不重复的元素集合。symmetric_difference_update()移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。union()返回两个集合的并集update()给集合添加元素

Python3 编程第一步

在前面的教程中我们已经学习了一些 Python3 的基本语法知识,下面我们尝试来写一个斐波纳契数列。

#!/usr/bin/python3# Fibonacci series: 斐波纳契数列# 两个元素的总和确定了下一个数a, b = 0, 1while b < 10:print(b)a, b = b, a+b

其中代码 a, b = b, a+b 的计算方式为先计算右边表达式,然后同时赋值给左边,等价于:

n=bm=a+ba=nb=m

执行以上程序,输出结果为:

112358

这个例子介绍了几个新特征。
第一行包含了一个复合赋值:变量 a 和 b 同时得到新值 0 和 1。最后一行再次使用了同样的方法,可以看到,右边的表达式会在赋值变动之前执行。右边表达式的执行顺序是从左往右的。
输出变量值:

>>> i = 256*256>>> print('i 的值为:', i)i 的值为: 65536

end 关键字

关键字end可以用于将结果输出到同一行,或者在输出的末尾添加不同的字符,实例如下:

#!/usr/bin/python3 # Fibonacci series: 斐波纳契数列# 两个元素的总和确定了下一个数a, b = 0, 1while b < 1000:print(b, end=',')a, b = b, a+b

执行以上程序,输出结果为:

1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

Python3 条件控制

Python 条件语句是通过一条或多条语句的执行结果(True 或者 False)来决定执行的代码块。
可以通过下图来简单了解条件语句的执行过程:

代码执行过程:

if 语句

Python中if语句的一般形式如下所示:

if condition_1:statement_block_1elif condition_2:statement_block_2else:statement_block_3
  • 如果 “condition_1” 为 True 将执行 “statement_block_1” 块语句
  • 如果 “condition_1” 为False,将判断 “condition_2”
  • 如果”condition_2″ 为 True 将执行 “statement_block_2” 块语句
  • 如果 “condition_2” 为False,将执行”statement_block_3″块语句
    Python 中用 elif 代替了 else if,所以if语句的关键字为:if – elif – else。
    注意:1
  • -每个条件后面要使用冒号 :,表示接下来是满足条件后要执行的语句块。
  • -使用缩进来划分语句块,相同缩进数的语句在一起组成一个语句块
  • 在 Python 中没有 switch…case 语句,但在 Python3.10 版本添加了
    match…case,功能也类似,详见下文。
    Gif 演示:

    实例
    以下是一个简单的 if 实例:
#!/usr/bin/python3 var1 = 100if var1:print ("1 - if 表达式条件为 true")print (var1) var2 = 0if var2:print ("2 - if 表达式条件为 true")print (var2)print ("Good bye!")

执行以上代码,输出结果为:

1 - if 表达式条件为 true100Good bye!

从结果可以看到由于变量 var2 为 0,所以对应的 if 内的语句没有执行。
以下实例演示了狗的年龄计算判断:

#!/usr/bin/python3 age = int(input("请输入你家狗狗的年龄: "))print("")if age <= 0:print("你是在逗我吧!")elif age == 1:print("相当于 14 岁的人。")elif age == 2:print("相当于 22 岁的人。")elif age > 2:human = 22 + (age -2)*5print("对应人类年龄: ", human) ### 退出提示input("点击 enter 键退出")

将以上脚本保存在dog.py文件中,并执行该脚本:

$ python3 dog.py 请输入你家狗狗的年龄: 1相当于 14 岁的人。点击 enter 键退出

以下为if中常用的操作运算符:

操作符描述<小于<=小于或等于>大于>=大于或等于==等于,比较两个值是否相等!=不等于
实例#!/usr/bin/python3# 程序演示了 == 操作符# 使用数字print(5 == 6)# 使用变量x = 5y = 8print(x == y)

以上实例输出结果:

FalseFalse

high_low.py文件演示了数字的比较运算:

#!/usr/bin/python3  # 该实例演示了数字猜谜游戏number = 7guess = -1print("数字猜谜游戏!")while guess != number:guess = int(input("请输入你猜的数字:")) if guess == number:print("恭喜,你猜对了!")elif guess < number:print("猜的数字小了...")elif guess > number:print("猜的数字大了...")

执行以上脚本,实例输出结果如下:

$ python3 high_low.py 数字猜谜游戏!请输入你猜的数字:1猜的数字小了...请输入你猜的数字:9猜的数字大了...请输入你猜的数字:7恭喜,你猜对了!

if 嵌套

在嵌套 if 语句中,可以把 if…elif…else 结构放在另外一个 if…elif…else 结构中。

if 表达式1:语句if 表达式2:语句elif 表达式3:语句else:语句elif 表达式4:语句else:语句实例
实例# !/usr/bin/python3 num=int(input("输入一个数字:"))if num%2==0:if num%3==0:print ("你输入的数字可以整除 2 和 3")else:print ("你输入的数字可以整除 2,但不能整除 3")else:if num%3==0:print ("你输入的数字可以整除 3,但不能整除 2")else:print("你输入的数字不能整除 2 和 3")

将以上程序保存到 test_if.py 文件中,执行后输出结果为:

$ python3 test.py 输入一个数字:6你输入的数字可以整除 23

match…case

Python 3.10 增加了 match…case 的条件判断,不需要再使用一连串的 if-else 来判断了。
match 后的对象会依次与 case 后的内容进行匹配,如果匹配成功,则执行匹配到的表达式,否则直接跳过,_ 可以匹配一切。
语法格式如下:

match subject:case <pattern_1>:<action_1>case <pattern_2>:<action_2>case <pattern_3>:<action_3>case _:<action_wildcard>

case _: 类似于 C 和 Java 中的 default:,当其他 case 都无法匹配时,匹配这条,保证永远会匹配成功。

mystatus=400print(http_error(400))def http_error(status):match status:case 400:return "Bad request"case 404:return "Not found"case 418:return "I'm a teapot"case _:return "Something's wrong with the internet"

以上是一个输出 HTTP 状态码的实例,输出结果为:

Bad request

一个 case 也可以设置多个匹配条件,条件使用 | 隔开,例如:

...case 401|403|404:return "Not allowed"

Python3 循环语句

本章节将为大家介绍 Python 循环语句的使用。
Python 中的循环语句有 for 和 while。
Python 循环语句的控制结构图如下所示:

执行 Gif 演示:

同样需要注意冒号和缩进。另外,在 Python 中没有 do…while 循环。
以下实例使用了 while 来计算 1 到 100 的总和:

#!/usr/bin/env python3 n = 100 sum = 0counter = 1while counter <= n:sum = sum + countercounter += 1 print("1 到 %d 之和为: %d" % (n,sum))

执行结果如下:

1100 之和为: 5050

无限循环

我们可以通过设置条件表达式永远不为 false 来实现无限循环,实例如下:

#!/usr/bin/python3 var = 1while var == 1 :# 表达式永远为 true num = int(input("输入一个数字:")) print ("你输入的数字是: ", num) print ("Good bye!")

执行以上脚本,输出结果如下:

输入一个数字:5你输入的数字是:5输入一个数字:

你可以使用 CTRL+C 来退出当前的无限循环。
无限循环在服务器上客户端的实时请求非常有用。

while 循环使用 else 语句

如果 while 后面的条件语句为 false 时,则执行 else 的语句块。
语法格式如下:

while <expr>:<statement(s)>else:<additional_statement(s)>

expr 条件语句为 true 则执行 statement(s) 语句块,如果为 false,则执行 additional_statement(s)。
循环输出数字,并判断大小:

#!/usr/bin/python3 count = 0while count < 5: print (count, " 小于 5") count = count + 1else: print (count, " 大于或等于 5")

执行以上脚本,输出结果如下:

0小于 51小于 52小于 53小于 54小于 55大于或等于 5

简单语句组

类似 if 语句的语法,如果你的 while 循环体中只有一条语句,你可以将该语句与 while 写在同一行中, 如下所示:

#!/usr/bin/python flag = 1 while (flag): print ('欢迎访问菜鸟教程!') print ("Good bye!")

注意:以上的无限循环你可以使用 CTRL+C 来中断循环。
执行以上脚本,输出结果如下:

欢迎访问菜鸟教程!欢迎访问菜鸟教程!欢迎访问菜鸟教程!欢迎访问菜鸟教程!欢迎访问菜鸟教程!……

for 语句

Python for 循环可以遍历任何可迭代对象,如一个列表或者一个字符串。
for循环的一般格式如下:

for <variable> in <sequence>:<statements>else:<statements>

流程图:

Python for 循环实例:

#!/usr/bin/python3 sites = ["Baidu", "Google","Runoob","Taobao"]for site in sites:print(site)

以上代码执行输出结果为:

BaiduGoogleRunoobTaobao

也可用于打印字符串中的每个字符:

#!/usr/bin/python3 word = 'runoob' for letter in word:print(letter)

以上代码执行输出结果为:

runoob

整数范围值可以配合 range() 函数使用:

#!/usr/bin/python3 #1 到 5 的所有数字:for number in range(1, 6):print(number)

以上代码执行输出结果为:

12345

for…else

在 Python 中,for…else 语句用于在循环结束后执行一段代码。
语法格式如下:

for item in iterable:# 循环主体else:# 循环结束后执行的代码

当循环执行完毕(即遍历完 iterable 中的所有元素)后,会执行 else 子句中的代码,如果在循环过程中遇到了 break 语句,则会中断循环,此时不会执行 else 子句。

for x in range(6):print(x)else:print("Finally finished!")

执行脚本后,输出结果为:

012345Finally finished!

以下 for 实例中使用了 break 语句,break 语句用于跳出当前循环体,不会执行 else 子句:

#!/usr/bin/python3 sites = ["Baidu", "Google","Runoob","Taobao"]for site in sites:if site == "Runoob":print("菜鸟教程!")breakprint("循环数据 " + site)else:print("没有循环数据!")print("完成循环!")

执行脚本后,在循环到 “Runoob”时会跳出循环体:

循环数据 Baidu循环数据 Google菜鸟教程!完成循环!

range() 函数

如果你需要遍历数字序列,可以使用内置 range() 函数。它会生成数列,例如:

>>>for i in range(5):... print(i)...01234

你也可以使用 range() 指定区间的值:

>>>for i in range(5,9) :print(i) 5678>>>

也可以使 range() 以指定数字开始并指定不同的增量(甚至可以是负数,有时这也叫做’步长’):

>>>for i in range(0, 10, 3) :print(i) 0369>>>

负数:

>>>for i in range(-10, -100, -30) :print(i) -10-40-70>>>

您可以结合 range() 和 len() 函数以遍历一个序列的索引,如下所示:

>>>a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']>>> for i in range(len(a)):... print(i, a[i])... 0 Google1 Baidu2 Runoob3 Taobao4 QQ>>>

还可以使用 range() 函数来创建一个列表:

>>>list(range(5))[0, 1, 2, 3, 4]>>>

break 和 continue 语句及循环中的 else 子句

break 执行流程图:

continue 执行流程图:
while 语句代码执行过程:

for 语句代码执行过程:
break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止,任何对应的循环 else 块将不执行。
continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句,然后继续进行下一轮循环。

实例

while 中使用 break:

n = 5while n > 0:n -= 1if n == 2:breakprint(n)print('循环结束。')

输出结果为:

43循环结束。

while 中使用 continue:

n = 5while n > 0:n -= 1if n == 2:continueprint(n)print('循环结束。')

输出结果为:

4310循环结束。

更多实例如下:

#!/usr/bin/python3 for letter in 'Runoob': # 第一个实例 if letter == 'b':break print ('当前字母为 :', letter)var = 10# 第二个实例while var > 0: print ('当前变量值为 :', var) var = var -1 if var == 5:break print ("Good bye!")

执行以上脚本输出结果为:

当前字母为 : R当前字母为 : u当前字母为 : n当前字母为 : o当前字母为 : o当前变量值为 : 10当前变量值为 : 9当前变量值为 : 8当前变量值为 : 7当前变量值为 : 6Good bye!

以下实例循环字符串 Runoob,碰到字母 o 跳过输出:

#!/usr/bin/python3 for letter in 'Runoob': # 第一个实例 if letter == 'o':# 字母为 o 时跳过输出continue print ('当前字母 :', letter) var = 10# 第二个实例while var > 0: var = var -1 if var == 5: # 变量为 5 时跳过输出continue print ('当前变量值 :', var)print ("Good bye!")

执行以上脚本输出结果为:

当前字母 : R当前字母 : u当前字母 : n当前字母 : b当前变量值 : 9当前变量值 : 8当前变量值 : 7当前变量值 : 6当前变量值 : 4当前变量值 : 3当前变量值 : 2当前变量值 : 1当前变量值 : 0Good bye!

循环语句可以有 else 子句,它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行,但循环被 break 终止时不执行。
如下实例用于查询质数的循环例子:

#!/usr/bin/python3 for n in range(2, 10):for x in range(2, n):if n % x == 0:print(n, '等于', x, '*', n//x)breakelse:# 循环中没有找到元素print(n, ' 是质数')

执行以上脚本输出结果为:

2是质数3是质数4 等于 2 * 25是质数6 等于 2 * 37是质数8 等于 2 * 49 等于 3 * 3

pass 语句

Python pass是空语句,是为了保持程序结构的完整性。
pass 不做任何事情,一般用做占位语句,如下实例:

>>>while True:... pass# 等待键盘中断 (Ctrl+C)

最小的类:

>>>class MyEmptyClass:... pass

以下实例在字母为 o 时 执行 pass 语句块:

#!/usr/bin/python3 for letter in 'Runoob':if letter == 'o':passprint ('执行 pass 块') print ('当前字母 :', letter) print ("Good bye!")

执行以上脚本输出结果为:

当前字母 : R当前字母 : u当前字母 : n执行 pass 块当前字母 : o执行 pass 块当前字母 : o当前字母 : bGood bye!

Python3 迭代器与生成器

迭代器
迭代是Python最强大的功能之一,是访问集合元素的一种方式。
迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法:iter() 和 next()。
字符串,列表或元组对象都可用于创建迭代器:

>>> list=[1,2,3,4]>>> it = iter(list)# 创建迭代器对象>>> print (next(it)) # 输出迭代器的下一个元素1>>> print (next(it))2>>>

迭代器对象可以使用常规for语句进行遍历:

#!/usr/bin/python3 list=[1,2,3,4]it = iter(list)# 创建迭代器对象for x in it:print (x, end=" ")

执行以上程序,输出结果如下:

1 2 3 4

也可以使用 next() 函数:

#!/usr/bin/python3 import sys # 引入 sys 模块 list=[1,2,3,4]it = iter(list)# 创建迭代器对象 while True:try:print (next(it))except StopIteration:sys.exit()

执行以上程序,输出结果如下:

1234

创建一个迭代器

把一个类作为一个迭代器使用需要在类中实现两个方法 iter() 与 next() 。
如果你已经了解的面向对象编程,就知道类都有一个构造函数,Python 的构造函数为 init(), 它会在对象初始化的时候执行。
更多内容查阅:Python3 面向对象
iter() 方法返回一个特殊的迭代器对象, 这个迭代器对象实现了 next() 方法并通过 StopIteration 异常标识迭代的完成。
next() 方法(Python 2 里是 next())会返回下一个迭代器对象。
创建一个返回数字的迭代器,初始值为 1,逐步递增 1:

class MyNumbers:def __iter__(self):self.a = 1return self def __next__(self):x = self.aself.a += 1return x myclass = MyNumbers()myiter = iter(myclass) print(next(myiter))print(next(myiter))print(next(myiter))print(next(myiter))print(next(myiter))

执行输出结果为:

12345

StopIteration

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

class MyNumbers:def __iter__(self):self.a = 1return self def __next__(self):if self.a <= 20:x = self.aself.a += 1return xelse:raise StopIteration myclass = MyNumbers()myiter = iter(myclass) for x in myiter:print(x)

执行输出结果为:

1234567891011121314151617181920

生成器

在 Python 中,使用了 yield 的函数被称为生成器(generator)。
跟普通函数不同的是,生成器是一个返回迭代器的函数,只能用于迭代操作,更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中,每次遇到 yield 时函数会暂停并保存当前所有的运行信息,返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数,返回的是一个迭代器对象。
以下实例使用 yield 实现斐波那契数列:

#!/usr/bin/python3 import sys def 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()

执行以上程序,输出结果如下:

0 1 1 2 3 5 8 13 21 34 55

Python3 函数

函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。
函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户自定义函数。

定义一个函数

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

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

语法

Python 定义函数使用 def 关键字,一般格式如下:

def 函数名(参数列表):函数体

默认情况下,参数值和参数名称是按函数声明中定义的顺序匹配起来的。

实例

让我们使用函数来输出”Hello World!”:

#!/usr/bin/python3def hello() :print("Hello World!")hello()

更复杂点的应用,函数中带上参数变量:
比较两个数,并返回较大的数:

#!/usr/bin/python3 def max(a, b):if a > b:return aelse:return b a = 4b = 5print(max(a, b))

以上实例输出结果:

5
计算面积函数:#!/usr/bin/python3 # 计算面积函数def area(width, height):return width * height def print_welcome(name):print("Welcome", name) print_welcome("Runoob")w = 4h = 5print("width =", w, " height =", h, " area =", area(w, h))

以上实例输出结果:

Welcome Runoobwidth = 4height = 5area = 20

函数调用

定义一个函数:给了函数一个名称,指定了函数里包含的参数,和代码块结构。
这个函数的基本结构完成以后,你可以通过另一个函数调用执行,也可以直接从 Python 命令提示符执行。
如下实例调用了 printme() 函数:

#!/usr/bin/python3 # 定义函数def printme( str ): # 打印任何传入的字符串 print (str) return # 调用函数printme("我要调用用户自定义函数!")printme("再次调用同一函数")

以上实例输出结果:

我要调用用户自定义函数!再次调用同一函数

参数传递在

python 中,类型属于对象,对象有不同类型的区分,变量是没有类型的:

a=[1,2,3]a="Runoob"

以上代码中,[1,2,3] 是 List 类型,“Runoob” 是 String 类型,而变量 a 是没有类型,她仅仅是一个对象的引用(一个指针),可以是指向 List 类型对象,也可以是指向 String 类型对象。

可更改(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 函数的参数传递:
  • 不可变类型:类似 C++ 的值传递,如整数、字符串、元组。如 fun(a),传递的只是 a 的值,没有影响 a 对象本身。如果在fun(a) 内部修改 a 的值,则是新生成一个 a 的对象。
  • 可变类型:类似 C++ 的引用传递,如 列表,字典。如 fun(la),则是将 la 真正的传过去,修改后 fun 外部的 la也会受影响.
    python 中一切都是对象,严格意义我们不能说值传递还是引用传递,我们应该说传不可变对象和传可变对象。

python 传不可变对象实例

通过 id() 函数来查看内存地址变化:

def change(a):print(id(a)) # 指向的是同一个对象a=10print(id(a)) # 一个新对象 a=1print(id(a))change(a)

以上实例输出结果为:

437936913643793691364379369424

可以看见在调用函数前后,形参和实参指向的是同一个对象(对象 id 相同),在函数内部修改形参后,形参指向的是不同的 id。

传可变对象实例

可变对象在函数里修改了参数,那么在调用这个函数的函数里,原始的参数也被改变了。例如:

#!/usr/bin/python3 # 可写函数说明def changeme( mylist ): "修改传入的列表" mylist.append([1,2,3,4]) print ("函数内取值: ", mylist) return # 调用changeme函数mylist = [10,20,30]changeme( mylist )print ("函数外取值: ", mylist)

传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下:

函数内取值:[10, 20, 30, [1, 2, 3, 4]]函数外取值:[10, 20, 30, [1, 2, 3, 4]]

参数

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

  • 必需参数
  • 关键字参数
  • 默认参数
  • 不定长参数
    必需参数
    必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
    调用 printme() 函数,你必须传入一个参数,不然会出现语法错误:
#!/usr/bin/python3 #可写函数说明def printme( str ): "打印任何传入的字符串" print (str) return # 调用 printme 函数,不加参数会报错printme()

以上实例输出结果:

Traceback (most recent call last):File "test.py", line 10, in <module>printme()TypeError: printme() missing 1 required positional argument: 'str'

关键字参数

关键字参数和函数调用关系紧密,函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致,因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名:

#!/usr/bin/python3 #可写函数说明def printme( str ): "打印任何传入的字符串" print (str) return #调用printme函数printme( str = "菜鸟教程")

以上实例输出结果:

菜鸟教程

以下实例中演示了函数参数的使用不需要使用指定顺序:

#!/usr/bin/python3 #可写函数说明def printinfo( name, age ): "打印任何传入的字符串" print ("名字: ", name) print ("年龄: ", age) return #调用printinfo函数printinfo( age=50, name="runoob" )

以上实例输出结果:

名字:runoob年龄:50

默认参数

调用函数时,如果没有传递参数,则会使用默认参数。以下实例中如果没有传入 age 参数,则使用默认值:

#!/usr/bin/python3 #可写函数说明def printinfo( name, age = 35 ): "打印任何传入的字符串" print ("名字: ", name) print ("年龄: ", age) return #调用printinfo函数printinfo( age=50, name="runoob" )print ("------------------------")printinfo( name="runoob" )

以上实例输出结果:

名字:runoob年龄:50------------------------名字:runoob年龄:35

不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数,和上述 2 种参数不同,声明时不会命名。基本语法如下:

def functionname([formal_args,] *var_args_tuple ): "函数_文档字符串" function_suite return [expression]

加了星号 * 的参数会以元组(tuple)的形式导入,存放所有未命名的变量参数。

#!/usr/bin/python3# 可写函数说明def printinfo( arg1, *vartuple ): "打印任何传入的参数" print ("输出: ") print (arg1) print (vartuple) # 调用printinfo 函数printinfo( 70, 60, 50 )

以上实例输出结果:

输出: 70(60, 50)

如果在函数调用时没有指定参数,它就是一个空元组。我们也可以不向函数传递未命名的变量。如下实例:

#!/usr/bin/python3 # 可写函数说明def printinfo( arg1, *vartuple ): "打印任何传入的参数" print ("输出: ") print (arg1) for var in vartuple:print (var) return # 调用printinfo 函数printinfo( 10 )printinfo( 70, 60, 50 )

以上实例输出结果:

输出:10输出:706050

还有一种就是参数带两个星号 **基本语法如下:

def functionname([formal_args,] **var_args_dict ): "函数_文档字符串" function_suite return [expression]

加了两个星号 ** 的参数会以字典的形式导入。

#!/usr/bin/python3# 可写函数说明def printinfo( arg1, **vardict ): "打印任何传入的参数" print ("输出: ") print (arg1) print (vardict) # 调用printinfo 函数printinfo(1, a=2,b=3)

以上实例输出结果:

输出: 1{'a': 2, 'b': 3}

声明函数时,参数中星号 * 可以单独出现,例如:

def f(a,b,*,c):return a+b+c

如果单独出现星号 *,则星号 * 后的参数必须用关键字传入:

>>> def f(a,b,*,c):... return a+b+c... >>> f(1,2,3) # 报错Traceback (most recent call last):File "", line 1, in <module>TypeError: f() takes 2 positional arguments but 3 were given>>> f(1,2,c=3) # 正常6>>>

匿名函数

Python 使用 lambda 来创建匿名函数。
所谓匿名,意即不再使用 def 语句这样标准的形式定义一个函数。

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

语法

lambda 函数的语法只包含一个语句,如下:

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

设置参数 a 加上 10:

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

以上实例输出结果:

15

以下实例匿名函数设置两个参数:

#!/usr/bin/python3 # 可写函数说明sum = lambda arg1, arg2: arg1 + arg2 # 调用sum函数print ("相加后的值为 : ", sum( 10, 20 ))print ("相加后的值为 : ", sum( 20, 20 ))

以上实例输出结果:

相加后的值为 :30相加后的值为 :40

我们可以将匿名函数封装在一个函数内,这样可以使用同样的代码来创建多个匿名函数。
以下实例将匿名函数封装在 myfunc 函数中,通过传入不同的参数来创建不同的匿名函数:

def myfunc(n):return lambda a : a * n mydoubler = myfunc(2)mytripler = myfunc(3) print(mydoubler(11))print(mytripler(11))

以上实例输出结果:

2233

return 语句

return [表达式] 语句用于退出函数,选择性地向调用方返回一个表达式。不带参数值的 return 语句返回 None。之前的例子都没有示范如何返回数值,以下实例演示了 return 语句的用法:

#!/usr/bin/python3 # 可写函数说明def sum( arg1, arg2 ): # 返回2个参数的和." total = arg1 + arg2 print ("函数内 : ", total) return total # 调用sum函数total = sum( 10, 20 )print ("函数外 : ", total)

以上实例输出结果:

函数内 :30函数外 :30

强制位置参数

Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数,不能使用关键字参数的形式。
在以下的例子中,形参 a 和 b 必须使用指定位置参数,c 或 d 可以是位置形参或关键字形参,而 e 和 f 要求为关键字形参:

def f(a, b, /, c, d, *, e, f):print(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 必须使用关键字参数的形式

Python3 数据结构

本章节我们主要结合前面所学的知识点来介绍Python数据结构。

列表

Python中列表是可变的,这是它区别于字符串和元组的最重要的特点,一句话概括即:列表可以修改,而字符串和元组不能。
以下是 Python 中列表的方法:

方法描述list.append(x)把一个元素添加到列表的结尾,相当于 a[len(a):] = [x]list.extend(L)通过添加指定列表的所有元素来扩充列表,相当于 a[len(a):] = L。list.insert(i, x)在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引,例如 a.insert(0, x) 会插入到整个列表之前,而 a.insert(len(a), x) 相当于 a.append(x)list.remove(x)删除列表中值为 x 的第一个元素。如果没有这样的元素,就会返回一个错误。list.pop([i])从列表的指定位置移除元素,并将其返回。如果没有指定索引,a.pop()返回最后一个元素。元素随即从列表中被移除。(方法中 i 两边的方括号表示这个参数是可选的,而不是要求你输入一对方括号,你会经常在 Python 库参考手册中遇到这样的标记。)list.clear()移除列表中的所有项,等于del a[:]list.index(x)返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。list.count(x)返回 x 在列表中出现的次数。list.sort()对列表中的元素进行排序。list.reverse()倒排列表中的元素。list.copy()返回列表的浅复制,等于a[:]

下面示例演示了列表的大部分方法:

>>> a = [66.25, 333, 333, 1, 1234.5]>>> print(a.count(333), a.count(66.25), a.count('x'))2 1 0>>> a.insert(2, -1)>>> a.append(333)>>> a[66.25, 333, -1, 333, 1, 1234.5, 333]>>> a.index(333)1>>> a.remove(333)>>> a[66.25, -1, 333, 1, 1234.5, 333]>>> a.reverse()>>> a[333, 1234.5, 1, 333, -1, 66.25]>>> a.sort()>>> a[-1, 1, 66.25, 333, 333, 1234.5]

注意:类似 insert, remove 或 sort 等修改列表的方法没有返回值。

将列表当做堆栈使用

列表方法使得列表可以很方便的作为一个堆栈来使用,堆栈作为特定的数据结构,最先进入的元素最后一个被释放(后进先出)。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。例如:

>>> stack = [3, 4, 5]>>> stack.append(6)>>> stack.append(7)>>> stack[3, 4, 5, 6, 7]>>> stack.pop()7>>> stack[3, 4, 5, 6]>>> stack.pop()6>>> stack.pop()5>>> stack[3, 4]

将列表当作队列使用

也可以把列表当做队列用,只是在队列里第一加入的元素,第一个取出来;但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快,然而在列表里插入或者从头部弹出速度却不快(因为所有其他的元素都得一个一个地移动)。

>>> from collections import deque>>> queue = deque(["Eric", "John", "Michael"])>>> queue.append("Terry") # Terry arrives>>> queue.append("Graham")# Graham arrives>>> queue.popleft() # The first to arrive now leaves'Eric'>>> queue.popleft() # The second to arrive now leaves'John'>>> queue # Remaining queue in order of arrivaldeque(['Michael', 'Terry', 'Graham'])

列表推导式

列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素,用其获得的结果作为生成新列表的元素,或者根据确定的判定条件创建子序列。
每个列表推导式都在 for 之后跟一个表达式,然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组,就必须使用括号。
这里我们将列表中每个数值乘三,获得一个新的列表:

>>> vec = [2, 4, 6]>>> [3*x for x in vec][6, 12, 18]

现在我们玩一点小花样:

>>> [[x, x**2] for x in vec][[2, 4], [4, 16], [6, 36]]

这里我们对序列里每一个元素逐个调用某方法:

>>> freshfruit = ['banana', 'loganberry ', 'passion fruit']>>> [weapon.strip() for weapon in freshfruit]['banana', 'loganberry', 'passion fruit']

我们可以用 if 子句作为过滤器:

>>> [3*x for x in vec if x > 3][12, 18]>>> [3*x for x in vec if x < 2][]

以下是一些关于循环和其它技巧的演示:

>>> vec1 = [2, 4, 6]>>> vec2 = [4, 3, -9]>>> [x*y for x in vec1 for y in vec2][8, 6, -18, 16, 12, -36, 24, 18, -54]>>> [x+y for x in vec1 for y in vec2][6, 5, -7, 8, 7, -5, 10, 9, -3]>>> [vec1[i]*vec2[i] for i in range(len(vec1))][8, 12, -54]

列表推导式可以使用复杂表达式或嵌套函数:

>>> [str(round(355/113, i)) for i in range(1, 6)]['3.1', '3.14', '3.142', '3.1416', '3.14159']

嵌套列表解析

Python的列表还可以嵌套。
以下实例展示了3X4的矩阵列表:

>>> matrix = [... [1, 2, 3, 4],... [5, 6, 7, 8],... [9, 10, 11, 12],... ]

以下实例将3X4的矩阵列表转换为4X3列表:

>>> [[row[i] for row in matrix] for i in range(4)][[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

以下实例也可以使用以下方法来实现:

>>> transposed = []>>> for i in range(4):... transposed.append([row[i] for row in matrix])...>>> transposed[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

另外一种实现方法:

>>> transposed = []>>> for i in range(4):... # the following 3 lines implement the nested listcomp... transposed_row = []... for row in matrix:... transposed_row.append(row[i])... transposed.append(transposed_row)...>>> transposed[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

del 语句

使用 del 语句可以从一个列表中根据索引来删除一个元素,而不是值来删除元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割,或清空整个列表(我们以前介绍的方法是给该切割赋一个空列表)。例如:

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]>>> del a[0]>>> a[1, 66.25, 333, 333, 1234.5]>>> del a[2:4]>>> a[1, 66.25, 1234.5]>>> del a[:]>>> a

也可以用 del 删除实体变量:
>>> del a

元组和序列

元组由若干逗号分隔的值组成,例如:

>>> t = 12345, 54321, 'hello!'>>> t[0]12345>>> t(12345, 54321, 'hello!')>>> # Tuples may be nested:... u = t, (1, 2, 3, 4, 5)>>> u((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))

如你所见,元组在输出时总是有括号的,以便于正确表达嵌套结构。在输入时可能有或没有括号, 不过括号通常是必须的(如果元组是更大的表达式的一部分)。

集合

集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。
可以用大括号({})创建集合。注意:如果要创建一个空集合,你必须用 set() 而不是 {} ;后者创建一个空的字典,下一节我们会介绍这个数据结构。
以下是一个简单的演示:

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}>>> print(basket)# 删除重复的{'orange', 'banana', 'pear', 'apple'}>>> 'orange' in basket # 检测成员True>>> 'crabgrass' in basketFalse>>> # 以下演示了两个集合的操作...>>> a = set('abracadabra')>>> b = set('alacazam')>>> a# a 中唯一的字母{'a', 'r', 'b', 'c', 'd'}>>> a - b# 在 a 中的字母,但不在 b 中{'r', 'd', 'b'}>>> a | b# 在 a 或 b 中的字母{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}>>> a & b# 在 a 和 b 中都有的字母{'a', 'c'}>>> a ^ b# 在 a 或 b 中的字母,但不同时在 a 和 b 中{'r', 'd', 'b', 'm', 'z', 'l'}

集合也支持推导式:

>>> a = {x for x in 'abracadabra' if x not in 'abc'}>>> a{'r', 'd'}

字典

另一个非常有用的 Python 内建数据类型是字典。序列是以连续的整数为索引,与此不同的是,字典以关键字为索引,关键字可以是任意不可变类型,通常用字符串或数值。理解字典的最佳方式是把它看做无序的键=>值对集合。在同一个字典之内,关键字必须是互不相同。一对大括号创建一个空的字典:{}。这是一个字典运用的简单例子:
>>> tel = {'jack': 4098, 'sape': 4139}>>> tel['guido'] = 4127>>> tel{'sape': 4139, 'guido': 4127, 'jack': 4098}>>> tel['jack']4098>>> del tel['sape']>>> tel['irv'] = 4127>>> tel{'guido': 4127, 'irv': 4127, 'jack': 4098}>>> list(tel.keys())['irv', 'guido', 'jack']>>> sorted(tel.keys())['guido', 'irv', 'jack']>>> 'guido' in telTrue>>> 'jack' not in telFalse

构造函数 dict() 直接从键值对元组列表中构建字典。如果有固定的模式,列表推导式指定特定的键值对:

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)]){'sape': 4139, 'jack': 4098, 'guido': 4127}

此外,字典推导可以用来创建任意键和值的表达式词典:

>>> {x: x**2 for x in (2, 4, 6)}{2: 4, 4: 16, 6: 36}

如果关键字只是简单的字符串,使用关键字参数指定键值对有时候更方便:

>>> dict(sape=4139, guido=4127, jack=4098){'sape': 4139, 'jack': 4098, 'guido': 4127}

遍历技巧

在字典中遍历时,关键字和对应的值可以使用 items() 方法同时解读出来:

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}>>> for k, v in knights.items():... print(k, v)...gallahad the purerobin the brave

在序列中遍历时,索引位置和对应值可以使用 enumerate() 函数同时得到:

>>> for i, v in enumerate(['tic', 'tac', 'toe']):... print(i, v)...0 tic1 tac2 toe

同时遍历两个或更多的序列,可以使用 zip() 组合:

>>> questions = ['name', 'quest', 'favorite color']>>> answers = ['lancelot', 'the holy grail', 'blue']>>> for q, a in zip(questions, answers):... print('What is your {0}" />.format(q, a))...What is your name?It is lancelot.What is your quest?It is the holy grail.What is your favorite color?It is blue.

要反向遍历一个序列,首先指定这个序列,然后调用 reversed() 函数:

>>> for i in reversed(range(1, 10, 2)):... print(i)...97531

要按顺序遍历一个序列,使用 sorted() 函数返回一个已排序的序列,并不修改原值:

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']>>> for f in sorted(set(basket)):... print(f)...applebananaorangepear

Python3 模块

在前面的几个章节中我们基本上是用 python 解释器来编程,如果你从 Python 解释器退出再进入,那么你定义的所有的方法和变量就都消失了。
为此 Python 提供了一个办法,把这些定义存放在文件中,为一些脚本或者交互式的解释器实例使用,这个文件被称为模块。
模块是一个包含所有你定义的函数和变量的文件,其后缀名是.py。模块可以被别的程序引入,以使用该模块中的函数等功能。这也是使用 python 标准库的方法。
下面是一个使用 python 标准库中模块的例子。

#!/usr/bin/python3# 文件名: using_sys.pyimport sysprint('命令行参数如下:')for i in sys.argv: print(i) print('\n\nPython 路径为:', sys.path, '\n

执行结果如下所示:

$ python using_sys.py 参数1 参数2命令行参数如下:using_sys.py参数1参数2Python 路径为: ['/root', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages'] 
  • 1、import sys 引入 python 标准库中的 sys.py 模块;这是引入某一模块的方法。
  • 2、sys.argv 是一个包含命令行参数的列表。
  • 3、sys.path 包含了一个 Python 解释器自动查找所需模块的路径的列表。

import 语句

想使用 Python 源文件,只需在另一个源文件里执行 import 语句,语法如下:

import module1[, module2[,... moduleN]

当解释器遇到 import 语句,如果模块在当前的搜索路径就会被导入。
搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support,需要把命令放在脚本的顶端:

support.py 文件代码#!/usr/bin/python3# Filename: support.py def print_func( par ):print ("Hello : ", par)return

test.py 引入 support 模块:

test.py 文件代码#!/usr/bin/python3# Filename: test.py # 导入模块import support# 现在可以调用模块里包含的函数了support.print_func("Runoob")

以上实例输出结果:

$ python3 test.py Hello :Runoob

一个模块只会被导入一次,不管你执行了多少次 import。这样可以防止导入模块被一遍又一遍地执行。
当我们使用 import 语句的时候,Python 解释器是怎样找到对应的文件的呢?
这就涉及到 Python 的搜索路径,搜索路径是由一系列目录名组成的,Python 解释器就依次从这些目录中去寻找所引入的模块。
这看起来很像环境变量,事实上,也可以通过定义环境变量的方式来确定搜索路径。
搜索路径是在 Python 编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在 sys 模块中的 path 变量,做一个简单的实验,在交互式解释器中,输入以下代码:

>>> import sys>>> sys.path['', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']>>> 

sys.path 输出是一个列表,其中第一项是空串 ‘’,代表当前目录(若是从一个脚本中打印出来的话,可以更清楚地看出是哪个目录),亦即我们执行python解释器的目录(对于脚本的话就是运行的脚本所在的目录)。
因此若像我一样在当前目录下存在与要引入模块同名的文件,就会把要引入的模块屏蔽掉。
了解了搜索路径的概念,就可以在脚本中修改sys.path来引入一些不在搜索路径中的模块。
现在,在解释器的当前目录或者 sys.path 中的一个目录里面来创建一个fibo.py的文件,代码如下:

# 斐波那契(fibonacci)数列模块 def fib(n):# 定义到 n 的斐波那契数列a, b = 0, 1while b < n:print(b, end=' ')a, b = b, a+bprint() def fib2(n): # 返回到 n 的斐波那契数列result = []a, b = 0, 1while b < n:result.append(b)a, b = b, a+breturn result

然后进入Python解释器,使用下面的命令导入这个模块:

>>> import fibo

这样做并没有把直接定义在fibo中的函数名称写入到当前符号表里,只是把模块fibo的名字写到了那里。
可以使用模块名称来访问函数:

>>>fibo.fib(1000)1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987>>> fibo.fib2(100)[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]>>> fibo.__name__'fibo'

如果你打算经常使用一个函数,你可以把它赋给一个本地的名称:

>>> fib = fibo.fib>>> fib(500)1 1 2 3 5 8 13 21 34 55 89 144 233 377

from … import 语句

Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中,语法如下:

from modname import name1[, name2[, ... nameN]]

例如,要导入模块 fibo 的 fib 函数,使用如下语句:

>>> from fibo import fib, fib2>>> fib(500)1 1 2 3 5 8 13 21 34 55 89 144 233 377

这个声明不会把整个fibo模块导入到当前的命名空间中,它只会将fibo里的fib函数引入进来。

from … import * 语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的,只需使用如下声明:

from modname import *

这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

深入模块

模块除了方法定义,还可以包括可执行的代码。这些代码一般用来初始化这个模块。这些代码只有在第一次被导入时才会被执行。
每个模块有各自独立的符号表,在模块内部为所有的函数当作全局符号表来使用。
所以,模块的作者可以放心大胆的在模块内部使用这些全局变量,而不用担心把其他用户的全局变量搞混。
从另一个方面,当你确实知道你在做什么的话,你也可以通过 modname.itemname 这样的表示法来访问模块内的函数。
模块是可以导入其他模块的。在一个模块(或者脚本,或者其他地方)的最前面使用 import 来导入一个模块,当然这只是一个惯例,而不是强制的。被导入的模块的名称将被放入当前操作的模块的符号表中。
还有一种导入的方法,可以使用 import 直接把模块内(函数,变量的)名称导入到当前操作模块。比如:

>>> from fibo import fib, fib2>>> fib(500)1 1 2 3 5 8 13 21 34 55 89 144 233 377

这种导入的方法不会把被导入的模块的名称放在当前的字符表中(所以在这个例子里面,fibo 这个名称是没有定义的)。
这还有一种方法,可以一次性的把模块中的所有(函数,变量)名称都导入到当前模块的字符表:

>>> from fibo import *>>> fib(500)1 1 2 3 5 8 13 21 34 55 89 144 233 377

这将把所有的名字都导入进来,但是那些由单一下划线(_)开头的名字不在此例。大多数情况, Python程序员不使用这种方法,因为引入的其它来源的命名,很可能覆盖了已有的定义。

__name__属性

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

#!/usr/bin/python3# Filename: using_name.pyif __name__ == '__main__': print('程序自身在运行')else: print('我来自另一模块')

运行输出如下:

$ python using_name.py程序自身在运行
$ python>>> import using_name我来自另一模块>>>

说明: 每个模块都有一个__name__属性,当其值是’main’时,表明该模块自身在运行,否则是被引入。
说明:namemain 底下是双下划线, _ _ 是这样去掉中间的那个空格。

dir() 函数

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

>>> import fibo, sys>>> dir(fibo)['__name__', 'fib', 'fib2']>>> dir(sys)['__displayhook__', '__doc__', '__excepthook__', '__loader__', '__name__', '__package__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe', '_home', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'getcheckinterval', 'getdefaultencoding', 'getdlopenflags', 'getfilesystemencoding', 'getobjects', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettotalrefcount', 'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1', 'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions']

如果没有给定参数,那么 dir() 函数会罗列出当前定义的所有名称:

>>> a = [1, 2, 3, 4, 5]>>> import fibo>>> fib = fibo.fib>>> dir() # 得到一个当前模块中定义的属性列表['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']>>> a = 5 # 建立一个新的变量 'a'>>> dir()['__builtins__', '__doc__', '__name__', 'a', 'sys']>>>>>> del a # 删除变量名a>>>>>> dir()['__builtins__', '__doc__', '__name__', 'sys']>>>

标准模块

Python 本身带着一些标准的模块库,在 Python 库参考文档中将会介绍到(就是后面的”库参考文档”)。
有些模块直接被构建在解析器里,这些虽然不是一些语言内置的功能,但是他却能很高效的使用,甚至是系统级调用也没问题。
这些组件会根据不同的操作系统进行不同形式的配置,比如 winreg 这个模块就只会提供给 Windows 系统。
应该注意到这有一个特别的模块 sys ,它内置在每一个 Python 解析器中。变量 sys.ps1 和 sys.ps2 定义了主提示符和副提示符所对应的字符串:

>>> import sys>>> sys.ps1'>>> '>>> sys.ps2'... '>>> sys.ps1 = 'C> 'C> print('Runoob!')Runoob!C> 

包是一种管理 Python 模块命名空间的形式,采用”点模块名称”。
比如一个模块的名称是 A.B, 那么他表示一个包 A中的子模块 B 。
就好像使用模块的时候,你不用担心不同模块之间的全局变量相互影响一样,采用点模块名称这种形式也不用担心不同库之间的模块重名的情况。
这样不同的作者都可以提供 NumPy 模块,或者是 Python 图形库。
不妨假设你想设计一套统一处理声音文件和数据的模块(或者称之为一个”包”)。
现存很多种不同的音频文件格式(基本上都是通过后缀名区分的,例如: .wav,:file:.aiff,:file:.au,),所以你需要有一组不断增加的模块,用来在不同的格式之间转换。
并且针对这些音频数据,还有很多不同的操作(比如混音,添加回声,增加均衡器功能,创建人造立体声效果),所以你还需要一组怎么也写不完的模块来处理这些操作。
这里给出了一种可能的包结构(在分层的文件系统中):

sound/顶层包__init__.py 初始化 sound 包formats/文件格式转换子包__init__.pywavread.pywavwrite.pyaiffread.pyaiffwrite.pyauread.pyauwrite.py...effects/声音效果子包__init__.pyecho.pysurround.pyreverse.py...filters/filters 子包__init__.pyequalizer.pyvocoder.pykaraoke.py...

在导入一个包的时候,Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。
目录只有包含一个叫做 init.py 的文件才会被认作是一个包,主要是为了避免一些滥俗的名字(比如叫做 string)不小心的影响搜索路径中的有效模块。
最简单的情况,放一个空的 :file:init.py就可以了。当然这个文件中也可以包含一些初始化代码或者为(将在后面介绍的) __all__变量赋值。
用户可以每次只导入一个包里面的特定模块,比如:

import sound.effects.echo

这将会导入子模块:sound.effects.echo。 他必须使用全名去访问:

sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)

还有一种导入子模块的方法是:

from sound.effects import echo

这同样会导入子模块: echo,并且他不需要那些冗长的前缀,所以他可以这样使用:

echo.echofilter(input, output, delay=0.7, atten=4)

还有一种变化就是直接导入一个函数或者变量:

from sound.effects.echo import echofilter

同样的,这种方法会导入子模块: echo,并且可以直接使用他的 echofilter() 函数:

echofilter(input, output, delay=0.7, atten=4)

注意:当使用 from package import item 这种形式的时候,对应的 item 既可以是包里面的子模块(子包),或者包里面定义的其他名称,比如函数,类或者变量。
import 语法会首先把 item 当作一个包定义的名称,如果没找到,再试图按照一个模块去导入。如果还没找到,抛出一个 :exc:ImportError 异常。
反之,如果使用形如 import item.subitem.subsubitem 这种导入形式,除了最后一项,都必须是包,而最后一项则可以是模块或者是包,但是不可以是类,函数或者变量的名字。

从一个包中导入*

如果我们使用 from sound.effects import * 会发生什么呢?
Python 会进入文件系统,找到这个包里面所有的子模块,然后一个一个的把它们都导入进来。
但这个方法在 Windows 平台上工作的就不是非常好,因为 Windows 是一个不区分大小写的系统。
在 Windows 平台上,我们无法确定一个叫做 ECHO.py 的文件导入为模块是 echo 还是 Echo,或者是 ECHO。
为了解决这个问题,我们只需要提供一个精确包的索引。
导入语句遵循如下规则:如果包定义文件 init.py 存在一个叫做 all 的列表变量,那么在使用 from package import * 的时候就把这个列表中的所有名字作为包内容导入。
作为包的作者,可别忘了在更新包之后保证 all 也更新了啊。
以下实例在 file:sounds/effects/init.py 中包含如下代码:

__all__ = ["echo", "surround", "reverse"]

这表示当你使用from sound.effects import *这种用法时,你只会导入包里面这三个子模块。
如果 all 真的没有定义,那么使用from sound.effects import *这种语法的时候,就不会导入包 sound.effects 里的任何子模块。他只是把包sound.effects和它里面定义的所有内容导入进来(可能运行__init__.py里定义的初始化代码)。
这会把 init.py 里面定义的所有名字导入进来。并且他不会破坏掉我们在这句话之前导入的所有明确指定的模块。看下这部分代码:

import sound.effects.echoimport sound.effects.surroundfrom sound.effects import *

这个例子中,在执行 from…import 前,包 sound.effects 中的 echo 和 surround 模块都被导入到当前的命名空间中了。(当然如果定义了 all 就更没问题了)
通常我们并不主张使用 * 这种方法来导入模块,因为这种方法经常会导致代码的可读性降低。不过这样倒的确是可以省去不少敲键的功夫,而且一些模块都设计成了只能通过特定的方法导入。
记住,使用 from Package import specific_submodule 这种方法永远不会有错。事实上,这也是推荐的方法。除非是你要导入的子模块有可能和其他包的子模块重名。
如果在结构中包是一个子包(比如这个例子中对于包sound来说),而你又想导入兄弟包(同级别的包)你就得使用导入绝对的路径来导入。比如,如果模块sound.filters.vocoder 要使用包 sound.effects 中的模块 echo,你就要写成 from sound.effects import echo。

from . import echofrom .. import formatsfrom ..filters import equalizer

无论是隐式的还是显式的相对导入都是从当前模块开始的。主模块的名字永远是”main“,一个Python应用程序的主模块,应当总是使用绝对路径引用。
包还提供一个额外的属性__path__。这是一个目录列表,里面每一个包含的目录都有为这个包服务的__init__.py,你得在其他__init__.py被执行前定义哦。可以修改这个变量,用来影响包含在包里面的模块和子包。
这个功能并不常用,一般用来扩展包里面的模块。

Python3 输入和输出

在前面几个章节中,我们其实已经接触了 Python 的输入输出的功能。本章节我们将具体介绍 Python 的输入输出。

输出格式美化

Python两种输出值的方式: 表达式语句和 print() 函数。
第三种方式是使用文件对象的 write() 方法,标准输出文件可以用 sys.stdout 引用。
如果你希望输出的形式更加多样,可以使用 str.format() 函数来格式化输出值。
如果你希望将输出的值转成字符串,可以使用 repr() 或 str() 函数来实现。

  • str(): 函数返回一个用户易读的表达形式。
  • repr(): 产生一个解释器易读的表达形式。

例如

>>> s = 'Hello, Runoob'>>> str(s)'Hello, Runoob'>>> repr(s)"'Hello, Runoob'">>> str(1/7)'0.14285714285714285'>>> x = 10 * 3.25>>> y = 200 * 200>>> s = 'x 的值为: ' + repr(x) + ',y 的值为:' + repr(y) + '...'>>> print(s)x 的值为: 32.5,y 的值为:40000...>>> #repr() 函数可以转义字符串中的特殊字符... hello = 'hello, runoob\n'>>> hellos = repr(hello)>>> print(hellos)'hello, runoob\n'>>> # repr() 的参数可以是 Python 的任何对象... repr((x, y, ('Google', 'Runoob')))"(32.5, 40000, ('Google', 'Runoob'))"

这里有两种方式输出一个平方与立方的表:

>>> for x in range(1, 11):... print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')... # 注意前一行 'end' 的使用... print(repr(x*x*x).rjust(4))... 1 11 2 48 3 9 27 416 64 525125 636216 749343 864512 98172910 100 1000>>> for x in range(1, 11):... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))... 1 11 2 48 3 9 27 416 64 525125 636216 749343 864512 98172910 100 1000

注意:在第一个例子中, 每列间的空格由 print() 添加。
这个例子展示了字符串对象的 rjust() 方法, 它可以将字符串靠右, 并在左边填充空格。
还有类似的方法, 如 ljust() 和 center()。 这些方法并不会写任何东西, 它们仅仅返回新的字符串。
另一个方法 zfill(), 它会在数字的左边填充 0,如下所示:

>>> '12'.zfill(5)'00012'>>> '-3.14'.zfill(7)'-003.14'>>> '3.14159265359'.zfill(5)'3.14159265359'

括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。
在括号中的数字用于指向传入对象在 format() 中的位置,如下所示:

>>> print('{0} 和 {1}'.format('Google', 'Runoob'))Google 和 Runoob>>> print('{1} 和 {0}'.format('Google', 'Runoob'))Runoob 和 Google

如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。
位置及关键字参数可以任意的结合:

>>> print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'Runoob', other='Taobao'))站点列表 Google, Runoob, 和 Taobao。

!a (使用 ascii()), !s (使用 str()) 和 !r (使用 repr()) 可以用于在格式化某个值之前对其进行转化:

>>> import math>>> print('常量 PI 的值近似为: {}。'.format(math.pi))常量 PI 的值近似为: 3.141592653589793>>> print('常量 PI 的值近似为: {!r}。'.format(math.pi))常量 PI 的值近似为: 3.141592653589793

命名空间和作用域

变量是拥有匹配对象的名字(标识符)。命名空间是一个包含了变量名称们(键)和它们各自相应的对象们(值)的字典。
一个 Python 表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名,则局部变量会覆盖全局变量。
每个函数都有自己的命名空间。类的方法的作用域规则和通常函数的一样。
Python 会智能地猜测一个变量是局部的还是全局的,它假设任何在函数内赋值的变量都是局部的。
因此,如果要给函数内的全局变量赋值,必须使用 global 语句。
global VarName 的表达式会告诉 Python, VarName 是一个全局变量,这样 Python 就不会在局部命名空间里寻找这个变量了。
例如,我们在全局命名空间里定义一个变量 Money。我们再在函数内给变量 Money 赋值,然后 Python 会假定 Money 是一个局部变量。然而,我们并没有在访问前声明一个局部变量 Money,结果就是会出现一个 UnboundLocalError 的错误。取消 global 语句前的注释符就能解决这个问题。

#!/usr/bin/python# -*- coding: UTF-8 -*- Money = 2000def AddMoney(): # 想改正代码就取消以下注释: # global Money Money = Money + 1 print MoneyAddMoney()print Money

dir()函数

dir() 函数一个排好序的字符串列表,内容是一个模块里定义过的名字。
返回的列表容纳了在一个模块里定义的所有模块,变量和函数。如下一个简单的实例:

#!/usr/bin/python# -*- coding: UTF-8 -*-# 导入内置math模块import mathcontent = dir(math)print content;

以上实例输出结果:

['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log','log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']

在这里,特殊字符串变量__name__指向模块的名字,__file__指向该模块的导入文件名。

globals() 和 locals() 函数

根据调用地方的不同,globals() 和 locals() 函数可被用来返回全局和局部命名空间里的名字。
如果在函数内部调用 locals(),返回的是所有能在该函数里访问的命名。
如果在函数内部调用 globals(),返回的是所有在该函数里能访问的全局名字。
两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。

reload() 函数

当一个模块被导入到一个脚本,模块顶层部分的代码只会被执行一次。
因此,如果你想重新执行模块里顶层部分的代码,可以用 reload() 函数。该函数会重新导入之前导入过的模块。语法如下:

reload(module_name)

在这里,module_name要直接放模块的名字,而不是一个字符串形式。比如想重载 hello 模块,如下:

reload(hello)

Python中的包

包是一个分层次的文件目录结构,它定义了一个由模块及子包,和子包下的子包等组成的 Python 的应用环境。
简单来说,包就是文件夹,但该文件夹下必须存在 init.py 文件, 该文件的内容可以为空。init.py 用于标识当前文件夹是一个包。
考虑一个在 package_runoob 目录下的 runoob1.py、runoob2.py、init.py 文件,test.py 为测试调用包的代码,目录结构如下:

test.pypackage_runoob|-- __init__.py|-- runoob1.py|-- runoob2.py

源代码如下:

package_runoob/runoob1.py#!/usr/bin/python# -*- coding: UTF-8 -*- def runoob1(): print "I'm in runoob1"
package_runoob/runoob2.py#!/usr/bin/python# -*- coding: UTF-8 -*- def runoob2(): print "I'm in runoob2"

现在,在 package_runoob 目录下创建 init.py:

package_runoob/__init__.py#!/usr/bin/python# -*- coding: UTF-8 -*- if __name__ == '__main__':print '作为主程序运行'else:print 'package_runoob 初始化'

然后我们在 package_runoob 同级目录下创建 test.py 来调用 package_runoob 包:

test.py#!/usr/bin/python# -*- coding: UTF-8 -*-# 导入 Phone 包from package_runoob.runoob1 import runoob1from package_runoob.runoob2 import runoob2runoob1()runoob2()

以上实例输出结果:

package_runoob 初始化I'm in runoob1I'm in runoob2

如上,为了举例,我们只在每个文件里放置了一个函数,但其实你可以放置许多函数。你也可以在这些文件里定义Python的类,然后为这些类建一个包。

Python 文件I/O

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

打印到屏幕

最简单的输出方法是用print语句,你可以给它传递零个或多个用逗号隔开的表达式。此函数把你传递的表达式转换成一个字符串表达式,并将结果写到标准输出如下:

#!/usr/bin/python# -*- coding: UTF-8 -*- print "Python 是一个非常棒的语言,不是吗?"

你的标准屏幕上会产生以下结果:

Python 是一个非常棒的语言,不是吗?

读取键盘输入

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

  • raw_input
  • input

raw_input函数

raw_input([prompt]) 函数从标准输入读取一个行,并返回一个字符串(去掉结尾的换行符):

#!/usr/bin/python# -*- coding: UTF-8 -*-  str = raw_input("请输入:")print "你输入的内容是: ", str

这将提示你输入任意字符串,然后在屏幕上显示相同的字符串。当我输入”Hello Python!”,它的输出如下:

请输入:Hello Python!你输入的内容是:Hello Python!

input函数

input([prompt]) 函数和 raw_input([prompt]) 函数基本类似,但是 input 可以接收一个Python表达式作为输入,并将运算结果返回。

#!/usr/bin/python# -*- coding: UTF-8 -*-  str = input("请输入:")print "你输入的内容是: ", str

这会产生如下的对应着输入的结果:

请输入:[x*5 for x in range(2,10,2)]你输入的内容是:[10, 20, 30, 40]

打开和关闭文件

现在,您已经可以向标准输入和输出进行读写。现在,来看看怎么读写实际的数据文件。
Python 提供了必要的函数和方法进行默认情况下的文件基本操作。你可以用 file 对象做大部分的文件操作。

open 函数

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

file object = open(file_name [, access_mode][, buffering])

各个参数的细节如下:

  • file_name:file_name变量是一个包含了你要访问的文件名称的字符串值。
  • access_mode:access_mode决定了打开文件的模式:只读,写入,追加等。所有可取值见如下的完全列表。这个参数是非强制的,默认文件访问模式为只读®。
  • buffering:如果buffering的值被设为0,就不会有寄存。如果buffering的值取1,访问文件时会寄存行。如果将buffering的值设为大于1的整数,表明了这就是的寄存区的缓冲大小。如果取负值,寄存区的缓冲大小则为系统默认。
    不同模式打开文件的完全列表:
模式描述t文本模式 (默认)。x写模式,新建一个文件,如果该文件已存在则会报错。b二进制模式。+打开一个文件进行更新(可读可写)。U通用换行模式(不推荐)。r以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。rb以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。r+打开一个文件用于读写。文件指针将会放在文件的开头。rb+以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。w打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。wb以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。一般用于非文本文件如图片等。w+打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。wb+以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。一般用于非文本文件如图片等。a打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。ab以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。a+打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。ab+以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。

下图很好的总结了这几种模式:

模式rr+ww+aa++++++++++创建++++覆盖++指针在开始++++指针在结尾++

File对象的属性

一个文件被打开后,你有一个file对象,你可以得到有关该文件的各种信息。
以下是和file对象相关的所有属性的列表:

属性描述file.closed返回true如果文件已被关闭,否则返回false。file.mode返回被打开文件的访问模式。file.name返回文件的名称。file.softspace如果用print输出后,必须跟一个空格符,则返回false。否则返回true。

如下实例:

#!/usr/bin/python# -*- coding: UTF-8 -*- # 打开一个文件fo = open("foo.txt", "w")print "文件名: ", fo.nameprint "是否已关闭 : ", fo.closedprint "访问模式 : ", fo.modeprint "末尾是否强制加空格 : ", fo.softspace

以上实例输出结果:

文件名:foo.txt是否已关闭 :False访问模式 :w末尾是否强制加空格 :0

close()方法

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

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

fileObject.close()

例子:

#!/usr/bin/python# -*- coding: UTF-8 -*- # 打开一个文件fo = open("foo.txt", "w")print "文件名: ", fo.name # 关闭打开的文件fo.close()

以上实例输出结果:

文件名:foo.txt

读写文件:
file对象提供了一系列方法,能让我们的文件访问更轻松。来看看如何使用read()和write()方法来读取和写入文件。

write()方法

write()方法可将任何字符串写入一个打开的文件。需要重点注意的是,Python字符串可以是二进制数据,而不是仅仅是文字。
write()方法不会在字符串的结尾添加换行符(‘\n’):
语法:

fileObject.write(string)

在这里,被传递的参数是要写入到已打开文件的内容。
例子:

#!/usr/bin/python# -*- coding: UTF-8 -*- # 打开一个文件fo = open("foo.txt", "w")fo.write( "www.runoob.com!\nVery good site!\n") # 关闭打开的文件fo.close()

上述方法会创建foo.txt文件,并将收到的内容写入该文件,并最终关闭文件。如果你打开这个文件,将看到以下内容:

$ cat foo.txt www.runoob.com!Very good site!

read()方法

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

fileObject.read([count])

在这里,被传递的参数是要从已打开文件中读取的字节计数。该方法从文件的开头开始读入,如果没有传入count,它会尝试尽可能多地读取更多的内容,很可能是直到文件的末尾。
例子:这里我们用到以上创建的 foo.txt 文件。

#!/usr/bin/python# -*- coding: UTF-8 -*- # 打开一个文件fo = open("foo.txt", "r+")str = fo.read(10)print "读取的字符串是 : ", str# 关闭打开的文件fo.close()

以上实例输出结果:

读取的字符串是 :www.runoob

文件定位

tell()方法告诉你文件内的当前位置, 换句话说,下一次的读写会发生在文件开头这么多字节之后。
seek(offset [,from])方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。
如果from被设为0,这意味着将文件的开头作为移动字节的参考位置。如果设为1,则使用当前的位置作为参考位置。如果它被设为2,那么该文件的末尾将作为参考位置。
例子:
就用我们上面创建的文件foo.txt。

#!/usr/bin/python# -*- coding: UTF-8 -*- # 打开一个文件fo = open("foo.txt", "r+")str = fo.read(10)print "读取的字符串是 : ", str # 查找当前位置position = fo.tell()print "当前文件位置 : ", position # 把指针再次重新定位到文件开头position = fo.seek(0, 0)str = fo.read(10)print "重新读取字符串 : ", str# 关闭打开的文件fo.close()

以上实例输出结果:

读取的字符串是 :www.runoob当前文件位置 :10重新读取字符串 :www.runoob

重命名和删除文件

Python的os模块提供了帮你执行文件处理操作的方法,比如重命名和删除文件。
要使用这个模块,你必须先导入它,然后才可以调用相关的各种功能。
rename() 方法
rename() 方法需要两个参数,当前的文件名和新文件名。
语法:

os.rename(current_file_name, new_file_name)

例子:
下例将重命名一个已经存在的文件test1.txt。

#!/usr/bin/python# -*- coding: UTF-8 -*-import os # 重命名文件test1.txt到test2.txt。os.rename( "test1.txt", "test2.txt" )

remove()方法
你可以用remove()方法删除文件,需要提供要删除的文件名作为参数。
语法:

os.remove(file_name)

例子:
下例将删除一个已经存在的文件test2.txt。

#!/usr/bin/python# -*- coding: UTF-8 -*-import os # 删除一个已经存在的文件test2.txtos.remove("test2.txt")

Python里的目录:

所有文件都包含在各个不同的目录下,不过Python也能轻松处理。os模块有许多方法能帮你创建,删除和更改目录。
mkdir()方法
可以使用os模块的mkdir()方法在当前目录下创建新的目录们。你需要提供一个包含了要创建的目录名称的参数。
语法:

os.mkdir("newdir")

例子:
下例将在当前目录下创建一个新目录test。

#!/usr/bin/python# -*- coding: UTF-8 -*-import os # 创建目录testos.mkdir("test")

chdir()方法
可以用chdir()方法来改变当前的目录。chdir()方法需要的一个参数是你想设成当前目录的目录名称。
语法:

os.chdir("newdir")

例子:
下例将进入”/home/newdir”目录。

#!/usr/bin/python# -*- coding: UTF-8 -*-import os # 将当前目录改为"/home/newdir"os.chdir("/home/newdir")

getcwd()方法:
getcwd()方法显示当前的工作目录。
语法:

os.getcwd()

例子:
下例给出当前目录:

#!/usr/bin/python# -*- coding: UTF-8 -*-import os # 给出当前的目录print os.getcwd()

rmdir()方法
rmdir()方法删除目录,目录名称以参数传递。
在删除这个目录之前,它的所有内容应该先被清除。
语法:

os.rmdir('dirname')

例子:
以下是删除” /tmp/test”目录的例子。目录的完全合规的名称必须被给出,否则会在当前目录下搜索该目录。

#!/usr/bin/python# -*- coding: UTF-8 -*-import os # 删除”/tmp/test”目录os.rmdir( "/tmp/test")

文件、目录相关的方法

File 对象和 OS 对象提供了很多文件与目录的操作方法,可以通过点击下面链接查看详情:

  • File 对象方法: file 对象提供了操作文件的一系列方法。
  • OS 对象方法: 提供了处理文件及目录的一系列方法。

Python File(文件) 方法

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 参数有:模式 描述
t 文本模式 (默认)。
x 写模式,新建一个文件,如果该文件已存在则会报错。
b 二进制模式。

  • 打开一个文件进行更新(可读可写)。 U 通用换行模式(不推荐)。 r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
    r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
    rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
    w 打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
    wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。一般用于非文本文件如图片等。
    w+ 打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
    wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。一般用于非文本文件如图片等。
    a 打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
    ab 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
    a+ 打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。
    ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。