葵花宝典教程,一个自学编程平台

葵花宝典教程,一个自学编程平台

Python - 异常处理

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


异常处理- 这将在本教程中介绍。这是 Python 中可用的标准异常列表:标准异常。


Assertions - 这将在 Python教程中的 Assertions 中介绍。


标准例外列表 -


编号 异常名称和描述

1

例外


所有异常的基类


2

停止迭代


当迭代器的 next() 方法不指向任何对象时引发。


3

系统退出


由 sys.exit() 函数引发。


4

标准错误


除 StopIteration 和 SystemExit 之外的所有内置异常的基类。


5

算术错误


数值计算发生的所有错误的基类。


6

溢出错误


当计算超出数值类型的最大限制时引发。


7

浮点错误


当浮点计算失败时引发。


8

零除法错误


当所有数字类型发生除零或模零时引发。


9

断言错误


在 Assert 语句失败的情况下引发。


10

属性错误


在属性引用或分配失败的情况下引发。


11

EOF错误


当 raw_input() 或 input() 函数没有输入并且到达文件末尾时引发。


12

导入错误


当导入语句失败时引发。


13

键盘中断


当用户中断程序执行时引发,通常通过按 Ctrl+c。


14

查找错误


所有查找错误的基类。


15

索引错误


在序列中未找到索引时引发。


16

键错误


当在字典中找不到指定的键时引发。


17

名称错误


在本地或全局命名空间中找不到标识符时引发。


18

UnboundLocalError


尝试访问函数或方法中的局部变量但未为其分配值时引发。


19

环境错误


在 Python 环境之外发生的所有异常的基类。


20

IO错误


当输入/输出操作失败时引发,例如尝试打开不存在的文件时的 print 语句或 open() 函数。


21

IO错误


针对与操作系统相关的错误引发。


22

语法错误


当 Python 语法出现错误时引发。


23

缩进错误


未正确指定缩进时引发。


24

系统错误


当解释器发现内部问题时引发,但遇到此错误时 Python 解释器不会退出。


25

系统退出


当使用 sys.exit() 函数退出 Python 解释器时引发。如果未在代码中处理,则导致解释器退出。


26

类型错误


当尝试对指定数据类型无效的操作或函数时引发。


27

值错误


当数据类型的内置函数具有有效的参数类型,但参数指定的值无效时引发。


28

运行时错误


当生成的错误不属于任何类别时引发。


29

未实现错误


当需要在继承的类中实现的抽象方法没有实际实现时引发。


Python 中的断言

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


考虑断言的最简单方法是将其比作raise-if语句(或者更准确地说,是 raise-if-not 语句)。测试表达式,如果结果为假,则引发异常。


断言由 assert 语句执行,它是 Python 的最新关键字,在 1.5 版中引入。


程序员经常在函数开头放置断言以检查有效输入,并在函数调用之后检查有效输出。


断言声明_

当遇到断言语句时,Python 会计算伴随的表达式,希望这是真的。如果表达式为假,Python 会引发AssertionError异常。


断言的语法是 -


assert Expression[, Arguments]

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


例子

这是一个将温度从开尔文度转换为华氏度的函数。由于开氏零度的温度非常低,因此如果它看到负温度,该功能就会退出 -


现场演示

#!/usr/bin/python

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 <module>

print KelvinToFahrenheit(-5)

File "test.py", line 4, in KelvinToFahrenheit

assert (Temperature >= 0),"Colder than absolute zero!"

AssertionError: Colder than absolute zero!

什么是异常?

异常是在程序执行期间发生的事件,它破坏了程序指令的正常流程。通常,当 Python 脚本遇到无法应对的情况时,它会引发异常。异常是表示错误的 Python 对象。


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


处理异常

如果您有一些可能引发异常的可疑代码,您可以通过将可疑代码放在try:块中来保护您的程序。在 try: 块之后,包含一个except:语句,然后是一个尽可能优雅地处理问题的代码块。


句法

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


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 块中的代码。


else 块是不需要 try: 块保护的代码的好地方。


例子

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


现场演示

#!/usr/bin/python


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/python


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子句

您还可以使用 except 语句,没有异常定义如下 -


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子句

您还可以使用相同的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 块是否引发异常。try-finally 语句的语法是这样的 -


try:

   You do your operations here;

   ......................

   Due to any exception, this may be skipped.

finally:

   This would always be executed.

   ......................

您不能同时使用else子句和 finally 子句。


例子

现场演示

#!/usr/bin/python


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"

如果您无权以写入模式打开文件,则会产生以下结果 -


Error: can't find file or read data

同样的例子可以写得更清楚如下 -


现场演示

#!/usr/bin/python


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块中的所有语句都执行完之后,再次引发异常,如果出现在try-except语句的下一个更高层中,则在except语句中处理。


异常论证

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


try:

   You do your operations here;

   ......................

except ExceptionType, Argument:

   You can print value of Argument here...

如果您编写代码来处理单个异常,则可以在 except 语句中的异常名称后面添加一个变量。如果要捕获多个异常,则可以在异常的元组后面添加一个变量。


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


例子

以下是单个异常的示例 -


现场演示

#!/usr/bin/python


# Define a function here.

def temp_convert(var):

   try:

      return int(var)

   except ValueError, 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是异常参数的值。参数是可选的;如果未提供,则异常参数为无。


最后一个参数 traceback 也是可选的(在实践中很少使用),如果存在,它是用于异常的 traceback 对象。


例子

异常可以是字符串、类或对象。Python 核心引发的大多数异常都是类,其参数是类的实例。定义新的异常非常容易,可以按如下方式完成 -


def functionName( level ):

   if level < 1:

      raise "Invalid level!", level

      # The code below to this would not be executed

      # if we raise the exception

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


try:

   Business Logic here...

except "Invalid level!":

   Exception handling here...

else:

   Rest of the code here...

用户定义的异常

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


Python - 文件 I/O

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


打印到屏幕

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


现场演示

#!/usr/bin/python


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

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


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

阅读键盘输入

Python 提供了两个内置函数来从标准输入中读取一行文本,默认情况下来自键盘。这些功能是 -


