Python-开篇

Python是一种通用的解释型，交互式，面向对象的高级编程语言。它是由Guido van Rossum在1985-1990年间创建的。与Perl一样，Python源代码也可以在GNU通用公共许可证（GPL）下获得。Python是根据电视节目“ Monty Python's Flying Circus”命名的，而不是以Python（蛇）命名。

Python 3.0于2008年发布。尽管该版本应该向后不兼容，但后来又将其许多重要功能向后移植到与2.7版本兼容。本教程对Python 3版本编程语言有足够的了解。

为什么要学习Python 3?

Python是一种高级，解释性，交互式和面向对象的脚本语言。Python的设计具有很高的可读性。与其他语言使用标点符号一样，它经常使用英语关键字，并且其语法结构比其他语言更少。

对于学生和在职专业人员，Python是必不可少的工具，尤其是当他们在Web Development Domain中工作时，他们必须成为一名出色的软件工程师。我将列出学习Python的一些关键优势：

• Python被解释 -Python在运行时由解释器处理。在执行程序之前，无需编译程序。这类似于PERL和PHP。

• Python是交互式的 -您实际上可以坐在Python提示符下并直接与解释器进行交互以编写程序。

• Python是面向对象的-Python支持将对象封装在代码中的面向对象的样式或编程技术。

• Python是一种初学者的语言 -Python对于初学者来说是一种很棒的语言，它支持从简单文本处理到WWW浏览器再到游戏的各种应用程序的开发。

Python的特征

以下是python的重要特征-

• 它支持功能性和结构化编程方法以及OOP。

• 它可以用作脚本语言，也可以编译为字节码以构建大型应用程序。

• 它提供了非常高级的动态数据类型，并支持动态类型检查。

• 它支持自动垃圾收集。

• 它可以轻松地与C，C ++，COM，ActiveX，CORBA和Java集成。

使用Python的Hello World。

为了给您带来一些关于Python的兴奋，我将为您提供一个小的常规Python Hello World程序，您可以使用Demo链接进行尝试。

print "Hello, Python!"

Python的应用

如前所述，Python是网络上使用最广泛的语言之一。我将在这里列出其中一些：

• 易于学习 -Python具有少量关键字，简单的结构和清晰定义的语法。这使学生可以快速掌握语言。

• 易于阅读 -Python代码更清晰地定义并且对眼睛可见。

• 易于维护 -Python的源代码非常易于维护。

• 广泛的标准库 -Python的大部分库在UNIX，Windows和Macintosh上具有很高的可移植性和跨平台兼容性。

• 交互式模式 -Python支持交互式模式，该模式允许交互式测试和调试代码片段。

• 可移植 -Python可在多种硬件平台上运行，并且在所有平台上具有相同的接口。

• 可扩展的 -您可以将低级模块添加到Python解释器。这些模块使程序员能够添加或自定义其工具，从而提高效率。

• 数据库 -Python提供了到所有主要商业数据库的接口。

• GUI编程 -Python支持可以创建并移植到许多系统调用，库和Windows系统（例如Windows MFC，Macintosh和Unix的X Window系统）的GUI应用程序。

• 可扩展 -Python提供比Shell脚本更好的结构和对大型程序的支持。

适合人群

本教程是为希望将其Python技能升级到Python 3的软件程序员设计的。本教程还可以用于从头学习Python编程语言。

先决条件

您应该对计算机编程术语有基本的了解。对任何一种编程语言都有基本的了解是加分的。

Python 3的新增功能

future 模块
Python 3.x引入了一些Python 2不兼容的关键字和功能，可以通过Python 2中的内置future模块导入这些关键字和功能。如果您打算为代码提供Python 3.x支持，建议使用future导入。

例如，如果我们想在Python 2中使用Python 3.x的整数除法，请添加以下import语句。

from __future__ import division

打印功能

Python 3中最显着和最广为人知的更改是如何使用打印功能。现在必须在打印功能中使用括号（）。在Python 2中是可选的。

print "Hello World" #is acceptable in Python 2
print ("Hello World") # in Python 3, print must be followed by ()

默认情况下，print（）函数在末尾插入新行。在Python 2中，可以通过在最后加上'，'来抑制它。在Python 3中，“ end =''”会附加空格而不是换行符。

print x,           # Trailing comma suppresses newline in Python 2
print(x, end=" ")  # Appends a space instead of a newline in Python 3

从键盘读取输入

Python 2有两个版本的输入函数，input（）和raw_input（）。如果输入的数据包含在引号“或”中，则input（）函数会将其视为字符串，否则将其视为数字。

在Python 3中，不建议使用raw_input（）函数。此外，接收到的数据始终被视为字符串。

In Python 2

>>> x = input('something:') 
something:10 #entered data is treated as number
>>> x
10

>>> x = input('something:')
something:'10' #entered data is treated as string
>>> x
'10'

>>> x = raw_input("something:")
something:10 #entered data is treated as string even without ''
>>> x
'10'

