Python学习笔记——Python起步

本章将对 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

1

就象你看到的, 运算符的优先级和你想象的同样: + 和 - 优先级最低, *, /, //, %优先级较高, 单目运算符 + 和 - 优先级更高, 乘方的优先级最高。(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

上面的代码还添加了一个额外的没有任何参数的 print 语句, 它用来输出一个换行符。不然, 提示信息就会马上出如今咱们的输出以后。下面是以上代码的输出:

I like to use the Internet for:

e-mail net-surfing homework chat

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

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

>>> foo = 'abc'

>>> for c in foo:

...

print c

...

a

b

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

0

1

4

9

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

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

>>>

>>> for i in sqdEvens:

... print i

0

4

16

36

文件和内建函数 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)

10

每一个方法的调用都返回咱们指望的结果。比较有趣的数据是类名字。在 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。

PEP 索引的网址是: http://python.org/dev/peps

实用的函数

dir([obj]) 显示对象的属性名,若是没有提供参数, 则显示全局变量的名字。

help([obj]) 以一种整齐美观的形式显示对象的文档字符串, 若是没有提供任何参数, 则会进入交互式帮助。

int(obj) 将一个对象转换为整数

len(obj) 返回对象的长度

open(fn, mode) 以mode('r' = 读, 'w'= 写)方式打开一个文件名为 fn 的文件

range([[start,]stop[,step]) 返回一个整数列表。起始值为 start, 结束值为 stop - 1; start默认值为 0, step默认值为1。

raw_input(str) 等待用户输入一个字符串, 能够提供一个可选的参数 str 用做提示信息。

str(obj) 将一个对象转换为字符串

type(obj) 返回对象的类型(返回值自己是一个type对象)