原始输入

输入

raw_input函数_

raw_input([prompt])函数从标准输入中读取一行并将其作为字符串返回(删除尾随的换行符)。


#!/usr/bin/python


str = raw_input("Enter your input: ")

print "Received input is : ", str

这会提示您输入任何字符串,它会在屏幕上显示相同的字符串。当我输入“Hello Python!”时,它的输出是这样的 -


Enter your input: Hello Python

Received input is :  Hello Python

输入函数_

input ( [prompt])函数等效于 raw_input,除了它假定输入是有效的 Python 表达式并将计算结果返回给您。


#!/usr/bin/python


str = input("Enter your input: ")

print "Received input is : ", str

这将针对输入的输入产生以下结果 -


Enter your input: [x*5 for x in range(2,10,2)]

Recieved input is :  [10, 20, 30, 40]

打开和关闭文件

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


默认情况下,Python 提供了操作文件所需的基本函数和方法。您可以使用文件对象进行大部分文件操作。


开放功能_

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


句法

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

以下是参数详细信息 -


file_name - file_name 参数是一个字符串值,其中包含您要访问的文件的名称。


access_mode - access_mode 确定必须打开文件的模式,即读取、写入、追加等。下表中给出了可能值的完整列表。这是可选参数,默认文件访问模式为读取 (r)。


buffering - 如果缓冲值设置为 0,则不会发生缓冲。如果缓冲值为 1,则在访问文件时执行行缓冲。如果将缓冲值指定为大于 1 的整数,则使用指示的缓冲区大小执行缓冲操作。如果为负,则缓冲区大小为系统默认值(默认行为)。


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


编号 模式和说明

1

r


打开一个只读文件。文件指针位于文件的开头。这是默认模式。


2

rb


以二进制格式打开一个只读文件。文件指针位于文件的开头。这是默认模式。


3

r+


打开一个文件进行读写。放置在文件开头的文件指针。


4

rb+


以二进制格式打开一个文件进行读写。放置在文件开头的文件指针。


5

w


打开一个仅用于写入的文件。如果文件存在,则覆盖文件。如果文件不存在,则创建一个新文件进行写入。


6

wb


打开一个仅以二进制格式写入的文件。如果文件存在,则覆盖文件。如果文件不存在,则创建一个新文件进行写入。


7

w+


打开一个文件进行写入和读取。如果文件存在,则覆盖现有文件。如果文件不存在,则创建一个新文件进行读写。


8

wb+


打开一个文件以二进制格式写入和读取。如果文件存在,则覆盖现有文件。如果文件不存在,则创建一个新文件进行读写。


9

一种


打开要追加的文件。如果文件存在,则文件指针位于文件末尾。也就是说,文件处于附加模式。如果文件不存在,它会创建一个新文件进行写入。


10

抗体


打开一个文件以二进制格式追加。如果文件存在,则文件指针位于文件末尾。也就是说,文件处于附加模式。如果文件不存在,它会创建一个新文件进行写入。


11

一个+


打开一个文件以进行追加和读取。如果文件存在,则文件指针位于文件末尾。该文件以附加模式打开。如果该文件不存在,则创建一个新文件进行读写。


12

ab+


以二进制格式打开一个文件以进行追加和读取。如果文件存在,则文件指针位于文件末尾。该文件以附加模式打开。如果该文件不存在,则创建一个新文件进行读写。


文件对象属性

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


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


编号 属性和描述

1

文件关闭


如果文件已关闭,则返回 true,否则返回 false。


2

文件模式


返回打开文件的访问模式。


3

文件名


返回文件的名称。


4

文件.softspace


如果 print 明确需要空间,则返回 false,否则返回 true。


例子

现场演示

#!/usr/bin/python


# 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

print "Softspace flag : ", fo.softspace

这会产生以下结果 -


Name of the file:  foo.txt

Closed or not :  False

Opening mode :  wb

Softspace flag :  0

close( )方法

文件对象的 close() 方法会刷新所有未写入的信息并关闭文件对象,之后就不能再进行写入了。


当一个文件的引用对象被重新分配给另一个文件时,Python 会自动关闭一个文件。使用 close() 方法关闭文件是一个好习惯。


句法

fileObject.close()

例子

现场演示

#!/usr/bin/python


# Open a file

fo = open("foo.txt", "wb")

print "Name of the file: ", fo.name


# Close opend file

fo.close()

这会产生以下结果 -


Name of the file:  foo.txt

读取和写入文件

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


write( )方法

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


write() 方法不会在字符串末尾添加换行符 ('\n') -


句法

fileObject.write(string)

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


例子

#!/usr/bin/python


# Open a file

fo = open("foo.txt", "wb")

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

这里,传递的参数是要从打开的文件中读取的字节数。此方法从文件开头开始读取,如果缺少计数,则尝试尽可能多地读取,可能直到文件末尾。


例子

让我们使用我们在上面创建的文件foo.txt。


#!/usr/bin/python


# Open a file

fo = open("foo.txt", "r+")

str = fo.read(10);

print "Read String is : ", str

# Close opend file

fo.close()

这会产生以下结果 -


Read String is :  Python is

文件位置

tell()方法告诉您文件中的当前位置;换句话说,下一次读取或写入将发生在文件开头的那么多字节处。


seek(offset[, from])方法改变当前文件位置。offset参数表示要移动的字节数。from参数指定要移动字节的参考位置。


如果from设置为0,表示以文件开头为参考位置,1表示以当前位置为参考位置,如果设置为2,则以文件结尾为参考位置.


例子

让我们获取我们在上面创建的文件foo.txt。


#!/usr/bin/python


# 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 opend 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/python

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/python

import os


# Delete file test2.txt

os.remove("text2.txt")

Python中的目录

所有文件都包含在不同的目录中,Python 处理这些也没有问题。os模块有几种方法可以帮助您创建、删除和更改目录。


mkdir( )方法

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


句法

os.mkdir("newdir")

例子

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


#!/usr/bin/python

import os


# Create a directory "test"

os.mkdir("test")

chdir( )方法

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


句法

os.chdir("newdir")

例子

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


#!/usr/bin/python

import os


