序言

Python是一种通用的解释型，交互式，面向对象和高级编程语言。 它由Guido van Rossum在1985 - 1990年间创建。与Perl一样，Python源代码也可以在GNU通用公共许可证（GPL）下获得。 Python的名字叫做“Monty Python的飞行马戏团”，而不是Python之后的蛇。

Python 3.0在2008年发布。虽然这个版本应该是后向不可兼容的，但后来它的许多重要功能已被反向移植到与2.7版兼容。本教程对Python 3版本编程语言提供了足够的理解。

本教程面向希望将其Python技能升级到Python 3的软件程序员而设计。本教程也可用于从头开始学习Python编程语言。

您应该对计算机编程术语有基本的了解。 对任何编程语言的基本理解是一个优点。

对于本教程中给出的大多数示例，您可以尝试去运行，并通过这种方式来学习。

Python 版本

通过下面命令查看Python 版本

python -V

以下是命令执行的结果

Python 3.3.4

Hello World 程序

对于大多数程序语言，第一个入门编程代码便是"Hello World！"，以下代码为使用Python输出"Hello World！"

#!/usr/bin/python3
print ("Hello, Python!")

Python 概述

Python是一种高级的，解释性的，交互式的和面向对象的脚本语言。 Python被设计为高度可读。它经常使用英文关键字，而其他语言使用标点符号。它的语法结构比其他语言少。

• Python被解释 - Python由解释器在运行时处理。在执行之前，您不需要编译程序。这与PERL和PHP类似。
• Python是交互式的 - 您可以坐在Python提示符处直接与解释器交互来编写程序。
• Python是面向对象的 - Python支持面向对象的风格或封装代码的编程技术。
• Python是初学者的语言 - Python对初学者级程序员来说是一种伟大的语言，并且支持从简单文本处理到WWW浏览器到游戏等各种应用程序的开发。

Python的历史

Python由Guido van Rossum在八十年代和九十年代初在荷兰国家数学和计算机科学研究所开发。

Python源自许多其他语言，包括ABC，Modula-3，C，C ++，Algol-68，SmallTalk和Unix shell以及其他脚本语言。

Python受版权保护。像Perl一样，Python源代码现在可以在GNU通用公共许可证（GPL）下获得。

Python现在由该研究所的核心开发团队维护，尽管Guido van Rossum在指导其进展方面仍然发挥着重要作用。

Python 1.0于1994年11月发布。2000年，Python 2.0发布。 Python 2.7.11是Python 2的最新版本。

与此同时，Python 3.0在2008年发布.Python 3不与Python 2向后兼容。Python 3的重点是删除重复的编程结构和模块，以便“应该有一个 - 最好只有一个 - 显而易见的做法。“ Python 3.5.1是Python 3的最新版本。

Python功能

Python的功能包括 -

• 简单易学 - Python几乎没有关键字，结构简单，语法清晰。这可以让学生快速掌握语言。
• 易于阅读 - Python代码更加清晰且易于阅读。
• 易于维护 - Python的源代码相当易于维护。
• 广泛的标准库 - Python的大部分库在UNIX，Windows和Macintosh上都非常便携且跨平台兼容。
• 交互模式 - Python支持交互模式，允许交互式测试和调试代码片段。
• 便携式 - Python可以在各种硬件平台上运行，并且在所有平台上具有相同的界面。
• 可扩展 - 您可以将低级模块添加到Python解释器。这些模块使程序员可以添加或定制他们的工具，以提高效率。
• 数据库 - Python为所有主要商业数据库提供接口。
• GUI编程--Python支持可以创建并移植到许多系统调用，库和Windows系统（例如Windows MFC，Macintosh和Unix的X Window系统）的GUI应用程序。
• 可扩展 - 与shell脚本相比，Python为大型程序提供了更好的结构和支持。

除了上面提到的功能，Python还有很多很好的功能。下面列出了几个 -

• 它支持功能和结构化编程方法以及OOP。
• 它可以用作脚本语言，或者可以编译为用于构建大型应用程序的字节码。
• 它提供非常高级的动态数据类型并支持动态类型检查。
• 它支持自动垃圾收集。
• 它可以很容易地与C，C ++，COM，ActiveX，CORBA和Java集成。

Python3 环境设置

Python 3适用于Windows，Mac OS和大多数Linux操作系统。 尽管Python 2可用于许多其他操作系统，但Python 3支持既未提供给他们，也未被删除。

本地环境设置

打开一个终端窗口并输入“python”以确定它是否已安装，以及安装了哪个版本。

安装Python

Windows系统

最新版本的Python 3（Python 3.5.1）的二进制文件可在此下载页面上找到https://www.python.org/downloads/windows/

注 - 为了安装Python 3.5.1，最低操作系统要求是Windows 7 SP1。 对于版本3.0到3.4.x，Windows XP是可以接受的。

Linux系统

不同风格的Linux使用不同的软件包管理器来安装新软件包。

在Ubuntu Linux上，使用以下命令从终端安装Python 3。

$sudo apt-get install python3-minimal

从源代码安装
从Python的下载URL下载Gzipped源代码tar-https://www.python.org/ftp/python/3.5.1/Python-3.5.1.tgz

Extract the tarball
tar xvfz Python-3.5.1.tgz
Configure and Install:
cd Python-3.5.1
./configure --prefix = /opt/python3.5.1
make  
sudo make install

Mac OS

从此URL下载Mac OS安装程序-https://www.python.org/downloads/mac-osx/

Python的官方网站提供了最新的和最新的源代码，二进制文件，文档，新闻等.

Python官方网站-https://www.python.org/

您可以从以下网站下载Python文档。 该文档以HTML，PDF和PostScript格式提供。

Python文档网站 - www.python.org/doc/

设置PATH

程序和其他可执行文件可以在许多目录中。因此，操作系统提供一个搜索路径，列出它搜索可执行文件的目录。

重要的特点是 -

• 该路径存储在环境变量中，该变量是操作系统维护的命名字符串。此变量包含可用于命令外壳程序和其他程序的信息。
• 路径变量在Unix中被命名为PATH或在Windows中被命名为Path（Unix是区分大小写的; Windows不是）。
• 在Mac OS中，安装程序处理路径详细信息。要从任何特定目录调用Python解释器，必须将Python目录添加到路径中。

在Unix / Linux上设置路径

在Python中添加Python目录到特定会话的路径 -

• 在csh shell中键入setenv PATH “$ PATH：/usr/local/bin/python3”，然后按Enter键。
• 在bash shell（Linux）中 - 输入export PYTHONPATH = /usr/local/bin/python3.4并按Enter键。
• 在sh或ksh shell中 - 键入PATH = “$ PATH：/usr/local/bin/python3”，然后按Enter键。

注 - /usr/local/bin/python3是Python目录的路径。

在Windows上设置路径

将Python目录添加到Windows中特定会话的路径 -

• 在命令提示符处 - 键入路径％path％; C：\Python并按Enter键。

注 - C：\Python是Python目录的路径

Python环境变量

这里有一些重要的环境变量，它们被Python识别 -

运行 Python

有三种不同的方法来启动Python -

互动式解释器

您可以从Unix，DOS或任何其他为您提供命令行解释器或shell窗口的系统启动Python。

输入python命令行。

在交互式解释器中立即开始编码。

$python             # Unix/Linux
or 
python%             # Unix/Linux
or 
C:>python        # Windows/DOS

以下是所有可用命令行选项的列表 -

来自命令行的脚本

通过在应用程序上调用解释器，可以在命令行执行Python脚本，如以下示例所示。

$ python script.py         ＃Unix/Linux
or
python％script.py          ＃Unix/Linux
or
C：＆gt; python script.py  ＃Windows / DOS

注 - 确保文件权限模式允许执行。

Python3 基本语法

Python语言与Perl，C和Java有许多相似之处。 但是，语言之间有一些明确的区别。

第一个Python程序

让我们以不同的编程模式执行程序。

交互模式编程

调用解释器而不传递脚本文件作为参数会显示以下提示 -

$ python

Python 3.3.2 (default, Dec 10 2013, 11:35:01)
[GCC 4.6.3] on Linux
Type "help", "copyright", "credits", or "license" for more information.
>>>

On Windows:

Python 3.4.3 (v3.4.3:9b73f1c3e601, Feb 24 2015, 22:43:06) [MSC v.1600 32 bit (Intel)] on win32
Type "copyright", "credits" or "license()" for more information.
>>>

在Python提示符处键入以下文本并按Enter键 -

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

如果您运行的是旧版本的Python（Python 2.x），则使用括号作为Inprint函数是可选的。 这产生了以下结果 -

Hello, Python!

脚本模式编程

用脚本参数调用解释器开始执行脚本并继续，直到脚本完成。 脚本完成后，解释器不再处于活动状态。

让我们在脚本中编写一个简单的Python程序。 Python文件的扩展名为.py。 在test.py文件中输入以下源代码 -

print ("Hello, Python!")

我们假设你已经在PATH变量中设置了Python解释器。 现在，尝试运行该程序如下 -

在Linux上

$ python test.py 

这产生了以下结果 -

Hello, Python!

在Windows上

C:\Python34>Python test.py

这产生了以下结果 -

Hello, Python!

让我们尝试另一种方式在Linux中执行Python脚本。 这里是修改后的test.py文件 -

#!/usr/bin/python3
print ("Hello, Python!")

我们假设你在/usr/bin目录下有Python解释器。 现在，尝试运行该程序如下 -

$ chmod +x test.py     # This is to make file executable
$./test.py

这产生了以下结果 -

Hello, Python!

Python标识符

Python标识符是用于标识变量，函数，类，模块或其他对象的名称。 标识符以字母A至Z或a至z或下划线（_）开头，后跟零个或多个字母，下划线和数字（0至9）。

Python不允许在标识符中使用标点符号，如@，$和％。 Python是一种区分大小写的编程语言。 因此，Person和person是Python中两种不同的标识符。

这里是Python标识符的命名约定 -

• 类名以大写字母开头。 所有其他标识符都以小写字母开头。
• 用一个前导下划线开始标识符表示该标识符是私有的。
• 用两个前导下划线开始标识符表示一个强大的私有标识符。
• 如果标识符也以两个尾随下划线结尾，则标识符是语言定义的特殊名称。

保留字

以下列表显示了Python关键字。 这些是保留字，您不能将它们用作常量或变量或任何其他标识符名称。 所有的Python关键字只包含小写字母。

行和缩进

Python不使用大括号（{}）来指示类和函数定义或流量控制的代码块。 代码块由线条缩进表示，严格执行。

缩进中的空格数是可变的，但块内的所有语句必须缩进相同的数量。 例如 -

if True:
print ("True")

else:
print ("False")

但是，以下块会生成错误 -

if True:
print ("Answer")
print ("True")

else:
print ("Answer")
print ("False")

因此，在Python中，所有用相同数量的空格缩进的连续行将形成一个块。 以下示例具有各种语句块 −

注 − 在这个时候不要试图理解逻辑。 只要确保你了解各种块，即使它们没有大括号。

#!/usr/bin/python3

import sys

try:
   # open file stream
   file = open(file_name, "w")

except IOError:
   print ("There was an error writing to", file_name)
   sys.exit()
print ("Enter '", file_finish,)
print "' When finished"
while file_text != file_finish:
   file_text = raw_input("Enter text: ")
   if file_text == file_finish:
	  # close the file
	  file.close
	  break
   file.write(file_text)
   file.write("\n")
