python浓缩（2）Python起步

时间 2019-12-18

标签 python 浓缩起步栏目 Python 繁體版

原文原文链接

本章对Python 的主要特性作一个快速介绍。python

在全部的交互示例中，你会看到Python 的主提示符( >>> )和次提示符( ... )。主提示符是解释器告诉你它在等待你输入下一个语句，次提示符告诉你解释器正在等待你输入当前语句的其它部分。程序员

语句和表达式（函数、算术表达式等）：
shell

语句使用关键字来组成命令，相似告诉解释器一个命令；express
表达式没有关键字。它们能够是使用数学运算符构成的算术表达式，也能够是使用括号调用的函数；编程

2.1 程序输出，print 语句及“Hello World!”

在交互式解释器中，能够用 print 语句显示变量的字符串表示，或者仅使用变量名查看该变量的原始值。
数组

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

下划线(_)在解释器中有特别的含义，表示最后一个表达式的值。app

Python 的print 语句，与字符串格式运算符( % )结合使用，可实现字符串替换功能。函数

%s 表示由一个字符串来替换；%d 表示由一个整数来替换；%f表示由一个浮点数来替换；布局

Print 语句也支持将输出重定向到文件。符号 >> 用来重定向输出，下面这个例子将输出重定向到标准错误输出：ui

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

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

获得数据输入的方法是使用raw_input()内建函数。它读取标准输入，并将读取到的数据赋值给指定的变量。

注：内建函数int()将数值字符串转换成整数值，这样才能够对它进行数学运算。

核心笔记：从交互式解释器中得到帮助

若是须要获得一个生疏函数的帮助，只须要对它调用内建函数help()：

eg:help(raw_input);

核心风格： 一直在函数外作用户交互操做

从用户那里获得须要的数据，而后调用函数处理，从函数获得返回值，而后显示结果给用户。

更重要的，将函数分为两大类，一类只作事，不须要返回值（好比与用户交互或设置变量的值），另外一类则执行一些运算，最后返回结果。若是输出就是函数的目的，那么在函数体内使用 print 语句也是能够接受的选择.

2.3 注释

Python 也使用 # 符号标示注释;
文档字符串：你能够在模块、类或者函数的起始添加一个字符串，起到在线文档的功能；与普通注释不一样，文档字符串能够在运行时访问，也能够用来自动生成文档

2.4 运算符

标准算术运算符：+ - * / // % **

Python 有两种除法运算符，单斜杠用做传统除法，双斜杠用做浮点除法（对结果进行四舍五入).

传统除法是指若是两个操做数都是整数的话，它将执行是地板除(取比商小的最大整数)；
而浮点除法是真正的除法，无论操做数是什么类型，浮点除法老是执行真正的除法【第五章详细介绍】；

标准比较运算符：< <= > >= == !=

逻辑运算符：and or not

eg:

3 < 4 < 5

该例子在其余语言中一般是不合法的，不过Python 支持这样的表达式。它其实是下面表达式的缩写：

>>> 3 < 4 and 4 < 5

2.5 变量和赋值

Python 中变量名规则与其它大多数高级语言同样;
Python变量名是大小写敏感的;
Python 是动态类型语言，变量的类型和值在赋值那一刻被初始化;
Python 也支持增量赋值，也就是运算符和等号合并在一块儿;
Python 不支持C 语言中的自增1 和自减1 运算符,会将 --n 解释为-(-n) 从而获得 n;

2.6 数字

Python 支持五种基本数字类型，其中有三种是整数类型。

int (有符号整数)
long (长整数)
bool (布尔值)
float (浮点值)
complex (复数)

请不要将Python 的长整数与C 语言的长整数混淆。Python 的长整数所能表达的范围远远超过C 语言的长整数， Python 长整数仅受限于用户计算机的虚拟内存总数。若是你熟悉 Java, Python 的长整数相似于 Java 中的BigInteger 类型;整型与长整型正在逐步统一为一种整数类型,从Python2.3 开始，不再会报整型溢出错误，结果会自动的被转换为长整数,在将来版本的Python 中，两种整数类型将会无缝结合，长整数后缀 “L”也会变得无关紧要；

布尔值是特殊的整数;

复数（包括-1 的平方根, 即所谓的虚数）在其它语言中一般不被直接支持（通常经过类来实现)；