# Changing a directory to "/home/newdir"

os.chdir("/home/newdir")

getcwd( )方法

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


句法

os.getcwd()

例子

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


#!/usr/bin/python

import os


# This would give location of the current directory

os.getcwd()

rmdir( )方法

rmdir()方法删除目录,该目录作为方法中的参数传递。


在删除目录之前,应该删除其中的所有内容。


句法

os.rmdir('dirname')

例子

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


#!/usr/bin/python

import os


# This would  remove "/tmp/test"  directory.

os.rmdir( "/tmp/test"  )

文件和目录相关方法

有三个重要的来源,它们提供了广泛的实用方法来处理和操作 Windows 和 Unix 操作系统上的文件和目录。它们如下 -


文件对象方法:文件对象提供操作文件的功能。


操作系统对象方法:这提供了处理文件和目录的方法。


Python - 模块

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


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


例子

名为aname的模块的 Python 代码通常位于名为aname.py的文件中。这是一个简单模块的示例,support.py


def print_func( par ):

   print "Hello : ", par

   return

进口声明_

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


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

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


#!/usr/bin/python


# Import module support

import support


# Now you can call defined function that module as follows

support.print_func("Zara")

执行上述代码时,会产生以下结果 -


Hello : Zara

一个模块只加载一次,不管它被导入多少次。如果发生多个导入,这可以防止模块执行一遍又一遍地发生。


from ...import语句

Python 的from语句允许您将模块中的特定属性导入当前命名空间。from...import具有以下语法 -


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

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


from fib import fibonacci

该语句不会将整个模块 fib 导入当前命名空间;它只是将模块 fib 中的项 fibonacci 引入到导入模块的全局符号表中。


from ...import *语句

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


from modname import *

这提供了一种将模块中的所有项目导入当前命名空间的简单方法;但是,应谨慎使用此语句。


定位模块

导入模块时,Python 解释器按以下顺序搜索模块 -


当前目录。


如果未找到该模块,Python 将搜索 shell 变量 PYTHONPATH 中的每个目录。


如果一切都失败了,Python 会检查默认路径。在 UNIX 上,此默认路径通常是 /usr/local/lib/python/。


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


PYTHONPATH变量_

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


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


set PYTHONPATH = c:\python20\lib;

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


set PYTHONPATH = /usr/local/lib/python

命名空间和作用域

变量是映射到对象的名称(标识符)。命名空间是变量名称(键)及其对应对象(值)的字典。


Python 语句可以访问本地命名空间和全局命名空间中的变量。如果局部变量和全局变量具有相同的名称,则局部变量会隐藏全局变量。


每个函数都有自己的本地命名空间。类方法遵循与普通函数相同的范围规则。


Python 对变量是局部变量还是全局变量进行有根据的猜测。它假定在函数中赋值的任何变量都是局部的。


因此,为了给函数内的全局变量赋值,必须首先使用 global 语句。


语句global VarName告诉 Python VarName 是一个全局变量。Python 停止在本地命名空间中搜索该变量。


例如,我们在全局命名空间中定义了一个变量Money。在函数Money中,我们为Money赋值,因此 Python 将Money假定为局部变量。但是,我们在设置之前访问了局部变量Money的值,所以结果是 UnboundLocalError。取消注释全局语句可以解决问题。


#!/usr/bin/python


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/python


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


def Pots():

   print "I'm Pots Phone"

类似地,我们还有另外两个具有不同功能的文件,其名称与上述相同 -


具有函数 Isdn() 的电话/Isdn.py文件


具有函数 G3() 的电话/G3.py文件


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


电话/__init__.py

要在导入 Phone 后使所有功能可用,您需要在 __init__.py 中添加显式导入语句,如下所示 -


from Pots import Pots

from Isdn import Isdn

from G3 import G3

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


#!/usr/bin/python


# 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 类,然后您可以从这些类中创建包。


Python - 函数

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


如您所知,Python 为您提供了许多内置函数,例如 print() 等,但您也可以创建自己的函数。这些函数称为用户定义函数。


定义函数

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


功能块以关键字def开头,后跟功能名称和括号 ( ( ) )。


任何输入参数或参数都应放在这些括号内。您还可以在这些括号内定义参数。


函数的第一条语句可以是可选语句 - 函数的文档字符串或docstring。


每个函数中的代码块都以冒号 (:) 开头并缩进。


语句 return [expression] 退出一个函数,可选择将一个表达式传回给调用者。没有参数的 return 语句与 return None 相同。


句法

def functionname( parameters ):

   "function_docstring"

   function_suite

   return [expression]

默认情况下,参数具有位置行为,您需要按照定义它们的顺序通知它们。


例子

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


def printme( str ):

   "This prints a passed string into this function"

   print str

   return

调用函数

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


一旦函数的基本结构最终确定,您可以通过从另一个函数调用它或直接从 Python 提示符调用它来执行它。以下是调用 printme() 函数的示例 -


现场演示

#!/usr/bin/python


# 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("I'm first call to user defined function!")

printme("Again second call to the same function")

执行上述代码时,会产生以下结果 -


I'm first call to user defined function!

Again second call to the same function

通过引用与值传递

Python 语言中的所有参数(参数)都是通过引用传递的。这意味着如果您更改函数中参数所指的内容,则更改也会反映在调用函数中。例如 -


现场演示

#!/usr/bin/python


# Function definition is here

def changeme( mylist ):

   "This changes a passed list into this function"

   mylist.append([1,2,3,4]);

   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

在这里,我们维护传递对象的引用并在同一个对象中附加值。因此,这将产生以下结果 -


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

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

还有一个例子,参数是通过引用传递的,而引用在被调用函数内部被覆盖。


现场演示

#!/usr/bin/python


# Function definition is here

def changeme( mylist ):

   "This changes a passed list into this function"

   mylist = [1,2,3,4]; # This would assig 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/python


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


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


# 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

默认参数

默认参数是一个参数,如果在该参数的函数调用中未提供值,则该参数采用默认值。下面的例子给出了一个关于默认参数的想法,如果它没有被传递,它会打印默认年龄 -


现场演示

#!/usr/bin/python


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


