Python学习笔记——Python起步

【推荐】2019 Java 开发者跳槽指南.pdf(吐血整理) >>>

本章将对 Python 的主要特性做一个快速介绍,这样你就可以借助以前的编程经验识别出熟悉的语言结构,并立刻将 Python 付诸使用。虽然细节内容会在后续的章节中逐一讲解,但是对整体的了解可以让你迅速融入到 Python 中。在Python解释器所有的交互示例中, 你会看到 Python 的主提示符( >>> )和次提示符( ... )。主提示符是解释器告诉你它在等待你输入下一个语句,次提示符告诉你解释器正在等待你输入当前语句的其它部分。Python 有两种主要的方式来完成你的要求:语句和表达式(函数、算术表达式等)。语句使用关键字来组成命令,类似告诉解释器一个命令。你告诉 Python 做什么,它就为你做什么,语句可以有输出,也可以没有输出。表达式没有关键字，它们可以是使用数学运算符构成的算术表达式，也可以是使用括号调用的函数。它们可以接受用户输入，也可以不接受用户输入，有些会有输出，有些则没有。(在 Python 中未指定返回值的函数会自动返回 None, 等价于 NULL)

程序输出,print 语句

有些语言, 比如 C, 通过函数输出数据到屏幕,例如函数 printf()。然而在 Python 和大多数解释执行的脚本语言,使用语句进行输出。很多的 shell 脚本语言使用 echo 命令来输出程序结果。

核心笔记:在交互式解释器中显示变量的值通常当你想看变量内容时,你会在代码中使用 print 语句输出。不过在交互式解释器中, 你可以用 print 语句显示变量的字符串表示,或者仅使用变量名查看该变量的原始值。

>>> myString = 'Hello World!'

>>> print myString

Hello World!

>>> myString

'Hello World!'

注意:在仅用变量名时,输出的字符串是被用单引号括起来了的。这是为了让非字符串对象也能以字符串的方式显示在屏幕上--即它显示的是该对象的字符串表示,而不仅仅是字符串本身。引号表示你刚刚输入的变量的值是一个字符串。等你对 Python 有了较深入的了解之后, 你就知道 print 语句调用 str()函数显示对象, 而交互式解释器则调用repr()函数来显示对象。

程序输入和 raw_input()内建函数

下划线(_)在解释器中有特别的含义, 表示最后一个表达式的值。所以上面的代码执行之后,下划线变量会包含字符串:

>>> _

'Hello World!'

Python 的 print 语句,与字符串格式运算符( % )结合使用,可实现字符串替换功能,这一点和 C 语言中的 printf()函数非常相似:

>>> print "%s is number %d!" % ("Python", 1)

Python is number 1!

%s 表示由一个字符串来替换, 而%d 表示由一个整数来替换, 另外一个很常用的就是%f, 它表示由一个浮点数来替换。

Python 非常灵活,所以即使你将数字传递给 %s,也不会像其他要求严格的语言一样引发严重后果。

Print 语句也支持将输出重定向到文件。这个特性是从Python2.0 开始新增的。符号 >> 用来重定向输出,下面这个例子将输出重定向到标准错误输出:

import sys

print >> sys.stderr, 'Fatal error: invalid input!'

import sys

print >> sys.stderr, 'Fatal error: invalid input!

下面是一个将输出重定向到日志文件的例子:

logfile = open('/tmp/mylog.txt', 'a')

print >> logfile, 'Fatal error: invalid input!'

logfile.close()

从用户那里得到数据输入的最容易的方法是使用 raw_input()内建函数。它读取标准输入, 并将读取到的数据赋值给指定的变量。你可以使用 int() 内建函数将用户输入的字符串转换为整数。

>>> user = raw_input('Enter login name: ')

Enter login name: root

>>> print 'Your login is:', user

Your login is: root

上面这个例子只能用于文本输入。下面是输入一个数值字符串(并将字符串转换为整数) 的例子:

>>> num = raw_input('Now enter a number: ')

Now enter a number: 1024

>>> print 'Doubling your number: %d' % (int(num) * 2)

Doubling your number: 2048

内建函数 int()将数值字符串转换成整数值,这样才可以对它进行数学运算。