decimal，用于十进制浮点数。举例来讲，因为在二进制表示中有一个无限循环片断，数字1.1 没法用二进制浮点数精确表示。所以，数字1.1 实际上会被表示成：

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

第五章详细将介绍全部的数字类型。

2.7 字符串

Python 支持使用成对的单引号或双引号，三引号（三个连续的单引号或者双引号）能够用来包含特殊字符。

使用索引运算符( [ ] )和切片运算符( [ : ] )能够获得子字符串；
字符串有其特有的索引规则：第一个字符的索引是 0，最后一个字符的索引是－1；
加号( + )用于字符串链接运算，星号( * )则用于字符串重复；

你能够在第六章学到更多有关字符串的知识。

2.8 列表和元组

能保存任意数量任意类型的Python 对象。和数组同样，经过从0 开始的数字索引访问元素，可是列表和元组能够存储不一样类型的对象。

列表和元组有几处重要的区别。列表元素用中括号( [ ])包裹，元素的个数及元素的值能够改变。
元组元素用小括号(( ))包裹，不能够更改（尽管他们的内容能够）。元组能够当作是只读的列表。

经过切片运算( [ ] 和 [ : ] )能够获得子集，这一点与字符串的使用方法同样。

你能够在第六章学到更多有关列表、元组以及字符串的知识。

2.9 字典

字典是Python 中的映射数据类型，由键-值(key-value)对构成。几乎全部类型的Python 对象均可以用做键，不过通常仍是以数字或者字符串最为经常使用。

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

在第七章中会详细讲解字典。

2.10 代码块及缩进对齐

代码块经过缩进对齐表达代码逻辑而不是使用大括号。

2.11 if 语句

标准if 条件语句的语法以下：

if expression:
    if_suite

Python 还支持 else、elif （意指 “else-if ”）语句。

在第8 章你能够学到更多有关 if, elif, else 条件语句的知识。

2.12 while 循环

while expression:
    while_suite

第8 章的循环一节进行详细讲解。

2.13 for 循环和range()内建函数

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

print 语句默认会给每一行添加一个换行符。只要在print 语句的最后添加一个逗号(,)，就能够改变它这种行为,带逗号的print 语句输出的元素之间会自动添加一个空格.

另外，经过指定输出格式，程序员能够最大程度的控制输出布局。它也能够将全部数据放到一处输出－－只须要将数据放在格式化运算符右侧的元组或字典中。

由于咱们不能改变 for 循环的行为（迭代一个序列），咱们能够生成一个数字序列。range()内建函数接受一个数值范围，生成一个列表.

range()函数常常和len()函数一块儿用于字符串索引.

>>> foo = 'abc'
>>> for i in range(len(foo)):
... print foo[i], '(%d)' % i

不过，这些循环有一个约束，你要么循环索引，要么循环元素。这致使了enumerate()函数的推出。它同时作到了这两点：

>>> for i, ch in enumerate(foo):
... print ch, '(%d)' % i

2.13 列表解析

你能够在一行中使用一个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

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

如何打开文件：handle = open(file_name, access_mode = 'r')

file_name 变量包含咱们但愿打开的文件的字符串名字；
access_mode 中 'r' 表示读取，'w' 表示写入， 'a' 表示添加。其它可能用到的标声还有 '+' 表示读写， 'b'表示二进制访问. 默认值为 'r'。若是 open() 成功，一个文件对象句柄会被返回。全部后续的文件操做都必须经过此文件句柄进行。当一个文件对象返回以后，咱们就能够访问它的一些方法，好比 readlines() 和close().

核心笔记：什么是属性？

属性能够是简单的数据值，也能够是可执行对象，好比函数和方法。哪些对象拥有属性呢？不少。 类，模块，文件还有复数等等对象都拥有属性。

filename = raw_input('Enter file name: ')
fobj = open(filename, 'r')
for eachLine in fobj:
    print eachLine,
fobj.close()

一次读入文件的全部行，而后关闭文件，再迭代每一行输出。这样写代码的好处是可以快速完整的访问文件。内容输出和文件访问没必要交替进行。

上面的代码适用于文件大小适中的文件。对于很大的文件来讲，会占用太多的内存，这时你最好一次读一行。（下一节有一个好例子）

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

在第9 章，咱们详细介绍文件对象，及它们的内建方法属性，以及如何访问本地文件系统。

2.16 错误和异常

编译时会检查语法错误，不过 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 语句故意引起一个异常。