# 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

匿名函数_

这些函数之所以称为匿名函数,是因为它们不是使用def关键字以标准方式声明的。您可以使用lambda关键字来创建小型匿名函数。


Lambda 形式可以采用任意数量的参数,但仅以表达式的形式返回一个值。它们不能包含命令或多个表达式。


匿名函数不能直接调用 print,因为 lambda 需要表达式


Lambda 函数有自己的本地命名空间,不能访问除参数列表和全局命名空间中的变量之外的变量。


尽管 lambda 看起来是函数的单行版本,但它们并不等同于 C 或 C++ 中的内联语句,其目的是出于性能原因在调用期间传递函数堆栈分配。


句法

lambda函数的语法仅包含一条语句,如下所示 -


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

以下是展示lambda形式的函数如何工作的示例 -


现场演示

#!/usr/bin/python


# 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 [expression] 退出一个函数,可选择将一个表达式传回给调用者。没有参数的 return 语句与 return None 相同。


以上所有示例均未返回任何值。您可以从函数返回一个值,如下所示 -


现场演示

#!/usr/bin/python


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


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


Python - 日期和时间

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


什么是蜱?

时间间隔是以秒为单位的浮点数。从 1970 年 1 月 1 日(纪元)00:00:00 开始,特定的时间点以秒表示。


Python 中有一个流行的时间模块,它提供了处理时间和在表示之间转换的函数。函数time.time()返回自 1970 年 1 月 1 日(纪元)00:00:00 以来的当前系统时间(以刻度为单位)。


例子

现场演示

#!/usr/bin/python

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: 7186862.73399

日期算术很容易用刻度来完成。但是,纪元之前的日期不能以这种形式表示。遥远未来的日期也不能用这种方式表示——对于 UNIX 和 Windows,截止点是 2038 年的某个时间。


什么是时间元组?

许多 Python 的时间函数将时间处理为 9 个数字的元组,如下所示 -


指数 场地 价值观

0 4 位数年份 2008年

1 1 到 12

2 1 至 31

3 小时 0 到 23

4 分钟 0 到 59

5 第二 0 到 61(60 或 61 是闰秒)

6 星期几 0 到 6(0 是星期一)

7 一年中的一天 1 至 366(儒略日)

8 夏令时 -1, 0, 1, -1 表示库确定 DST

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


指数 属性 价值观

0 tm_year 2008年

1 tm_mon 1 到 12

2 tm_mday 1 至 31

3 tm_hour 0 到 23

4 tm_min 0 到 59

5 tm_sec 0 到 61(60 或 61 是闰秒)

6 tm_wday 0 到 6(0 是星期一)

7 tm_yday 1 至 366(儒略日)

8 tm_isdst -1, 0, 1, -1 表示库确定 DST

获取当前时间

要将自纪元浮点值以来的秒数转换为时间元组,请将浮点值传递给一个函数(例如,本地时间),该函数返回一个所有九项都有效的时间元组。


现场演示

#!/usr/bin/python

import time;


localtime = time.localtime(time.time())

print "Local current time :", localtime

这将产生以下结果,可以以任何其他可呈现的形式格式化 -


Local current time : time.struct_time(tm_year=2013, tm_mon=7, 

tm_mday=17, tm_hour=21, tm_min=26, tm_sec=3, tm_wday=2, tm_yday=198, tm_isdst=0)

获取格式化时间

您可以根据您的要求随时格式化,但是以可读格式获取时间的简单方法是 asctime() -


现场演示

#!/usr/bin/python

import time;


localtime = time.asctime( time.localtime(time.time()) )

print "Local current time :", localtime

这将产生以下结果 -


Local current time : Tue Jan 13 10:17:09 2009

获取一个月的日历

日历模块提供了多种使用年历和月历的方法。在这里,我们打印给定月份的日历(2008 年 1 月) -


现场演示

#!/usr/bin/python

import calendar


cal = calendar.month(2008, 1)

print "Here is the calendar:"

print cal

这将产生以下结果 -


Here is the calendar:

   January 2008

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 30 31

时间模块_

Python中有一个流行的时间模块,它提供了处理时间和在表示之间转换的函数。这是所有可用方法的列表 -


编号 功能说明

1 时间.altzone

本地 DST 时区的偏移量,以 UTC 以西的秒数为单位(如果已定义)。如果当地 DST 时区在 UTC 以东(如在西欧,包括英国),则这是负数。仅当日光不为零时才使用此选项。


2 time.asctime([元组时间])

接受时间元组并返回可读的 24 个字符的字符串,例如 'Tue Dec 11 18:07:14 2008'。


3 时间.时钟()

以浮点秒数返回当前 CPU 时间。为了衡量不同方法的计算成本,time.clock 的值比 time.time() 的值更有用。


4 time.ctime([秒])

像 asctime(localtime(secs)) 并且没有参数就像 asctime()


5 time.gmtime([秒])

接受自纪元以来以秒表示的瞬间,并返回带有 UTC 时间的时间元组 t。注意:t.tm_isdst 始终为 0


6 time.localtime([秒])

接受自纪元以来以秒表示的瞬间,并返回带有本地时间的时间元组 t(t.tm_isdst 为 0 或 1,取决于 DST 是否适用于本地规则的瞬间秒)。


7 time.mktime(元组时间)

接受以本地时间表示为时间元组的瞬间,并返回一个浮点值,该瞬间以自纪元以来的秒数表示。


8 时间.睡眠(秒)

将调用线程挂起 secs 秒。


9 time.strftime(fmt[,tupletime])

接受以本地时间表示为时间元组的瞬间,并返回表示由字符串 fmt 指定的瞬间的字符串。


10 time.strptime(str,fmt='%a %b %d %H:%M:%S %Y')

根据格式字符串 fmt 解析 str 并以时间元组格式返回瞬间。


11 时间.时间()

返回当前时刻,即自纪元以来的浮点秒数。


12 时间.tzset()

重置库例程使用的时间转换规则。环境变量 TZ 指定如何完成。


让我们简要介绍一下这些功能 -


时间模块有以下两个重要属性 -


编号 带有描述的属性