>>> x = raw_input("something:")
something:'10' #entered data treated as string including ''
>>> x
"'10'"

In Python 3

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

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

>>> x = raw_input("something:") # will result NameError
Traceback (most recent call last):
   File "<pyshell#3>", line 1, in 
  <module>
   x = raw_input("something:")
NameError: name 'raw_input' is not defined

整数部

在Python 2中，将两个整数相除的结果四舍五入为最接近的整数。结果，3/2将显示1。为了获得浮点除法，必须将分子或分母明确用作浮点数。因此，如果3.0 / 2或3 / 2.0或3.0 / 2.0将得出1.5

Python 3默认将3/2评估为1.5，这对于新程序员来说更加直观。

Unicode表示

如果要存储为Unicode，Python 2要求您用au标记字符串。

默认情况下，Python 3将字符串存储为Unicode。我们有Unicode（utf-8）字符串和2个字节的类：字节和字节数组。

xrange（）函数已删除

在Python 2中，range（）返回一个列表，而xrange（）返回一个仅在需要时才生成范围内项目的对象，从而节省了内存。

在Python 3中，删除了range（）函数，并将xrange（）重命名为range（）。此外，range（）对象支持Python 3.2及更高版本中的切片。

引发例外

Python 2接受“旧”和“新”两种语法。如果我们不将括号中的异常参数括起来，Python 3会引发SyntaxError。

raise IOError, "file error" #This is accepted in Python 2
raise IOError("file error") #This is also accepted in Python 2
raise IOError, "file error" #syntax error is raised in Python 3
raise IOError("file error") #this is the recommended syntax in Python 3

异常参数
在Python 3中，异常参数应使用'as'关键字声明。

except Myerror, err: # In Python2
except Myerror as err: #In Python 3

next（）函数和.next（）方法

在Python 2中，允许将next（）作为生成器对象的方法。在Python 2中，还接受了对生成器对象进行迭代的next（）函数。但是，在Python 3中，将next（0作为生成器方法停用，并引发AttributeError。

gen = (letter for letter in 'Hello World') # creates generator object
next(my_generator) #allowed in Python 2 and Python 3
my_generator.next() #allowed in Python 2. raises AttributeError in Python 3

2to3实用程序

通常将2to3.py脚本与Python 3解释器一起安装在tools / scripts文件夹中。它读取Python 2.x源代码，并应用一系列修复程序将其转换为有效的Python 3.x代码。

Here is a sample Python 2 code (area.py):

def area(x,y = 3.14): 
   a = y*x*x
   print a
   return a

a = area(10)
print "area",a

To convert into Python 3 version:

$2to3 -w area.py

Converted code :

def area(x,y = 3.14): # formal parameters
   a = y*x*x
   print (a)
   return a

a = area(10)
print("area",a)

Python 3-概述

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

• Python被解释 -Python在运行时由解释器处理。在执行程序之前，无需编译程序。这类似于PERL和PHP。

• Python是交互式的 -您实际上可以坐在Python提示符下并直接与解释器进行交互以编写程序。

• Python是面向对象的-Python支持将对象封装在代码中的面向对象的样式或编程技术。

• Python是一种初学者的语言 -Python对于初学者来说是一种很棒的语言，它支持从简单文本处理到WWW浏览器再到游戏的各种应用程序的开发。

Python的历史

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

Python衍生自许多其他语言，包括ABC，Modula-3，C，C ++，Algol-68，SmallTalk和Unix Shell和其他脚本语言。

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

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

1994年11月发布了Python1.0。2000年，发布了Python 2.0。Python 2.7.11是Python 2的最新版本。

同时，Python 3.0于2008年发布。Python3不向后兼容Python2。Python3的重点在于删除重复的编程构造和模块，以便“应该有一个-最好只有一个-显而易见的方法。” 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应用程序。

• 可扩展 -Python提供比Shell脚本更好的结构和对大型程序的支持。

除了上述功能外，Python还有很多不错的功能。

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

Python 3-环境设置

Python 3适用于Windows，Mac OS和大多数Linux操作系统。尽管Python 2可用于许多其他操作系统，但尚未提供对Python 3的支持或已将其删除。

本地环境设置

打开一个终端窗口，然后键入“ python”以查明它是否已经安装以及安装了哪个版本。

获取Python

Windows平台

此下载页面上提供了最新版本的Python 3（Python 3.5.1）的二进制文件。

可以使用以下不同的安装选项。

• Windows x86-64可嵌入的zip文件
• Windows x86-64可执行安装程序
• Windows x86-64基于Web的安装程序
• Windows x86可嵌入的zip文件
• Windows x86可执行安装程序
• Windows x86基于Web的安装程序

注 –为了安装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下载压缩的tarball- 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

苹果系统

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

• Mac OS X 64位/ 32位安装程序-python-3.5.1-macosx10.6.pkg
• Mac OS X 32位i386 / PPC安装程序-python-3.5.1-macosx10.5.pkg