file.close()
file_name = input("Enter filename: ")
if len(file_name) == 0:
   print ("Next time please enter something")
   sys.exit()

try:
   file = open(file_name, "r")

except IOError:
   print ("There was an error reading file")
   sys.exit()
file_text = file.read()
file.close()
print (file_text)

多行语句

Python中的语句通常以新行结束。 但是，Python允许使用行连续字符（\）来表示该行应该继续。 例如 −

total = item_one + \
		item_two + \
		item_three

包含在[]，{}或（）括号内的语句不需要使用行连续字符。 例如 −

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

Python中的引用

只要相同类型的引号开始和结束字符串，Python就接受单引号（'），双引号（“）和三引号（'''或”“”）来表示字符串文字。

三重引号用于跨多行跨越字符串。 例如，以下所有内容都是合法的 −

word = 'word'
sentence = "This is a sentence."
paragraph = """This is a paragraph. It is
made up of multiple lines and sentences."""

Python中的注释

不在字符串内的散列符号（＃）是注释的开始。 ＃之后的所有字符，直到物理线的末尾，都是注释的一部分，Python解释器忽略它们。

#!/usr/bin/python3

# First comment
print ("Hello, Python!") # second comment

这会产生以下结果 −

Hello, Python!

您可以在语句或表达式之后的同一行输入注释 −

name = "Madisetti" # This is again comment

Python没有多行注释功能。 您必须按照以下方式分别评论每一行 −

# This is a comment.
# This is a comment, too.
# This is a comment, too.
# I said that already.

使用空白行

仅包含空格的行（可能带有注释）被称为空行，Python完全忽略它。

在交互式解释器会话中，您必须输入一个空的物理行来终止多行语句。

等待用户输入

程序的下面一行显示提示和说“按Enter键退出”的语句，然后等待用户采取行动 −

#!/usr/bin/python3

input("\n\nPress the enter key to exit.")

在此，“\n\n”用于在显示实际行之前创建两个新行。 一旦用户按下该键，程序结束。 在用户完成应用程序之前，保持控制台窗口处于打开状态是一个很好的技巧。

同一行显示多条语句

分号（;）允许在一行中使用多个语句，因为没有语句会启动一个新的代码块。 这是一个使用分号的示例片段 −

import sys; x = 'foo'; sys.stdout.write(x + '\n')

多个语句组作为代码组

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

标题行以语句开始（使用关键字）并以冒号（：）结尾，后跟一个或多个构成代码组。 例如 −

if expression : 
   suite
elif expression : 
   suite 
else : 
   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. ]

Python3 数据类型

变量只是保留内存位置来存储值。 这意味着当你创建一个变量时，你在内存中保留了一些空间。

根据变量的数据类型，解释程序分配内存并决定可以在保留内存中存储的内容。 因此，通过为变量分配不同的数据类型，可以在这些变量中存储整数，小数或字符。

赋值给变量

Python变量不需要显式声明来保留内存空间。 当您为变量赋值时，声明会自动发生。 等号（=）用于赋值给变量。

=运算符左侧的操作数是变量的名称，=运算符右侧的操作数是存储在变量中的值。 例如 -

#!/usr/bin/python3

counter = 100          # An integer assignment
miles   = 1000.0       # A floating point
name    = "John"       # A string

print (counter)
print (miles)
print (name)

这里，100,1000.0和“John”分别是分配给计数器，英里和名称变量的值。 这会产生以下结果 −

100
1000.0
John

多重分配

Python允许您同时为多个变量分配单个值。例如 -

a = b = c = 1

在这里，用值1创建一个整型对象，并将所有这三个变量分配给相同的内存位置。 您也可以将多个对象分配给多个变量。 例如 -

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

这里，将两个值分别为1和2的整数对象分别分配给变量a和b，并将一个值为“john”的字符串对象分配给变量c。

标准数据类型

存储在内存中的数据可以有多种类型。 例如，一个人的年龄被存储为一个数值，他或她的地址被存储为字母数字字符。 Python有各种标准数据类型，用于定义可能的操作以及每种操作的存储方法。

Python有五种标准数据类型 -

• Number（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Dictionary（字典）

Number（数字）

Number数据类型存储数字值。 数字对象在您为其分配值时创建。 例如 -

var1 = 1
var2 = 10

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

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

您可以使用del语句删除单个对象或多个对象。例如 -

del var
del var_a, var_b

Python支持三种不同的数字类型 -

• int（有符号整数）
• float（浮点数实数值）
• complex（复数）

Python3中的所有整数都表示为长整数。 因此，没有单独的数字类型。

以下是一些数字的例子 -

一个复数由一个由x + yj表示的有序实浮点数组成，其中x和y是实数，j是虚数单位。

String（字符串）

Python中的字符串被标识为用引号表示的一组连续的字符。 Python允许使用一对单引号或双引号。 可以使用slice操作符（[]和[：]）来获取字符串的子集，索引从字符串开头的0开始，从-1到结束。

加号（+）是字符串连接运算符，星号（*）是重复运算符。 例如 -

#!/usr/bin/python3

str = 'Hello World!'

print (str)          # Prints complete string
print (str[0])       # Prints first character of the string
print (str[2:5])     # Prints characters starting from 3rd to 5th
print (str[2:])      # Prints string starting from 3rd character
print (str * 2)      # Prints string two times
print (str + "TEST") # Prints concatenated string

这将产生以下结果 −

Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

List（列表）

列表是Python的复合数据类型中功能最多的。 列表包含用逗号分隔的项目，并用方括号（[]）括起来。 在某种程度上，列表与C中的数组类似。它们之间的差异之一是属于列表的所有项目可以具有不同的数据类型。

存储在列表中的值可以使用slice操作符（[]和[：]）进行访问，索引从列表开始的0开始，并以结束-1的方式工作。 加号（+）是列表级联运算符，星号（*）是重复运算符。 例如 -

#!/usr/bin/python3

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']

print (list)          # Prints complete list
print (list[0])       # Prints first element of the list
print (list[1:3])     # Prints elements starting from 2nd till 3rd 
print (list[2:])      # Prints elements starting from 3rd element
print (tinylist * 2)  # Prints list two times
print (list + tinylist) # Prints concatenated lists

这产生了以下结果 -

['abcd', 786, 2.23, 'john', 70.200000000000003]
abcd
[786, 2.23]
[2.23, 'john', 70.200000000000003]
[123, 'john', 123, 'john']
['abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john']

Tuple（元组）

元组是另一种与列表相似的序列数据类型。 一个元组由多个用逗号分隔的值组成。 然而，与列表不同，元组被括在括号内。

列表和元组的主要区别是 - 列表括在括号（[]）中，它们的元素和大小可以更改，而元组括在括号（（）中并且不能更新。 元组可以被认为是只读列表。 例如 -

#!/usr/bin/python3

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2  )
tinytuple = (123, 'john')

print (tuple)           # Prints complete tuple
print (tuple[0])        # Prints first element of the tuple
print (tuple[1:3])      # Prints elements starting from 2nd till 3rd 
print (tuple[2:])       # Prints elements starting from 3rd element
print (tinytuple * 2)   # Prints tuple two times
print (tuple + tinytuple) # Prints concatenated tuple

这会产生以下结果 −

('abcd', 786, 2.23, 'john', 70.200000000000003)
abcd
(786, 2.23)
(2.23, 'john', 70.200000000000003)
(123, 'john', 123, 'john')
('abcd', 786, 2.23, 'john', 70.200000000000003, 123, 'john')

下面的代码对元组无效，因为我们试图更新一个不允许的元组。 类似的情况是可能的列表 −

#!/usr/bin/python3

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2  )
list = [ 'abcd', 786 , 2.23, 'john', 70.2  ]
tuple[2] = 1000    # Invalid syntax with tuple
list[2] = 1000     # Valid syntax with list

Dictionary（字典）

Python的字典是一种散列表类型。 它们像Perl中的关联数组或哈希函数一样工作，并由键值对组成。 字典键可以是几乎任何Python类型，但通常是数字或字符串。 另一方面，值可以是任意的Python对象。

字典由大括号（{}）括起来，并且可以使用方括号（[]）分配和访问值。 例如 -

#!/usr/bin/python3

dict = {}
dict['one'] = "This is one"
dict[2]     = "This is two"

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}

print (dict['one'])       # Prints value for 'one' key
print (dict[2])           # Prints value for 2 key
print (tinydict)          # Prints complete dictionary
print (tinydict.keys())   # Prints all the keys
print (tinydict.values()) # Prints all the values

这会产生以下结果 −

This is one
This is two
{'name': 'john', 'dept': 'sales', 'code': 6734}
dict_keys(['name', 'dept', 'code'])
dict_values(['john', 'sales', 6734])

Python数据类型转换

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

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

Python3 运算符

运算符是可以操纵操作数值的构造。 考虑表达式4 + 5 = 9。这里，4和5被称为操作数，+被称为运算符。

Python语言支持以下类型的运算符 -

• 算术运算符
• 比较（关系）运算符
• 赋值运算符
• 逻辑运算符
• 位运算符
• 成员运算符
• 身份运算符

让我们逐个看看所有的运算符。

算术运算符

以下假设变量a为10，变量b为21

例子

假设变量a保存值10，变量b保存值20，则 −

#!/usr/bin/python3

a = 21
b = 10
c = 0

c = a + b
print ("Line 1 - Value of c is ", c)

c = a - b
print ("Line 2 - Value of c is ", c )

c = a * b
print ("Line 3 - Value of c is ", c)

c = a / b
print ("Line 4 - Value of c is ", c )

c = a % b
print ("Line 5 - Value of c is ", c)

a = 2
b = 3
c = a**b 
print ("Line 6 - Value of c is ", c)

a = 10
b = 5
c = a//b 
print ("Line 7 - Value of c is ", c)

当你执行上述程序时，它会产生以下结果 −

Line 1 - Value of c is  31
Line 2 - Value of c is  11
Line 3 - Value of c is  210
Line 4 - Value of c is  2.1
Line 5 - Value of c is  1
Line 6 - Value of c is  8
Line 7 - Value of c is  2

比较（关系）运算符

这些运算符比较它们两边的值并决定它们之间的关系。 他们也被称为关系运算符。

假设变量a保持值10，变量b保持值20，则 -

例子

假设变量a保存值10，变量b保存值20，则 −

#!/usr/bin/python3

a = 21
b = 10

if ( a == b ):
   print ("Line 1 - a is equal to b")
else:
   print ("Line 1 - a is not equal to b")

if ( a != b ):
   print ("Line 2 - a is not equal to b")
else:
   print ("Line 2 - a is equal to b")

if ( a < b ):
   print ("Line 3 - a is less than b" )
else:
   print ("Line 3 - a is not less than b")

if ( a > b ):
   print ("Line 4 - a is greater than b")
else:
   print ("Line 4 - a is not greater than b")

a,b=b,a #values of a and b swapped. a becomes 10, b becomes 21

if ( a <= b ):
   print ("Line 5 - a is either less than or equal to  b")
else:
   print ("Line 5 - a is neither less than nor equal to  b")

if ( b >= a ):
   print ("Line 6 - b is either greater than  or equal to b")
else:
   print ("Line 6 - b is neither greater than  nor equal to b")

