【python】简明Python教程

基础

int 类型可以指任何大小的整数
字符串是不可变的
标识符名称区分大小写
Python 鼓励每一行使用一句独立语句（不用分号）从而使得代码更加可读
请确保你在缩进中使用数量一致的空格，否则你的程序将不会运行，或引发不期望的行为。

help—有关任何函数或语句的快速信息

“”" 或 ‘’’ —指定多行字符串

format—将每个参数值替换至格式所在的位置

print('{name} wrote {book}'.format(name='Swaroop', book='A Byte of Python'))
Swaroop wrote A Byte of Python

end—指定结尾

print('a', end='')
print('b', end='')
ab

\反斜杠—转义序列

原始字符串

如果你需要指定一些未经过特殊处理的字符串，比如转义序列，那么你需要在字符串前增加
r 或 R 来指定一个 原始（Raw） 字符串。下面是一个例子：

r"Newlines are indicated by \n"

针对正则表达式用户的提示

在处理正则表达式时应全程使用原始字符串。否则，将会有大量 Backwhacking 需要处
理。举例说明的话，反向引用可以通过 ‘\1’ 或 r’\1’ 来实现。

在某些情况下，会存在一个隐含的假设，允许你不使用反斜杠。这一情况即逻辑行以括号开
始，它可以是方括号或花括号，但不能是结束括号。这被称作 隐式行连接（Implicit Line
Joining）。你可以在后面当我们讨论列表（List）的章节时了解这一点。

Python 将始终对块使用缩进，并且绝不会使用大括号。你可以通过运行
from__future__import braces 来了解更多信息。
【hello.py】

运算符与表达式

运算符概览

+ （加）
两个对象相加。
3+5 则输出 8 。 ‘a’ + ‘b’ 则输出 ‘ab’ 。

- （减）
从一个数中减去另一个数，如果第一个操作数不存在，则假定为零。
-5.2 将输出一个负数， 50 - 24 输出 26 。

* （乘）
给出两个数的乘积，或返回字符串重复指定次数后的结果。
2 * 3 输出 6 。 ‘la’ * 3 输出 ‘lalala’ 。

** （乘方）
返回 x 的 y 次方。
3 ** 4 输出 81 （即 3 * 3 * 3 * 3 ）。

/ （除）
x 除以 y
13 / 3 输出 4.333333333333333 。

// （整除）
x 除以 y 并对结果向下取整至最接近的整数。
13 // 3 输出 4 。
-13 // 3 输出 -5 。

% （取模）
返回除法运算后的余数。
13 % 3 输出 1 。 -25.5 % 2.25 输出 1.5 。

<< （左移）
将数字的位向左移动指定的位数。（每个数字在内存中以二进制数表示，即 0 和1）
2 << 2 输出 8 。 2 用二进制数表示为 10 。
向左移 2 位会得到 1000 这一结果，表示十进制中的 8 。

>> （右移）
将数字的位向右移动指定的位数。
11 >> 1 输出 5 。
11 在二进制中表示为 1011 ，右移一位后输出 101 这一结果，表示十进制中的
5 。

& （按位与）
对数字进行按位与操作。
5 & 3 输出 1 。

| （按位或）
对数字进行按位或操作。
5 | 3 输出 7 。

^ （按位异或）
对数字进行按位异或操作。
5 ^ 3 输出 6 。

~ （按位取反）
x 的按位取反结果为 -(x+1)。
~5 输出 -6 。

有关本例的更多细节可以参阅：
http://stackoverflow.com/a/11810203。

< （小于）
返回 x 是否小于 y。所有的比较运算符返回的结果均为 True 或 False 。请注意这
些名称之中的大写字母。
5 < 3 输出 False ， 3 < 6 输出 True 。
比较可以任意组成组成链接： 3 < 5 < 7 返回 True 。

> （大于）
返回 x 是否大于 y。
5 > 3 返回 True 。如果两个操作数均为数字，它们首先将会被转换至一种共同的
类型。否则，它将总是返回 False 。

<= （小于等于）
返回 x 是否小于或等于 y。
x = 3; y = 6; x<=y 返回 True 。

