-

Python概述：

Python是一种高级，解释，交互和面向对象的脚本语言。

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

Python的功能亮点包括：

获取Python：

最新和最新的源代码，二进制，文档，新闻等可以在Python的官方网站上找到：

Python官方网站： https ：//www.python.org/

您可以从以下站点下载Python文档。该文档有HTML，PDF和PostScript格式。

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

第一个Python程序：

交互模式编程：

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

root# python
Python 2.5 (r25:51908, Nov  6 2007, 16:54:01)
[GCC 4.1.2 20070925 (Red Hat 4.1.2-27)] on linux2
Type "help", "copyright", "credits" or "license" for more info.
>>>

在Python提示符的右侧键入以下文本，然后按Enter键：

>>> print "Hello, Python!";

输出结果如下：

Hello, Python!

Python标识符：

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

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

以下是Python的标识符命名约定：

保留字：

以下列表显示了Python中的保留字。这些保留字不能用作常量或变量或任何其他标识符名称。

&&执行不
break最后||
break对于通过
class从打印
continute全球提高
def如果return
德尔进口尝试
elif在而
othertrue与
除lambda产量

行和缩进：

程序员在学习Python时遇到的第一个注意事项之一是没有大括号来表示类和函数定义或流程控制的代码块。代码块由行缩进表示，它被严格地执行。

缩进中的空格数是可变的，但块内的所有语句必须缩进相同的数量。这个例子中的两个块都很好：

if True:
    print "True"
else:
  print "False"

但是，此示例中的第二个块将生成错误：

if True:
    print "Answer"
    print "True"
else:
    print "Answer"
  print "False"

多行语句：

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

total = item_one + 
        item_two + 
        item_three

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

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

Python中的引用：

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

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

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

Python中的注释

不在字符string文字内的散列符号（＃）开始注释。＃之后的所有字符和物理行末端都是注释的一部分，Python解释器忽略它们。

#!/usr/bin/python

# First comment
print "Hello, Python!";  # second comment

输出结果如下：

Hello, Python!

声明或表达后，注释可能位于同一行：

name = "Madisetti" # This is again comment

您可以注释多行如下：

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

使用空行：

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

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

单行多重语句：

分号（;）允许在一行上的多个语句，因为两个语句都不会启动新的代码块。这是一个使用分号的示例snip：