1

时间.时区


属性 time.timezone 是本地时区(不含 DST)与 UTC 的偏移量(在美洲 > 0;在欧洲、亚洲、非洲的大部分地区 <= 0)。


2

时间.tzname


属性 time.tzname 是一对依赖于语言环境的字符串,它们分别是不带夏令时和带夏令时的本地时区名称。


日历模块_

日历模块提供与日历相关的功能,包括打印给定月份或年份的文本日历的功能。


默认情况下,日历将星期一作为一周的第一天,将星期日作为最后一天。要更改这一点,请调用 calendar.setfirstweekday() 函数。


这是日历模块可用的功能列表-


编号 功能说明

1

calendar.calendar(年,w=2,l=1,c=6)


返回一个多行字符串,其中包含一年的日历,格式为由 c 个空格分隔的三列。w 是每个日期的字符宽度;每行的长度为 21*w+18+2*c。l 是每周的行数。


2

calendar.firstweekday()


返回每周开始的工作日的当前设置。默认情况下,首次导入日历时,此值为 0,表示星期一。


3

calendar.isleap(年)


如果 year 是闰年,则返回 True;否则为假。


4

calendar.leapdays(y1,y2)


返回范围 (y1,y2) 内年份的闰日总数。


5

calendar.month(年,月,w=2,l=1)


返回一个多行字符串,其中包含一年中月份的日历,每周一行加上两个标题行。w 是每个日期的字符宽度;每行的长度为 7*w+6。l 是每周的行数。


6

calendar.monthcalendar(年,月)


返回整数列表的列表。每个子列表表示一周。年月月外的天数设置为 0;月内的天数设置为当月的第 1 天及以上。


7

calendar.monthrange(年,月)


返回两个整数。第一个是年年月月第一天的工作日代码;第二个是一个月的天数。工作日代码为 0(星期一)至 6(星期日);月份数字是 1 到 12。


8

calendar.prcal(年,w=2,l=1,c=6)


就像打印 calendar.calendar(year,w,l,c)。


9

calendar.prmonth(年,月,w=2,l=1)


就像打印 calendar.month(year,month,w,l)。


10

calendar.setfirstweekday(工作日)


将每周的第一天设置为工作日代码工作日。工作日代码为 0(星期一)到 6(星期日)。


11

calendar.timegm(元组时间)


time.gmtime 的倒数:接受时间元组形式的时间瞬间,并返回与自纪元以来的浮点秒数相同的瞬间。


12

calendar.weekday(年,月,日)


返回给定日期的工作日代码。工作日代码为 0(星期一)至 6(星期日);月份编号为 1(一月)到 12(十二月)。


其他模块和功能

如果您有兴趣,那么在这里您可以找到在 Python 中使用日期和时间的其他重要模块和函数的列表 -


日期时间模块


pytz模块_


dateutil模块_


Python - 字典

每个键与其值用冒号 (:) 分隔,项目用逗号分隔,整个内容用花括号括起来。一个没有任何项目的空字典只用两个花括号编写,如下所示:{}。


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


访问字典中的值

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


现场演示

#!/usr/bin/python


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/python


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

print "dict['Alice']: ", dict['Alice']

执行上述代码时,会产生以下结果 -


dict['Alice']:

Traceback (most recent call last):

   File "test.py", line 4, in <module>

      print "dict['Alice']: ", dict['Alice'];

KeyError: 'Alice'

更新字典

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


现场演示

#!/usr/bin/python


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/python


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/python


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

print "dict['Name']: ", dict['Name']

执行上述代码时,会产生以下结果 -


dict['Name']:  Manni

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


现场演示

#!/usr/bin/python


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: unhashable type: 'list'

内置字典函数和方法

Python 包括以下字典函数 -


编号 功能说明

1 cmp(dict1, dict2)

比较两个字典的元素。


2 len(字典)

给出字典的总长度。这将等于字典中的项目数。


3 字符串(字典)

生成字典的可打印字符串表示


4 类型(变量)

返回传递变量的类型。如果传递的变量是字典,那么它将返回字典类型。


Python 包括以下字典方法 -


编号 带有描述的方法

1 dict.clear()

删除字典dict的所有元素


2 dict.copy()

返回字典dict的浅拷贝


3 dict.fromkeys()

使用来自 seq 的键和设置为value的值创建一个新字典。


4 dict.get(键,默认=无)

对于键键,如果键不在字典中,则返回值或默认值


5 dict.has_key(key)

如果字典dict中的键返回true,否则返回false


6 dict.items()

返回dict的 (key, value) 元组对的列表


7 dict.keys()

返回字典 dict 键的列表


8 dict.setdefault(键,默认=无)

类似于 get(),但如果key不在dict 中,将设置 dict[key]=default


9 dict.update(dict2)

将字典dict2的键值对添加到dict


10 dict.values()

返回字典dict的值列表


Python - 元组

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


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


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

tup2 = (1, 2, 3, 4, 5 );

tup3 = "a", "b", "c", "d";

空元组写成两个括号,不包含任何内容 -


tup1 = ();

要编写一个包含单个值的元组,您必须包含一个逗号,即使只有一个值 -


tup1 = (50,);

像字符串索引一样,元组索引从 0 开始,它们可以被切片、连接等等。


访问元组中的值

要访问元组中的值,请使用方括号进行切片以及索引或索引以获得该索引处可用的值。例如 -


现场演示

#!/usr/bin/python


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/python


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/python


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

基本元组操作

元组对 + 和 * 运算符的响应很像字符串;他们在这里也意味着连接和重复,除了结果是一个新的元组,而不是一个字符串。


事实上,元组响应我们在前一章中对字符串使用的所有一般序列操作 -


Python 表达式 结果 描述

长度 ((1, 2, 3)) 3 长度

(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) 级联

('嗨!',)* 4 (“嗨!”、“嗨!”、“嗨!”、“嗨!”) 重复

3 英寸 (1, 2, 3) 真的 会员资格

对于 (1, 2, 3) 中的 x:打印 x, 1 2 3 迭代

索引、切片和矩阵

因为元组是序列,所以索引和切片对元组的工作方式与对字符串的工作方式相同。假设以下输入 -