= （大于等于）
返回 x 是否大于或等于 y。
x = 4; y = 3; x>=3 返回 True 。

== （等于）
比较两个对象是否相等。
x = 2; y = 2; x == y 返回 True 。
x = ‘str’; y = ‘stR’; x == y 返回 False 。
x = ‘str’; y = ‘str’; x == y 返回 True 。

!= （不等于）
比较两个对象是否不相等。
x = 2; y = 3; x != y 返回 True 。

not （布尔“非”）
如果 x 是 Ture ，则返回 False 。如果 x 是 False ，则返回 True 。
x = Ture; not x 返回 False 。

and （布尔“与”）
如果 x 是 False ，则 x and y 返回 False ，否则返回 y 的计算值。
当 x 是 False 时， x = False; y = True; x and y 将返回 False 。在这一情境中，
Python 将不会计算 y，因为它已经了解 and 表达式的左侧是 False ，这意味着整个
表达式都将是 False 而不会是别的值。这种情况被称作短路计算（Short-circuit
Evaluation）。

or （布尔“或”）
如果 x 是 True ，则返回 True ，否则它将返回 y 的计算值。
x = Ture; y = False; x or y 将返回 Ture 。在这里短路计算同样适用。

最低优先级（最少绑定）到最高优先级（最多绑定）的优先级表

lambda ：Lambda 表达式

if - else ：条件表达式

or ：布尔“或”

and ：布尔“与”

not x ：布尔“非”

in, not in, is, is not, <, <=, >, >=, !=, == ：比较，包括成员资格测试
（Membership Tests）和身份测试（Identity Tests）。

| ：按位或

^ ：按位异或

& ：按位与

<<, >> ：移动

+, - ：加与减

*, /, //, % ：乘、除、整除、取余

+x, -x, ~x ：正、负、按位取反

** ：求幂

x[index], x[index:index], x(arguments…), x.attribute ：下标、切片、调用、属性引用

(expressions…), [expressions…], {key: value…}, {expressions…} ：显示绑定或数组、显示列表、显示字典、显示设置

【Expression.py】printf中的引号使用有所出入

控制流

• 【if.py】

if 语句在结尾处包含一个冒号——我们借此向 Python 指定接下来会有一块语句在后头。

• 【while.py】

• 【for.py】

==- 【break.py】Input Error

• continue.py】Input Error==

函数

• 【functon1.py】

• 【function_param.py】

• 【function_local.py】

• 【function_global.py】

可以在同一句 global 语句中指定不止一个的全局变量，例如 global x, y, z

• 【function_default.py】

默认参数值应该是常数。在函数的参数列表中拥有默认参数值的参数不能位于没有默认参数值的参数之前。

• 【function_keyword.py】

• 【function_varargs.py】

当我们声明一个诸如 *param 的星号参数时，从此处开始直到结束的所有位置参数（Positional Arguments）都将被收集并汇集成一个称为“param”的元组（Tuple）。
类似地，当我们声明一个诸如 **param 的双星号参数时，从此处开始直至结束的所有关键字
参数都将被收集并汇集成一个名为 param 的字典（Dictionary）。

• 【function_return.py】

如果 return 语句没有搭配任何一个值则代表着 返回 None 。每一个函数都在其末尾隐含了一句 return None ，除非你写了你自己的 return 语句。Python 中的 pass 语句用于指示一个没有内容的语句块。

• 【function_docstring.py】

==该文档字符串所约定的是一串多行字符串，其中第一行以某一大写字母开始，以句号结束。第二行为空行，后跟的第三行开始是任何详细的解释说明。在此强烈建议你在有关你所有非凡功能的文档字符串中都遵循这一约定。

我们可以通过使用函数的__doc__（注意其中的双下划线）属性（属于函数的名称）来获取函数 print_max 的文档字符串属性。只消记住Python将所有东西都视为一个对象，这其中自然包括函数。==

模块

• 【module_using_sys.py】
  如果它不是一个已编译好的模块，即用Python编写的模块，那么Python解释器将从它的sys.path变量所提供的目录中进行搜索。如果找到了对应模块，则该模块中的语句将开始运行，并能够为你所使用。在这里需要注意的是，初始化工作只需在我们第一次导入模块时完成。