当你执行上述程序时，它会产生以下结果 −

Line 1 - a is not equal to b
Line 2 - a is not equal to b
Line 3 - a is not less than b
Line 4 - a is greater than b
Line 5 - a is either less than or equal to  b
Line 6 - b is either greater than  or equal to b

赋值运算符

假设变量a保持值10，变量b保持值20，则 -

例子

假设变量a保存值10，变量b保存值20，则 −

#!/usr/bin/python3

a = 21
b = 10
c = 0

c = a + b
print ("Line 1 - Value of c is ", c)

c += a
print ("Line 2 - Value of c is ", c )

c *= a
print ("Line 3 - Value of c is ", c )

c /= a 
print ("Line 4 - Value of c is ", c )

c  = 2
c %= a
print ("Line 5 - Value of c is ", c)

c **= a
print ("Line 6 - Value of c is ", c)

c //= a
print ("Line 7 - Value of c is ", c)

当你执行上述程序时，它会产生以下结果 −

Line 1 - Value of c is  31
Line 2 - Value of c is  52
Line 3 - Value of c is  1092
Line 4 - Value of c is  52.0
Line 5 - Value of c is  2
Line 6 - Value of c is  2097152
Line 7 - Value of c is  99864

位运算符

按位运算符在位上工作并执行按位操作。 假设a = 60; 和b = 13; 现在以二进制格式，他们将如下 -

a = 0011 1100
b = 0000 1101
-----------------
a＆b = 0000 1100
a | b = 0011 1101
a ^ b = 0011 0001
〜a = 1100 0011

Python的内置函数bin（）可用于获取整数的二进制表示。

Python语言支持以下位运算符 -

例子

#!/usr/bin/python3

a = 60            # 60 = 0011 1100
b = 13            # 13 = 0000 1101
print ('a=',a,':',bin(a),'b=',b,':',bin(b))
c = 0

c = a & b;        # 12 = 0000 1100
print ("result of AND is ", c,':',bin(c))

c = a | b;        # 61 = 0011 1101 
print ("result of OR is ", c,':',bin(c))

c = a ^ b;        # 49 = 0011 0001
print ("result of EXOR is ", c,':',bin(c))

c = ~a;           # -61 = 1100 0011
print ("result of COMPLEMENT is ", c,':',bin(c))

c = a << 2;       # 240 = 1111 0000
print ("result of LEFT SHIFT is ", c,':',bin(c))

c = a >> 2;       # 15 = 0000 1111
print ("result of RIGHT SHIFT is ", c,':',bin(c))

当你执行上述程序时，它会产生以下结果 −

a = 60 : 0b111100 b = 13 : 0b1101
result of AND is  12 : 0b1100
result of OR is  61 : 0b111101
result of EXOR is  49 : 0b110001
result of COMPLEMENT is  -61 : -0b111101
result of LEFT SHIFT is  240 : 0b11110000
result of RIGHT SHIFT is  15 : 0b111

逻辑运算符

Python语言支持以下逻辑运算符。 假设变量a成立True并且变量b成立False，那么 -

成员运算符

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

例子

#!/usr/bin/python3

a = 10
b = 20
list = [1, 2, 3, 4, 5 ]

if ( a in list ):
   print ("Line 1 - a is available in the given list")
else:
   print ("Line 1 - a is not available in the given list")

if ( b not in list ):
   print ("Line 2 - b is not available in the given list")
else:
   print ("Line 2 - b is available in the given list")

c=b/a
if ( c in list ):
   print ("Line 3 - a is available in the given list")
else:
   print ("Line 3 - a is not available in the given list")

当你执行上述程序时，它会产生以下结果 −

Line 1 - a is not available in the given list
Line 2 - b is not available in the given list
Line 3 - a is available in the given list

身份运算符

身份运算符比较两个对象的内存位置。 有两个身份运算符，如下所述 -

例子

#!/usr/bin/python3

a = 20
b = 20
print ('Line 1','a=',a,':',id(a), 'b=',b,':',id(b))

if ( a is b ):
   print ("Line 2 - a and b have same identity")
else:
   print ("Line 2 - a and b do not have same identity")

if ( id(a) == id(b) ):
   print ("Line 3 - a and b have same identity")
else:
   print ("Line 3 - a and b do not have same identity")

b = 30
print ('Line 4','a=',a,':',id(a), 'b=',b,':',id(b))

if ( a is not b ):
   print ("Line 5 - a and b do not have same identity")
else:
   print ("Line 5 - a and b have same identity")

当你执行上述程序时，它会产生以下结果 −

Line 1 a= 20 : 1594701888 b= 20 : 1594701888
Line 2 - a and b have same identity
Line 3 - a and b have same identity
Line 4 a= 20 : 1594701888 b= 30 : 1594702048
Line 5 - a and b do not have same identity

Python运算符优先级

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

运算符优先级影响表达式的评估。

例如，x = 7 + 3 * 2; 在这里，x被赋值为13，而不是20，因为运算符*的优先级高于+，所以它先乘以3 * 2然后加到7。

这里，优先级最高的操作符出现在表的顶部，最低的操作符出现在底部。

例子

#!/usr/bin/python3

a = 20
b = 10
c = 15
d = 5

print ("a:%d b:%d c:%d d:%d" % (a,b,c,d ))
e = (a + b) * c / d       #( 30 * 15 ) / 5
print ("Value of (a + b) * c / d is ",  e)

e = ((a + b) * c) / d     # (30 * 15 ) / 5
print ("Value of ((a + b) * c) / d is ",  e)

e = (a + b) * (c / d)    # (30) * (15/5)
print ("Value of (a + b) * (c / d) is ",  e)

e = a + (b * c) / d      #  20 + (150/5)
print ("Value of a + (b * c) / d is ",  e)

当你执行上述程序时，它会产生以下结果 −

a:20 b:10 c:15 d:5
Value of (a + b) * c / d is  90.0
Value of ((a + b) * c) / d is  90.0
Value of (a + b) * (c / d) is  90.0
Value of a + (b * c) / d is  50.0

Python3 条件控制

条件控制是对执行计划期间发生的情况的预期，并根据条件采取具体行动。

条件控制评估多个表达式，其结果产生TRUE或FALSE。 如果结果为TRUE或FALSE，则需要确定执行哪个操作以及执行哪些语句。

以下是大多数编程语言中典型条件控制的一般形式 -

Python编程语言将任何非零值和非空值假定为TRUE，并将任何零或空值假定为FALSE值。

Python编程语言提供了以下类型的决策声明。

if语句

if语句与其他语言相似。 if语句包含一个逻辑表达式，使用该逻辑表达式比较数据，并根据比较结果做出决定。

语法

if expression:
   statement(s)

如果布尔表达式求值为TRUE，则执行if语句内的语句块。 在Python中，块中的语句在：符号后统一缩进。 如果布尔表达式计算结果为FALSE，则执行块结束后的第一组代码。

例子

#!/usr/bin/python3

var1 = 100
if var1:
   print ("1 - Got a true expression value")
   print (var1)

var2 = 0
if var2:
   print ("2 - Got a true expression value")
   print (var2)
print ("Good bye!")

当上面的代码被执行时，它会产生以下结果 -

1 - Got a true expression value
100
Good bye!

if...else语句

else语句可以与if语句结合使用。 如果if语句中的条件表达式解析为0或FALSE值，则else语句包含一段代码。

else语句是一个可选语句，if后面最多只能有一个else语句。

语法

if expression:
   statement(s)

else:
   statement(s)

例子

#!/usr/bin/python3

amount = int(input("Enter amount: "))

if amount<1000:
   discount = amount*0.05
   print ("Discount",discount)
else:
   discount = amount*0.10
   print ("Discount",discount)
	
print ("Net payable:",amount-discount)

在上面的例子中，折扣是根据输入金额计算的。 如果金额低于1000，则折扣率为5％，如果高于10000，则折扣率为10％。当执行上述代码时，会产生以下结果 -

Enter amount: 600
Discount 30.0
Net payable: 570.0

Enter amount: 1200
Discount 120.0
Net payable: 1080.0

elif语句

elif语句允许您检查多个表达式为TRUE，并在其中一个条件评估为TRUE时立即执行一段代码。

与else类似，elif语句是可选的。 然而，与else不同的是，最多只能有一条语句，if后面可以有任意数量的elif语句。

语法

if expression1:
   statement(s)
elif expression2:
   statement(s)
elif expression3:
   statement(s)
else:
   statement(s)

Core Python不提供与其他语言相同的switch或case语句，但我们可以使用if..elif ...语句来模拟switch case，如下所示 -

#!/usr/bin/python3

amount = int(input("Enter amount: "))

if amount<1000:
   discount = amount*0.05
   print ("Discount",discount)
elif amount<5000:
   discount = amount*0.10
   print ("Discount",discount)
else:
   discount = amount*0.15
   print ("Discount",discount)
	
print ("Net payable:",amount-discount)

当上面的代码被执行时，它会产生以下结果＆minus;

Enter amount: 600
Discount 30.0
Net payable: 570.0

Enter amount: 3000
Discount 300.0
Net payable: 2700.0

Enter amount: 6000
Discount 900.0
Net payable: 5100.0

嵌套if语句

当条件解析为真时，您可能会想要检查另一个条件。 在这种情况下，你可以使用嵌套的if结构。

在嵌套if结构中，如果... elif ... else构造，则可以在另一个结构中包含if ... elif ... else构造。

语法

if expression1:
   statement(s)
   if expression2:
	  statement(s)
   elif expression3:
	  statement(s)
   else
	  statement(s)
elif expression4:
   statement(s)
else:
   statement(s)

例子

# !/usr/bin/python3
num = int(input("enter number"))
if num%2 == 0:
   if num%3 == 0:
	  print ("Divisible by 3 and 2")
   else:
	  print ("divisible by 2 not divisible by 3")
else:
   if num%3 == 0:
	  print ("divisible by 3 not divisible by 2")
   else:
	  print  ("not Divisible by 2 not divisible by 3")

当上面的代码被执行时，它会产生以下结果 -

enter number8
divisible by 2 not divisible by 3

enter number15
divisible by 3 not divisible by 2

enter number12
Divisible by 3 and 2

enter number5
not Divisible by 2 not divisible by 3

Python3 循环语句

通常，语句是按顺序执行的 - 函数中的第一个语句先执行，然后执行第二个语句，依此类推。 当您需要多次执行一段代码时，可能会出现这种情况。

编程语言提供了各种控制结构，允许更复杂的执行路径。

循环语句允许我们多次执行一个语句或一组语句。 下图说明了一个循环语句 -

Python编程语言提供以下类型的循环来处理循环要求。

while循环

只要给定条件为真，Python编程语言中的while循环语句会重复执行目标语句。

语句

while expression:
   statement(s)

在这里，陈述可以是单一陈述或统一缩进陈述。 该条件可以是任何表达式，true表示任何非零值。 循环在条件为真时迭代。

当条件变为假时，程序控制传递到循环后面的行。

在Python中，所有在编程构造之后由相同数量的字符空间缩进的语句被认为是单个代码块的一部分。 Python使用缩进作为分组语句的方法。

这里，while循环的一个关键点是循环可能永远不会运行。 当测试条件并且结果为false时，循环体将被跳过，while循环之后的第一条语句将被执行。

例子

#!/usr/bin/python3

count = 0
while (count < 9):
   print ('The count is:', count)
   count = count + 1