双击该程序包文件，然后按照向导说明进行安装。

最新的源代码，二进制文件，文档，新闻等可在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目录添加到Unix中特定会话的路径-

• 在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％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:>python script.py         # Windows/DOS

注意 -确保文件许可模式允许执行。

集成开发环境

如果您的系统上有支持Python的GUI应用程序，则也可以从图形用户界面（GUI）环境中运行Python。

• Unix -IDLE是第一个用于Python的Unix IDE。

• Windows - PythonWin是Python的第一个Windows界面，并且是带有GUI的IDE。

• Macintosh-可以从主网站上获得Macintosh版本的Python和IDLE IDE，可以将其下载为MacBinary或BinHex文件。

如果您无法正确设置环境，则可以寻求系统管理员的帮助。确保正确设置了Python环境，并且工作正常。

注 –后续章节中给出的所有示例均使用Windows 7和Ubuntu Linux上可用的Python 3.4.1版本执行。

我们已经在线设置了Python编程环境，以便您在学习理论的同时可以在线执行所有可用的示例。随意修改任何示例并在线执行。

Python 3-基本语法

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），则将括号用作打印功能是可选的。这产生以下结果-

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是区分大小写的编程语言。因此，“ 人力”和“ 人力”是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

file_finish = "end"
file_text = ""
contents=[]

file_name=input("Enter filename: ")
if len(file_name) == 0:
   print("Please enter filename")
   sys.exit()

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 = input("Enter text: ")
   contents.append(file_text)

   if file_text == file_finish:
      # close the file
      file.close()
      break

print(contents)
data = ' '.join([str(elem) for elem in contents])  
print(data)
file.write(data)
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')

多个语句组作为套件

组成单个代码块的单个语句组在Python 中称为套件。复合或复杂的语句，例如if，while，def和class需要标头行和套件。

标题行（使用关键字）以语句开头，并以冒号（：）结尾，然后是组成该套件的一行或多行。例如-

if expression : suite elif expression : suite else  : suite

命令行参数

可以运行许多程序来为您提供有关应如何运行的一些基本信息。蟒蛇使您能够做到这一点- ^ 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 3-变量类型

变量不过是用于存储值的保留内存位置。这意味着在创建变量时，将在内存中保留一些空间。

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

给变量赋值

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具有五种标准数据类型-

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

Python数字

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

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是虚数单位。

Python字符串

Python中的字符串被标识为用引号引起来的连续字符集。Python允许使用单引号或双引号。可以使用切片运算符（[]和[：]）来获取字符串的子集，其中的索引从字符串的开头开始为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

Python列表

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

可以使用切片运算符（[]和[：]）访问列表中存储的值，其中的索引从列表开头的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']

Python元组

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

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

#!/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

Python字典

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 3-基本运算符

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

运算符类型

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

• 算术运算符
• 比较（关系）运算符
• 赋值运算符
• 逻辑运算符
• 按位运算符
• 成员运算符
• 标识运算符

让我们一一看一下所有的运算符。

Python算术运算符

假设变量a的值为10，变量b的值为21，则-

#!/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)

Python比较运算符

这些运算符比较它们两侧的值并确定它们之间的关系。它们也称为关系运算符。

假设变量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")

Python赋值运算符

假设变量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)

Python按位运算符

按位运算符对位进行运算并执行逐位操作。假设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))

Python逻辑运算符

Python语言支持以下逻辑运算符。假设变量a保持True，变量b保持False，则-

Python成员运算符

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")

Python标识运算符

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

#!/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")

Python运算符优先级

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

#!/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)

Python 3-条件判断

条件判断是对程序执行期间发生的条件以及根据条件采取的指定操作的预期。

条件判断多个表达式，这些表达式产生TRUE或FALSE作为结果。如果结果为TRUE或FALSE，则需要确定要执行的操作以及要执行的语句。

以下是大多数编程语言中常见的典型条件判断的一般形式-

做决定

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

Python编程语言提供以下类型的条件判断语句。

if语句

#!/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!")

if...else语句

#!/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)

嵌套if语句

# !/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")

注意：如果if子句仅包含一行，则它可能与header语句位于同一行。

#!/usr/bin/python3
var = 100
if ( var  == 100 ) : print ("Value of expression is 100")
print ("Good bye!")

Python 3-循环

通常，语句按顺序执行-函数中的第一个语句首先执行，然后执行第二个，依此类推。在某些情况下，您需要多次执行一个代码块。

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

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

循环架构

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

循环样例1

#!/usr/bin/python3

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

print ("Good bye!")

循环样例2

#!/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!")

循环样例3

#!/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")

循环样例4

#!/usr/bin/python3

flag = 1
while (flag): print ('Given flag is really true!')
print ("Good bye!")

循环控制语句

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

Python支持以下控制语句。

中断声明样例1

#!/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

print ("Good bye!")

中断声明样例2

#!/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')

继续声明样例1

#!/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!")

通过声明样例1

#!/usr/bin/python3

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