另外要注意的是当前目录指的是程序启动的目录。你可以通过运行以下代码来查看你的程序目前所处在的目录。

import os;
print(os.getcwd()) 

按字节码编译的 .pyc 文件

为了减少导入模块所带来的代价，这一文件以 .pyc 为其扩展名，是将 Python 转换成中间形式的文件

**注意：**这些 .pyc 文件通常会创建在与对应的.py文件所处的目录中。如果Python没有相应的权限对这一目录进行写入文件的操作，那么 .pyc 文件将不会被创建。

from…import 语句

如果你希望直接将 argv 变量导入你的程序（为了避免每次都要输入 sys. ），那么你可以通过使用 from sys import argv 语句来实现这一点。

**警告：**一般来说，你应该尽量避免使用from…import语句，而去使用import语句。这是为了避免在你的程序中出现名称冲突，同时也为了使程序更加易读。

模块的 name

每个模块都有一个名称，而模块中的语句可以找到它们所处的模块的名称。
【module_using_name.py】

要记住该模块应该放置于与其它我们即将导入这一模块的程序相同的目录下，或者是放置在sys.path 所列出的其中一个目录下。
【mymodule_demo.py】

from mymodule import *

这将导入诸如 say_hi 等所有公共名称，但不会导入 version 名称，因为后者以双下划线开头。尽量避免此种写法。

可以通过在 Python 中运行 import this来了解更多内容。

dir 函数

• 内置的 dir() 函数能够返回由对象所定义的名称列表。如果这一对象是一个模块，则该列表会包括函数内所定义的函数、类与变量。
• 该函数接受参数。 如果参数是模块名称，函数将返回这一指定模块的名称列表。如果没有提供参数，函数将返回当前模块的名称列表。

包

包是指一个包含模块与一个特殊的__init__.py文件的文件夹，后者向Python表明这一文件夹是特别的，因为其包含了 Python 模块。

数据结构

列表（List）

【ds_using_list.py】

列表是一种用于保存一系列有序项目的集合，也就是说，你可以利用列表保存一串项目的序列。

对象（Object）与类（Class）

• 一个类可以带有方法（Method），也就是说对这个类定义仅对于它启用某个函数。使用点号的方法来访问。
• 一个类同样也可以具有字段（Field），它是只为该类定义且只为该类所用的变量。使用点号的方法来访问。

元组（Tuple）

【ds_using_tuple.py】

• 元组（Tuple）用于将多个对象保存到一起。元组的一大特征类似于字符串，它们是不可变的，也就是说，你不能编辑或更改元组。
• 元组是通过特别指定项目来定义的，在指定项目时，你可以给它们加上括号，并在括号内部用逗号进行分隔。一个空的元组 myempty = () 。一个只拥有一个项目的元组 singleton = (2, ) 。
• 元组通常用于保证某一语句或某一用户定义的函数可以安全地采用一组数值，意即元组内的数值不会改变。
• 可以通过在方括号中指定项目所处的位置来访问元组中的各个项目。这种使用方括号的形式被称作索引（Indexing）运算符。

字典（Dictionary）

【ds_using_dict.py】

• 字典将键值（Keys）（即姓名）与值（Values）（即地址等详细信息）联立到一起。键值必须是唯一的。e.g. d = {key : value1 , key2 : value2}
• 只能使用不可变的对象（如字符串）作为字典的键值，但是你可以使用可变或不可变的对象作为字典中的值。
  - 字典中的成对的键值—值配对不会以任何方式进行排序。如果你希望为它们安排一个特别的次序，只能在使用它们之前自行进行排序。
• 字典是属于 dict 类下的实例或对象。

序列（Sequence）

【ds_seq.py】

• 列表、元组和字符串可以看作序列（Sequence）的某种表现形式。
• 序列的主要功能是资格测试（Membership Test）（也就是 in 与 not in 表达式）和索引操作（Indexing Operations），它们能够允许我们直接获取序列中的特定项目。
• 使用切片（Slicing）运算符，可以得到序列中的某段切片。在切片操作中，第一个数字（冒号前面的那位）指的是切片开始的位置，第二个数字（冒号后面的那位）指的是切片结束的位置。第三个参数是切片的步长（Step）（在默认情况下，步长大小为 1）