import sys; x = "foo"; sys.stdout.write(x + "
")

多个语句组作为套件：

组成单个代码块的单独语句组在Python 中称为套件。

复合或复杂语句（如if，while，def和class）是需要标题行和套件的语句。

标题行开始声明（使用关键字），并以冒号（：）结尾，后跟一个或多个构成套件的行。

例：

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite

Python - 变量类型：

变量只不过是保存存储值的内存位置。这意味着当您创建一个变量时，您可以在内存中保留一些空间。

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

将值分配给变量：

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

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

print counter
print miles
print name

标准数据类型：

Python有五种标准数据类型：

Python编号：

当您为其分配值时，将创建数字对象。例如：

var1 = 1
var2 = 10

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

以下是一些数字示例：

int长float复杂
1051924361L0.03.14j
100-0x19323L15.2045.j
-7860122L-21.99.322e-36j
0800xDEFABCECBDAECBFBAEL32.3 + e18.876j
-0490535633629843L-90。-655 + 0J
-0x260-052318172735L-32.54e1003e + 26J
0x69-4721885298529L70.2-E124.53e-7j

Python字符string：

Python中的字符string被标识为引号之间的连续字符集。

例：

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 6th
print str[2:]      # Prints string starting from 3rd character
print str * 2      # Prints string two times
print str + "TEST" # Prints concatenated string

Python列表：

列表是Python复合数据类型中最多功能的。一个列表包含用逗号分隔并括在方括号（[]）中的项目。

#!/usr/bin/python

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 to 4th
print list[2:]      # Prints elements starting from 3rd element
print tinylist * 2  # Prints list two times
print list + tinylist # Prints concatenated lists

Python元组：

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

元组可以被认为是只读列表。

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

print tuple           # Prints complete list
print tuple[0]        # Prints first element of the list
print tuple[1:3]      # Prints elements starting from 2nd to 4th
print tuple[2:]       # Prints elements starting from 3rd element
print tinytuple * 2   # Prints list two times
print tuple + tinytuple # Prints concatenated lists

Python字典：

Python的字典是哈希表类型。它们像Perl中发现的关联数组或散列一样工作，由键值对组成。

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

Python - 基本操作符：

操作符描述例
+加法 - 在运算符的两边添加值 a + b将给予30
- 减法 - 从左手操作数减去右手操作数 a - b会给-10
*乘法 - 在运算符的两边乘以值 a * b会给予200
/部门 - 用右手操纵数除数左手操作数 b / a将给予2
％模数 - 用右手操作数除左手操作数并返回余数 b％a会给0
**指数 - 对运算符执行指数（幂）计算 a ** b将给予权力20
//地板分区 - 操作数的除法，其结果是删除小数点后的数字的商。 9 // 2等于4和9.0 // 2.0等于4.0
== 检查两个操作数的值是否相等，如果是，则条件成立。 （a == b）不正确。
！= 检查两个操作数的值是否相等，如果值不等于条件成立。 （a！= b）是真的。
> 检查左操作数的值是否大于右操作数的值，如果是，则条件成为真。 （a> b）不正确。
< 检查左操作数的值是否小于右操作数的值，如果是，则条件成为真。 （a <b）是真的。
> = 检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成为真。 （a> = b）不是真的。
<= 检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成为真。 （a <= b）是真的。
=简单赋值运算符，将右侧操作数的值分配给左侧操作数 c = a + b将a + b的值分配给c
+ =添加AND赋值运算符，将右操作数添加到左操作数，并将结果分配给左操作数 c + = a等价于c = c + a
- =减去AND赋值运算符，从左操作数中减去右操作数，并将结果分配给左操作数 c - = a等价于c = c - a
* =乘以AND赋值运算符，将右操作数与左操作数相乘，并将结果分配给左操作数 c * = a等价于c = c * a
/ =除以AND赋值运算符，它将左操作数与右操作数分开，并将结果分配给左操作数 c / = a等价于c = c / a
％=模数和赋值运算符，它使用两个操作数，并将结果分配给左操作数 c％= a等价于c = c％a
** =指数AND赋值运算符，对运算符进行指数（幂次）运算，并将值分配给左操作数 c ** = a等价于c = c ** a
// =Floor Dividion并分配值，对运算符进行分区，并将值分配给左操作数 c // = a等价于c = c // a
＆ 如果二进制AND运算符存在于两个操作数中，则二进制AND运算符将对结果复制一位。 （a＆b）将给出12是0000 1100
| 二进制OR运算符如果存在于操作数中，则复制一位。 （a | b）将给出61，其为0011 1101
^ 二进制XOR操作符复制该位，如果它设置在一个操作数中，而不是两者。 （a ^ b）将给出49，其为0011 0001
〜 二进制补码运算符是一元的，具有“翻转”位的效果。 （〜a）将给出-61，由于有符号的二进制数，它是以2的补码形式的1100 0011。
<<二进制左移操作符。左操作数值左移由右操作数指定的位数。 一个<< 2将给出240是1111 0000
>>二进制右移操作符。左操作数值被右操作数指定的位移动。 a >> 2将给出15是0000 1111
&&称为逻辑AND运算符。如果两个操作数都为真，那么条件成为真。 （a和b）是真的。
||称为逻辑或运算符。如果两个操作数中的任何一个都为非零，则条件变为真。 （a或b）是真的。
不称为逻辑非运算符。用于反转其操作数的逻辑状态。如果条件为真，则逻辑NOT运算符将为false。 不（a && b）是假的。
在如果在指定的序列中找到一个变量，则返回true，否则返回false。中的x Y，这里在以1的结果，如果x是序列y的成员。
不在如果在指定序列中找不到变量，则返回true，否则返回false。x不在y中，这里不是在 1中，如果x不是序列y的成员。
true如果操作符任一侧的变量指向相同的对象，则返回true，否则返回false。x是y，如果id（x）等于id（y），则结果为1。
不是如果操作符任一侧的变量指向相同的对象，则返回false，否则返回true。x不是y，如果id（x）不等于id（y），这里不会导致1。

Python运算符优先级

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

操作符描述
** 指数（提高权力）
〜+ - 补码，一元加减（最后两个的方法名称是+ @和 - @）
* /％// 乘法，除法，模数和地板分割
+ - 加减
>> << 左右向右移位
＆ 按位“AND”
^ | 按位异或“OR”和常规的“OR”
<= <>> = 比较运算符
<> ==！= 平等经营者
=％= / = // = - = + = | =＆= >> = << = * = ** = 作业操作符
是不是 身份运算符
不在 会员运算符
注意或 逻辑运算符

该如果语句：

if语句的语法是：

if expression:
   statement(s)

在别的声明：

if ... else语句的语法是：

if expression:
   statement(s)
else:
   statement(s)

该ELIF声明

if ... elif语句的语法是：

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

嵌套if ... elif ...其他构造

嵌套if ... elif ... else构造的语法可能是：

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

在同时循环：

while的语法是：

while expression:
   statement(s)

无限循环：

使用while循环时必须谨慎使用，因为这种情况永远不会解决为false值。这导致永远不会结束的循环。这样的循环被称为无限循环。

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

单声明套房：

类似于if语句的语法，如果你的while子句只包含一个语句，那么它可能被放在与while头相同的行上。

以下是一行while子句的示例：

while expression : statement

该用于循环：

循环外观的语法是：

for iterating_var in sequence:
   statements(s)

按序列索引迭代：

迭代遍历每个项目的另一种方法是通过索引偏移到序列本身中：

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

print "Good bye!"

该破声明：

Python中的break语句终止当前循环，并在下一个语句中恢复执行，就像在C中发现的传统break一样。

最常见的破坏用途是当触发一些外部条件需要仓促退出循环时。该休息语句既可以使用，同时并进行循环。

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

将继续陈述：

Python中的continue语句将控件返回到while循环的开头。在继续声明将拒绝在循环的当前迭代所有剩余的语句和移动控制回到循环的顶部。

继续语句既可以使用，同时并进行循环。

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

var = 10                    # Second Example
while var > 0:              
   print "Current variable value :", var
   var = var -1
   if var == 5:
      continue

print "Good bye!"

与循环一起使用的else语句

Python支持有一个其他与循环语句联合声明。

该通声明：

当语法需要语法但不需要执行任何命令或代码时，Python中的pass语句将被使用。

通语句是一个空操作; 执行时没有任何反应。该通行证在您的代码最终会出现但尚未写入的地方也是有用的（例如，以存根为例）：

#!/usr/bin/python

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

print "Good bye!"

定义功能

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

用法：

def functionname( parameters ):
   "function_docstring"
   function_suite
   return [expression]

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

例：

这是Python函数中最简单的形式。此功能将一个字符string作为输入参数，并在标准屏幕上打印。

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 - 模块：

一个模块允许您逻辑地组织您的Python代码。将相关代码分组到一个模块中，使代码更容易理解和使用。

一个模块是一个具有任意命名的属性的Python对象，可以绑定和引用。

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

例：

名为aname的模块的Python代码通常位于名为aname.py的文件中。以下是一个简单的模块hello.py的例子

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

该进口声明：

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

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

当解释器遇到导入语句时，如果该模块存在于搜索路径中，它将导入该模块。搜索路径是导入模块之前解释器搜索的目录的列表。

例：

要导入模块hello.py，您需要将以下命令放在脚本的顶部：

#!/usr/bin/python

# Import module hello
import hello

# Now you can call defined function that module as follows
hello.print_func("Zara")

输出结果如下：

Hello : Zara

模块只能加载一次，而不管导入的次数。这样可以防止在多次导入时重复执行模块。

打开和关闭文件：

在开放功能：

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

用法：

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

这里是参数细节：

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

模式描述
r打开仅供阅读的文件。文件指针位于文件的开头。这是默认模式。
rb打开仅用二进制格式读取的文件。文件指针位于文件的开头。这是默认模式。
r +打开一个用于阅读和写作的文件。文件指针将位于文件的开头。
rb +打开二进制格式的读写文件。文件指针将位于文件的开头。
w打开仅供写入的文件。如果文件存在，则覆盖该文件。如果文件不存在，则创建一个新文件进行写入。
wb打开仅用二进制格式写入的文件。如果文件存在，则覆盖该文件。如果文件不存在，则创建一个新文件进行写入。
w +打开写入和阅读的文件。如果文件存在，则覆盖现有文件。如果文件不存在，则创建一个新文件进行阅读和写入。
wb +打开一个二进制格式的写入和读取文件。如果文件存在，则覆盖现有文件。如果文件不存在，则创建一个新文件进行阅读和写入。
一个打开一个文件进行追加。如果文件存在，文件指针位于文件末尾。也就是说，该文件处于附加模式。如果该文件不存在，它将创建一个新文件进行写入。
ab打开一个二进制格式的文件。如果文件存在，文件指针位于文件末尾。也就是说，该文件处于附加模式。如果该文件不存在，它将创建一个新文件进行写入。
a +打开一个文件，用于追加和阅读。如果文件存在，文件指针位于文件末尾。文件以附加模式打开。如果文件不存在，它将创建一个新文件进行阅读和写入。
ab +打开一个二进制格式的附加和阅读文件。如果文件存在，文件指针位于文件末尾。文件以附加模式打开。如果文件不存在，它将创建一个新文件进行阅读和写入。

该文件对象atrributes：

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

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

属性描述
file.closed如果文件关闭，则返回true，否则返回false。
file.mode返回打开文件的访问模式。
文件名返回文件的名称。
file.softspace如果空格明确地需要print，则返回false，否则返回true。

在接近（）方法：

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

fileObject.close();

阅读和写作文件：

在写（）方法：

用法：

fileObject.write(string);

在读（）方法：

用法：

fileObject.read([count]);

文件位置：

在告诉（）方法告诉你，换句话说在文件中的当前位置，下一个读或写会发生在从文件的开头很多字节：

的寻道（偏移[，从]）方法改变当前文件位置。所述偏移参数指示要被移动的字节数。该从 参数指定从其中字节是要移动的基准位置。

如果从设置为0，则表示使用文件的开头作为参考位置，1表示使用当前位置作为参考位置，如果设置为2，则将文件的末尾作为参考位置。

重命名和删除文件：

用法：

os.rename(current_file_name, new_file_name)

该删除（）方法：

用法：

os.remove(file_name)

Python中的目录：

该MKDIR（）方法：

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

用法：

os.mkdir("newdir")

该CHDIR（）方法：

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

用法：

os.chdir("newdir")

该GETCWD（）方法：

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

用法：

os.getcwd()

该命令rmdir（）方法：

该命令rmdir（）方法删除的目录，其作为在该方法的参数传递。

删除目录之前，应删除其中的所有内容。

用法：

os.rmdir("dirname")

处理例外：

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

用法：

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

try:
   Do you 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.

以下是上述语法的几点要点：

在除了没有例外条款：

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

try:
   Do you operations here;
   ......................
except:
   If there is any exception, then execute this block.
   ......................
else:
   If there is no exception then execute this block.

具有多个例外的except子句：

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

try:
   Do you 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.

标准例外：

这是一个列表标准Python中提供的异常：标准异常

try-finally子句：

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

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

例外的论证：

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

try:
   Do you operations here;
   ......................
except ExceptionType, Argument:
   You can print value of Argument here...

提出例外：

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

用法：

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

用户定义的异常：

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

创建类：

在类的语句创建一个新的类定义。类的名称紧跟在关键字类后跟冒号如下：

class ClassName:
   "Optional class documentation string"
   class_suite

创建实例对象：

要创建类的实例，可以使用类名调用该类，并传递其__init__方法接受的任何参数。

"This would create first object of Employee class"
emp1 = Employee("Zara", 2000)
"This would create second object of Employee class"
emp2 = Employee("Manni", 5000)

访问属性：

您可以使用带有对象的点运算符来访问对象的属性。将使用类名称访问类变量，如下所示：

emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

内置类属性：

每个Python类保持以下内置属性，并且可以像任何其他属性一样使用点运算符访问它们。

摧毁对象（垃圾收集）：

Python自动删除不需要的对象（内置类型或类实例）以释放内存空间。Python定期回收不再使用的内存块的过程称为垃圾收集。

Python的垃圾收集器在程序执行期间运行，并且当对象的引用计数达到零时触发。对象的引用计数随着指向它的别名数量的变化而变化：

当对象的引用计数被分配一个新名称或放置在容器（列表，元组或字典）中时，引用计数会增加。当它与删除的对象的引用计数减少德尔，其基准被重新分配，或它引用超出范围。当对象的引用计数达到零时，Python会自动收集它。

类继承：

而不是从头开始，您可以通过在新类名后面的括号中列出父类来从预先存在的类派生它来创建一个类：

子类继承其父类的属性，您可以像子类中定义的一样使用这些属性。子类也可以从父代替代数据成员和方法。

用法：

派生类被声明为很像他们的父类; 然而，继承的基类的列表在类名之后给出：

class SubClassName (ParentClass1[, ParentClass2, ...]):
   "Optional class documentation string"
   class_suite

覆盖方法：

您可以随时覆盖您的父类方法。覆盖父方法的一个原因是因为您可能需要在子类中使用特殊或不同的功能。

class Parent:        # define parent class
   def myMethod(self):
      print "Calling parent method"

class Child(Parent): # define child class
   def myMethod(self):
      print "Calling child method"

c = Child()          # instance of child
c.myMethod()         # child calls overridden method

基本重载方法：

下表列出了您可以在自己的类中覆盖的一些通用功能：

SN方法，说明和样品呼叫
1__init__（self [，args ...]）
构造函数（带任意可选参数）
示例调用：obj = className（args）
2__del __（self）
析构函数，删除一个对象
Sample Call：dell obj
3__repr __（self）可
评估字符string表示
样本调用：repr（obj）
4__str __（self）可
打印的字符string表示
样本调用：str（obj）
5__cmp__（self，x）
对象比较
示例调用：cmp（obj，x）

重载操作符：

假设您已经创建了一个Vector类来表示二维向量。当您使用加号运算符添加它们时会发生什么？很可能Python会对你大喊大叫。

但是，您可以在类中定义__add__方法来执行向量加法，然后加运算符将按照期望行为：

#!/usr/bin/python

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return "Vector (%d, %d)" % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print v1 + v2

数据隐藏：

对象的属性在类定义之外可能或不可见。对于这些情况，您可以使用双下划线前缀命名属性，这些属性将不会对外部人员直接可见：

#!/usr/bin/python

class JustCounter:
   __secretCount = 0
  
   def count(self):
      self.__secretCount += 1
      print self.__secretCount

counter = JustCounter()
counter.count()
counter.count()
print counter.__secretCount

一个正则表达式是一个字符的特殊序列，可帮助您匹配或查找其他字符string或字符string集，使用的模式举办了专门的语法。正则表达式在UNIX世界中被广泛使用。

该模块重新提供了对Python中Perl类正则表达式的全面支持。如果在编译或使用正则表达式时发生错误，则re模块会引发异常re.error。

我们将覆盖将用于处理正则表达式的两个重要功能。但是一件小事首先：在正则表达式中使用时会有特殊的含义。为了在处理正则表达式时避免混淆，我们将使用Raw Strings作为r表达式。

该匹配功能

此功能尝试重新匹配模式，以string与可选的标志。

这是这个函数的语法：

re.match(pattern, string, flags=0)

以下是参数的说明：

参数描述
模式这是要匹配的正则表达式。
string这将是搜索匹配模式的字符string
标志您可以使用异或（|）指定不同的标志。这些是下表中列出的修饰符。

该re.match函数返回匹配成功，对象没有失败。我们将使用match （num）或groups（）函数来匹配表达式。

匹配对象方法描述
组（num = 0）此方法返回整个匹配（或特定子组num）
组（）此方法返回一个元组中的所有匹配子组（如果没有，则为空）

该搜索功能

此功能可以使用可选标志搜索字符string内第一次出现RE 模式。

这是这个函数的语法：

re.string(pattern, string, flags=0)

以下是参数的说明：

参数描述
模式这是要匹配的正则表达式。
string这将是搜索匹配模式的字符string
标志您可以使用异或（|）指定不同的标志。这些是下表中列出的修饰符。

该re.search函数返回匹配成功，对象没有失败。我们将使用match （num）或groups（）函数来匹配表达式。

匹配对象方法描述
组（num = 0）此方法返回整个匹配（或特定子组num）
组（）此方法返回一个元组中的所有匹配子组（如果没有，则为空）

配对vs搜索：

Python提供基于正则表达式的两种不同的原始操作：匹配检查仅匹配字符string的开头，而搜索则检查字符string中任何位置的匹配（这是Perl在默认情况下所做的）。

搜索和替换：

使用正则表达式的一些最重要的re方法是sub。

用法：

sub(pattern, repl, string, max=0)

此方法代替RE的所有匹配图案中的字符string与REPL，用所有出现除非最大提供。此方法将返回修改的字符string。

正则表达式修饰符 - 选项标志

正则表达式文字可能包含一个可选修饰符，用于控制匹配的各个方面。修饰符指定为可选标志。您可以使用异或（|）提供多个修改，如前所示，可以由以下之一表示：

修饰符描述
re.I执行不区分大小写的匹配。
re.L根据当前语言环境解释单词。该解释会影响字母组（ w和 W）以及字边界行为（ b和 B）。
re.M使$匹配一行的结尾（而不仅仅是字符string的结尾），并使^匹配任何行的开始（而不仅仅是字符string的开头）。
re使一个句点（点）匹配任何字符，包括换行符。
re.U根据Unicode字符集解释字母。此标志影响 w， W， b， B的行为。
re.X允许“cuter”正则表达式语法。它忽略空格（除了一个集合[]之外，或者用反斜杠转义），并将未转义的＃作为注释标记。

正则表达式：

除了控制字符（+？。* ^ $（）[] {} | ），所有字符都与其自身匹配。您可以通过使用反斜杠将其转换为控制字符。

下表列出了Python中可用的正则表达式语法。

模式描述
^匹配开始行
$匹配行尾。
。匹配除换行符以外的任何单个字符。使用m选项可以使其匹配换行符。
[...]匹配括号中的任何单个字符。
[^ ...]匹配不在括号中的任何单个字符
回覆*匹配0或更多出现前面的表达式。
re +匹配0或1出现前面的表达式。
re {n}匹配正好n个前面表达式的出现次数。
re {n，}匹配前面表达式出现n次或更多次。
re {n，m}匹配至少n个和最多m个先前表达式的出现。
a | b匹配a或b。
（回覆）组合正则表达式并记住匹配的文本。
（？imx）临时切换正则表达式中的i，m或x选项。如果在括号中，只有该区域受到影响。
（？-imx）临时切换正则表达式中的i，m或x选项。如果在括号中，只有该区域受到影响。
（？： 回覆）组合正则表达式而不记住匹配的文本。
（？imx：re）暂时在括号内切换i，m或x选项。
（？-imx：re）暂时在括号内切换i，m或x选项。
（？＃...）注释。
（？= re）使用模式指定位置。没有范围。
（？！ 回覆）使用模式否定指定位置。没有范围。
（？> re）匹配独立模式，无需追溯。
w匹配字符字符
W匹配非字符字符。
s匹配空格 相当于[ t n r f]。
S匹配非空格。
d匹配数字 相当于[0-9]。
D匹配不一致
一个匹配字符string开始。
Z匹配字符string的结尾。如果存在换行符，则它将在换行符之前匹配。
z匹配字符string的结尾。
G比赛最后一场比赛结束。
b外部括号匹配字边界。在括号内匹配退格（0x08）。
B匹配非字边界。
n， t等等匹配换行符，回车符，制表符等
1 ... 9匹配第n个分组子表达式。
10匹配第n个分组子表达式，如果它已经匹配。否则指的是字符代码的八进制表示。

正则表达式：

文字：

例描述
蟒蛇匹配“python”。

角色类：

例描述
[Pp] yyon 匹配“Python”或“python”
揉搓匹配“ruby”或“rube”
[aeiou]匹配任何一个小写元音
[0-9]匹配任何数字; 与[0123456789]
[az]匹配任何小写的ASCII字母
[AZ]匹配任何大写的ASCII字母
[a-zA-Z0-9]匹配上述任何一种
[^ aeiou]匹配除小写元音之外的任何东西
[^ 0-9]匹配数字以外的任何东西

特殊字符类：

例描述
。匹配除换行符以外的任何字符
d匹配数字：[0-9]
D 匹配一个非数字：[^ 0-9]
s匹配空格字符：[ t r n f]
S 匹配非空格：[^ t r n f]
w匹配单字字符：[A-Za-z0-9_]
W匹配非字符：[^ A-Za-z0-9_]

重复案例：

例描述
红宝石？ 匹配“rub”或“ruby”：y是可选的
红宝石* 匹配“擦”加0或更多ys
红宝石+匹配“擦”加上1个或更多的y
d {3}完全匹配3位数字
d {3，}匹配3位或更多位数字
d {3,5}匹配3，4或5位数

不朽的重复：

这匹配最小的重复次数：

例描述
<。*>贪婪重复：匹配“<python> perl>”
<。*？>Nongreedy：在“<python> perl”中匹配“<python>”

分组括号：

例描述
D d +没有组：+重复 d
（ D d）+分组：+重复 D d对
（[Pp] ython（，）？）+匹配“Python”，“Python，python，python”等

反向引用

这将重新匹配以前匹配的组：

例描述
（[Pp]）ython＆ 1ails匹配python和pails或Python和Pails
（["“]）[^ 1] * 1单引号或双引号字符string。 1匹配第一组匹配。 2匹配任何第二组匹配等

备择方案：

例描述
python | perl匹配“python”或“perl”
擦（y | le））匹配“红宝石”或“卢布”
Python（！+ | ？）“Python”后跟一个或多个！还是一个？

锚点：

这需要指定匹配位置

例描述
^ Python匹配“Python”在字符string或内部行的开头
Python $ 匹配“Python”在字符string或行的末尾
APython 在字符string的开头匹配“Python”
Python Z匹配“Python”在字符string的末尾
bPython b在字边界匹配“Python”
brub B B是非字边界：在“rube”和“ruby”中匹配“rub”，而不是单独
Python（？=！）匹配“Python”，如果紧跟感叹号
蟒蛇（？！！）匹配“Python”，如果不跟着感叹号

带括号的特殊语法：

例描述
R（？＃注释）匹配“R”。其余的都是注释
R（？i）uby匹配“uby”时不区分大小写
R（？i：uby）与上述相同
擦（？：y | le））仅组合而不创建 1反向引用

© 2023 mianshi8.net MIT license