L = ('spam', 'Spam', 'SPAM!')

 


Python 表达式 结果 描述

L[2] '垃圾邮件!' 偏移量从零开始

L[-2] '垃圾邮件' 负数:从右数

L[1:] ['垃圾邮件','垃圾邮件!'] 切片获取部分

没有封闭分隔符

任何一组多个对象,逗号分隔,不带识别符号,即列表的括号,元组的括号等,默认为元组,如这些简短的示例所示 -


现场演示

#!/usr/bin/python


print 'abc', -4.24e93, 18+6.6j, 'xyz';

x, y = 1, 2;

print "Value of x , y : ", x,y;

执行上述代码时,会产生以下结果 -


abc -4.24e+93 (18+6.6j) xyz

Value of x , y : 1 2

内置元组函数

Python 包括以下元组函数 -


编号 功能说明

1 cmp(元组1,元组2)

比较两个元组的元素。


2 len(元组)

给出元组的总长度。


3 最大值(元组)

从具有最大值的元组中返回项目。


4 分钟(元组)

从具有最小值的元组中返回项目。


5 元组(序列)

将列表转换为元组。


Python - 列表

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


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


您可以对所有序列类型执行某些操作。这些操作包括索引、切片、加法、乘法和检查成员资格。此外,Python 具有用于查找序列长度以及查找其最大和最小元素的内置函数。


Python 列表

列表是 Python 中最通用的数据类型,可以写成方括号之间的逗号分隔值(项目)列表。关于列表的重要一点是列表中的项目不必属于同一类型。


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


list1 = ['physics', 'chemistry', 1997, 2000];

list2 = [1, 2, 3, 4, 5 ];

list3 = ["a", "b", "c", "d"]

与字符串索引类似,列表索引从 0 开始,列表可以切片、连接等。


访问列表中的值

要访问列表中的值,请使用方括号进行切片以及索引或索引以获得该索引处可用的值。例如 -


现场演示

#!/usr/bin/python


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/python


list = ['physics', 'chemistry', 1997, 2000];

print "Value available at index 2 : "

print list[2]

list[2] = 2001;

print "New value available at index 2 : "

print list[2]

注意- append() 方法将在后续部分讨论。


执行上述代码时,会产生以下结果 -


Value available at index 2 :

1997

New value available at index 2 :

2001

删除列表元素

要删除列表元素,如果您确切知道要删除的元素,可以使用 del 语句,如果不知道,可以使用 remove() 方法。例如 -


现场演示

#!/usr/bin/python


list1 = ['physics', 'chemistry', 1997, 2000];

print list1

del list1[2];

print "After deleting value at index 2 : "

print list1

执行上述代码时,会产生以下结果 -


['physics', 'chemistry', 1997, 2000]

After deleting value at index 2 :

['physics', 'chemistry', 2000]

注意- remove() 方法将在后续部分讨论。


基本列表操作

列表响应 + 和 * 操作符很像字符串;它们在这里也意味着连接和重复,只是结果是一个新列表,而不是一个字符串。


事实上,列表响应了我们在前一章中对字符串使用的所有一般序列操作。


Python 表达式结果描述

len([1, 2, 3])3长度

[1, 2, 3] + [4, 5, 6][1、2、3、4、5、6]级联

['嗨!'] * 4['嗨!','嗨!','嗨!','嗨!']重复

3 在 [1, 2, 3]真的会员资格

对于 [1, 2, 3] 中的 x:打印 x,1 2 3迭代

索引、切片和矩阵

因为列表是序列,所以索引和切片对列表的工作方式与对字符串的工作方式相同。


假设以下输入 -


L = ['spam', 'Spam', 'SPAM!']

Python 表达式结果描述

L[2]垃圾邮件!偏移量从零开始

L[-2]垃圾邮件负数:从右数

L[1:]['垃圾邮件','垃圾邮件!']切片获取部分

内置列表函数和方法

Python 包括以下列表函数 -


编号功能说明

1cmp(列表 1,列表 2)

比较两个列表的元素。


2长度(列表)

给出列表的总长度。


3最大值(列表)

从列表中返回具有最大值的项目。


4分钟(列表)

从列表中返回具有最小值的项目。


5列表(序列)

将元组转换为列表。


Python 包括以下列表方法


编号带有描述的方法

1list.append(obj)

将对象 obj 附加到列表


2list.count(obj)

返回 obj 在列表中出现的次数


3list.extend(seq)

将 seq 的内容追加到列表中


4list.index(obj)

返回 obj 出现的列表中的最低索引


5list.insert(索引,obj)

将对象 obj 插入到偏移索引处的列表中


6list.pop(obj=list[-1])

从列表中移除并返回最后一个对象或 obj


7list.remove(obj)

从列表中删除对象 obj


8list.reverse()

将列表对象反转到位


9list.sort([函数])

对列表对象进行排序,如果给定则使用比较函数


Python - 字符串

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


var1 = 'Hello World!'

var2 = "Python Programming"

访问字符串中的值

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


要访问子字符串,请使用方括号进行切片以及索引或索引来获取子字符串。例如 -


现场演示

#!/usr/bin/python


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/python


var1 = 'Hello World!'

print "Updated String :- ", var1[:6] + 'Python'

执行上述代码时,会产生以下结果 -


Updated String :-  Hello Python

转义字符

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


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


反斜杠符号 十六进制字符 描述

\一种 0x07 响铃或警报

\b 0x08 退格

\cx 控制-x

\Cx 控制-x

\e 0x1b 逃脱

\F 0x0c 换页

\M-\Cx 元控制-x

\n 0x0a 新队

\nnn 八进制表示法,其中 n 在 0.7 范围内

\r 0x0d 回车

\s 0x20 空间

\t 0x09 标签

\v 0x0b 垂直选项卡

\X 字符 x

\xnn 十六进制表示法,其中 n 在 0.9、af 或 AF 范围内

字符串特殊运算符

假设字符串变量a持有“Hello”,变量b持有“Python”,那么 -


操作员 描述 例子

+ 串联 - 在运算符的任一侧添加值 a + b 会给 HelloPython

