此文为简明Python教程笔记。

第一部分

介绍

Python特点
简单、易学——伪代码本质
免费开源——FLOSS（自由/开放源码软件）
高层语言
可移植性强——支持多平台
解释性——更易移植
面向对象——既面向过程也面向对象
可扩展性
可嵌入性
丰富的库

最初的步骤

环境变量

如果是windows，使用前需要编辑path变量——c\python23

运行方式

命令行，交互式解释器，或者源文件。
交互式解释器作用是把python代码翻译成机器码
交互式解释器有哪些？
Python——命令行启动
IPython
JPython
CPython
ironPython
IDLE（集成开发环境Python GUI）——提示符： >>>是你键入python语句的提示符。退出python提示符：按Ctrl-z再按Enter。

注释

“#”符号右面的内容都是注释
“#!”后面跟着一个程序
组织行：

#！/usr/bin/python

这行告诉系统该运行哪个解释器
python文件第一行有这个才能直接运行。

编码解码

# -*- encoding:utf-8 -*-

文件首行有这行才能显示中文。
文件保存为utf-8格式的文件。

基本概念

常量

特点：
不能改变它的值
在赋值给变量之前不需要声明
访问一个未赋值的变量会产生一个异常

some_other_var  # Raises a name error

if 可以作为表达式来使用

"yahoo!" if 3 > 2 else 2 #=> "yahoo!"

数

包含整数，长整数，浮点数，复数。

字符串

字符串相关

引号：

单引号
双引号与单引号完全相同
三引号——指示多行字符串

转义符
自然字符串——前缀r或R
Unicode字符串——前缀u或U
字符串是不可变的
按字面意义级连接字符串

字符串处理

1.字符串连接：

##两种方法
+
" ".join[a,b]

2.转义符：

'What\'s your name?'
##行末的单独一个反斜杠表示字符串在下一行继续，而不是开始一个新的行
\\ 反斜杠
\000 空
\’ 单引号
\” 双引号
\n 换行
\t Tab制表符
\40表示空格

3.使用dir(str)查看常见的字符串方法。
4.比较两个序列值是否相同

cmp(str1,str2)

5.字符串格式化输出
占位符：

%s  字符串（采用str()的显示）
%f 浮点数
%r 字符串（采用repr()的显示）
%c 单个字符
%b 二进制整数
%d 十进制整数
%e 指数

format函数：

##检测字符串里有没有大括号{}，有的话ID替换掉
url.format(itemid)

变量

标识符

1.规则
第一个字符必须是字母表中的字母（大写或小写）或者一个下划线，名称的其他部分可以由字母（大写或小写）、下划线（‘ _ ’）或数字（0-9）组成。
2.变量
使用规则：变量要先赋值，后使用
相关方法：id(a)，可以查看a变量在python解释器中定义的位置
3.函数
4.类

数据类型

数据类型有哪些

None——null
str——字符串类型，ASCII，以8位的ASCII码储存，比如：‘abc’，’中国’
unicode——Unicode字符串类型，16位的Unicode字符，比如：u’Hello world’
float——双精度（64）浮点数
bool——布尔类型，Ture或者False（大写）

表示Ture：
1
“****”——字符串不为空
[1，2，3]——列表不为空
{“a”:"aaa"}
只要不是空的
表示False：
0
“”——字符串为空
[]——列表为空
{}——字典为空

int——有符号整数，最大值由平台决定
long——任意精度的有符号整数，int类型数字一旦超过最大值，会自动转换为long

数

整数，长整数，浮点数，复数complex。

如何判断一个变量的类型

type函数可以用于得到某个对象的类型
isinstance 函数用于判断某个对象类型是否属于指定的类型中的一种

类型转换函数

str字符串调用decode方法转为unicode（解码）。
unicode字符串调用encode方法转为str字符串。
工厂函数:

int  将其他对象转成整数类型  
float() bool() str() long()

对象

任何东西

逻辑行与物理行

物理行是你在编写程序时所 看见的。逻辑行是Python 看见 的单个语句。
想要在一个物理行中使用多于一个逻辑行，那么你需要使用分号（;）
反斜杠的使用，有时候有一种暗示的假设，可以不需要使用反斜杠

缩进

同一层次的语句合起来称为一个块

None

不要使用相等符号 == 来把对象和 None 进行比较

"etc" is None

None、0 以及空字符串和空列表都等于 False，除此以外的所有值都等于 True

0 == False  #=> True
"" == False #=> True

运算符与表达式

运算符

1.注意优先级
2.计算顺序——圆括号改变
3.结合规律：
具有相同优先级的运算符从左到右顺序：