print ("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

发生器是产生或产生使用产量的方法值的序列的功能。

调用生成器函数时，它甚至不开始执行该函数就返回生成器对象。首次调用next（）方法时，该函数开始执行直到到达yield语句，该语句返回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()

Python 3-数字

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

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

var1 =  1 
var2 =  10

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

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

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

del  var  
del var_a, var_b

Python支持不同的数值类型-

• int（有符号整数） -它们通常仅称为整数或ints。它们是没有小数点的正或负整数。Python 3中的整数没有大小限制。Python 2有两种整数类型-int和long。Python 3中不再有“ 长整数 ”了。

• float（浮点实数值） -也称为浮点数，它们表示实数，并用小数点表示，该整数除以整数和小数部分。浮点数也可以用科学计数法表示，E或e表示10的幂（2.5e2 = 2.5 x 10 ² = 250）。

• 复数（复数） -形式为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转换为纯整数。

• long（x）将x转换为长整数。

• float（x）将x转换为浮点数。

• complex（x）将x转换为具有实部x和虚部为零的复数。

• complex（x，y）将x和y转换为具有实部x和虚部y的复数。x和y是数字表达式

数学函数

Python包含以下用于执行数学计算的函数。

#!/usr/bin/python3
import math   # This will import math module

print ("abs(-45) : ", abs(-45))
print ("abs(100.12) : ", abs(100.12))

print ("math.ceil(-45.17) : ", math.ceil(-45.17))
print ("math.ceil(100.12) : ", math.ceil(100.12))
print ("math.ceil(100.72) : ", math.ceil(100.72))
print ("math.ceil(math.pi) : ", math.ceil(math.pi))

print ("math.cmp(1,2) : ", math.cmp(1,2) )
print ("math.cmp(2,1) : ", math.cmp(2,1) )
print ("math.cmp(2,2) : ", math.cmp(2,2) )

print ("math.exp(-45.17) : ", math.exp(-45.17))
print ("math.exp(100.12) : ", math.exp(100.12))
print ("math.exp(100.72) : ", math.exp(100.72))
print ("math.exp(math.pi) : ", math.exp(math.pi))

print ("math.fabs(-45.17) : ", math.fabs(-45.17))
print ("math.fabs(100.12) : ", math.fabs(100.12))
print ("math.fabs(100.72) : ", math.fabs(100.72))
print ("math.fabs(math.pi) : ", math.fabs(math.pi))

print ("math.floor(-45.17) : ", math.floor(-45.17))
print ("math.floor(100.12) : ", math.floor(100.12))
print ("math.floor(100.72) : ", math.floor(100.72))
print ("math.floor(math.pi) : ", math.floor(math.pi))

print ("math.log(100.12) : ", math.log(100.12))
print ("math.log(100.72) : ", math.log(100.72))
print ("math.log(math.pi) : ", math.log(math.pi))

print ("math.log10(100.12) : ", math.log10(100.12))
print ("math.log10(100.72) : ", math.log10(100.72))
print ("math.log10(119) : ", math.log10(119))
print ("math.log10(math.pi) : ", math.log10(math.pi))

print ("max(80, 100, 1000) : ", max(80, 100, 1000))
print ("max(-20, 100, 400) : ", max(-20, 100, 400))
print ("max(-80, -20, -10) : ", max(-80, -20, -10))
print ("max(0, 100, -400) : ", max(0, 100, -400))

print ("min(80, 100, 1000) : ", min(80, 100, 1000))
print ("min(-20, 100, 400) : ", min(-20, 100, 400))
print ("min(-80, -20, -10) : ", min(-80, -20, -10))
print ("min(0, 100, -400) : ", min(0, 100, -400))

print ("math.modf(100.12) : ", math.modf(100.12))
print ("math.modf(100.72) : ", math.modf(100.72))
print ("math.modf(119) : ", math.modf(119))
print ("math.modf(math.pi) : ", math.modf(math.pi))

print ("math.pow(100, 2) : ", math.pow(100, 2))
print ("math.pow(100, -2) : ", math.pow(100, -2))
print ("math.pow(2, 4) : ", math.pow(2, 4))
print ("math.pow(3, 0) : ", math.pow(3, 0))

print ("round(70.23456) : ", round(70.23456))
print ("round(56.659,1) : ", round(56.659,1))
print ("round(80.264, 2) : ", round(80.264, 2))
print ("round(100.000056, 3) : ", round(100.000056, 3))
print ("round(-100.000056, 3) : ", round(-100.000056, 3))

print ("math.sqrt(100) : ", math.sqrt(100))
print ("math.sqrt(7) : ", math.sqrt(7))
print ("math.sqrt(math.pi) : ", math.sqrt(math.pi))

随机数函数

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

#!/usr/bin/python3
import random

print ("returns a random number from range(100) : ",random.choice(range(100)))
print ("returns random element from list [1, 2, 3, 5, 9]) : ", random.choice([1, 2, 3, 5, 9]))
print ("returns random character from string 'Hello World' : ", random.choice('Hello World'))

# randomly select an odd number between 1-100 
print ("randrange(1,100, 2) : ", random.randrange(1, 100, 2))
# randomly select a number between 0-99 
print ("randrange(100) : ", random.randrange(100))

# First random number
print ("random() : ", random.random())
# Second random number
print ("random() : ", random.random())

random.seed()
print ("random number with default seed", random.random())
random.seed(10)
print ("random number with int seed", random.random())
random.seed("hello",2)
print ("random number with string seed", random.random())

list = [20, 16, 10, 5];
random.shuffle(list)
print ("Reshuffled list : ",  list)

random.shuffle(list)
print ("Reshuffled list : ",  list)

print ("Random Float uniform(5, 10) : ",  random.uniform(5, 10))
print ("Random Float uniform(7, 14) : ",  random.uniform(7, 14))

三角函数

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

#!/usr/bin/python3
import math

print ("acos(0.64) : ",  math.acos(0.64))
print ("acos(0) : ",  math.acos(0))
print ("acos(-1) : ",  math.acos(-1))
print ("acos(1) : ",  math.acos(1))

print ("asin(0.64) : ",  math.asin(0.64))
print ("asin(0) : ",  math.asin(0))
print ("asin(-1) : ",  math.asin(-1))
print ("asin(1) : ",  math.asin(1))

print ("atan(0.64) : ",  math.atan(0.64))
print ("atan(0) : ",  math.atan(0))
print ("atan(10) : ",  math.atan(10))
print ("atan(-1) : ",  math.atan(-1))
print ("atan(1) : ",  math.atan(1))

print ("atan2(-0.50,-0.50) : ",  math.atan2(-0.50,-0.50))
print ("atan2(0.50,0.50) : ",  math.atan2(0.50,0.50))
print ("atan2(5,5) : ",  math.atan2(5,5))
print ("atan2(-10,10) : ",  math.atan2(-10,10))
print ("atan2(10,20) : ",  math.atan2(10,20))

print ("cos(3) : ",  math.cos(3))
print ("cos(-3) : ",  math.cos(-3))
print ("cos(0) : ",  math.cos(0))
print ("cos(math.pi) : ",  math.cos(math.pi))
print ("cos(2*math.pi) : ",  math.cos(2*math.pi))

print ("hypot(3, 2) : ",  math.hypot(3, 2))
print ("hypot(-3, 3) : ",  math.hypot(-3, 3))
print ("hypot(0, 2) : ",  math.hypot(0, 2))

print ("sin(3) : ",  math.sin(3))
print ("sin(-3) : ",  math.sin(-3))
print ("sin(0) : ",  math.sin(0))
print ("sin(math.pi) : ",  math.sin(math.pi))
print ("sin(math.pi/2) : ",  math.sin(math.pi/2))

print ("(tan(3) : ",  math.tan(3))
print ("tan(-3) : ",  math.tan(-3))
print ("tan(0) : ",  math.tan(0))
print ("tan(math.pi) : ",  math.tan(math.pi))
print ("tan(math.pi/2) : ",  math.tan(math.pi/2))
print ("tan(math.pi/4) : ",  math.tan(math.pi/4))

print ("degrees(3) : ",  math.degrees(3))
print ("degrees(-3) : ",  math.degrees(-3))
print ("degrees(0) : ",  math.degrees(0))
print ("degrees(math.pi) : ",  math.degrees(math.pi))
print ("degrees(math.pi/2) : ",  math.degrees(math.pi/2))
print ("degrees(math.pi/4) : ",  math.degrees(math.pi/4))

print ("radians(3) : ",  math.radians(3))
print ("radians(-3) : ",  math.radians(-3))
print ("radians(0) : ",  math.radians(0))
print ("radians(math.pi) : ",  math.radians(math.pi))
print ("radians(math.pi/2) : ",  math.radians(math.pi/2))
print ("radians(math.pi/4) : ",  math.radians(math.pi/4))

数学常数

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

Python 3-字符串

字符串是Python中最流行的类型之一。我们只需将字符括在引号中即可创建它们。Python将单引号与双引号相同。创建字符串就像将值分配给变量一样简单。例如-

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

访问字符串中的值

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

要访问子字符串，请使用方括号和一个或多个索引进行切片以获得您的子字符串。例如-

#!/usr/bin/python3

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

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

更新字符串

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

#!/usr/bin/python3

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

转义字符

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

转义字符被解释；用单引号和双引号引起来。

字符串特殊运算符

假设字符串变量a持有“ Hello”，变量b持有“ Python”，则-
参考列表：

字符串格式化运算符

Python最酷的功能之一是字符串格式运算符％。该运算符是字符串所独有的，并弥补了C的printf（）系列具有的功能。以下是一个简单的例子-

#!/usr/bin/python3

print ("My name is %s and weight is %d kg!" % ('Zara', 21)) 

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

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

三引号

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

三重引号的语法包含三个连续的单引号或双引号。

#!/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)

原始字符串根本不会将反斜杠视为特殊字符。您输入到原始字符串中的每个字符都保持您编写它的方式-

#!/usr/bin/python3

print ('C:\\nowhere')

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

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

Unicode字串

在Python 3中，所有字符串均以Unicode表示。在Python 2中，内部存储为8位ASCII，因此需要附加'u'使其成为Unicode。现在不再需要。

内置字符串方法
Python包含以下内置方法来处理字符串-

#!/usr/bin/python3

str = "this is string example....wow!!!"
print ("str.capitalize() : ", str.capitalize())

str = "this is string example....wow!!!"
print ("str.center(40, 'a') : ", str.center(40, 'a'))

str = "this is string example....wow!!!"
sub = 'i'
print ("str.count('i') : ", str.count(sub))
sub = 'exam'
print ("str.count('exam', 10, 40) : ", str.count(sub,10,40))

Str = "this is string example....wow!!!";
Str = Str.encode('base64','strict');

print "Encoded String: " + Str
print "Decoded String: " + Str.decode('base64','strict')

import base64

Str = "this is string example....wow!!!"
Str = base64.b64encode(Str.encode('utf-8',errors = 'strict'))

print ("Encoded String: " , Str)

Str = 'this is string example....wow!!!'
suffix = '!!'
print (Str.endswith(suffix))
print (Str.endswith(suffix,20))

suffix = 'exam'
print (Str.endswith(suffix))
print (Str.endswith(suffix, 0, 19))

str = "this is\tstring example....wow!!!"
print ("Original string: " + str)
print ("Defualt exapanded tab: " +  str.expandtabs())
print ("Double exapanded tab: " +  str.expandtabs(16))

str1 = "this is string example....wow!!!"
str2 = "exam";

print (str1.find(str2))
print (str1.find(str2, 10))
print (str1.find(str2, 40))

str1 = "this is string example....wow!!!"
str2 = "exam";

print (str1.index(str2))
print (str1.index(str2, 10))
print (str1.index(str2, 40))

str = "this2016"  # No space in this string
print (str.isalnum())

str = "this is string example....wow!!!"
print (str.isalnum())

str = "this";  # No space & digit in this string
print (str.isalpha())

str = "this is string example....wow!!!"
print (str.isalpha())

str = "123456";  # Only digit in this string
print (str.isdigit())

str = "this is string example....wow!!!"
print (str.isdigit())

str = "THIS is string example....wow!!!"
print (str.islower())

str = "this is string example....wow!!!"
print (str.islower())

str = "this2016"  
print (str.isnumeric())

str = "23443434"
print (str.isnumeric())

str = "       " 
print (str.isspace())

str = "This is string example....wow!!!"
print (str.isspace())

str = "This Is String Example...Wow!!!"
print (str.istitle())

str = "This is string example....wow!!!"
print (str.istitle())

str = "THIS IS STRING EXAMPLE....WOW!!!"
print (str.isupper())

str = "THIS is string example....wow!!!"
print (str.isupper())

s = "-"
seq = ("a", "b", "c") # This is sequence of strings.
print (s.join( seq ))

str = "this is string example....wow!!!"
print ("Length of the string: ", len(str))

str = "this is string example....wow!!!"
print str.ljust(50, '*')

str = "THIS IS STRING EXAMPLE....WOW!!!"
print (str.lower())

str = "     this is string example....wow!!!"
print (str.lstrip())

str = "*****this is string example....wow!!!*****"
print (str.lstrip('*'))

intab = "aeiou"
outtab = "12345"
trantab = str.maketrans(intab, outtab)

str = "this is string example....wow!!!"
print (str.translate(trantab))

str = "this is a string example....really!!!"
print ("Max character: " + max(str))

str = "this is a string example....wow!!!"
print ("Max character: " + max(str))

str = "www.tutorialspoint.com"
print ("Min character: " + min(str))

str = "TUTORIALSPOINT"
print ("Min character: " + min(str))

str = "this is string example....wow!!! this is really string"
print (str.replace("is", "was"))
print (str.replace("is", "was", 3))

str1 = "this is really a string example....wow!!!"
str2 = "is"

print (str1.rfind(str2))
print (str1.rfind(str2, 0, 10))
print (str1.rfind(str2, 10, 0))

print (str1.find(str2))
print (str1.find(str2, 0, 10))
print (str1.find(str2, 10, 0))

str1 = "this is really a string example....wow!!!"
str2 = "is"

print (str1.rindex(str2))
print (str1.rindex(str2,10))

str = "this is string example....wow!!!"
print (str.rjust(50, '*'))

str = "     this is string example....wow!!!     "
print (str.rstrip())

str = "*****this is string example....wow!!!*****"
print (str.rstrip('*'))

str = "this is string example....wow!!!"
print (str.split( ))
print (str.split('i',1))
print (str.split('w'))

str = "this is \nstring example....\nwow!!!"
print (str.splitlines( ))

str = "this is string example....wow!!!"
print (str.startswith( 'this' ))
print (str.startswith( 'string', 8 ))
print (str.startswith( 'this', 2, 4 ))

str = "*****this is string example....wow!!!*****"
print (str.strip( '*' ))

str = "this is string example....wow!!!"
print (str.swapcase())

str = "This Is String Example....WOW!!!"
print (str.swapcase())

str = "this is string example....wow!!!"
print (str.title())

from string import maketrans # Required to call maketrans function.

intab = "aeiou"
outtab = "12345"
trantab = maketrans(intab, outtab)

str = "this is string example....wow!!!";
print (str.translate(trantab))

str = "this is string example....wow!!!"
print ("str.upper : ",str.upper())

str = "this is string example....wow!!!"
print ("str.zfill : ",str.zfill(40))
print ("str.zfill : ",str.zfill(50))

str = "this2016"
print (str.isdecimal())

str = "23443434"
print (str.isdecimal())

Python 3-列表

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

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])