核心笔记:从交互式解释器中获得帮助在学习 Python 的过程中, 如果需要得到一个生疏函数的帮助, 只需要对它调用内建函数help()。通过用函数名作为 help()的参数就能得到相应的帮助信息：

>>> help(raw_input)

Help on built-in function raw_input in module __builtin__:

raw_input(...)

raw_input([prompt]) -> string

Read a string from standard input. The trailing newline is stripped.

If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError.

On Unix, GNU readline is used if enabled. The prompt string, if given, is printed without a trailing newline before reading.

核心风格: 保持在函数外做用户交互操作

注释

和大部分脚本及 Unix-shell 语言一样,Python 也使用 # 符号标示注释,从 # 开始,直到一行结束的内容都是注释。

>>> # one comment

... print 'Hello World!' # another comment

Hello World!

有一种叫做文档字符串的特别注释。你可以在模块、类或者函数的起始添加一个字符串, 起到在线文档的功能,这是 Java 程序员非常熟悉的一个特性。

def foo():

"This is a doc string."

return True

运算符

和其他绝大多数的语言一样,Python 中的标准算术运算符以你熟悉的方式工作,加、减、乘、除和取余都是标准运算符。Python 有两种除法运算符, 单斜杠用作传统除法, 双斜杠用作浮点除法(对结果进行四舍五入)。传统除法是指如果两个操作数都是整数的话, 它将执行是地板除(取比商小的最大整数)，而浮点除法是真正的除法,不管操作数是什么类型,浮点除法总是执行真正的除法。

还有一个乘方运算符, 双星号(**)：

>>> print -2 * 4 + 3 ** 2

就象你看到的, 运算符的优先级和你想象的一样: + 和 - 优先级最低, *, /, //, %优先级较高, 单目运算符 + 和 - 优先级更高, 乘方的优先级最高。(3 ** 2) 首先求值, 然后是 (-2 * 4), 然后是对两个结果进行求和。

Python 目前支持两种“不等于”比较运算符, != 和 <> , 分别是 C 风格和 ABC/Pascal风格。目前后者慢慢地被淘汰了, 所以我们推荐使用前者。

Python 也提供了逻辑运算符:and or not

变量和赋值

Python 是动态类型语言, 也就是说不需要预先声明变量的类型。变量的类型和值在赋值那一刻被初始化。变量赋值通过等号来执行。

Python 也支持增量赋值,也就是运算符和等号合并在一起, 看下面的例子: n *= 10

Python 不支持 C 语言中的自增 1 和自减 1 运算符, 这是因为 + 和 - 也是单目运算符,Python 会将 --n 解释为-(-n) 从而得到 n , 同样 ++n 的结果也是 n.

数字

Python支持五种基本数字类型：

int (有符号整数)

long (长整数)

bool (布尔值)

float (浮点值)

complex (复数)

Python 中有两种有趣的类型是 Python 的长整型和复数类型。请不要将 Python 的长整数与 C 语言的长整数混淆。Python 的长整数所能表达的范围远远超过 C 语言的长整数,事实上,Python 长整数仅受限于用户计算机的虚拟内存总数。如果你熟悉 Java, Python 的长整数类似于 Java 中的 BigInteger 类型。

布尔值是特殊的整数。尽管布尔值由常量 True 和 False 来表示, 如果将布尔值放到一个数值上下文环境中(比方将 True 与一个数字相加), True 会被当成整数值 1, 而 False则会被当成整数值 0。复数(包括-1 的平方根, 即所谓的虚数)在其它语言中通常不被直接支持(一般通过类来实现)。

其实还有第六种数字类型, decimal, 用于十进制浮点数。不过它并不是内建类型, 你必须先导入 decimal 模块才可以使用这种数值类型。由于需求日渐强烈, Python 2.4 增加了这种类型。举例来说, 由于在二进制表示中有一个无限循环片段,数字 1.1 无法用二进制浮点数精确表示。因此, 数字 1.1 实际上会被表示成:

>>> 1.1

1.1000000000000001

>>> print decimal.Decimal('1.1')

1.1

字符串

Python 中字符串被定义为引号之间的字符集合。Python 支持使用成对的单引号或双引号,三引号(三个连续的单引号或者双引号)可以用来包含特殊字符。使用索引运算符( [ ] )和切片运算符( [ : ] )可以得到子字符串。字符串有其特有的索引规则:第一个字符的索引是 0,最后一个字符的索引是 -1。