2+3+4的等同于（2+3）+4

赋值运算符是自右向左:

a=b=c等同于a=(b=c)

表达式

1.数学运算表达式
其中，关于除法

除法，有一个是小数，结果是小数。
整数相除，默认得到商。
from__future__import division让两整数相除得到浮点数结果

2.逻辑运算表达式——or,and
3.比较运算表达式——1>2
4.python中表达式都有值，其值就是表达式运算后的结果

第二部分

控制流

选择结构（判断语句）

if语句
用来检验一个条件， 如果 条件为真，我们运行一块语句

if-elif-else
##逻辑行结尾处有一个冒号,else可选
##冒号后跟着语句块

循环结构

while语句

1.循环次数未知
2.只要在一个条件为真的情况下，while语句允许你重复执行一块语句
3.else可选

for循环（迭代历遍语句）

1.迭代字符串
2.for..in——for i in range(1, 5):
3.在一序列的对象上 递归 即逐一使用队列中的每个项目
4.else可选
5.range(数字)：
– 返回从零到给定的数字的数字列表
– range（0，1001，2）
– 包头不包尾，默认是0
– 迭代器，先把要迭代的数全部生成好存在内存，再一个个操作
– 必须整数
– 3.5版本默认就是生成器
6.xrange——生成器，一次生成一个（性能的提升），3.5版本没有
7.循环次数已知

break语句

如果你从for或while循环中 终止 ，任何对应的循环else块将不执行
if s == ‘quit’: break
跳出循环

continue语句

用来告诉Python跳过当前循环块中的剩余语句，然后 继续 进行下一轮循环。
略过循环。

if len(s) < 3:  continue
##如果长度小于3，我们将使用continue语句，忽略块中的剩余的语句。否则，这个循环中的剩余语句将被执行

函数

组成

定义

1.函数是重用的程序段
2.通过def关键字定义

def sayHello():

3.

if__name__=='__main__':pass
##python文件在被调用的时候，__name__值为模块名
##当python文件被运行之后，__name__值为‘__main__’
##上面只定义函数、常用属性，下面写主逻辑。

参数

1.参数名称为 形参
2.函数调用的值称为实参
3.默认参数值

##只有在形参表末尾的那些参数可以有默认参数值
def func(a, b=5)是有效的

4.关键参数

##使用名字（关键字）而不是位置来给函数指定实参
"{name} wants to eat {food}".format(name="Bob", food="lasagna")

5.可变数量参数

##也可以定义一个函数，并让它接受可变数量的关键字参数
def keyword_args(**kwargs):
keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
##你可以定义一个函数，并让它接受可变数量的定位参数
def varargs(*args)
varargs(1, 2, 3) #=> (1,2,3)
##还可以同时使用这两类参数
def all_the_args(*args, **kwargs):
##使用 * 来展开元组，使用 ** 来展开关键字参数

局部变量

所有变量的作用域是它们被定义的块
global语句

global x, y, z
##声明是全局变量

语句与文档字符串

return语句

从一个函数 返回 即跳出函数
没有返回值的return语句等价于return None

文档字符串（DocStrings）

1.标准格式
文档字符串以大写字母开始，句号结尾。第二行是空行，从第三行开始是详细的描述。

''' '''

2.调用方法
用doc（注意双下划线）调用printMax函数的文档字符串属性
3.也适用模块和类

匿名函数

(lambda x: x > 2)(3) #=> True

dir()函数

查看该模块的函数列表
dir + help的使用

内置的常用数学函数

divmod 返回两个数相除的商和余数
round 四舍五入

Math模块常用的函数

pow 幂运算
sqrt 开方运算
floor/ceil
fabs
fmod

高阶函数

map:

map(lambda x:x*2+1,data)
map(add_10, [1,2,3]) #=> [11, 12, 13]

reduce:

##求10的阶乘
num=[1,2,3,4,5,6,7,8,9,10]
reduce(lambda x,y:x*y,num)

使用列表推导式来模拟 map 和 filter

[add_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]

filter

##1000以内的偶数
res=filter(lambda x: x%2==0,a)
filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
##过滤判断好的

模块

导入方法

绝对导入

import sys语句

sys.argv

相对导入

from..import语句

from sys import argv
from sys import *    ##你可以从一个模块中导入所有函数
##不建议使用这种方式,import 更易读

字节编译的.pyc文件

安装其他人的模块

1.Anaconda2\Scripts

所有python的工具都在这个文件夹
conda.exe

2.模块的安装
pip命令(python自带)：

c:\python27\scripts>pip.exe install pymysql
c:\python27\lib\site-packages   ##所有第三方库的文件夹