更新清单

您可以通过在赋值运算符的左侧提供切片来更新列表的单个或多个元素，并可以使用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（）方法。

删除列表元素

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

#!/usr/bin/python3 
list =  ['physics',  'chemistry',  1997,  2000]  
print  (list)  
del list[2]  
print  ("After deleting value at index 2 : ", list)

注意 -remove（）方法将在后续章节中讨论。

基本清单操作

列表对+和*运算符的响应非常类似于字符串；它们在这里也意味着串联和重复，只是结果是一个新列表，而不是字符串。

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

索引，切片和矩阵

由于列表是序列，因此索引和切片对列表的作用与对字符串的作用相同。

假设以下输入-

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

内置列表功能和方法

Python包含以下列表函数-

#!/usr/bin/python3
list1 = ['physics', 'chemistry', 'maths']
print (len(list1))

list2 = list(range(5)) #creates list of numbers between 0-4
print (len(list2))

list1, list2 = ['C++','Java', 'Python'], [456, 700, 200]
print ("Max value element : ", max(list1))
print ("Max value element : ", max(list2))

list1, list2 = ['C++','Java', 'Python'], [456, 700, 200]
print ("min value element : ", min(list1))
print ("min value element : ", min(list2))

list1, list2 = ['C++','Java', 'Python'], [456, 700, 200]
print ("min value element : ", min(list1))
print ("min value element : ", min(list2))