print ("Good bye!")

当上面的代码被执行时，它会产生以下结果 -

The count is: 0
The count is: 1
The count is: 2
The count is: 3
The count is: 4
The count is: 5
The count is: 6
The count is: 7
The count is: 8
Good bye!

此处由打印和增量语句组成的块会重复执行，直到计数不再小于9.每次迭代时，显示索引计数的当前值，然后增加1。

无限循环

如果条件从不变为FALSE，则循环变成无限循环。 使用while循环时必须谨慎，因为这种情况可能永远不会解析为FALSE值。 这导致了一个永不止息的循环。 这样的循环称为无限循环。

在服务器需要连续运行的客户端/服务器编程中，无限循环可能很有用，以便客户端程序可以在需要时与其通信。

#!/usr/bin/python3

var = 1
while var == 1 :  # This constructs an infinite loop
   num = int(input("Enter a number  :"))
   print ("You entered: ", num)

print ("Good bye!")

当上面的代码被执行时，它会产生以下结果 -

Enter a number  :20
You entered:  20
Enter a number  :29
You entered:  29
Enter a number  :3
You entered:  3
Enter a number  :11
You entered:  11
Enter a number  :22
You entered:  22
Enter a number  :Traceback (most recent call last):
   File "examples\test.py", line 5, in 
	  num = int(input("Enter a number  :"))
KeyboardInterrupt

上面的例子进入无限循环，你需要使用CTRL + C来退出程序。

使用else语句和循环

Python支持具有与循环语句相关的else语句。

• 如果else语句与for循环一起使用，则在循环用完迭代列表时执行else语句。
• 如果else语句与while循环一起使用，则在条件变为false时执行else语句。

以下示例说明了else语句与while语句的组合，只要它小于5，就会打印一个数字，否则将执行else语句。

#!/usr/bin/python3

count = 0
while count < 5:
   print (count, " is  less than 5")
   count = count + 1
else:
   print (count, " is not less than 5")

当上面的代码被执行时，它会产生以下结果＆minus;

0 is less than 5
1 is less than 5
2 is less than 5
3 is less than 5
4 is less than 5
5 is not less than 5

单行语句

与if语句语法类似，如果while子句仅包含单个语句，则它可能与while标题放在同一行。

例子

以下是单行while子句的语法和示例 -

#!/usr/bin/python3

flag = 1

while (flag): print ('Given flag is really true!')

print ("Good bye!")

上面的例子进入无限循环，你需要按下CTRL + C键退出。

for循环

Python中的for语句有能力迭代任何序列的项目，例如列表或字符串。

语法

for iterating_var in sequence:
   statements(s)

如果一个序列包含一个表达式列表，它将首先被判断。 然后，将序列中的第一项分配给迭代变量iterating_var。 接下来，执行语句块。 列表中的每个项目都分配给iterating_var，并且执行语句块直到整个序列耗尽。

range()函数

内置的函数range()是迭代一系列数字的正确函数。 它生成算术级数的迭代器。

range()生成一个迭代器，以从0开始到n-1为止的整数。 要获取序列的列表对象，可以将它指定为list()。 现在可以使用for语句迭代此列表。

>>> for var in list(range(5)):
   print (var)

这将产生以下输出。

0 1 2 3 4

#!/usr/bin/python3

for letter in 'Python':     # traversal of a string sequence
   print ('Current Letter :', letter)
print()
fruits = ['banana', 'apple',  'mango']
for fruit in fruits:        # traversal of List sequence
   print ('Current fruit :', fruit)

print ("Good bye!")

当上面的代码被执行时，它会产生以下结果 -

Current Letter : P
Current Letter : y
Current Letter : t
Current Letter : h
Current Letter : o
Current Letter : n

Current fruit : banana
Current fruit : apple
Current fruit : mango
Good bye!

按序列索引迭代

迭代遍历每个项目的另一种方法是将索引偏移到序列本身中。 以下是一个简单的例子 -

#!/usr/bin/python3

fruits = ['banana', 'apple',  'mango']
for index in range(len(fruits)):
   print ('Current fruit :', fruits[index])

print ("Good bye!")

当上面的代码被执行时，它会产生以下结果 -

Current fruit : banana
Current fruit : apple
Current fruit : mango
Good bye!

在这里，我们接受了len（）内置函数的协助，该函数提供元组中元素的总数以及range（）内置函数，为我们提供了迭代的实际序列。

使用else语句和循环

Python支持具有与循环语句相关的else语句。

• 如果else语句与for循环一起使用，则只有for循环正常终止（而不是遇到break语句），才会执行else块。
• 如果else语句与while循环一起使用，则在条件变为false时执行else语句。

以下示例说明了else语句与for语句的组合，该语句在给定列表中搜索偶数。

#!/usr/bin/python3

numbers = [11,33,55,39,55,75,37,21,23,41,13]

for num in numbers:
   if num%2 == 0:
	  print ('the list contains an even number')
	  break
else:
   print ('the list doesnot contain even number')

当上面的代码被执行时，它会产生以下结果 -

the list does not contain even number

嵌套循环

Python编程语言允许在另一个循环内使用一个循环。 以下部分将举例说明这个概念。

语法

for iterating_var in sequence:
   for iterating_var in sequence:
	  statements(s)
   statements(s)

Python编程语言中嵌套while循环语句的语法如下所示 -

while expression:
   while expression:
	  statement(s)
   statement(s)

关于循环嵌套的最后一个注意事项是，您可以将任何类型的循环放入任何其他类型的循环中。 例如for循环可以在while循环内，反之亦然。

例子

以下程序使用嵌套for循环来显示1-10的乘法表。

#!/usr/bin/python3
import sys
for i in range(1,11):
   for j in range(1,11):
	  k=i*j
	  print (k, end=' ')
   print()

print（）函数的内部循环有end =''，它附加了一个空格而不是默认的换行符。 因此，这些数字将出现在一行中。

最后的print（）将在inner for循环的最后执行。

当上面的代码被执行时，它会产生以下结果 -

1 2 3 4 5 6 7 8 9 10 
2 4 6 8 10 12 14 16 18 20 
3 6 9 12 15 18 21 24 27 30 
4 8 12 16 20 24 28 32 36 40 
5 10 15 20 25 30 35 40 45 50 
6 12 18 24 30 36 42 48 54 60 
7 14 21 28 35 42 49 56 63 70 
8 16 24 32 40 48 56 64 72 80 
9 18 27 36 45 54 63 72 81 90 
10 20 30 40 50 60 70 80 90 100 

循环控制语句

循环控制语句从其正常序列改变执行。 当执行离开作用域时，在该作用域中创建的所有自动对象都将被销毁。

Python支持以下控制语句。

break语句

break语句用于提前终止当前循环。 放弃循环后，恢复下一个语句的执行，就像C中的传统break语句一样。

中断的最常见用法是当某些外部条件触发时，需要从循环中快速退出。 break语句可以用于while和for循环。

如果使用嵌套循环，则break语句将停止最内层循环的执行，并开始执行块之后的代码的下一行。

语法

break

#!/usr/bin/python3

for letter in 'Python':     # First Example
   if letter == 'h':
	  break
   print ('Current Letter :', letter)
  
var = 10                    # Second Example
while var > 0:              
   print ('Current variable value :', var)
   var = var -1
   if var == 5:
	  break

当上面的代码被执行时，它会产生以下结果 -

Current Letter : P
Current Letter : y
Current Letter : t
Current variable value : 10
Current variable value : 9
Current variable value : 8
Current variable value : 7
Current variable value : 6
Good bye!

以下程序演示了在循环列表中使用for循环的中断。 用户输入一个在列表中搜索到的号码。 如果找到了，那么循环终止于'找到'消息。

例子

#!/usr/bin/python3
no = int(input('any number: '))
numbers = [11,33,55,39,55,75,37,21,23,41,13]

for num in numbers:
   if num == no:
	  print ('number found in list')
	  break
else:
   print ('number not found in list')

上述程序将产生以下输出 -

any number: 33
number found in list

any number: 5
number not found in list

continue语句

Python中的continue语句将控件返回到当前循环的开始处。 遇到时，循环开始下一次迭代，而不执行当前迭代中的其余语句。

continue语句可以用于while和for循环。

语法

continue

#!/usr/bin/python3

for letter in 'Python':     # First Example
   if letter == 'h':
	  continue
   print ('Current Letter :', letter)

var = 10                    # Second Example
while var > 0:              
   var = var -1
   if var == 5:
	  continue
   print ('Current variable value :', var)
print ("Good bye!")

当上面的代码被执行时，它会产生以下结果＆minus;

Current Letter : P
Current Letter : y
Current Letter : t
Current Letter : o
Current Letter : n
Current variable value : 9
Current variable value : 8
Current variable value : 7
Current variable value : 6
Current variable value : 4
Current variable value : 3
Current variable value : 2
Current variable value : 1
Current variable value : 0
Good bye!

pass语句

当语句需要语法时使用它，但不希望执行任何命令或代码。

pass语句是空操作; 执行时没有任何反应。 pass语句在你的代码最终会去的地方也很有用，但是还没有被写入，即在stub中。

语法

pass

例子

#!/usr/bin/python3

for letter in 'Python': 
   if letter == 'h':
	  pass
	  print ('This is pass block')
   print ('Current Letter :', letter)

print ("Good bye!")

当上面的代码被执行时，它会产生以下结果 -

Current Letter : P
Current Letter : y
Current Letter : t
This is pass block
Current Letter : h
Current Letter : o
Current Letter : n
Good bye!

迭代器和生成器

迭代器是一个允许程序员遍历集合中所有元素的对象，无论其具体实现如何。 在Python中，迭代器对象实现了两个方法，iter（）和next（）。

字符串，列表或元组对象可用于创建迭代器。

list = [1,2,3,4]
it = iter(list) # this builds an iterator object
print (next(it)) #prints next available element in iterator
Iterator object can be traversed using regular for statement
!usr/bin/python3
for x in it:
   print (x, end=" ")
or using next() function
while True:
   try:
	  print (next(it))
   except StopIteration:
	  sys.exit() #you have to import sys module for this

生成器是使用yield方法生成或生成一系列值的函数。

当一个生成器函数被调用时，它会返回一个生成器对象，甚至不会开始执行该函数。 当第一次调用next（）方法时，该函数开始执行，直到它到达yield语句，该语句返回所产生的值。 产量保持跟踪，即记住最后一次执行，并且第二次next（）调用从先前的值继续。

例子

下面的例子定义了一个生成器，它为所有的斐波那契数字生成一个迭代器。

!usr/bin/python3
import sys
def fibonacci(n): #generator function
   a, b, counter = 0, 1, 0
   while True:
	  if (counter > n): 
		 return
	  yield a
	  a, b = b, a + b
	  counter += 1
f = fibonacci(5) #f is iterator object

while True:
   try:
	  print (next(f), end=" ")
   except StopIteration:
	  sys.exit()

Python3 数字

数字数据类型存储数字值。 它们是不可变的数据类型。 这意味着，更改数字数据类型的值将导致新分配的对象。

数字对象在您为其分配值时创建。 例如 -

var1 = 1
var2 = 10

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

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

您可以使用del语句删除单个对象或多个对象。 例如 -

del var
del var_a, var_b

Python支持不同的数字类型 -