conda命令(anaconda环境特有):

conda.exe install scrapy
conda.exe list  ##把当前python环境里安装的所有第三方模块都返回

优先使用
好处：能够自动分析模块之间的依赖，如果安装A模块中，引用了B模块，可以自动安装好B模块
缺点：网络不好易下载失败，解决办法：尝试使用代理
whl文件的安装（google一下）:
二进制文件
搜索需要的包，复制到scripts文件夹下，使用pip等安装，输入首字母按Tab自动补全。

sys.path

当前python文件的目录
site-packages

模块方法

1.模块的属性
模块的name
当一个模块被第一次输入的时候，这个模块的主块将被运行。假如我们只想在程序本身被使用的时候运行主块，而在它被别的模块输入的时候不运行主块，我们该怎么做呢？这可以通过模块的name属性完成。

if __name__ == '__main__':

2.join的方法

print" ".join("1","2","3")

模块类别

常见模块

1.sys系统相关
2.datetime日期
3.re正则表达式
4.math数学运算模块
5.Numpy科学计算 Pandas结构化函数 Scipy数值积分 matplotlib绘制数据图表
6.request http访问库 scrapy网络爬虫工具库
7.学习方法
dir()函数:
列出模块定义的标识符。标识符有函数、类和变量。
当你为dir()提供一个模块名的时候，它返回模块定义的名称列表
如果不提供参数，它返回当前模块中定义的名称列表
help()函数:
详细定义
8.python标准库

制造你自己的模块

这个模块应该被放置在我们输入它的程序的同一个目录中，或者在sys.path所列目录之一
使用了点号来使用模块的成员
from mymodule import sayhi, version

库、包、模块之间的关系

包含关系：库-包-模块
一个包下面可以有很多模块
包的文件下面必须有init.py

数据结构

类与对象的概念

当你使用变量i并给它赋值的时候，你可以认为你创建了一个类（类型）int的对象（实例）i

列表list

属性

1.方括号

shoplist = ['apple', 'mango', 'carrot', 'banana']

2.比如赋整数5，你可以认为你创建了一个类（类型）int的对象（实例）i
3.用 in 来检查是否存在于某个列表中
4.索引indexing、分片slicing
5.获取列表长度

len(a)
a.__len__()

6.在print 语句的结尾使用一个逗号来消除每个语句自动打印的换行符，就是不回车了

print 'these items are:',

修改

1.添加

##在末尾添加
shoplist.append('rice')
##插入，在索引为1的位置插入
mylist.insert(1,3000)

2.排序
shoplist.sort()

shoplist.sort(reverse=ture)   ##表示从大到小
##这个方法影响列表本身，而不是返回一个修改后的列表
##与字符串工作的方法不同，因此我们说列表可变，字符串不可变

reverse——把列表的元素反过来
3.修改索引为1的元素

把列表的元素反过来

4.删除

##删除
del shoplist[0]
##移除最后一个元素，并且返回删除的值
li.pop()        #=> 3 and li is now [1, 2, 4]
#删除指定元素（有多个删除第一个，没有抛出异常）
remove

5.输出列表元素

print mylist(0:10:2)
##0-10隔一个取

6.列表求和

print sum(mylist)

表与表

1.列表相加

li + other_li
##结果[1, 2, 3, 4, 5, 6] - 请留意 li 和 other_li 并不会被修改

2.用 extend 来合并列表

li.extend(other_li)
现在 li 是 [1, 2, 3, 4, 5, 6]

不定常列表

def funcw(*args):
##后面就可以将args作为列表使用
func2(1,2,2,2,3,4,5)

元组tuple

属性

1.圆括号

zoo = ('wolf', 'elephant', 'penguin')

2.不可变
3.来访问new_zoo元组的第三个项目的第三个项目

new_zoo[2][2]

4.含有单个元素的元组，在第一个项目后跟一个逗号,这样Python才能区分元组和表达式中一个带圆括号的对象

singleton = (2 , )

基本使用方法

1.元组最通常的用法是用在打印语句中

print '%s is %d years old'   % (name, age)
"{0} can be {1}".format("strings", "formatted")  ##format 方法

2.定制字符串
%s——表示字符串
%d——表示整数
3.也可以一个定制

print 'why is %s playing with that python?' % name

方法

1.元组拆包
你可以把元组（或列表）中的元素解包赋值给多个变量

a, b, c = (1, 2, 3)
##现在 a 是 1，b 是 2，c 是 3
##如果你省去了小括号，那么元组会被自动创建
d, e, f = 4, 5, 6

2.交换两个值

e, d = d, e
##现在 d 是 5 而 e 是 4