aTuple = (123, 'C++', 'Java', 'Python')
list1 = list(aTuple)
print ("List elements : ", list1)

str = "Hello World"

list2 = list(str)
print ("List elements : ", list2)

Python包括以下列表方法-

#!/usr/bin/python3

list1 = ['C++', 'Java', 'Python']
list1.append('C#')
print ("updated list : ", list1)

aList = [123, 'xyz', 'zara', 'abc', 123];

print ("Count for 123 : ", aList.count(123))
print ("Count for zara : ", aList.count('zara'))

list1 = ['physics', 'chemistry', 'maths']
list2 = list(range(5))     #creates list of numbers between 0-4
list1.extend(list2)
print ('Extended List :', list1)

list1 = ['physics', 'chemistry', 'maths']
print ('Index of chemistry', list1.index('chemistry'))
print ('Index of C#', list1.index('C#'))

list1 = ['physics', 'chemistry', 'maths']
list1.insert(1, 'Biology')
print ('Final list : ', list1)

list1 = ['physics', 'Biology', 'chemistry', 'maths']
list1.pop()
print ("list now : ", list1)

list1.pop(1)
print ("list now : ", list1)

list1 = ['physics', 'Biology', 'chemistry', 'maths']
list1.remove('Biology')
print ("list now : ", list1)
list1.remove('maths')
print ("list now : ", list1)