集合（Set）

【Collection.py】

• 集合（Set）是简单对象的无序集合（Collection）。

>>> bri = set(['brazil', 'russia', 'india'])
>>> 'india' in bri
True
>>> 'usa' in bri
False
>>> bric = bri.copy()
>>> bric.add('china')
>>> bric.issuperset(bri)
True
>>> bri.remove('russia')
>>> bri & bric # OR bri.intersection(bric)
{'brazil', 'india'}

引用

【ds_reference.py】

如果你希望创建一份诸如序列等复杂对象的副本（而非整数这种简单的对象（Object）），你必须使用切片操作来制作副本。如果你仅仅是将一个变量名赋予给另一个名称，那么它们都将“查阅”同一个对象，如果你对此不够小心，那么它将造成麻烦。（母本更改子本也更改，但子本更改母本不更改）

字符串

【ds_str_methods.py】

在程序中使用的所有字符串都是 str 类下的对象（类似Java，String有自己的方法）

面向对象编程

self

• 如果你有一个没有参数的功能，你依旧必须拥有一个参数—— self

类

【oop_simplestclass.py】

方法

【oop_method.py】

init 方法

【oop_init.py】

init 方法会在类的对象被实例化（Instantiated）时立即运行。这一方法可以对任何你想进行操作的目标对象进行初始化（Initialization）操作。这里你要注意在 init 的前后加上的双下划线。

类变量与对象变量

【oop_objvar.py】

• 类变量（Class Variable）是共享的（Shared）——它们可以被属于该类的所有实例访问。该类变量只拥有一个副本，当任何一个对象对类变量作出改变时，发生的变动将在其它所有实例中都会得到体现。
• 对象变量（Object variable）由类的每一个独立的对象或实例所拥有。
• 当一个对象变量与一个类变量名称相同时，类变量将会被隐藏。

@classmethod 装饰器等价于调用：

how_many = classmethod(how_many)

只能使用 self 来引用同一对象的变量与方法。这被称作属性引用（Attribute Reference）。

所有的类成员都是公开的。但有一个例外：如果你使用数据成员并在其名字中使用双下划线作为前缀，形成诸如 __privatervar 这样的形式，Python会使用名称调整（Namemangling）来使其有效地成为一个私有变量。因此，你需要遵循这样的约定：任何在类或对象之中使用的对象其命名应以下划线开头，其它所有非此格式的名称都将是公开的，并可以为其它任何类或对象所使用。请记得这只是一个约定，Python并不强制如此（除了双下划线前缀这点）。

继承

【oop_subclass.py】

• 重用（Reuse）与多态（Polymorphism）都与Java类似。基类（Base Class） 或是超类（Superclass）- 派生类（Derived Classes）或是子类（Subclass）。
• 如果我们没有在一个子类中定义一个 init 方法，Python 将会自动调用基类的构造函数。
• 可以通过在类名前面添加前缀连接类与方法，然后通过self变量调用并传递任何参数，来调用基类的方法。
• 如果继承元组（Inheritance Tuple）中有超过一个类，这种情况就会被称作多重继承（Multiple Inheritance）。

输入与输出

文件

【io_using_file.py】

Pickle

【io_pickle.py】

Python 提供了一个叫作 Pickle的标准模块，通过它你可以将任何纯Python对象存储到一个文件中，并在稍后将其取回。这叫作持久地（Persistently）存储对象。

异常

错误（Error）

异常（Exception）

处理异常

【exceptions_handle.py】

将所有可能引发异常或错误的语句放在 try 代码块中，并将相应的错误或异常的处理器（Handler）放在 except 子句或代码块中。

抛出（Thrown）异常

【exceptions_raise.py】

Try … Finally

【exceptions_finally.py】

with 语句

【exceptions_using_with.py】