• int（有符号整数） - 它们通常被称为整数或整数。 它们是正整数或负整数，没有小数点。 Python 3中的整数的大小是无限的。 Python 2有两个整型 - int和long。 Python 3中没有“长整数”了。
• float（浮点实数值） - 也称为浮点数，它们表示实数，并用小数点除整数和小数部分来表示。 浮点数也可以用科学计数法表示，E或e表示10的乘方（2.5e2 = 2.5×102 = 250）。
• complex（复数） - 形式为a + bJ，其中a和b是浮点数，J（或j）表示-1（它是一个虚数）的平方根。 数字的实部是a，虚部是b。 复杂的数字在Python编程中用处不大。

可以用十六进制或八进制表示一个整数

>>> number = 0xA0F #Hexa-decimal
>>> number
2575

>>> number = 0o37 #Octal
>>> number
31

以下是一些数字的例子。

一个复数由一个由a + bj表示的有序实浮点数组成，其中a是实数部分，b是复数的虚数部分。

数字类型转换

Python将内部数字转换为包含混合类型的表达式，以便将其用于评估。 有时，为了满足操作符或函数参数的要求，您需要明确地将一个数字从一种类型强制转换为另一种类型。

• int（x）将x转换为纯整数。
• float（x）将x转换为浮点数。
• complex（x）将x转换为实部x和虚部零的复数。
• complex（x，y）将x和y转换为具有实部x和虚部y的复数。 x和y是数字表达式。

数学函数

Python包含执行数学计算的以下功能。

随机数函数

随机数用于游戏，模拟，测试，安全和隐私应用程序。 Python包含以下常用的函数。

三角函数

Python包含执行三角函数计算的以下函数。

数学常量

该模块还定义了两个数学常数 -

Python3 字符串

字符串是Python中最流行的类型之一。 我们可以简单地通过将字符括在引号中来创建它们。 Python将单引号视为双引号。 创建字符串就像为变量赋值一样简单。 例如 -

var1 = 'Hello World!'
var2 = "Python Programming"

访问字符串

Python不支持字符类型; 这些被视为长度为1的字符串，因此也被视为子字符串。

要访问子字符串，请使用方括号与索引或索引一起切片以获取您的子字符串。 例如 -

#!/usr/bin/python3

var1 = 'Hello World!'
var2 = "Python Programming"

print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])

当上面的代码被执行时，它会产生以下结果 -

var1[0]:  H
var2[1:5]:  ytho

更新字符串

您可以通过（更新）将变量分配给另一个字符串来“更新”现有的字符串。 新值可以与其先前的值相关联，也可以与完全不同的字符串完全相关。 例如 -

#!/usr/bin/python3

var1 = 'Hello World!'
print ("Updated String :- ", var1[:6] + 'Python')

当上面的代码被执行时，它会产生以下结果 -

Updated String :-  Hello Python

转义字符

下表是可用反斜线表示法表示的转义字符或不可打印字符的列表。

转义字符被解释; 在单引号以及双引号字符串中。

Python字符串运算符

下表实例变量a值为字符串 "Hello"，b变量值为 "Python"

            print( r'\n' )
			print( R'\n' )

字符串格式化

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

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

#!/usr/bin/python3
	
print ("My name is %s and weight is %d kg!" % ('Zara', 21))

当上面的代码被执行时，它会产生以下结果 -

My name is Zara and weight is 21 kg!

以下是可以与％一起使用的完整符号集列表 -

下表中列出了其他支持的符号和功能 -

Python三引号

Python的三重引号通过允许字符串跨越多行，包括逐字NEWLINE，TAB和任何其他特殊字符来解决问题。

三重引号的语法由三个连续的单引号或双引号组成。

#!/usr/bin/python3

para_str = """this is a long string that is made up of
several lines and non-printable characters such as
TAB ( \t ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [ \n ], or just a NEWLINE within
the variable assignment will also show up.
"""
print (para_str)

当上面的代码执行时，它会产生以下结果。 请注意，每个特殊字符如何转换为其打印形式，直到“up”之间字符串末尾的最后一个NEWLINE。 并关闭三重报价。 另外请注意，NEWLINEs会在行末或其转义码（\n）＆minus中显式回车;

this is a long string that is made up of
several lines and non-printable characters such as
TAB (    ) and they will show up that way when displayed.
NEWLINEs within the string, whether explicitly given like
this within the brackets [
], or just a NEWLINE within
the variable assignment will also show up.

原始字符串不会将反斜杠视为特殊字符。 你放入一个原始字符串的每个字符都是你写它的方式 −

#!/usr/bin/python3
	
print ('C:\\nowhere')

当上面的代码执行时，它会产生以下结果 −

C:\nowhere

现在让我们使用原始字符串。 我们会将表达式放在r'表达式'中，如下所示：

#!/usr/bin/python3
	
print (r'C:\\nowhere')

当上面的代码执行时，它会产生以下结果 −

C:\\nowhere

Unicode 字符串

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

在Python3中，所有的字符串都是Unicode字符串。

Python 的字符串内建函数

Python3 列表

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

Python有六种内置类型的序列，但最常见的是列表和元组，我们将在本教程中看到。

你可以对所有的序列类型做某些事情。 这些操作包括索引，切片，添加，乘法和检查成员资格。 另外，Python内置了查找序列长度和查找其最大和最小元素的函数。

列表是Python中可用的最通用的数据类型，可以用方括号中的逗号分隔值（项目）列表编写。 列表中的重要事项是列表中的项目不必是相同的类型。

创建列表与在方括号中放置不同的逗号分隔值一样简单。 例如 -

list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];

与字符串索引类似，列表索引从0开始，列表可以被切分，连接等。

访问列表中的值

要访问列表中的值，请使用方括号将切片与索引或索引一起使用，以获取该索引处可用的值。 例如 -

#!/usr/bin/python3

list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]

print ("list1[0]: ", list1[0])
print ("list2[1:5]: ", list2[1:5])

当上面的代码被执行时，它会产生以下结果 -

list1[0]:  physics
list2[1:5]:  [2, 3, 4, 5]

更新列表

您可以通过在赋值运算符的左侧给定切片来更新列表的单个或多个元素，并且可以使用append（）方法将其添加到列表中的元素。 例如 -

#!/usr/bin/python3

list = ['physics', 'chemistry', 1997, 2000]
print ("Value available at index 2 : ", list[2])

list[2] = 2001
print ("New value available at index 2 : ", list[2])

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

当上面的代码被执行时，它会产生以下结果 -

Value available at index 2 :  1997
New value available at index 2 :  2001

删除列表元素

要删除一个列表元素，如果你确切知道你正在删除的元素，你可以使用del语句。 如果您不确切知道要删除的项目，则可以使用remove（）方法。 例如 -

#!/usr/bin/python3
list = ['physics', 'chemistry', 1997, 2000]

print (list)
del list[2]
print ("After deleting value at index 2 : ", list)

当上面的代码被执行时，它会产生以下结果 -

['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 :  ['physics', 'chemistry', 2000]

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

列表脚本操作符

列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

索引，切片和矩阵

由于列表是序列，因此索引和切片对列表的处理方式与字符串的处理方式相同。

L = ['C++', 'Java', 'Python']

Python列表函数和方法

Python包含以下函数

Python包含以下方法

Python3 元组

元组是一系列不可变的Python对象。 元组是序列，就像列表一样。 元组和列表之间的主要区别在于元组不能像列表那样改变。 元组使用括号，而列表使用方括号。

创建一个元组与放置不同的逗号分隔值一样简单。 或者，您也可以将这些以逗号分隔的值放在括号中。 例如 -

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"

空元组被写为两个不包含任何内容的圆括号 -

tup1 = ();

要写一个包含单个值的元组，即使只有一个值，也必须包含逗号

tup1 = (50,)

像字符串索引一样，元组索引从0开始，并且它们可以被分片，连接等等。

访问元组数据

要访问元组中的值，请使用方括号将切片与索引一起使用，以获取该索引处可用的值。 例如 -

#!/usr/bin/python3

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )

print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

当上面的代码被执行时，它会产生以下结果 -

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

修改元组数据

元组是不可变的，这意味着你不能更新或改变元组元素的值。 您可以使用现有元组的一部分来创建新元组，如以下示例所示 -

#!/usr/bin/python3

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')

# Following action is not valid for tuples
# tup1[0] = 100;

# So let's create a new tuple as follows
tup3 = tup1 + tup2
print (tup3)

当上面的代码被执行时，它会产生以下结果 -

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

删除元组元素

删除单个元组元素是不可能的。 当然，将另一个元组与放弃的不需要的元素组合在一起没有任何问题。

要显式删除整个元组，只需使用del语句。 例如 -

#!/usr/bin/python3

tup = ('physics', 'chemistry', 1997, 2000);

print (tup)
del tup;
print "After deleting tup : "
print tup

这会产生以下结果。

注 - 引发异常。 这是因为在del tup之后，元组不再存在了。

('physics', 'chemistry', 1997, 2000)
After deleting tup :
Traceback (most recent call last):
File "test.py", line 9, in <module>
print tup;
NameError: name 'tup' is not defined

基本元组操作

元组很像字符串一样对+和*运算符作出响应; 它们也意味着连接和重复，除了结果是一个新的元组，而不是一个字符串。

实际上，元组对上一章中我们在字符串中使用的所有常规序列操作做出了响应。

元组索引，截取

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

元组：

L = ('C++', 'Java', 'Python')

内置元组函数

Python包含以下元组函数 -

Python3 字典

每个键都用冒号（:)分隔，其值用逗号分隔，整个事物用大括号括起来。 没有任何项目的空字典仅用两个大括号编写，如下所示：{}

键在字典中是唯一的，而值可能不是。 字典的值可以是任何类型，但键必须是不可变的数据类型，例如字符串，数字或元组。

访问字典

要访问字典元素，可以使用熟悉的方括号和键来获取它的值。 以下是一个简单的例子 -

#!/usr/bin/python3

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])

当上面的代码被执行时，它会产生以下结果 -

dict['Name']:  Zara
dict['Age']:  7

如果我们尝试使用不属于字典一部分的键访问数据项，我们会得到如下错误 -

#!/usr/bin/python3

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
print "dict['Alice']: ", dict['Alice']

当上面的代码被执行时，它会产生以下结果 -

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

更新字典

您可以通过添加新条目或键值对，修改现有条目或删除现有条目来更新字典，如下面的简单示例所示。

#!/usr/bin/python3

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School" # Add new entry

print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

当上面的代码被执行时，它会产生以下结果 -

dict['Age']:  8
dict['School']:  DPS School

删除字典元素

您可以删除单个字典元素，也可以清除字典的全部内容。 您也可以在一个操作中删除整个字典。

要显式删除整个字典，只需使用del语句。 以下是一个简单的例子 -

#!/usr/bin/python3

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

del dict['Name'] # remove entry with key 'Name'
dict.clear()     # remove all entries in dict
del dict         # delete entire dictionary

print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

这会产生以下结果。

因为del字典后字典不再存在，所以引发了一个异常。

dict['Age']:
Traceback (most recent call last):
File "test.py", line 8, in <module>
print "dict['Age']: ", dict['Age'];
TypeError: 'type' object is unsubscriptable

注 − del()方法在后面的章节中讨论。

字典的键值属性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。

关于字典键有两点要记住 -<

(1)不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

#!/usr/bin/python3

dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}
print ("dict['Name']: ", dict['Name'])

当上面的代码被执行时，它会产生以下结果 -

dict['Name']:  Manni

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

#!/usr/bin/python3

dict = {['Name']: 'Zara', 'Age': 7}
print ("dict['Name']: ", dict['Name'])

当上面的代码被执行时，它会产生以下结果 -

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

内置的字典功能和方法

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

Python3 日期和时间

Python程序可以通过几种方式处理日期和时间。 日期格式之间的转换是计算机常见的琐事。 Python的时间和日历模块有助于跟踪日期和时间。

时间间隔是以秒为单位的浮点数。 在1970年1月1日中午12点以后，时间的特定时刻以秒表示。

Python中有一个流行的时间模块，它提供了用于处理时间和在表示之间转换的函数。 函数time.time（）返回1970年1月1日中午12:00（epoch）以来的当前系统时间。

#!/usr/bin/python3
import time;  # This is required to include time module.

ticks = time.time()
print ("Number of ticks since 12:00am, January 1, 1970:", ticks)

这会产生如下结果 -

Number of ticks since 12:00am, January 1, 1970: 1455508609.34375

时间戳单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到2038年。

什么是时间元组？

很多Python函数用一个元组装起来的9组数字处理时间:

import time
print (time.localtime());

这将产生如下结果 -

time.struct_time(tm_year = 2016, tm_mon = 2, tm_mday = 15, tm_hour = 9,
	tm_min = 29, tm_sec = 2, tm_wday = 0, tm_yday = 46, tm_isdst = 0)

上面的元组相当于struct_time结构。 该结构具有以下属性 -

获取当前时间

从返回浮点数的时间辍方式向时间元组转换，只要将浮点数传递给如localtime之类的函数。

#!/usr/bin/python3
import time

localtime = time.localtime(time.time())
print ("Local current time :", localtime)

这将产生以下结果，可以用任何其他形式的格式 -

Local current time : time.struct_time(tm_year = 2016, tm_mon = 2, tm_mday = 15,
	tm_hour = 9, tm_min = 29, tm_sec = 2, tm_wday = 0, tm_yday = 46, tm_isdst = 0)

获取格式化的时间

你可以根据需求选取各种格式，但是最简单的获取可读的时间模式的函数是asctime()

#!/usr/bin/python3
import time

localtime = time.asctime( time.localtime(time.time()) )
print ("Local current time :", localtime)

以上实例输出结果

Local current time : Mon Feb 15 09:34:03 2016

获取某月日历

Calendar模块有很广泛的方法用来处理年历和月历，例如打印某月的月历

#!/usr/bin/python3
import calendar

cal = calendar.month(2016, 2)
print ("Here is the calendar:")
print (cal)

以上实例输出结果

Here is the calendar:
February 2016
Mo Tu We Th Fr Sa Su
1  2  3  4  5  6  7
8  9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29

Time 模块

Time 模块包含了以下内置函数，既有时间处理的，也有转换时间格式的

Time模块包含了以下2个非常重要的属性

日历（Calendar）模块

此模块的函数都是日历相关的，例如打印某月的字符月历。

星期一是默认的每周第一天，星期天是默认的最后一天。更改设置需调用calendar.setfirstweekday()函数。模块包含了以下内置函数

Python3 函数

函数是一组有组织的，可重用的代码，用于执行单个相关操作。 函数为您的应用程序提供更好的模块性，并提供高度的代码重用。

正如你已经知道的那样，Python为你提供了许多内置的函数，如print（）等，但是你也可以创建你自己的函数。 这些功能被称为用户定义的功能。

定义一个函数

您可以定义函数来提供所需的功能。 以下是在Python中定义函数的简单规则。

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

语法

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

def 函数名（参数列表）:
	函数体

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

以下函数将字符串作为输入参数并将其打印在标准屏幕上。

def printme(str):
	"This prints a passed string into this function"
	print (str)
	return

函数调用

定义一个函数给它一个名字，指定要包含在函数中的参数并构造代码块。

一旦函数的基本结构完成后，您可以通过从另一个函数或直接从Python提示符调用它来执行它。 以下是调用printme（）函数的示例 -

#!/usr/bin/python3

# Function definition is here
def printme( str ):
	"This prints a passed string into this function"
	print (str)
	return

# Now you can call printme function
printme("This is first call to the user defined function!")
printme("Again second call to the same function")

当上面的代码被执行时，它会产生以下结果 -

This is first call to the user defined function!
Again second call to the same function

参数传递

Python语言中的所有参数（参数）均通过引用传递。 这意味着，如果您更改某个函数中参数的含义，则该更改也会反映到调用函数中。 例如 -

#!/usr/bin/python3

# Function definition is here
def changeme( mylist ):
	"This changes a passed list into this function"
	print ("Values inside the function before change: ", mylist)
	mylist[2]=50
	print ("Values inside the function after change: ", mylist)
	return

# Now you can call changeme function
mylist = [10,20,30]
changeme( mylist )
print ("Values outside the function: ", mylist)

在这里，我们保持对传入对象的引用以及在同一对象值修改。 因此，这会产生以下结果 -

Values inside the function before change:  [10, 20, 30]
Values inside the function after change:  [10, 20, 50]
Values outside the function:  [10, 20, 50]

还有一个例子，其中参数被引用传递，引用被覆盖在被调用的函数内部。

#!/usr/bin/python3

# Function definition is here
def changeme( mylist ):
	"This changes a passed list into this function"
	mylist = [1,2,3,4] # This would assi new reference in mylist
	print ("Values inside the function: ", mylist)
	return

# Now you can call changeme function
mylist = [10,20,30]
changeme( mylist )
print ("Values outside the function: ", mylist)

参数mylist对于函数changeme是本地的。 在函数内改变mylist不会影响mylist。 该功能没有完成任何操作，最后这会产生以下结果 -

Values inside the function: [1, 2, 3, 4] Values outside the function: [10, 20, 30]

函数参数

您可以使用以下类型的形式参数调用函数 -

• 必需参数
• 关键字参数
• 默认参数
• 不定长参数

必需参数

必需的参数是以正确的位置顺序传递给函数的参数。 这里，函数调用中参数的数量应该与函数定义完全匹配。

要调用函数printme（），您肯定需要传递一个参数，否则会给出语法错误，如下所示 -

#!/usr/bin/python3

# Function definition is here
def printme( str ):
	"This prints a passed string into this function"
	print (str)
	return

# Now you can call printme function
printme()

当上面的代码被执行时，它会产生以下结果 -

Traceback (most recent call last):
File "test.py", line 11, in <module>
printme();
TypeError: printme() takes exactly 1 argument (0 given)

关键字参数

关键字参数与函数调用相关。 当在函数调用中使用关键字参数时，调用方用参数名称标识参数。

这允许您跳过参数或将其置乱，因为Python解释器能够使用提供的关键字来将值与参数匹配。 您还可以通过以下方式对printme（）函数进行关键字调用 -

#!/usr/bin/python3

# Function definition is here
def printme( str ):
	"This prints a passed string into this function"
	print (str)
	return

# Now you can call printme function
printme( str = "My string")

当上面的代码被执行时，它会产生以下结果 -

My string

下面的例子给出了一个更清晰的图片。 请注意参数的顺序无关紧要。

#!/usr/bin/python3

# Function definition is here
def printinfo( name, age ):
	"This prints a passed info into this function"
	print ("Name: ", name)
	print ("Age ", age)
	return

# Now you can call printinfo function
printinfo( age = 50, name = "miki" )

当上面的代码被执行时，它会产生以下结果 -

Name: miki Age 50

默认参数

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

#!/usr/bin/python3

# Function definition is here
def printinfo( name, age = 35 ):
	"This prints a passed info into this function"
	print ("Name: ", name)
	print ("Age ", age)
	return

# Now you can call printinfo function
printinfo( age = 50, name = "miki" )
printinfo( name = "miki" )

当上面的代码被执行时，它会产生以下结果 -

Name:  miki
Age  50
Name:  miki
Age  35

不定长参数

您可能需要处理函数以获取比定义函数时指定的更多参数。 这些参数被称为可变长度参数，并且不需要在函数定义中命名，与所需参数和缺省参数不同。

具有非关键字变量参数的函数的语法如下所示 -

def functionname([formal_args,] *var_args_tuple ):
	"function_docstring"
	function_suite
	return [expression]

加了星号（*）的变量名会存放所有未命名的变量参数。如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。

#!/usr/bin/python3

# Function definition is here
def printinfo( arg1, *vartuple ):
	"This prints a variable passed arguments"
	print ("Output is: ")
	print (arg1)
	for var in vartuple:
		print (var)
	return

# Now you can call printinfo function
printinfo( 10 )
printinfo( 70, 60, 50 )

当上面的代码被执行时，它会产生以下结果 -

Output is:
10
Output is:
70
60
50

匿名函数

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

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

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

语法

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

以下是一个示例，展示函数的lambda表单如何工作 -

#!/usr/bin/python3

# Function definition is here
sum = lambda arg1, arg2: arg1 + arg2


# Now you can call sum as a function
print ("Value of total : ", sum( 10, 20 ))
print ("Value of total : ", sum( 20, 20 ))

当上面的代码被执行时，它会产生以下结果 -

Value of total :  30
Value of total :  40

return语句

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

#!/usr/bin/python3

# Function definition is here
def sum( arg1, arg2 ):
	# Add both the parameters and return them."
	total = arg1 + arg2
	print ("Inside the function : ", total)
	return total

# Now you can call sum function
total = sum( 10, 20 )
print ("Outside the function : ", total )

当上面的代码被执行时，它会产生以下结果 -

Inside the function :  30
Outside the function :  30

变量作用域

程序中的所有变量可能无法在该程序中的所有位置访问。 这取决于你声明变量的地方。

变量的范围决定了程序中可以访问特定标识符的部分。 Python中有两个基本的变量范围 -

• 局部变量
• 全局变量

全局变量和局部变量

在函数体内定义的变量具有局部范围，而在外部定义的变量具有全局范围。

这意味着局部变量只能在声明它的函数内部访问，而全局变量可以通过所有函数在整个程序体中访问。 当你调用一个函数时，在它内部声明的变量被引入到作用域中。 以下是一个简单的例子 -

#!/usr/bin/python3
	
total = 0 # This is global variable.
# Function definition is here
def sum( arg1, arg2 ):
	# Add both the parameters and return them."
	total = arg1 + arg2; # Here total is local variable.
	print ("Inside the function local total : ", total)
	return total
	
# Now you can call sum function
sum( 10, 20 )
print ("Outside the function global total : ", total )

当上面的代码被执行时，它会产生以下结果 -

Inside the function local total :  30
Outside the function global total :  0

Python3 模块

一个模块允许你在逻辑上组织你的Python代码。 将相关代码分组到模块中使代码更易于理解和使用。 一个模块是一个具有任意命名属性的Python对象，您可以将其绑定和引用。

简单地说，一个模块是一个由Python代码组成的文件。 模块可以定义函数，类和变量。 一个模块还可以包含可运行代码。

例子

名为aname的模块的Python代码通常驻留在名为aname.py的文件中。 这是一个简单模块support.py的例子 -

def print_func( par ):
	print "Hello : ", par
	return

import 语句

通过在其他Python源文件中执行import语句，可以将任何Python源文件用作模块。 导入具有以下语法 -

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