list1 = ['physics', 'Biology', 'chemistry', 'maths']
list1.reverse()
print ("list now : ", list1)

list1 = ['physics', 'Biology', 'chemistry', 'maths']
list1.sort()
print ("list now : ", list1)

Python 3-元组

元组是有序且不可变的对象的集合。元组是序列，就像列表一样。元组和列表之间的主要区别在于，与列表不同，不能更改元组。元组使用括号，而列表使用方括号。

创建元组就像放置不同的逗号分隔值一样简单。您也可以选择将这些逗号分隔的值放在括号之间。例如-

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])

更新元组

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

#!/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)

删除元组元素

无法删除单个元组元素。当然，将另一个元组与不想要的元素丢弃在一起并没有错。

要显式删除整个元组，只需使用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

元组基本操作

元组对+和*运算符的响应非常类似于字符串；它们在这里也意味着串联和重复，只是结果是一个新的元组，而不是字符串。

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

索引，切片和矩阵

由于元组是序列，因此假设以下输入，对元组进行索引和切片的方式与对字符串进行处理的方式相同：

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

没有封闭的分隔符

如以下简短示例所示，没有任何封闭的定界符是用逗号分隔的多个对象的任何集合，这些对象用逗号分隔，没有标识符号，即列表的括号，元组的括号等，默认情况下为元组。