加号( + )用于字符串连接运算,星号( * )则用于字符串重复。

列表和元组

可以将列表和元组当成普通的“数组”,它能保存任意数量任意类型的 Python 对象。和数组一样,通过从 0 开始的数字索引访问元素,但是列表和元组可以存储不同类型的对象。

列表和元组有几处重要的区别。列表元素用中括号( [ ])包裹,元素的个数及元素的值可以改变。元组元素用小括号(( ))包裹,不可以更改(尽管他们的内容可以)。元组可以看成是只读的列表。通过切片运算( [ ] 和 [ : ] )可以得到子集,这一点与字符串的使用方法一样。

字典

字典是 Python 中的映射数据类型,几乎所有类型的 Python 对象都可以用作键,不过一般还是以数字或者字符串最为常用。

值可以是任意类型的 Python 对象,字典元素用大括号({ })包裹。

代码块及缩进对齐

代码块通过缩进对齐表达代码逻辑而不是使用大括号,因为没有了额外的字符,程序的可读性更高。而且缩进完全能够清楚地表达一个语句属于哪个代码块。当然,代码块也可以只有一个语句组成。

if 语句

标准 if 条件语句的语法如下:

if expression:

if_suite

如果条件表达式的值非 0 或者为布尔值 True, 则代码组 if_suite 被执行; 否则就去执行下一条语句。代码组是一个Python术语, 它由一条或多条语句组成,表示一个子代码块。Pthon与其它语言不同, 条件表达式并不需要用括号括起来。

if x < .0:

print '”x” must be atleast 0!'

Python 当然也支持 else 语句, 语法如下:

if expression:

if_suite

else:

else_suite

Python 还支持 elif (意指 “else-if ”)语句,语法如下:

if expression1:

if_suite

elif expression2:

elif_suite

else:

else_suite

while 循环

标准 while 条件循环语句的语法类似 if. 再说一次, 要使用缩进来分隔每个子代码块。

for 循环和 range()内建函数

Python 中的 for 循环与传统的 for 循环(计数器循环)不太一样, 它更象 shell 脚本里的foreach 迭代。Python 中的 for 接受可迭代对象(例如序列或迭代器)作为其参数,每次迭代其中一个元素。

>>> print 'I like to use the Internet for:'

I like to use the Internet for:

>>> for item in ['e-mail', 'net-surfing', 'homework','chat']:

... print item

...

e-mail

net-surfing

homework

chat

上面例子的输出如果能在同一行就会美观许多。print 语句默认会给每一行添加一个换行符。只要在 print 语句的最后添加一个逗号(,), 就可以改变它这种行为。

print 'I like to use the Internet for:'

for item in ['e-mail', 'net-surfing', 'homework', 'chat']:

print item,

上面的代码还添加了一个额外的没有任何参数的 print 语句, 它用来输出一个换行符。否则, 提示信息就会立刻出现在我们的输出之后。下面是以上代码的输出:

I like to use the Internet for:

e-mail net-surfing homework chat

为了输出清晰美观, 带逗号的 print 语句输出的元素之间会自动添加一个空格。通过指定输出格式, 程序员可以最大程度的控制输出布局, 也不用担心这些自动添加的空格。它也可以将所有数据放到一处输出—只需要将数据放在格式化运算符右侧的元组或字典中。

对字符串来说, 很容易迭代每一个字符：

>>> foo = 'abc'

>>> for c in foo:

...

print c

...

range()函数经常和 len()函数一起用于字符串索引。在这里我们要显示每一个元素及其索引值:

>>> foo = 'abc'

>>> for i in range(len(foo)):

... print foo[i], '(%d)' % i

...

a (0)

b (1)

c (2)

不过, 这些循环有一个约束, 你要么循环索引, 要么循环元素。这导致了 enumerate()函数的推出(Python2.3 新增)。它同时做到了这两点:

>>> for i, ch in enumerate(foo):

... print ch, '(%d)' % i

...

a (0)

b (1)

c (2)

列表解析

这是一个让人欣喜的术语, 表示你可以在一行中使用一个 for 循环将所有值放到一个列表

当中:

>>> squared = [x ** 2 for x in range(4)]

>>> for i in squared:

... print i