在第10 章你能够学到更多有关Python 异常的知识。

2.17 函数

若是函数中没有 return 语句， 就会自动返回 None 对象。

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

如何定义函数

def function_name([arguments]):
    "optional documentation string"
    function_suite

定义一个函数的语法由 def 关键字及紧随其后的函数名再加上该函数须要的几个参数组成。这个语句由一个冒号(:)结束，以后是表明函数体的代码组， eg：

def addMe2Me(x):
    'apply + operation to argument'
    return (x + x)

加号运算符几乎与全部数据类型工做，不论是数值相加仍是序列合并。

如何调用函数

>>> addMe2Me(4.25)
8.5
>>> addMe2Me('Python')
'PythonPython'
>>> addMe2Me([-1, 'abc'])
[-1, 'abc', -1, 'abc']

注意一下， + 运算符在非数值类型中如何工做。

默认参数

>>> def foo(debug=True):
... 'determine if in debug mode with default argument'
... if debug:
...     print 'in debug mode'
...     print 'done'
>>> foo()
in debug mode
done
>>> foo(False)
done

请阅读第11 章以了解更详细的函数的信息。

2.18 类

类是面向对象编程的核心，它扮演相关数据及逻辑的容器角色。它们提供了建立“真实”对象(也就是实例)的蓝图。

如何定义类

class ClassName(base_class[es]):
    "optional documentation string"
    static_member_declarations
    method_declarations

能够提供一个可选的父类或者说基类; 若是没有合适的基类，那就使用 object 做为基类。class 行以后是可选的文档字符串，静态成员定义，及方法定义。

class FooClass(object):
    """my very first class: FooClass"""
    version = 0.1 # class (data) attribute  // 定义了一个静态变量 version
    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

__init__() 方法有一个特殊名字，全部名字开始和结束都有两个下划线的方法都是特殊方法。

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

如何建立类实例

>>> foo1 = FooClass()
Created a class instance for John Doe

类实例使用一样的函数运算符调用一个函数或方法:

>>> foo1.showname() Your name is John Doe
My name is __main__.FooClass
>>> foo1.showver()
0.1
>>> print foo1.addMe2Me(5)
10
>>> print foo1.addMe2Me('xyz')
xyzxyz

比较有趣的数据是类名字。在showname()方法中，咱们显示 self.__class__.__name__ 变量的值。对一个实例来讲，这个变量表示实例化它的类的名字。（self.__class__引用实际的类）。在咱们的例子里，建立类实例时咱们并未传递名字参数，所以默认参数 'John Doe' 就被自动使用。不使用默认值的示例以下：

>>> foo2 = FooClass('Jane Smith') 
Created a class instance for Jane Smith
>>> foo2.showname()
Your name is Jane Smith
My name is FooClass

第十三章将详细介绍Python 类和类实例。

2.19 模块

模块是一种组织形式，它将彼此有关系的Python 代码组织到一个个独立文件当中。模块能够包含可执行代码，函数和类或者这些东西的组合。

当你建立了一个 Python 源文件，模块的名字就是不带 .py 后缀的文件名。一个模块建立以后，你能够从另外一个模块中使用 import 语句导入这个模块来使用。

如何导入模块

import module_name

如何访问一个模块函数或访问一个模块变量？一旦导入完成，一个模块的属性（函数和变量）能够经过熟悉的 .句点属性标识法访问。

module.function()
module.variable

如今咱们再次提供 Hello World! 例子，不过此次使用 sys 模块中的输出函数。

>>> 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 中增长新特性的方式。它们不但提供了新特性的完整描述，还有添加这些新特性的理由，若是须要的话，还会提供新的语法、技术实现细节、向后兼容信息等等。在一个新特性被整合进Python 以前，必须经过Python 开发社区， PEP 做者及实现者，还有Python 的创始人， Guidovan Rossum(Python 终身的仁慈的独裁者）的一致赞成。PEP1 阐述了PEP 的目标及书写指南。在PEP0 中能够找到全部的PEP。 PEP 索引的网址是： http://python.org/dev/peps.

关于模块和导入，你能够在第12 章中获得更多有用的信息。

2.19 实用的函数

本章中，咱们用到了不少实用的内建函数。咱们在表2.1 中总结了这些函数，而且提供了一些其它的有用函数。（注意咱们并无提供完整的使用语法，仅提供了咱们认为可能对你有用的部分）

函数描述

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 对象！）