内置元组功能

Python包含以下元组函数-

#!/usr/bin/python3

tuple1, tuple2 = (123, 'xyz'), (456, 'abc')

print cmp(tuple1, tuple2)
print cmp(tuple2, tuple1)
tuple3 = tuple2 + (786,);
print cmp(tuple2, tuple3)

tuple1, tuple2 = (123, 'xyz', 'zara'), (456, 'abc')
print ("First tuple length : ", len(tuple1))
print ("Second tuple length : ", len(tuple2))

tuple1, tuple2 = ('maths', 'che', 'phy', 'bio'), (456, 700, 200)
print ("Max value element : ", max(tuple1))
print ("Max value element : ", max(tuple2))

tuple1, tuple2 = ('maths', 'che', 'phy', 'bio'), (456, 700, 200)
print ("min value element : ", min(tuple1))
print ("min value element : ", min(tuple2))

list1 = ['maths', 'che', 'phy', 'bio']
tuple1 = tuple(list1)
print ("tuple elements : ", tuple1)

Python 3-字典

每个键都由一个冒号（:)与其值分隔，各项目之间以逗号分隔，并且整个内容都用花括号括起来。一个没有任何项目的空字典仅用两个大括号书写，例如：{}。

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

在字典中访问值

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

#!/usr/bin/python3

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

如果我们尝试使用不是字典一部分的键来访问数据项，则会出现如下错误：

#!/usr/bin/python3

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
print ("dict['Alice']: ", dict['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'])

删除字典元素

您可以删除单个词典元素，也可以清除词典的全部内容。您也可以通过单个操作删除整个词典。

要显式删除整个字典，只需使用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之后，字典不再存在。

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对象，可以是标准对象或用户定义的对象。但是，对于密钥来说并非如此。

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

（a）每个密钥不允许输入多个。这意味着不允许重复的密钥。如果在分配过程中遇到重复的键，则以最后一个分配为准。例如-

#!/usr/bin/python3

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

（b）键必须是不变的。这意味着您可以使用字符串，数字或元组作为字典键，但是不允许使用['key']之类的东西。以下是一个简单的例子-

#!/usr/bin/python3

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

内置词典功能和方法

Python包含以下字典函数-

Python包括以下字典方法-

#!/usr/bin/python3

dict1 = {'Name': 'Zara', 'Age': 7};
dict2 = {'Name': 'Mahnaz', 'Age': 27};
dict3 = {'Name': 'Abid', 'Age': 27};
dict4 = {'Name': 'Zara', 'Age': 7};
print "Return Value : %d" %  cmp (dict1, dict2)
print "Return Value : %d" %  cmp (dict2, dict3)
print "Return Value : %d" %  cmp (dict1, dict4)

dict = {'Name': 'Manni', 'Age': 7, 'Class': 'First'}
print ("Length : %d" % len (dict))

dict = {'Name': 'Manni', 'Age': 7, 'Class': 'First'}
print ("Equivalent String : %s" % str (dict))

dict = {'Name': 'Manni', 'Age': 7, 'Class': 'First'}
print ("Variable Type : %s" %  type (dict))

dict = {'Name': 'Zara', 'Age': 7}
print ("Start Len : %d" %  len(dict))

dict.clear()
print ("End Len : %d" %  len(dict))

dict1 = {'Name': 'Manni', 'Age': 7, 'Class': 'First'}
dict2 = dict1.copy()
print ("New Dictionary : ",dict2)

seq = ('name', 'age', 'sex')

dict = dict.fromkeys(seq)
print ("New Dictionary : %s" %  str(dict))

dict = dict.fromkeys(seq, 10)
print ("New Dictionary : %s" %  str(dict))

dict = {'Name': 'Zara', 'Age': 27}

print ("Value : %s" %  dict.get('Age'))
print ("Value : %s" %  dict.get('Sex', "NA"))

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

print ("Value : %s" %  dict.has_key('Age'))
print ("Value : %s" %  dict.has_key('Sex'))

dict = {'Name': 'Zara', 'Age': 7}
print ("Value : %s" %  dict.items())

dict = {'Name': 'Zara', 'Age': 7}
print ("Value : %s" %  dict.items())

dict = {'Name': 'Zara', 'Age': 7}
print ("Value : %s" %  dict.keys())

dict = {'Name': 'Zara', 'Age': 7}
print ("Value : %s" %  dict.setdefault('Age', None))
print ("Value : %s" %  dict.setdefault('Sex', None))
print (dict)

dict = {'Name': 'Zara', 'Age': 7}
dict2 = {'Sex': 'female' }

dict.update(dict2)
print ("updated dict : ", dict)

dict = {'Sex': 'female', 'Age': 7, 'Name': 'Zara'}
print ("Values : ",  list(dict.values()))

Python 3 - Date & Time

• https://www.tutorialspoint.com/python3