列表解析甚至能做更复杂的事情, 比如挑选出符合要求的值放入列表:

>>> sqdEvens = [x ** 2 for x in range(8) if not x % 2]

>>>

>>> for i in sqdEvens:

... print i

文件和内建函数 open() 、file()

如何打开文件：

handle = open(file_name, access_mode = 'r')

file_name 变量包含我们希望打开的文件的字符串名字, access_mode 中 'r' 表示读取,'w' 表示写入, 'a' 表示添加。其它可能用到的标声还有 '+' 表示读写, 'b'表示二进制访问. 如果未提供 access_mode , 默认值为 'r'。如果 open() 成功, 一个文件对象句柄会被返回。所有后续的文件操作都必须通过此文件句柄进行。当一个文件对象返回之后, 我们就可以访问它的一些方法, 比如 readlines() 和 close()。

下面有一些代码, 提示用户输入文件名, 然后打开一个文件, 并显示它的内容到屏幕上:

filename = raw_input('Enter file name: ')

fobj = open(filename, 'r')

for eachLine in fobj:

print eachLine,

fobj.close()

代码中另一个有趣的语句是我们又一次在 print 语句中使用逗号来抑制自动生成的换行符号。为什么要这样做?因为文件中的每行文本已经自带了换行字符, 如果我们不抑制 print语句产生的换行符号, 文本在显示时就会有额外的空行产生。

file()内建函数是最近才添加到 Python 当中的。它的功能等同于 open(), 不过 file()这个名字可以更确切的表明它是一个工厂函数。(生成文件对象)类似 int()生成整数对象,dict()生成字典对象。

错误和异常

编译时会检查语法错误, 不过 Python 也允许在程序运行时检测错误。当检测到一个错误,Python 解释器就引发一个异常, 并显示异常的详细信息。程序员可以根据这些信息迅速定位问题并进行调试, 并找出处理错误的办法。

要给你的代码添加错误检测及异常处理, 只要将它们封装在 try-except 语句当中。 try之后的代码组, 就是你打算管理的代码。 except 之后的代码组, 则是你处理错误的代码。

try:

filename = raw_input('Enter file name: ')

fobj = open(filename, 'r')

for eachLine in fobj:

print eachLine,

fobj.close()

except IOError, e:

print 'file open error:', e

程序员也可以通过使用 raise 语句故意引发一个异常。

函数

类似其它的语言, Python 中的函数使用小括号( () )调用。函数在调用之前必须先定义。如果函数中没有 return 语句, 就会自动返回 None 对象。

Python 是通过引用调用的。这意味着函数内对参数的改变会影响到原始对象。不过事实上只有可变对象会受此影响, 对不可变对象来说, 它的行为类似按值调用。

下面是一个简短的例子:

def addMe2Me(x):

'apply + operation to argument'

return (x + x)

这个函数, 干的是“在我的值上加我”的活。它接受一个对象, 将它的值加到自身, 然后返回和。对于数值类型参数, 它的结果是显而易见的, 不过我要在这里指出, 加号运算符几乎与所有数据类型工作。换句话说, 几乎所有的标准数据类型都支持 + 运算符, 不管是数值相加还是序列合并。

函数的参数可以有一个默认值, 如果提供有默认值,在函数定义中, 参数以赋值语句的形式提供。事实上这仅仅是提供默认参数的语法,它表示函数调用时如果没有提供这个参数, 它就取这个值做为默认值。

类

类是面向对象编程的核心, 它扮演相关数据及逻辑的容器角色。它们提供了创建“真实”对象(也就是实例)的蓝图。因为 Python 并不强求你以面向对象的方式编程(与 Java 不同),此刻你也可以不学习类。

如何定义类

class ClassName(base_class[es]):

"optional documentation string"

static_member_declarations

method_declarations

使用 class 关键字定义类。可以提供一个可选的父类或者说基类; 如果没有合适的基类,那就使用 object 作为基类。class 行之后是可选的文档字符串, 静态成员定义, 及方法定义。

class FooClass(object):

"""my very first class: FooClass"""

version = 0.1 # class (data) attribute

def __init__(self, nm='John Doe'):

"""constructor"""

self.name = nm # class instance (data) attribute

print 'Created a class instance for', nm

def showname(self):

"""display instance attribute and class name"""

print 'Your name is', self.name