它总会在代码块开始之前调用thefile.__enter__函数，并且总会在代码块执行完毕之后调用thefile.exit 。因此，我们在 finally代码块中编写的代码应该格外留心__exit__方法的自动操作。这能够帮助我们避免重复发显式使用 try…finally 语句。

标准库

更多

传递元祖

一个函数中返回两个不同的值：

>>> def get_error_details():
... return (2, 'details')
...
>>> errnum, errstr = get_error_details()
>>> errnum
2
>>> errstr
'details'

交换两个变量的最快方法：

>>> a = 5; b = 8
>>> a, b
(5, 8)
>>> a, b = b, a
>>> a, b
(8, 5)

特殊方法

• init(self, …)
  • 这一方法在新创建的对象被返回准备使用时被调用。
• del(self)
  • 这一方法在对象被删除之前调用（它的使用时机不可预测，所以避免使用它）
• str(self)
  • 当我们使用 print 函数时，或 str() 被使用时就会被调用。
• lt(self, other)
  • 当小于运算符（<）被使用时被调用。类似地，使用其它所有运算符（+、>等等）时都会有特殊方法被调用。
• getitem(self, key)
  • 使用 x[key] 索引操作时会被调用。
• len(self)
  • 当针对序列对象使用内置 len() 函数时会被调用

单语句块

>>> flag = True
>>> if flag: print('Yes')
...
Yes

Lambda 表格

【more_lambda.py】
lambda 语句可以创建一个新的函数对象。从本质上说， lambda 需要一个参数，后跟一个表
达式作为函数体，这一表达式执行的值将作为这个新函数的返回值。

列表推导

【more_list_comprehension.py】
列表推导（List Comprehension）用于从一份现有的列表中得到一份新列表

在函数中接收元组与字典

有一种特殊方法，即分别使用 * 或 ** 作为元组或字典的前缀，来使它们作为一个参数为
函数所接收。当函数需要一个可变数量的实参时，这将颇为有用。

>>> def powersum(power, *args):
... '''Return the sum of each argument raised to the specified power.'''
... total = 0
... for i in args:
... total += pow(i, power)
... return total
...
>>> powersum(2, 3, 4)
25
>>> powersum(2, 10)
100

因为我们在 args 变量前添加了一个 * 前缀，函数的所有其它的额外参数都将传递到
args 中，并作为一个元组予以储存。如果采用的是 ** 前缀，则额外的参数将被视为字典
的键值—值配对。

assert 语句

>>> mylist = ['item']
>>> assert len(mylist) >= 1
>>> mylist.pop()
'item'
>>> assert len(mylist) >= 1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AssertionError

装饰器

装饰器（Decorators）是应用包装函数的快捷方式。

Reference

• 项目
  • https://github.com/thekarangoel/Projects#numbers
  • Exercises for Programmers: 57 Challenges to Develop Your Coding Skills
  • Intermediate Python Projects
• 示例代码
  • Python Cookbook 是一本极具价值的“烹饪法”与提示的集合，它介绍了如何通过 Python
    解决某些特定类型的问题。
  • Python Module of the Week 是另一本优秀的标准库必读指南。
• 书籍
  • The Hitchhiker’s Guide to Python!
  • The Elements of Python Style
  • Python Big Picture
  • “Writing Idiomatic Python” ebook （付费）
• 视频
  • Full Stack Web Development with Flask
  • PyVideo
• 问与答
  • Official Python Dos and Don’ts
  • Official Python FAQ
  • Norvig’s list of Infrequently Asked Questions
  • Python Interview Q & A
  • StackOverflow questions tagged with python
• 教程
  • Hidden features of Python
  • What’s the one code snippet/python trick/etc did you wish you knew when you learned
    python?
  • Awaretek’s comprehensive list of Python tutorials
• 新闻
  • Official Python Planet
• 创建一个网站（Flask）
  • Flask Official Quickstart
  • https://www.strikingly.com/s/sites/11646246/edit?new=1
  • The Flask Mega-Tutorial
  • Example Flask Projects
• 函数式编程
  • Functional Programming Howto by A.M. Kuchling
  • Functional programming chapter in ‘Dive Into Python’ book
  • Functional Programming with Python presentation
  • Funcy library
  • PyToolz library