当解释器遇到导入语句时，如果模块出现在搜索路径中，它将导入模块。 搜索路径是解释器在导入模块之前搜索的目录列表。 例如，要导入模块hello.py，您需要将以下命令放在脚本的顶部 -

#!/usr/bin/python3
	
# Import module support
import support
	
# Now you can call defined function that module as follows
support.print_func("Zara")

当上面的代码被执行时，它会产生以下结果 -

Hello : Zara

无论导入次数如何，模块只能加载一次。 如果发生多个导入，这可以防止模块执行重复发生。

rom…import 语句

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

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

例如，要从模块fib中导入函数fibonacci，请使用以下语句 -

#!/usr/bin/python3
	
# Fibonacci numbers module
	
def fib(n): # return Fibonacci series up to n
	result = []
	a, b = 0, 1
	while b < n:
		result.append(b)
		a, b = b, a + b
	return result
>>> from fib import fib
>>> fib(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

此语句不会将整个模块fib导入当前名称空间; 它只是将来自模块fib的项目fibonacci引入导入模块的全局符号表。

From…import* 语句

也可以通过使用以下import语句将模块中的所有名称导入当前名称空间 -

from modname import *

这提供了一种将模块中的所有项目导入当前名称空间的简单方法; 但是，应该谨慎使用这种说法。

作为脚本执行模块

在模块中，模块的名称（作为字符串）可用作全局变量__name__的值。 模块中的代码将被执行，就像导入它一样，但__name__设置为“__main__”。

将此代码添加到模块的末尾 -

#!/usr/bin/python3
	
# Fibonacci numbers module
	
def fib(n): # return Fibonacci series up to n
	result = []
	a, b = 0, 1
	while b < n:
		result.append(b)
		a, b = b, a + b
	return result
if __name__ == "__main__":
	f = fib(100)
	print(f)

当您运行上述代码时，将显示以下输出。

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

定位模块

当你导入一个模块时，Python解释器按以下顺序搜索模块 -

• 当前目录。
• 如果找不到该模块，则Python会搜索shell变量PYTHONPATH中的每个目录。
• 如果一切都失败了，Python会检查默认路径。 在UNIX上，这个默认路径通常是/usr/local/lib/python3/。

模块搜索路径作为sys.path变量存储在系统模块sys中。 sys.path变量包含当前目录PYTHONPATH和依赖于安装的缺省值。

PYTHONPATH变量

PYTHONPATH是一个环境变量，由一系列目录组成。 PYTHONPATH的语法与shell变量PATH的语法相同。

这是来自Windows系统的典型PYTHONPATH -

set PYTHONPATH = c:\python34\lib;

这是来自UNIX系统的典型PYTHONPATH -

set PYTHONPATH = /usr/local/lib/python

命名空间和作用域

变量是映射到对象的名称（标识符）。 名称空间是变量名称（键）及其相应对象（值）。

• Python语句可以访问本地命名空间和全局命名空间中的变量。 如果本地变量和全局变量具有相同的名称，则局部变量会隐藏全局变量。
• 每个函数都有自己的本地名称空间。 类方法遵循与普通函数相同的范围规则。
• Python对变量是本地还是全局进行了有根据的猜测。 它假定在函数中赋值的任何变量都是本地的。
• 因此，为了给函数中的全局变量赋值，你必须首先使用全局语句。
• 语句全局VarName告诉Python VarName是一个全局变量。 Python停止搜索变量的本地名称空间。

例如，我们在全局名称空间中定义一个变量Money。 在Money函数中，我们为Money分配一个值，因此Python将Money作为局部变量。

但是，在设置它之前，我们访问了局部变量Money的值，因此UnboundLocalError是结果。 取消全球声明可以解决问题。

#!/usr/bin/python3
	
Money = 2000
def AddMoney():
	# Uncomment the following line to fix the code:
	# global Money
	Money = Money + 1
	
print (Money)
AddMoney()
print (Money)

dir()函数

dir（）内置函数返回一个包含由模块定义的名称的字符串的排序列表。

该列表包含在模块中定义的所有模块，变量和函数的名称。 以下是一个简单的例子 -

#!/usr/bin/python3

# Import built-in module math
import math

content = 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（）函数再次导入以前导入的模块。 reload（）函数的语法是这样的 -

reload(module_name)

这里，module_name是要重新加载的模块的名称，而不是包含模块名称的字符串。 例如，要重新加载hello模块，请执行以下操作 -

reload(hello)

Python中的包

包是一个分层文件目录结构，它定义了一个由模块，子包和子子包组成的单一Python应用程序环境，等等。

考虑Phone目录中可用的文件Pots.py。 该文件具有以下一行源代码 -

#!/usr/bin/python3
	
def Pots():
	print ("I'm Pots Phone")

类似的，我们还有其他两个文件具有不同的功能，其名称与上面相同。 他们是 -

• 具有函数Isdn（）的Phone/Isdn.py文件
• 具有函数G3（）的Phone/G3.py文件

现在，在Phone目录中再创建一个__init__.py文件 -

• Phone/__init__.py

要在导入Phone使所有函数都可用，您需要在__init__.py中显式输入语句，如下所示 -

from Pots import Pots
from Isdn import Isdn
from G3 import G3

将这些行添加到__init__.py之后，当您导入Phone包时，所有这些类都可用。

#!/usr/bin/python3

# Now import your Phone Package.
import Phone

Phone.Pots()
Phone.Isdn()
Phone.G3()

当上面的代码被执行时，它会产生以下结果 -

I'm Pots Phone
I'm 3G Phone
I'm ISDN Phone

在上面的例子中，我们已经在每个文件中使用了单个函数的示例，但是您可以在文件中保留多个函数。 你也可以在这些文件中定义不同的Python类，然后你可以从这些类中创建你的包。

Python3 文件输入输出

本章涵盖Python 3中可用的所有基本I / O函数。有关更多功能，请参阅标准Python文档。

打印到屏幕上

生成输出的最简单方法是使用print语句，您可以传递零个或多个用逗号分隔的表达式。 该函数将您传递的表达式转换为字符串，并将结果写入标准输出，如下所示 -

#!/usr/bin/python3
	
print ("Python is really a great language,", "isn't it?")

这会在您的标准屏幕上产生以下结果 -

Python is really a great language, isn't it?

读取键盘输入

Python 2有两个内置函数来读取标准输入的数据，默认情况下来自键盘。 这些函数是input（）和raw_input（）

在Python 3中，raw_input（）函数已被弃用。 而且，input（）函数以字符串的形式从键盘读取数据，而不管是否用引号（“或”）括起来。

input函数

input（[prompt]）函数等同于raw_input，只是它假定输入是一个有效的Python表达式并将评估结果返回给您。

#!/usr/bin/python3

>>> x = input("something:")
something:10

>>> x
'10'

>>> x = input("something:")
something:'10' #entered data treated as string with or without ''

>>> x
"'10'"

打开和关闭文件

到目前为止，您一直在阅读和写入标准输入和输出。 现在，我们将看到如何使用实际的数据文件。

Python提供了缺省操作文件所需的基本函数和方法。 您可以使用文件对象完成大部分文件操作。

open函数

在读取或写入文件之前，必须使用Python的内置open（）函数打开它。 该函数创建一个文件对象，该对象将用于调用与其关联的其他支持方法。

语法

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

这里是参数详细信息 -

• file_name - file_name参数是一个字符串值，其中包含要访问的文件的名称。
• access_mode - access_mode确定文件必须打开的模式，即读，写，追加等。表中给出了可能值的完整列表。 这是一个可选参数，读取默认文件访问模式（r）。
• buffering - 如果缓冲值设置为0，则不发生缓冲。 如果缓冲值为1，则在访问文件时执行行缓冲。 如果将缓冲值指定为大于1的整数，则使用指定的缓冲区大小执行缓冲操作。 如果为负值，则缓冲区大小为系统默认值（默认行为）。

以下是打开文件的不同模式列表 -

文件对象属性

一旦文件被打开并且你有一个文件对象，你就可以获得与该文件相关的各种信息。

以下是与文件对象相关的所有属性的列表 -

#!/usr/bin/python3

# Open a file
fo = open("foo.txt", "wb")
print ("Name of the file: ", fo.name)
print ("Closed or not : ", fo.closed)
print ("Opening mode : ", fo.mode)
fo.close()

这产生了以下结果 -

Name of the file:  foo.txt
Closed or not :  False
Opening mode :  wb

close()函数

文件对象的close（）方法会刷新所有未写入的信息并关闭文件对象，之后不会再进行写入操作。

当文件的引用对象被重新分配给另一个文件时，Python自动关闭文件。 使用close（）方法关闭文件是一种很好的做法。

语法

fileObject.close();

#!/usr/bin/python3

# Open a file
fo = open("foo.txt", "wb")
print ("Name of the file: ", fo.name)

# Close opened file
fo.close()

这产生了以下结果 -

Name of the file:  foo.txt

读写文件

文件对象提供了一组访问方法，使我们的生活更轻松。 我们将看到如何使用read（）和write（）方法来读取和写入文件。

write()函数

write（）方法将任何字符串写入打开的文件。 需要注意的是，Python字符串可以包含二进制数据，而不仅仅是文本。

write（）方法不会在字符串的末尾添加换行符（'\ n'） -

语法

fileObject.write(string);

这里，传递参数是要写入打开文件的内容。

#!/usr/bin/python3

# Open a file
fo = open("foo.txt", "w")
fo.write( "Python is a great language.\nYeah its great!!\n")

# Close opend file
fo.close()

上面的方法会创建foo.txt文件，并在该文件中写入给定的内容，最后它会关闭该文件。 如果你打开这个文件，它会有以下内容 -

Python is a great language.
Yeah its great!!

read()函数

read（）方法从打开的文件中读取一个字符串。 需要注意的是，Python字符串可以有二进制数据。 除了文本数据。

语法

fileObject.read([count]);

这里，传递的参数是从打开的文件中读取的字节数。 该方法从文件开始处开始读取，如果count缺失，则尽可能多地尝试读取，也许直到文件结束。

让我们取一个我们上面创建的文件foo.txt。

#!/usr/bin/python3

# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10)
print ("Read String is : ", str)

# Close opened file
fo.close()

这产生了以下结果 -

Read String is :  Python is

文件位置

tell（）方法告诉你文件中的当前位置; 换句话说，下一次读或写操作将在文件开头的许多字节处出现。

seek（offset [，from]）方法更改当前文件位置。 偏移参数表示要移动的字节数。 from参数指定要移动字节的参考位置。

如果from设置为0，则文件的开头将用作参考位置。 如果设置为1，则将当前位置用作参考位置。 如果它设置为2，那么文件的结尾将被视为参考位置。

让我们取一个我们上面创建的文件foo.txt。

#!/usr/bin/python3

# Open a file
fo = open("foo.txt", "r+")
str = fo.read(10)
print ("Read String is : ", str)

# Check current position
position = fo.tell()
print ("Current file position : ", position)

# Reposition pointer at the beginning once again
position = fo.seek(0, 0)
str = fo.read(10)
print ("Again read String is : ", str)

# Close opened file
fo.close()

这产生了以下结果 -

Read String is :  Python is
Current file position :  10
Again read String is :  Python is

重命名和删除文件

Python os模块提供了帮助您执行文件处理操作的方法，例如重命名和删除文件。

要使用这个模块，你需要先导入它，然后你可以调用任何相关的函数。

rename()函数

rename（）方法接受两个参数，即当前文件名和新文件名。

os.rename(current_file_name, new_file_name)

以下是重命名现有文件test1.txt的示例 -

#!/usr/bin/python3
import os

# Rename a file from test1.txt to test2.txt
os.rename( "test1.txt", "test2.txt" )

remove()函数

通过提供要删除的文件的名称作为参数，可以使用remove（）方法删除文件。

os.remove(file_name)

以下是删除现有文件test2.txt的示例 -

#!/usr/bin/python3
import os

# Delete file test2.txt
os.remove("text2.txt")

Python中目录

所有文件都包含在各种目录中，Python也没有问题处理。 os模块有几个方法可以帮助您创建，删除和更改目录。

mkdir()函数

您可以使用os模块的mkdir（）方法在当前目录中创建目录。 您需要为此方法提供参数，其中包含要创建的目录的名称。

os.mkdir("newdir")

以下是在当前目录中创建目录测试的示例 -

#!/usr/bin/python3
import os

# Create a directory "test"
os.mkdir("test")

chdir()函数

您可以使用chdir（）方法更改当前目录。 chdir（）方法接受一个参数，它是您想要创建当前目录的目录的名称。

os.chdir("newdir")

以下是进入“/home/newdir”目录的示例 -

#!/usr/bin/python3
import os

# Changing a directory to "/home/newdir"
	os.chdir("/home/newdir")

getcwd()函数

getcwd（）方法显示当前的工作目录。

os.getcwd()

以下是给出当前目录的示例 -

#!/usr/bin/python3
import os

# This would give location of the current directory
os.getcwd()

rmdir()函数

rmdir（）方法删除目录，该目录作为方法中的参数传递。

在删除一个目录之前，它的所有内容都应该被删除。

os.rmdir('dirname')

以下是删除“/tmp/test”目录的示例。 它需要给出完全限定的目录名称，否则它会在当前目录中搜索该目录。

#!/usr/bin/python3
import os

# This would  remove "/tmp/test"  directory.
os.rmdir("/tmp/test")

文件和目录相关的方法

有两个重要来源，它们提供了各种实用方法来处理和操作Windows和Unix操作系统上的文件和目录。 他们如下 -

• 文件对象方法（File Object Methods）
  该文件对象提供了操作文件的功能。
• OS对象方法 (OS Object Methods)
  这提供了处理文件以及目录的方法。

Python3 异常处理

Python提供了两个非常重要的功能来处理Python程序中的任何意外错误，并在其中添加调试功能 -

• 异常处理 (Exception Handling) - 这将在本教程中介绍。 以下是Python中可用的标准异常列表 - 标准异常。
• 断言 (Assertions) - 这将在本章中介绍。

Python中有Exception, StopIteration, SystemExit, StandardError, ArithmeticError, OverflowError,FloatingPointError,ZeroDivisonError,AssertionError, AttributeError等标准异常

Python中的断言（Assertions）

断言是一种健全性检查，您可以在完成程序测试后打开或关闭该功能。

• 想想一个断言的最简单方法是将它比作一个raise-if语句（或者更准确的说，是一个if-not-statement语句）。 测试表达式，如果结果为false，则会引发异常。
• 断言由assert语句执行，这是1.5版本中引入的最新的Python关键字。
• 程序员经常在函数的开始处放置断言来检查有效输入，并在函数调用后检查有效输出。

assert声明

当它遇到一个assert语句时，Python会对伴随的表达式进行评估，这有希望是正确的。 如果表达式为false，则Python会引发AssertionError异常。

assert的语法是 -

assert Expression[, Arguments]

如果断言失败，Python将使用ArgumentExpression作为AssertionError的参数。 AssertionError异常可以像使用try-except语句一样被其他异常捕获和处理。 如果他们没有处理，他们将终止程序并产生追溯。

这是一个将给定温度从开氏度转换成华氏度的函数。 由于0°K与其温度一样冷，因此，如果它看到负温度，功能就会消失 -

#!/usr/bin/python3
def KelvinToFahrenheit(Temperature):
assert (Temperature >= 0),"Colder than absolute zero!"
return ((Temperature-273)*1.8)+32

print (KelvinToFahrenheit(273))
print (int(KelvinToFahrenheit(505.78)))
print (KelvinToFahrenheit(-5))

当上面的代码被执行时，它会产生以下结果 -

32.0
451
Traceback (most recent call last):
File "test.py", line 9, in 
	print KelvinToFahrenheit(-5)
	File "test.py", line 4, in KelvinToFahrenheit
	assert (Temperature >= 0),"Colder than absolute zero!"
	AssertionError: Colder than absolute zero!

什么是异常（Exception）？

异常是一个事件，在执行程序期间发生，这会中断程序指令的正常流程。 通常，当Python脚本遇到无法应付的情况时，会引发异常。 一个异常是表示错误的Python对象。

当Python脚本引发异常时，它必须立即处理异常，否则它会终止并退出。

处理异常

如果您有一些可能引发异常的可疑代码，您可以通过将可疑代码放在try：区块中来捍卫您的程序。 在try：块之后，包含一个except：语句，接着是一段代码，它尽可能优雅地处理问题。

这里是try ...的简单语法.... except ... else blocks -

try:
	You do your operations here
	......................
except ExceptionI:
	If there is ExceptionI, then execute this block.
except ExceptionII:
	If there is ExceptionII, then execute this block.
	......................
else:
	If there is no exception then execute this block.

这里有几点关于上述语法的重要观点 -

• 一个try语句可以有多个except语句。 当try块包含可能引发不同类型异常的语句时，这很有用。
• 您也可以提供一个通用的except子句，它处理任何异常。
• 在except子句之后，可以包含一个else子句。 如果try：块中的代码不引发异常，则else-block中的代码将执行。
• else-block是不需要try：block保护的代码的好地方。

这个例子打开一个文件，在文件中写入内容，并优雅地出现，因为根本没有问题 -

#!/usr/bin/python3
	
try:
	fh = open("testfile", "w")
	fh.write("This is my test file for exception handling!!")
except IOError:
	print ("Error: can\'t find file or read data")
else:
	print ("Written content in the file successfully")
	fh.close()

这产生了以下结果 -

Written content in the file successfully

这个例子试图打开一个你没有写权限的文件，所以会引发一个异常 -

#!/usr/bin/python3

try:
fh = open("testfile", "r")
fh.write("This is my test file for exception handling!!")
except IOError:
print ("Error: can\'t find file or read data")
else:
print ("Written content in the file successfully")

这产生了以下结果 -

Error: can't find file or read data

您也可以使用except语句，没有exceptions的定义如下

try:
	You do your operations here
	......................
except:
	If there is any exception, then execute this block.
	......................
else:
	If there is no exception then execute this block.

这种try-except语句捕获所有发生的异常。 虽然使用这种try-except语句并不被认为是一种很好的编程习惯，因为它捕获所有的异常，但不会让程序员确定可能发生的问题的根本原因。

您也可以使用相同的except语句来处理多个异常，如下所示 -

try:
	You do your operations here
	......................
except(Exception1[, Exception2[,...ExceptionN]]]):
	If there is any exception from the given exception list,
	then execute this block.
	......................