* 重复 - 创建新字符串,连接同一字符串的多个副本 a*2 将给出 -HelloHello

[] Slice - 给出给定索引中的字符 a[1] 会给 e

[:] Range Slice - 给出给定范围内的字符 a[1:4] 会给 ell

Membership - 如果给定字符串中存在字符,则返回 true H in a 将给出 1

不在 Membership - 如果给定字符串中不存在字符,则返回 true M not in a 将给出 1

读/读 原始字符串 - 抑制转义字符的实际含义。原始字符串的语法与普通字符串的语法完全相同,但原始字符串运算符除外,即引号前面的字母“r”。“r”可以是小写字母 (r) 或大写字母 (R),并且必须紧挨在第一个引号之前。 print r'\n' 打印 \n 和 print R'\n' 打印 \n

% Format - 执行字符串格式化 见下一节

字符串格式化运算符

Python 最酷的特性之一是字符串格式运算符 %。该运算符是字符串独有的,弥补了 C 的 printf() 系列中的函数包。以下是一个简单的例子 -


现场演示

#!/usr/bin/python


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

执行上述代码时,会产生以下结果 -


My name is Zara and weight is 21 kg!

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


格式化符号 转换

%C 特点

%s 在格式化之前通过 str() 进行字符串转换

%一世 有符号十进制整数

%d 有符号十进制整数

%u 无符号十进制整数

%o 八进制整数

%X 十六进制整数(小写字母)

%X 十六进制整数(大写字母)

%e 指数符号(带小写“e”)

%E 指数符号(大写“E”)

%F 浮点实数

%G %f 和 %e 中较短的一个

%G %f 和 %E 中较短的一个

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


象征 功能性

* 参数指定宽度或精度

- 左对齐

+ 显示标志

<sp> 在正数前留一个空格

# 添加八进制前导零(“0”)或十六进制前导“0x”或“0X”,具体取决于使用的是“x”还是“X”。

0 从左边用零填充(而不是空格)

% '%%' 给你留下一个文字 '%'

(变种) 映射变量(字典参数)

m 是最小总宽度,n 是小数点后显示的位数(如果适用)

三重引号

Python 的三重引号允许字符串跨越多行,包括逐字换行符、制表符和任何其他特殊字符,从而起到救援作用。


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


现场演示

#!/usr/bin/python


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


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/python


print 'C:\\nowhere'

执行上述代码时,会产生以下结果 -


C:\nowhere

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


现场演示

#!/usr/bin/python


print r'C:\\nowhere'

执行上述代码时,会产生以下结果 -


C:\\nowhere

Unicode 字符串

Python 中的普通字符串在内部存储为 8 位 ASCII,而 Unicode 字符串存储为 16 位 Unicode。这允许使用更多样化的字符集,包括来自世界上大多数语言的特殊字符。我将对 Unicode 字符串的处理限制为以下内容 -


现场演示

#!/usr/bin/python


print u'Hello, world!'

执行上述代码时,会产生以下结果 -


Hello, world!

如您所见,Unicode 字符串使用前缀 u,就像原始字符串使用前缀 r 一样。


内置字符串方法

Python 包括以下操作字符串的内置方法 -


编号 带有描述的方法

1 大写()

将字符串的第一个字母大写


2 中心(宽度,填充字符)

返回一个空格填充的字符串,其中原始字符串以总宽度列为中心。


3 计数(str,beg=0,end=len(字符串))

如果给定了起始索引 beg 和结束索引 end,则计算 str 在字符串或字符串的子字符串中出现的次数。


4 解码(编码='UTF-8',错误='严格')

使用为编码注册的编解码器对字符串进行解码。encoding 默认为默认字符串编码。


5 编码(编码='UTF-8',错误='严格')

返回字符串的编码字符串版本;出错时,默认是引发 ValueError ,除非使用“忽略”或“替换”给出错误。


6 结束(后缀,乞求 = 0,结束 = 长度(字符串))

确定字符串或字符串的子字符串(如果给出了起始索引 beg 和结束索引 end)是否以后缀结尾;如果是,则返回 true,否则返回 false。


7 展开标签(标签大小=8)

将字符串中的制表符扩展到多个空格;如果未提供 tabsize,则默认为每个制表符 8 个空格。


8 查找(str,beg=0 end=len(字符串))

如果给出了起始索引 beg 和结束索引 end,则确定 str 出现在字符串中还是出现在字符串的子字符串中,如果找到则返回 index,否则返回 -1。


9 索引(str,beg=0,end=len(字符串))

与 find() 相同,但如果未找到 str,则会引发异常。


10 isalnum()

如果字符串至少有 1 个字符并且所有字符都是字母数字,则返回 true,否则返回 false。


11 是阿尔法()

如果字符串至少有 1 个字符并且所有字符都是字母,则返回 true,否则返回 false。


12 是数字()

如果字符串仅包含数字,则返回 true,否则返回 false。


13 下层()

如果字符串至少有 1 个大小写字符并且所有大小写字符都是小写,则返回 true,否则返回 false。


14 非数字()

如果 unicode 字符串仅包含数字字符,则返回 true,否则返回 false。


15 空间()

如果字符串仅包含空白字符,则返回 true,否则返回 false。


16 标题()

如果字符串正确“标题大小写”,则返回 true,否则返回 false。


17 isupper()

如果字符串至少有一个大小写字符并且所有大小写字符都是大写,则返回 true,否则返回 false。


18 加入(序列)

将序列 seq 中元素的字符串表示合并(连接)成一个字符串,并带有分隔符字符串。


19 长度(字符串)

返回字符串的长度


20 ljust(宽度[,填充字符])

返回一个空格填充的字符串,原始字符串左对齐到总宽度列。


21 降低()

将字符串中的所有大写字母转换为小写。


22 lstrip()

删除字符串中的所有前导空格。


23 maketrans()

返回要在翻译函数中使用的翻译表。


24 最大值(str)

返回字符串 str 中的最大字母字符。


25 分钟(str)

返回字符串 str 中的最小字母字符。


26 替换(旧,新 [,最大])

