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 为10的20次方, 输出结果 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表示假。这分别与特殊的变量 True 和 False 等价。(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) 返回 20。orx or y布尔"或" - 如果 x 是非 0,它返回 x 的计算值,否则它返回 y 的计算值。(a or b) 返回 10。notnot x布尔"非" - 如果 x 为 True,返回 False 。如果 x 为 False,它返回 True。not(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 序列中返回 True。not 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 不在给定的列表中 list 中2 - 变量 b 不在给定的列表中 list 中3 - 变量 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)),从0到9中随机挑选一个整数。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,否则返回 False。7expandtabs(tabsize=8)把字符串 string 中的 tab 符号转为空格,tab 符号默认的空格数是 8 。8find(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的键/值对更新到dict里10dict.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你输入的数字可以整除 2 和 3
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))
执行结果如下:
1 到 100 之和为: 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()。但你也可以自己创建函数,这被叫做用户自定义函数。
定义一个函数
你可以定义一个由自己想要功能的函数,以下是简单的规则:
- 函数代码块以 def 关键词开头,后接函数标识符名称和圆括号 ()。
- 任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数。
- 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
- 函数内容以冒号 : 起始,并且缩进。
- 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’时,表明该模块自身在运行,否则是被引入。
说明:name 与 main 底下是双下划线, _ _ 是这样去掉中间的那个空格。
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+ 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。