print 'My name is', self.__class__.__name__

def showver(self):

"""display class(static) attribute"""

print self.version

# references FooClass.version

def addMe2Me(self, x): # does not use 'self'

"""apply + operation to argument"""

return x + x

在上面这个类中, 我们定义了一个静态变量 version, 它将被所有实例及四个方法共享,__init__(), showname(), showver(), 及熟悉的 addMe2Me(). 这些 show*()方法并没有做什么有用的事情, 仅仅输出对应的信息。 __init__() 方法有一个特殊名字, 所有名字开始和结束都有两个下划线的方法都是特殊方法。

当一个类实例被创建时, __init__() 方法会自动执行, 在类实例创建完毕后执行, 类似构建函数。__init__() 可以被当成构建函数, 不过不象其它语言中的构建函数, 它并不创建实例--它仅仅是你的对象创建后执行的第一个方法。它的目的是执行一些该对象的必要的初始化工作。通过创建自己的 __init__() 方法, 你可以覆盖默认的 __init__()方法(默认的方法什么也不做),从而能够修饰刚刚创建的对象。在这个例子里, 我们初始化了一个名为 name的类实例属性(或者说成员)。这个变量仅在类实例中存在, 它并不是实际类本身的一部分。__init__()需要一个默认的参数, 前一节中曾经介绍过。毫无疑问,你也注意到每个方法都有的一个参数, self.

什么是 self ? 它是类实例自身的引用。其他语言通常使用一个名为 this 的标识符。

如何创建类实例

>>> foo1 = FooClass()

Created a class instance for John Doe

屏幕上显示的字符串正是自动调用 __init__() 方法的结果。当一个实例被创建,__init__()就会被自动调用。不管这个__int__()是自定义的还是默认的。

创建一个类实例就像调用一个函数, 它们确实拥有一样的语法。它们都是可调用对象。类实例使用同样的函数运算符调用一个函数或方法。既然我们成功创建了第一个类实例, 那现在来进行一些方法调用:

>>> foo1.showname() Your name is John Doe

My name is __main__.FooClass

>>> foo1.showver()

0.1

>>> print foo1.addMe2Me(5)

每个方法的调用都返回我们期望的结果。比较有趣的数据是类名字。在 showname()方法中,我们显示 self.__class__.__name__ 变量的值。对一个实例来说, 这个变量表示实例化它的类的名字。(self.__class__引用实际的类)。在我们的例子里, 创建类实例时我们并未传递名字参数, 因此默认参数 'John Doe' 就被自动使用。

模块

模块是一种组织形式, 它将彼此有关系的 Python 代码组织到一个个独立文件当中。模块可以包含可执行代码, 函数和类或者这些东西的组合。当你创建了一个 Python 源文件,模块的名字就是不带 .py 后缀的文件名。一个模块创建之后, 你可以从另一个模块中使用 import 语句导入这个模块来使用。

如何导入模块

import module_name

如何访问一个模块函数或访问一个模块变量

一旦导入完成, 一个模块的属性(函数和变量)可以通过熟悉的 .句点属性标识法访问。

module.function()

module.variable

>>> import sys

>>> sys.stdout.write('Hello World!\n')

Hello World!

>>> sys.platform

'win32'

>>> sys.version

'2.4.2 (#67, Sep 28 2005, 10:51:12) [MSC v.1310 32 bit (Intel)]'

这些代码的输出与我们使用 print 语句完全相同。唯一的区别在于这次调用了标准输出的write()方法,而且这次需要显式的在字符串中提供换行字符, 不同于 print 语句, write()不会自动在字符串后面添加换行符号。

核心笔记:什么是“PEP”?

一个 PEP 就是一个 Python 增强提案(Python Enhancement Proposal), 这也是在新版 Python 中增加新特性的方式。从初学者的角度看,它们是一些高级读物, 它们不但提供了新特性的完整描述, 还有添加这些新特性的理由, 如果需要的话, 还会提供新的语法、技术实现细节、向后兼容信息等等。在一个新特性被整合进 Python 之前,必须通过 Python 开发社区,PEP 作者及实现者,还有 Python 的创始人,Guido van Rossum(Python 终身的仁慈的独裁者)的一致同意。PEP1 阐述了 PEP 的目标及书写指南。在 PEP0 中可以找到所有的 PEP。