将字符串中所有出现的 old 替换为新的,或者如果给定 max,则最多替换为 max 出现。


27 rfind(str, beg=0,end=len(string))

与 find() 相同,但在字符串中向后搜索。


28 rindex(str,beg=0,end=len(字符串))

与 index() 相同,但在字符串中向后搜索。


29 rjust(宽度,[,填充字符])

返回一个空格填充的字符串,原始字符串右对齐到总宽度列。


30 rstrip()

删除字符串的所有尾随空格。


31 拆分(str="", num=string.count(str))

根据分隔符 str 拆分字符串(如果未提供空格)并返回子字符串列表;如果给定,最多拆分为 num 个子字符串。


32 分割线(num=string.count('\n'))

在所有(或 num)个 NEWLINE 处拆分字符串,并返回删除了 NEWLINE 的每一行的列表。


33 开始(str,beg=0,end=len(字符串))

确定字符串或字符串的子字符串(如果给出了起始索引 beg 和结束索引 end)是否以子字符串 str 开头;如果是,则返回 true,否则返回 false。


34 剥离([字符])

对字符串执行 lstrip() 和 rstrip()。


35 交换箱()

反转字符串中所有字母的大小写。


36 标题()

返回“titlecased”版本的字符串,即所有单词都以大写开头,其余的都是小写。


37 翻译(表,删除字符=“”)

根据翻译表 str(256 chars) 翻译字符串,删除 del 字符串中的那些。


38 上()

将字符串中的小写字母转换为大写。


39 zfill(宽度)

返回用零填充到总宽度字符的原始字符串;用于数字,zfill() 保留任何给定的符号(少一个零)。


40 十进制()

如果 unicode 字符串仅包含十进制字符,则返回 true,否则返回 false。


Python - numbers

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


Number 对象是在您为其赋值时创建的。例如 -


var1 = 1

var2 = 10

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


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

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


del var

del var_a, var_b

Python 支持四种不同的数值类型 -


int (signed integers) - 它们通常被称为整数或整数,是没有小数点的正整数或负整数。


long (long integers) - 也称为 long,它们是无限大小的整数,写成整数,后跟大写或小写 L。


float (floating point real values) - 也称为浮点数,它们代表实数,并用小数点分隔整数和小数部分。浮点数也可以是科学记数法,E 或 e 表示 10 的幂 (2.5e2 = 2.5 x 10 2 = 250)。


complex(复数) - 形式为 a + bJ,其中 a 和 b 是浮点数,J(或 j)表示 -1(虚数)的平方根。数的实部是a,虚部是b。Python 编程中很少使用复数。


例子

以下是一些数字示例


整数 漂浮 复杂的

10 51924361L 0.0 3.14j

100 -0x19323L 15.20 45.j

-786 0122L -21.9 9.322e-36j

080 0xDEFABCECBDAECBFBAEL 32.3+e18 .876j

-0490 535633629843L -90。 -.6545+0J

-0x260 -052318172735L -32.54e100 3e+26J

0x69 -4721885298529L 70.2-E12 4.53e-7j

Python 允许您将小写 L 与 long 一起使用,但建议您仅使用大写 L 以避免与数字 1 混淆。Python 使用大写 L 显示长整数。


复数由一对有序的实数浮点数组成,用 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 包括以下执行数学计算的函数。


编号 函数和返回(描述)

1 绝对值(x)

x 的绝对值:x 和零之间的(正)距离。


2 细胞(x)

x的上限:不小于x的最小整数


3 cmp(x, y)

如果 x < y,则为 -1,如果 x == y,则为 0,如果 x > y,则为 1


4 exp(x)

x 的指数:e x


5 晶圆厂(x)

x 的绝对值。


6 楼层(x)

x的下限:不大于x的最大整数


7 日志(x)

x 的自然对数,对于 x> 0


8 日志10(x)

x> 0 时 x 的以 10 为底的对数。


9 最大值(x1,x2,...)

它的最大参数:最接近正无穷大的值


10 最小(x1,x2,...)

最小的参数:最接近负无穷的值


11 模数(x)

两项元组中 x 的小数和整数部分。两个部分都具有与 x 相同的符号。整数部分作为浮点数返回。


12 pow(x, y)

x**y 的值。


13 圆形(x [,n])

x从小数点四舍五入到 n 位。Python 从零四舍五入作为决胜局:round(0.5) 是 1.0,round(-0.5) 是 -1.0。


14 平方(x)

x > 0 时 x 的平方根


随机数函数

随机数用于游戏、模拟、测试、安全和隐私应用。Python 包括以下常用函数。


编号 功能说明

1 选择(序列)

列表、元组或字符串中的随机项。


2 randrange([开始,]停止[,步骤])

从范围(开始,停止,步骤)中随机选择的元素


3 随机的()

一个随机浮点数 r,使得 0 小于或等于 r 并且 r 小于 1


4 种子([x])

设置用于生成随机数的整数起始值。在调用任何其他随机模块函数之前调用此函数。返回无。


5 洗牌(一首)

随机化列表中的项目。返回无。


6 统一(x,y)

一个随机浮点数 r,使得 x 小于或等于 r 并且 r 小于 y


三角函数

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


编号 功能说明

1 acos(x)

返回 x 的反余弦,以弧度为单位。


2 阿辛(X)

返回 x 的反正弦,以弧度为单位。


3 atan(x)

返回 x 的反正切,以弧度为单位。


4 atan2(y, x)

返回 atan(y / x),以弧度为单位。


5 余弦(x)

返回 x 弧度的余弦。


6 假设(x,y)

返回欧几里得范数 sqrt(x*x + y*y)。


7 罪(x)

返回 x 弧度的正弦值。


8 tan(x)

返回 x 弧度的正切。


9 度(x)

将角度 x 从弧度转换为度。


10 弧度(x)

将角度 x 从度转换为弧度。


数学常数

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


编号 常量和描述

1

圆周率


数学常数 pi。


2

e


数学常数 e。


<< < 1 2 3 4 5 6 7 8 9 10 > >>

Copyright www.jennal.cn Rights Reserved葵花宝典教程.鄂icp2022001145号-1

分享:

支付宝

微信