字典

属性

1.字典是dict类的实例/对象
2.花括号

ab = { 'Swaroop' : 'swaroopch@byteofpython.info'}
d = {key1 : value1, key2 : value2 }

3.字典输出无序
4.映射mapping：
通过名称来引用值的数据结构
把键（名字）和值（详细情况）联系在一起
哈希映射或相联数组(重要)

基本使用方法

1.

print "Swaroop's address is %s" % ab['Swaroop']

2.用索引操作符来寻址一个键并为它赋值

ab['Guido'] = 'guido@python.org'

3.del语句来删除键/值对

del ab['Spammer']

4.使用in操作符检验一个键/值对是否存在
或者使用dict类的has_key方法

if 'Guido' in ab:

5.使用 in 来检查一个字典是否包含某个键名

"one" in filled_dict #=> True

方法

1.与键名有关
将字典的所有键名获取为一个列表

filled_dict.keys() #=> ["three", "two", "one"]
##请注意：无法保证字典键名的顺序如何排列

将字典的所有键值获取为一个列表

filled_dict.values() #=> [3, 2, 1]

2.与键值有关
使用 [] 来查询键值：

filled_dict["one"] #=> 1

get根据key获取value值，key不存在时返回None，查询一个不存在的键名会产生一个键名错误：

filled_dict["four"] # KeyError
##所以要使用 get 方法来避免键名错误
filled_dict.get("one") #=> 1
filled_dict.get("four") #=> None
##get 方法支持传入一个默认值参数，将在取不到值时返回
filled_dict.get("one", 4) #=> 1
filled_dict.get("four", 4) #=> 4

pop获取指定键的值，然后将该键值对从字典中移除。
setdefault根据key返回对应的value值，key不存在则返回默认值并相应更新字典。
3.都有关
items：

字典的items方法来使用字典中的每个键/值对，来使用字典中的每个键/值对。
将所有的项以列表的方式返回。
iteritems返回迭代器。

Setdefault 方法可以安全地把新的名值对添加到字典里：

filled_dict.setdefault("five", 5)
##filled_dict["five"] 被设置为 5
filled_dict.setdefault("five", 6)
##filled_dict["five"] 仍然为 5

copy、deepcopy复制（浅复制、深复制）。
popitem随机移除某个键值对。
clear清除字典中所有的项。
update使用一个字典去更新另一个字典：

字典重点键值对会添加到原来的字典中
有相同的key则更新对应的value

其他

person_info={uid[0]:{"name":name[0],"age":age[0],"sex":sex[0]}}
person_info["u1"]['name']
##取u1中name是什么

不定常字典:

def func3(**kwargs)
func3(host="localhost",port="3366")
连接数据库时方便使用

先创建空表，后逐步填充:

employee={}.fromkeys(("name","age","salary")."i,do not know")

集合

1.set 用于保存集合

empty_set = set()
some_set = set([1,2,2,3,4])
##some_set 现在是 set([1, 2, 3, 4])
##从 Python 2.7 开始，{} 可以用来声明一个集合
filled_set = {1, 2, 2, 3, 4}
##（译注：集合是种无序不重复的元素集，因此重复的 2 被滤除了。）
##（译注：{} 不会创建一个空集合，只会创建一个空字典。）

2.把更多的元素添加进一个集合

filled_set.add(5)
##filled_set 现在是 {1, 2, 3, 4, 5}

3.使用 & 来获取交集

other_set = {3, 4, 5, 6}
filled_set & other_set #=> {3, 4, 5}

4.使用 – 来获取补集

{1,2,3,4} - {2,3,5} #=> {1, 4}

序列

1.列表、元组和字符串都是序列
2.索引操作符

print 'Item 0 is', shoplist[0]

3.切片操作符

print 'Item 1 to -1 is', shoplist[1:-1]
##相当于数学中的左闭右开区间

4.使用 | 来获取并集

filled_set | other_set #=> {1, 2, 3, 4, 5, 6}

引用/参考

如果是想复制，使用切片操作，复制后复制副本不受原始对象变化影响。
如果只是使用另一个变量名，那么是只是参考同一个对象。

更多字符串的方法

1.startwith方法
测试字符串是否以给定字符串开始
2.in操作符
给定字符串是否是另一个字符串的一部分
3.find方法
找出位置，返回-1表示找不到
4.字符串join
返回一个生成的大字符串：

delimiter = '_*_'
print delimiter.join(mylist)
mylist = ['Brazil','Russia','India','China']
##结果:
Brazil_*_Russia_*_India_*_China

python推导式

for循环结合表达式
列表推导式
字典推导式
集合推导式