else:
	If there is no exception then execute this block.

try-finally语句

你可以使用finally：块和try：块。 finally：块是放置任何必须执行的代码的地方，无论try-block是否引发异常。 try-finally语句的语法是这样的 -

try:
	You do your operations here;
	......................
	Due to any exception, this may be skipped.
finally:
	This would always be executed.
	......................

注 - 您可以提供except子句或finally子句，但不能同时提供。 您不能使用else子句以及finally子句。

#!/usr/bin/python3

try:
	fh = open("testfile", "w")
	fh.write("This is my test file for exception handling!!")
finally:
	print ("Error: can\'t find file or read data")
	fh.close()

如果您无权以书面模式打开文件，则会产生以下结果 -

Error: can't find file or read data

同样的例子可以写得更干净如下 -

#!/usr/bin/python3

try:
	fh = open("testfile", "w")
	try:
		fh.write("This is my test file for exception handling!!")
	finally:
		print ("Going to close the file")
		fh.close()
except IOError:
	print ("Error: can\'t find file or read data")

当try块中抛出异常时，执行立即传递给finally块。 在finally块中的所有语句都执行完后，异常再次引发，并在except语句中处理，如果出现在try-except语句的下一个更高层中。

异常的参数

一个异常可以有一个参数，它是一个提供有关该问题的附加信息的值。 参数的内容因例外而异。 通过在except子句中提供一个变量来捕获异常的参数，如下所示 -

try:
	You do your operations here
	......................
except ExceptionType as Argument:
	You can print value of Argument here...

如果您编写处理单个异常的代码，则可以在except语句中使用一个变量来跟随异常的名称。 如果你正在捕获多个异常，你可以在异常的元组后面有一个变量。

该变量接收大多包含异常原因的异常值。 变量可以以元组的形式接收单个值或多个值。 该元组通常包含错误字符串，错误编号和错误位置。

以下是一个例外 -

#!/usr/bin/python3 # Define a function here. def temp_convert(var): try: return int(var) except ValueError as Argument: print ("The argument does not contain numbers\n", Argument) # Call above function here. temp_convert("xyz")

这产生了以下结果 -

The argument does not contain numbers
invalid literal for int() with base 10: 'xyz'

引发异常

您可以通过使用raise语句以几种方式引发异常。 raise语句的一般语法如下 -

raise [Exception [, args [, traceback]]]

这里，Exception是异常的类型（例如NameError），argument是异常参数的值。 该论点是可选的; 如果未提供，则异常参数为None。

最后一个参数traceback也是可选的（在实际中很少使用），如果存在，则是用于该异常的追踪对象。

异常可以是字符串，类或对象。 Python核心提出的大多数例外都是类，其中一个参数是该类的一个实例。 定义新的例外非常简单，可以按如下方式完成 -

def functionName( level ):
if level <1:
	raise Exception(level)
	# The code below to this would not be executed
	# if we raise the exception
	return level

注 - 为了捕获异常，“except”子句必须引用作为类对象或简单字符串引发的相同异常。 例如，要捕获上述异常，我们必须按如下方式编写except子句：

try:
	Business Logic here...
except Exception as e:
	Exception handling here using e.args...
else:
	Rest of the code here...

以下示例说明了引发异常的用法 -

#!/usr/bin/python3
def functionName( level ):
	if level <1:
		raise Exception(level)
		# The code below to this would not be executed
		# if we raise the exception
	return level
	
try:
	l = functionName(-10)
	print ("level = ",l)
except Exception as e:
	print ("error in level argument",e.args[0])

这将产生以下结果

error in level argument -10

用户自定义异常

Python还允许您通过从标准内置异常中派生类来创建自己的异常。

这里是一个与RuntimeError相关的例子。 在这里，创建一个从RuntimeError子类化的类。 当发现异常时需要显示更具体的信息时，这非常有用。

在try块中，用户定义的异常被引发并捕获到except块中。 变量e用于创建类Networkerror的实例。

class Networkerror(RuntimeError):
	def __init__(self, arg):
		self.args = arg

所以一旦你定义了上面的类，你可以举例如下 -

try:
	raise Networkerror("Bad hostname")
except Networkerror,e:
	print e.args