1.1.将Python程序代码保存为以.py结尾的文件 1.2.缩进的一致性 1.3.获取用户输入： >>>x=raw_input('x:')
# raw_input与input区别，前者获取用户输入后返回的类型是字符串，后者返回初始值。 x:2
>>>y=raw_input('y:') y:3
print x*y 6# 结束
1.4.赋值时要注意，如果赋的是列表、字典和set，那么不能直接用赋值号=，而是要用copy函数，因为这三种容器本质上赋的是地址。其他情况的赋值无所谓。
二.python基本语法 2.1.python文件类型 2.1.1文件分类：
1）*.py文件，这就是我们常见的py源文件，没什么好说的；
2）*.pyc， py源文件编译成的二进制字节码文件，依然由python加载执行，不过速度会提高，也会隐藏源码；
3）*.pyo，优化编译后的程序，也是二进制文件，适用于嵌入式系统。 2.1.2、生成pyc和pyo文件 1）如何生成pyc文件呢？
假设我们有一个1.py文件需要编译成pyc文件，则在python shell输入 import py_compile
py_compile.compile('1.py') 这样就可以生成pyc文件了 2）如何生成pyo文件呢？ python -O -m py_compile 1.py
另外，pyc和pyo跟py文件是一样的，依然可以用python 1.pyc等形式执行
2.2.python编码规则(见pdf文件)
2.2.1. 关于缩进：python 是通过缩进来进行代码布局的。使用 vi 可以在~/.vimrc 中配置几个空格来代表一个 tab，从而来布局 python 函数的缩进。可以只用空格，也可以全部使用 tab键，这样也不会出错。注意空格与tab不能混用。 2.2.2.关于行长度：反斜杠续行。
2.2.3.用两行分割顶层函数和类的定义；用一行分割类成员方法的定义；在一个函数内用空行时请注意谨慎使用于一个逻辑段。
2.2.4. 在 python 2.4 之后内核已经开始支持 Unicode 了。 无论什么情况下，使用 UTF-8 才是王道！ 1 # -*- coding:utf-8 -*- 2
2.2.5. 导入
通常应该在单独行中使用导入。 例如：No: import sys, os Yes: import sys import os
但是这样也是可以的：
from types import StringType, ListType
imports 应该放在文件的顶部，仅在模块注释和文档字符串之后，在模块的全局变量和 常量之前。
Imports 也是有顺序的： 1)Python 标准库的 import；2)第三方库的 import；3)自定义的库的 import；
并且在每组的 import 之间使用一行空行分割。 2.2.6.以下地方不推荐出现空格:
1) 紧挨着圆括号,方括号和花括号的
如:\"spam( ham[ 1 ], { eggs: 2 } )\".写成\"spam(ham[1], {eggs: 2})\". 2) 紧贴在逗号,分号或冒号前的
如: \"if x == 4 : print x , y ; x , y = y , x\". 写成 \"if x == 4: print x, y; x, y = y, x\". 3) 紧贴着函数调用的参数列表前开式括号的
如: \"dict ['key'] = list [index]\". 写成 \"dict['key'] = list[index]\". 4) 紧贴在索引或切片下标开始的开式括号前
如: \"dict ['key'] = list [index]\".写成\"dict['key'] = list[index]\".
5) 在赋值(或其它)运算符周围的用于和其它并排的一个以上的空格,如: 1 x = 1 2 y = 2
3 long_variable = 3
写成 1 x = 1 2 y = 2
3 long_variable = 3
6)始终在这些二元运算符两边放置一个空格:赋值(=), 比较(==, <, >, !=, <>, <=,>=, in, not in, is, isnot), 布尔运算 (and, or, not). 按你的看法在算术运算符周围插入空格. 始终保持二元运算符两边空格的一致.一些例子: 1 i = i+1
2 submitted = submitted + 1 3 x = x*2 - 1
4 ypot2 = x*x + y*y 5 c = (a+b) * (a-b) 6 c = (a + b) * (a - b)
7)不要在用于指定关键字参数或默认参数值的'='号周围使用空格,例如: 1 def complex(real, imag=0.0): 2 return magic(r=real, i=imag)
2.2.7. 不要将多条语句写在同一行上. No: if foo == 'blah': do_blah_thing() Yes: if foo == 'blah': do_blah_thing()
No: do_one(); do_two(); do_three() Yes: do_one() do_two() do_three()
2.2.8. 注释
1)注释必须跟代码保持一致，当你想修改代码时，建议优先修改注释。
2)注释以'#'和一个空格开始，必须用英语，可以是句子或短语,首字母应大写。 3)如果注释很短，建议省略句末的句号
4)注释块通常由一个或多个由完整句子构成的段落组成，每个句子应该以句号结尾。 5)注释块通常应用于跟随着一些(或者全部)代码并和这些代码有着相同的缩进层次。 6)注释块中每行都是以'#'和一个空格开始(除非他是注释内的缩进文本)。 7)注释块内的段落以仅含单个'#'的行分割。
8)注释块上下方最好有一空行包围(或上方两行下方一行，对一个新函数定义段的注释)。 9)行内注释应该至少用两个空格和语句分开. 它们应该以'#'和单个空格开始. x = x+1 # Increment x
10)约定使用统一的文档化注释格式有助于良好的习惯和团队的进步。
2.2.9.为配合 pydoc;epydoc,Doxygen 等等文档化工具的使用，应该一直遵守编写好的文档字符串的约定。
2.2.10.多行文档字符串结尾的\"\"\" 应该单独成行，例如: \"\"\"Return a foobang
Optional plotz says to frobnicate the bizbaz first. \"\"\"
对单行的文档字符串,结尾的\"\"\"在同一行也可以。 2.2.11.版本注解 1 __version__ = \"$Revision: 1.0.0.0 $\"
这个行应该包含在模块的文档字符串之后,所有代码之前,上下用一个空行分割。 当然也可以这样： 1 ‘’’
2 @version: 1.0.0.0 3 ‘’’
跟其他相关信息（如 author、copyright、date 等）一起。 2.2.12.命名规则 1）单下划线作为前导，如： _single_begin，这是弱的内部使用标识，例如使用“from M import*”的时候不会被导入；
2）单下划线作为结尾的，如：single_end_，这一般用于跟 python 关键词冲突； 3）双下划线前导，如：__double_begin，类私有名；
4）双下划线前导+结尾，如：__double_begin_and_end__，特殊对象或属性，存在于用户控制的命名空间中，如：__init__，__import__等。有时可以被用户定义，用于触发某个特殊行为，如运算符重载。
5）模块名应该是不含下划线的，简短的，小写的名字
6）类名总是使用首字母大写、驼峰命名（第一个单词以小写字母开始；第二个单词的首字母大写或每一个单词的首字母都采用大写字母）单词串的约定。
7）函数名函数名应该为小写、动宾短语，可能用下划线风格单词以增加可读性。如：open_file()
2.3.变量和常量 2.3.1.数字常量，如下是python的一些常量表示形式： 2 整数
3.23 浮点数
52.3e-4 科学技术法表示的浮点数 -5 -4.6j 复数
和C类的语法不同的是，Python是内置了复数的。 2.3.2.布尔常量：布尔值的表示方式是True和False
2.3.3.字符串常量：字符串常量有三种表示显示：单引号（'）双引号（\"）三引号（'''或\"\"\"） 其中单引号和双引号功能完全相同，和C的双引号表示字符串方式一样，主要是新增了一个三引号的多行模式，在三引号的模式中，可以使用单引号和双引号，也可以接收换行符号，对于表示多行来说非常方便。
'''This is a multi-line string. This is the first line. This is the second line.
\"What's your name?,\" I asked. He said \"Bond, James Bond.\" '''
2.3.4.None常量
None是一个特殊的常量。 None和False不同。 None不是0。
None不是空字符串。#想判断字符串是否为空if s.strip()=='':或者if not s.strip(): None和任何其他的数据类型比较永远返回False。 None有自己的数据类型NoneType。
你可以将None复制给任何变量，但是你不能创建其他NoneType对象。 （具体None用法在下文中查找即可）
2.3.4.转义符
转义符的功能基本上和C语言系统相同，以'\\+转义字符'的显示来表示引号，换行等特殊字符
\\n 换行 \ tab
2.3.5.取消转义符
转义字符很多时候给使用带来的不便，如文件路径，正则表达式等。对于无需转义的字符串中可以通过r前缀会取消转义符，从而方便阅读。 r\"C:\\Python27\\python.exe\" Unicode字符串
Python默认的编码是不支持中文的： >>> print '中文abc' ä¸æ–‡abc
对于中文字符串，我们需要加u前缀来转换为unicode形式：
>>> print u'中文abc' 中文abc
2.3.6.连接字符串
相邻放置的字符串会自动级连。例如，'What\\'s' 'your name?'会被自动转为\"What's your name?\"
2.3.7.变量命名规范：Python变量命名规范基本和C语言一样，感兴趣的可以看看： 标识符的第一个字符必须是字母表中的字母（大写或小写）或者一个下划线（' _ '）。 标识符名称的其他部分可以由字母（大写或小写）、下划线（' _ '）或数字（0-9）组成。 标识符名称是对大小写敏感的。例如，myname和myName不是一个标识符。注意前者中的小写n和后者中的大写N。
有效标识符名称的例子有i、__my_name、name_23和a1b2_c3。 无效标识符名称的例子有2things、this is spaced out和my-name。 2.3.8.变量赋值语法 变量赋值语法如下： >>> i = 123
从中可以看出，python是没有变量类型这个概念的，如下方式也是合法的： >>> i = 123
>>> i = 'hello world' 2.3.9.数学运算符
数学运算基本上和C一样
2.4.数据类型
python中的基本数据类型有：整数，浮点数，字符串，布尔类型（True 或 False），空（None） 由于python中变量名是区分大小写的，所以布尔类型中的True和False也是要区分大小写，当然None也是的！（None并不等于数字0！） python中的扩展数据类型：列表（list），元组（tuple），字典（dict），集合（set）
2.4.1.Python数据类型之间的转换 函数 int(x [,base]) long(x [,base] ) float(x) 描述 将x转换为一个整数 将x转换为一个长整数 将x转换到一个浮点数 complex(real [,imag]) 创建一个复数 str(x) repr(x) eval(str) tuple(s) list(s) set(s) dict(d) frozenset(s) 将对象 x 转换为字符串 将对象 x 转换为表达式字符串 用来计算在字符串中的有效Python表达式,并返回一个对象 将序列 s 转换为一个元组 将序列 s 转换为一个列表 转换为可变集合 创建一个字典。d 必须是一个序列 (key,value)元组。 转换为不可变集合 chr(x) unichr(x) ord(x) hex(x) oct(x) 将一个整数转换为一个字符 将一个整数转换为Unicode字符 将一个字符转换为它的整数值 将一个整数转换为一个十六进制字符串 将一个整数转换为一个八进制字符串 查看变量数据类型： a=3
import types type(a)
int(a) #转换为整型 str(a) #转换为字符串
2.4.2.Python数学函数 函数 abs(x)ceil(x)返回值 ( 描述 ) 返回数字的绝对值，如abs(-10) 返回 10 返回数字的上入整数，如math.ceil(4.1) 返回 5 cmp(x, y)exp(x)如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 fabs(x)返回数字的绝对值，如math.fabs(-10) 返回10.0 floor(x)log(x)返回数字的下舍整数，如math.floor(4.9)返回 4 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 log10(x)返回以10为基数的x的对数，如math.log10(100)返回 2.0 max(x1, x2,...)min(x1, x2,...)modf(x)返回给定参数的最大值，参数可以为序列。 返回给定参数的最小值，参数可以为序列。 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。 pow(x, y)x**y 运算后的值。 round(x [,n])sqrt(x)
返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。 返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j 2.5.运算符和表达式 2.5.1.操作符及其用途 操作符 名称 + - * 加 减 乘 用途 使两操作数相加 举例 3 + 5 得到 8. 'a' + 'b' 得到 'ab'. 求出前后两数之差。若第一个操-5.2 得道一个负数， 50 - 24得到26。 作数未写则默认为0。 得出两数乘积或返回重复若干2 * 3得到6。'la' * 3得到'lalala'. 次的字符串。 ** / // % << 幂 除 取整除 取模 左位移 返回x的y次幂。 将x除以y。 返回最大的整数商。 返回余数。 3 ** 4得到81 （ 3 * 3 * 3 * 3） 4 / 3 得到 1.3333333333333333。 4 // 3 得到 1。 8% 3 得到2。 -25.5% 2.25得到1.5. 2 << 2 得到 8。 2在二进制中表示为10 。将操作数向左移动若干bit位。左位移两bit位后得到1000，十进制中表示（数字在内存中以二进制表示） 为8。 将操作数向右移动若干bit位。 数的按位与。 数的按位或。 11 >> 1得到5， 11二进制下表示为1011，右位移一位后得到101，十进制中表示为5。 5 & 3 得到 1。 5 | 3得到7。 5 ^ 3得到6。 ~5得到-6。 >> & | ^ ~ < 右位移 按位与 按位或 按位异或 数的按位异或。 按位翻转 x的按位翻转是-(x+1)。 小于 返回x是否小于y。所有比较运5 < 3得到False，3 < 5得到True. 算符返回布尔值True或False。比较运算符可任意连接，如3 < 5 < 7得到True. 请注意布尔值大小心敏感。 返回x是否大于y。 5 > 3 得到True。如果两个操作符都是数字，解释器会将其转换到同一类型后再比较。若否则返回False。 x = 3; y = 6; x <= y返回True。 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是否小于等于y。 大于等于 返回x是否大于等于y。 等于 不等于 布尔非 比较两操作数是否相等。 比较两操作数是否不相等。 若X为True则返回False，反之x = True; not x返回False。 亦然。 x = False; y = True; x and y由于x为False返无论y值为何，若X为False则x 回False。此例中Python因为已知and左值and y 返回False。 为False而不会计算整个布尔表达式，这是短路求值法。 若x为True则返回True，否则返x = True; y = False; x or y返回True。布尔或回y的布尔值。 同样使用短路求值。 计算结果为true，如果它在指定x在y中，在这里产生一个1，如果x是序找到变量的顺序，否则false。 列y的成员。 计算结果为true，如果它不找到x不在y中，这里产生结果不为1，如果x在指定的变量顺序，否则为不是序列y的成员。 false。 and 布尔与 or in 布尔或 not in is 计算结果为true，如果操作符两x是y，这里结果是1，如果id（x）的值为侧的变量指向相同的对象，否则id（y）。 为false。 计算结果为false，如果两侧的变x不为y，这里结果不是1，当id（x）不等量操作符指向相同的对象，否则于id（y）。 为true。 is not 2.5.2.数值运算捷径，例如：a = 2; a = a * 3写成：a = 2; a *= 3 2.5.3.优先级由低到高： lambda or and not x in，not in is，is not <，<=，>，>=，!=，== | ^ & <<，>> +，- *，/，% +x，-x ~x ** x.attribute x[index] x[index:index] f(arguments...) (experession,...) [expression,...] {key:datum,...} 'expression,...' Lambda表达式 布尔“或” 布尔“与” 布尔“非” 成员测试 同一性测试 比较 按位或 按位异或 按位与 移位 加法与减法 乘法、除法与取余 正负号 按位翻转 指数 属性参考 下标 寻址段 函数调用 绑定或元组显示 列表显示 字典显示 字符串转换 2.5.4.试一个：使用表达式（表达式由常量、变量与运算符） #!/usr/bin/python
# Filename: expression.py
length = 5 breadth = 2
area = length * breadth print 'Area is', area
print 'Perimeter is', 2 * (length + breadth) （源文件：code/expression.py） 输出
$ python expression.py Area is 10
Perimeter is 14
下面看看它如何工作：矩形的长度与宽度存储在以它们命名的变量中。我们借助表达式使用它们计算矩形的面积和边长。我们表达式length * breadth的结果存储在变量area中，然后用print语句打印。在另一个打印语句中，我们直接使用表达式2 * (length + breadth)的值。 另外，注意Python如何打印“漂亮的”输出。尽管我们没有在'Area is'和变量area之间指定空格，Python自动在那里放了一个空格，这样我们就可以得到一个清晰漂亮的输出，而程序也变得更加易读（因为我们不需要担心输出之间的空格问题）。这是Python如何使程序员的生活变得更加轻松的一个例子。
三.控制语句
3.1语句基本知识
（1）print打印多个表达式时中间用逗号隔开即可，打印出来时会把逗号替换成空格 >>> print 1,2,3# 此逗号不会形成元组 1 2 3
若希望打印出来的结果带逗号，可以用+',',例如： >>> print '1'+',','2'+',','3' 1, 2, 3
在结尾加上逗号，下一行打印的内容会与前一条语句在同一行打印 print 'hello,', print 'world'
输出hello,world #这只在脚本中起作用，在Python shell(交互式会话)所有语句会被立即单独执行，所以此做法不起作用 （2）import从模块导入函数
可以用from 模块名 import 函数名
或者用from 模块名 import 函数名1,函数名2,函数名3 或者用from 模块名 import* # 导入所有功能
（3）若好几个模块（module1，module2）有同一函数，用：
import module1 然后以 module1.function1() 和module2.function2()的方式用函数即可 （4）多个变量同时赋值： >>>x,y,z=1,2,3 >>> print x, y,z 1 2 3
（5）语句块：条件语句中条件为真执行的一组语句，或循环语句中多次执行的一组语句。 在代码前放置空格可以创建语句块。
Python中前一句末尾的冒号（:）表示一个语句块的开始。
语句块中每个语句都缩进且缩进量相同。 当取消此语句块的缩进量时，当前语句块结束 3.2.结构化程序设计
（1）自顶向下、逐步求精；
（2）把需要的问题分解成若干那个小问题，对每个小问题设计求解 （3）三种基本结构，顺序结构，条件语句（选择结构），循环结构（满足某条件时，让程序重复执行同一个代码块） 3.3.条件语句
（1）if 条件：当条件（if与冒号之间的表达式）为真时，后面的语句块将被执行。 （2）else子句，例如 if a==x:
print 'shit' else:
print'fuck'
（3）elif子句
num=input('enter a number') if num>0:
print 'the number is positive' elif num<0:
print'the number is negative' else:
print 'the number is zero' （4）嵌套代码块 if 条件1： if 条件2： print... elif条件3： print... else: print... else: print...
（5）比较运算符： == 等于；！= 不等于；>=大于等于；<=小于等于；
x is（not）y x,y（不）是同一个对象； x（not）in y x（不）在y中 # 是is一定是==，但反之不一定，is不仅有相等性（==），还有同一性，例如： >>> x=[1,2,3] >>> y=[1,2,3]
>>> x==y结果为True >>> x is y结果为False
（6）布尔运算符and or not # 它们可以随意组合，让if 直接包含多个条件，用()将优先计算的括起来
if number<=10 and number>=1: # 也可以直接1<=number<=10 print 'good'
else: print 'wrong' 3.4.循环语句 3.4.1.while循环
（1）while基本操作 while 条件： 执行 # 直到不满足此条件，才会跳出 （2）break与continue break跳出最近的整个循环 continue跳出本次循环
3.4.2.for循环（特别在对序列或其他可迭代对象，对每个元素都执行代码块） （1）基本形式： for 对象 in 对相集合 if 条件1： 语句块1 break；#终止此for循环 if条件2： 语句块2 continue；# 跳过下面语句，进入下一循环 语句块3
else: # 如果for循环未被break终止，则执行else块中的语句 语句块4
（2）依次输出列表中所有元素方法一： numbers=[0,1,2,3,4,5,6] for x in numbers: print x
（3）对列表中的数字求和 numbers=[0,1,2,3,4,5,6] sum=0
for x in numbers: sum+=x
print 'sum='+str(sum)
（4）依次输出一个字符串内每一个字符 s=\"python\" for c in s:
print c， # print后面加上逗号，为了使输出的字符在同一行。 （5）for遍历字典元素，例如： a={'x':1,'y':2,'z':3} for key in a: print key,'corresponds to',a[key]
（5）range()函数 # for 循环经常和range()一起用 语法：range(初始值，结束值，步长) 初始值不是必须，默认为0 结束值是必须
步长不是必须，默认值为1
range应用举例1：>>> range(10) #默认起始值为0，步长为1 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> range(3,8) #默认步长为1 [3, 4, 5, 6, 7] >>>range(3,8,1) [3, 4, 5, 6, 7]
>>> range(3,8,2)#指定步长为2 [3, 5, 7]
>>>range(5,-5,-1)
[5, 4, 3, 2, 1, 0, -1, -2, -3, -4] >>>range(5,-5) []
range应用举例2：依次输出列表中的每个元素方法二： aList=['apple','orange','banana']; #定义一个列表
#每次循环都将列表中的一个元素赋值给目标对象x for x in range(len(aList)): print aList[x]; #输出目标对象
range应用举例3：在0～99的数中查找用户输入的值 sx=raw_input(\"输入x的值\"); x=int(sx);
for y in range(0,100): if x==y: print \"find the number \"+str(x); break; else: print \"did't find the number\"
四.内置数据结构
（注意，把一个列表，字典或set赋值给另一个时，要用copy号，而不能用=，因为它们本质上赋的是地址）
4.1.序列
序列中最常用的是列表，元组和字符串，列表可以更改，元组和字符串不可更改（比如字典的键不能修改，所以用元组）
以下特征是列表元组和字符串共有的 4.1.1.序列引索，例如day[2]
4.1.2.序列分片，例如day[2:6] #从第2 个开始，从第6个开始不算 访问前三个，day[:3] 访问后三个，day[-3:]
访问所有，day[:]
等间距访问（步长）day[0:9:3] # 其中3就是步长 每隔一个访问所有元素day[::2] 步长可为负，倒过来访问day[::-1] 4.1.3.序列相加，例如
[1,2,3]+[4,5,6] 得到 [1,2,3,4,5,6] 'hello,'+'world!' 得到'hello,world'
[1,2,3]+'hello' 会报错#只有相同类型的序列才能进行相加，所以列表和字符串不能相加。 4.1.4.序列乘法 >>> 'python'*5
'pythonpythonpythonpythonpython' >>> [42,43]*3
[42, 43, 42, 43, 42, 43]
4.1.5.空列表：[]
占用十个元素空间却没有任何内容的列表：[None]*10 # None是一个python内建值，表示里面什么也没有 4.1.6.成员资格：用in（布尔运算符），真返回true，假返回false，true为布尔值，例如： >>> bibi=['you','i','he'] >>>'you' in bibi True
>>> raw_input('please enter your name, son of bitch:') in bibi please enter your name, son of bitch:he True
4.1.7.len,min,max分别返回序列长度，序列中最小元素，序列中最大元素。对元组来说，比较第一个元素，返回第一个元组最大的元组。 4.2.列表（列表是可变的）
4.2.1.list函数可以把任意类型的序列变成列表。(用join函数可以把字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串，例如''.join9(day)可以把列表转换为字符串)
>>>list('Hello')得到['H','e','l','l','o']
4.2.2.基本的列表操作：元素赋值，元素删除，分片赋值，列表方法。 4.2.3.元素赋值，例如，x[1]=2,即把列表中第二个元素变为了2。
4.2.4.元素删除，例如，del[0]是删除第一个元素，del[:2]是删除前两个元素，delx 是把整个列表删除。（字典与字符串中元素删除也可以使用del）
4.2.5.分片赋值可以进行替换，插入，删除（与del效果相同）等功能。 替换：
>>>name=list('perl')
>>>name[1:]=list('ython') #分片赋值可以用不等长的列表来替换原分片 >>>name
得到结果['p','y','t','h','o','n'] 插入：>>>numbers[1,5] >>>numbers[1:1]=[2,3,4] >>>numbers [1,2,3,4,5]
删除：number[1:4]=[] >>>numbers [1,5]
4.2.6.列表方法：方法是作用于某些对象的函数，对象可以是列表、数字、字符串等等。 列表使用方法：对象.方法(参数). 以下为几种列表方法： (1).append在列表末尾追加新对象。#append是直接修改原表 >>>lst=[1,2,3] >>>lst.append(4) >>>lst [1,2,3,4]
(2).count统计某元素在列表中出现的次数。
>>>['to','be','or','not','to','be'].count('to') 结果是2 >>>x=[[1,2],1,1,2]
>>>x.count(1) 结果是2 >>>x.count([1,2]) 结果是1
(3).extend在列表某末尾追加另一个列表# 注意，加法+不改变原列表a, extend改变a a.extend(b) 在a末尾加上b
a.extend([1,2]) 同理。#也可用分片赋值，但可读性不如extend
(4).index找到某元素最先出现的位置,例如： >>>knight=['we','are','the',knights'','ha','ha','ha'] >>>knight.index('ha') 结果为4
(5).insert方法将对象插入列表中，例如： >>>numbers=[1,2,3,5,6,7] >>>numbers.insert(3,'four')
>>>numbers 结果为 [1,2,3,'four',5,6,7]#也可用分片赋值，但可读性不如insert
(6).pop方法移除列表中的一个元素，（不写是哪个就默认最后一个），并返回该元素值。 # pop是唯一一个既能修改列表又返回元素值的列表方法。 >>>x=[1,2,3]
>>>x.pop() 结果为3 >>>x 结果为[1,2] >>>x.pop(0) 结果为1 >>>x 结果为[2]
# pop可以实现一种常见数据结构——栈。后进先出，就像一堆盘子，先从上面拿。栈操作分为出栈（pop）和入栈（push），入栈用append。>>>x.append(x.pop())得到的还是原来的栈。若要先进先出，insert（0，...）加上pop() 或者用 append 加上 pop(0)
(7).remove移除某元素在列表中出现的第一次匹配项。例如x.remove('be')
(8).reverse将列表中元素反向存放。例如x.reverse()
(9).sort对列表中元素排序，但无返回值。正向排序加上reverse即可 >>>x=[4,6,2,1,7,9] >>>x.sort() >>>x
[1,2,4,6,7,9]
错误做法：
>>>x=[4,6,2,1,7,9]
>>>y=x.sort() # sort只能改变x,但没有返回值（返回空值）。 >>>print y None
正确做法：
>>>x=[4,6,2,1,7,9]
>>>y=x[:] #把x的副本赋给y,注意不能把x直接赋给y,因为那样的话使x,y指向同一个列表 >>>y.sort() >>>
正确做法2：用sorted函数# sorted不改变原序列，sorted用于任何序列总是可以返回一个列表，例如sorted('python') >>>x=[4,6,2,1,7,9] >>>y=sorted(x)
(10).用sort进行高级排序 关键字参数cmp #python中不常用，不跟你玩了。
关键字参数key 例如x.sort(key=len) 按元素长度排序# key需要先提供一个函数，该函数为每个元素创建一个键，所有元素根据键来排序。在上例中len就是键函数
关键字参数 reverse 例如x.sort(reverse=True)，reverse为布尔值True即说明进行反向排序。
(11)copy与deepcopy,把一个序列的值赋给另一个（对字典也同样适用）
# 注意序列a的值给b,不能直接用赋值语句，不然的话改变b也会带来a的变化 应该引入copy模块 a=[1,2] b=[] import copy
b=copy.copy(a) # 也可以用b=a[:],但列表套列表时没用,此时用deepcopy: x=[[1,2],[3,4]] y=[] y=copy.deepcopy(x)
(12)any,all对列表，元祖都可以
any有一个不空，为True，全空，为False >>>any('123') True
>>>any([0, 1]) True
>>>any([0, '']) False
all全不为空，为True, 有空，为False
>>>all('123') True
>>>all([0, 1]) False
>>>all([1, 2]) True
4.2.7.列表解析 在一个序列的值上应用一个任意表达式，将其结果收集到一个新的列表中并返回。它的基本形式是一个方括号里面包含一个for语句对一个iterable对象迭代 例如：
>>> res=[ord(x) for x in 'spam'] >>> res
[115, 112, 97, 109]
>>> [x**2 for x in range(10)] [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
对列表迭代时也可以加上条件：
>>> doubled_odds = [n * 2 for n in numbers if n % 2 == 1]
4.3.元组（元组是不可变的）
4.3.1.用逗号分隔开一些值可以自动创建元组,例如：>>>1,2,3 得到 (1,2,3) 4.3.2.元组大部分情况通过圆括号括起来：>>>(1,2,3)得到 (1,2,3)
一个值的元组，加个逗号实现：>>>42, 得到 (42,) 或者>>>(42,) 得到 (42,) 4.3.3.tuple函数可以把任意序列转换为元组。例如：>>>tuple([1,2,3]) 得到 (1,2,3) 4.3.4.基本元组操作——创建元组，访问元组，其他没了。 >>>x=1,2,3
>>>x[1] 得到2 >>>x[0:2] 得到(1,2) 4.3.5元组存在的意义：
第一，元组在映射（和集合的成员）中可以当做键使用，而列表不行。 第二，一些方法和函数的返回值是元组。 4.4.字符串（不可变） 4.4.0.Python值转为字符串有三种方式，str, repr, 反引号（与repr相同，可忽视）。str让字符串更易读。repr让字符串转换为合法的Python值。
4.4.1字符串基本操作：所有标准的序列操作（索引、分片、乘法、判断成员资格，求长度，取最小值和最大值），但由于字符串不可变，类似分片赋值什么的并不合法。 4.4.2.字符串格式化操作符(%)只适用于字符串类型 4.4.2.1操作符(%)只适用于字符串类型
4.4.2.2.将需要与不需要格式化的字符(需要部分设为a)输入同一个字符串b,例如： b='hello, %s. %d enough for you?' a=('world',9) print b % a
hello, world. 9 enough for you?
#格式化字符串时，python使用字符串b作为模板，%s与%d为两个格式符，a为一个tuple值（元组），模板和Tuple之间有一个分隔符%，它代表了格式化操作。 4.4.2.3.字符串格式化符号（转义字符号） %s 字符串 (采用str()的显示) %r 字符串 (采用repr()的显示) %c 单个字符 %b 二进制整数
%d / %i 十进制整数 %o 八进制整数 %x 十六进制整数 %e 指数 (基底写为e) %E 指数 (基底写为E) %f /%F 浮点数
%g 指数(e)或浮点数 (根据显示长度) %G 指数(E)或浮点数 (根据显示长度) %% 输出字符\"%\" 4.4.2.4.辅助符号： 辅助符号 - + 0 # m.n *
说明
靠左对齐(不给左边留空格) 表示给数字加上正负号
若转换值位数不够，显示的数字前面填充“0”
在八进制数前面显示零(0)，在十六进制前面显示“0x”或者“0X”（取决于用的是“x”还是“X”）
m 是显示的最小总宽度，n 在转换实数时表示小数点后的位数（在表示字符串时表示最大字段宽度）
定义宽度或者小数点精度。用法示范\"%.*s\" % (5, 'food fed')
4.4.2.5.辅助符号与字符串格式化符号的顺序： （1）%符号，表示转换说明符的开始。（2）转换标志（可选）-,+,\" \。（3）最小字段宽度，若加*，宽度值从元组中读出（可选）。（4）点.与后面跟的精度值（可选），若加*，宽度值从元组中读出。（5）转换类型d,s啥的...... 4.4.2.6.字段宽度，点号，精度与星号的用法举例： from math import pi
>>>'%10F' % pi # 字段宽10 结果为' 3.141593' >>>'%10.2f'%pi # 字段宽10，精度2 结果为' 3.14' >>>'%.2f'%pi # 精度2结果为'3.14'
>>>'%.5s'%'guido van rossum' #字段宽5 结果为'guido'
>>> '%5s'%'guido van rossum' #字段宽不小于5 结果为'guido van rossum' 4.4.2.7.正负号和0的用法举例：
在字段宽度和精度值前面可以放置0.加减号或空格。 0表示字符串内有空格时用0来填充。 >>>'%010.2f'%pi
'0000003.14' # 表示字段宽度为10，并且用0填充空位
4.4.2.8.应用总范例，做一个物价表：pdf page66 4.4.2.9.希望反斜线不产生转义功能的方法： (1).用双反斜线\\\\
(2).在字符串前加r,表示原始字符串。
4.4.3.字符串方法：
（1）.find:在一个字符串a='...'中找某个字符串'b...'：a.find('b...'),存在的话返回最左端索引的位置，不存在的话返回-1.
a.find('b...',1)表示从下标1开始查找。 rfind表示从末尾开始查找
（2）.join(split的逆方法):在队列a的各元素之间中添加同一个元素c='b' c.join(a)或者'b'.join(a)
（3）.lower全改为小写：a='Gumpy',b=a.lower(),则结果为gumpy. （4）.replace:把字符串a中所有的'b'替换为'c':a.replace('b','c')
（5）split(join的逆方法):以某种分隔符(或元素)为断点来把原字符串分割成字符串序列： a='1+1+2+1+3'
a.split('+') 结果是['1', '1', '2', '1', '3']# 字符串中每出现一个\"+\"就断开产生新元素 a.split('1')结果是['', '+', '+2+', '+3'] # 以'1'为分隔符
（6）.strip去除字符串两边的指定字符（默认删除多余的字符空格、\\n换行、\\r回车、\横向制表符）：
a=' gumpy ',b=a.strip(),结果为gumpy.
'*!!!***!*d79*hiy!8*!!!*!**!!*!'.strip('*!')结果为'd79*hiy!8' 4.4.4. String模块中的常量： string.digits：数字0~9
string.letters：所有字母（大小写） string.lowercase：所有小写字母
string.printable：可打印字符的字符串 string.punctuation：所有标点 string.uppercase：所有大写字母 应用举例：
>>> import string >>> string.digits '0123456789' 4.5.字典 4.5.1简介：列表是通过编号对值进行引用的数据结构。
而映射是通过名字引用值的数据结构。字典是python中唯一的映射类型。 字典中的值没有特定顺序，储存在键（key）里，键可以是数字、字符串、元组 4.5.2.字典：phonebook={'alice':'2341','beth':'9102','cecil':'3258'} 字典中每一项由键，冒号和值组成，项之间用逗号隔开。空字典没有项，只有大括号。 4.5.3.创建字典的三种方法： （1）直接用{}写,例如： >>> dict1={}
>>> dict1[1]=213768 >>> dict1['1']=213 >>> dict1
{'1': 213, 1: 213768}
（2）用dict函数：通过(键,值)或[键,值]组成项，项组成元组或序列，把此元组或序列放到dict函数中。例如： y=((\"a\
x = dict(y)得到结果{'a': '1', 'b': '2'} # 共有2*2=4中选择，只记住元组套元组就够了吧 （3）以映射为dict()的参数： >>> x = dict(a=\"1\
>>> print x结果为{'a': '1', 'b': '2'}
（4）用方法fromkeys() 来创建一个\"默认\"字典, 字典中元素具有相同的值 (如果没有给出，默认为None)，例如:
>>> ddict = {}.fromkeys(('x', 'y'), -1) >>> ddict 结果为{'y': -1, 'x': -1} >>> edict = {}.fromkeys(('foo', 'bar'))
>>> edict结果为{'foo': None, 'bar': None} 4.5.4.如何访问字典中的值 （1）用for循环遍历，比如： >>>dict1={'name': 'earth', 'port': 80} >>>for key in dict:
print' key=%s, value=%s' % (key,dict1[key]) 结果为
key=name, value=earth key=port,value=80
（2）得到某一个键a值,用x[a]即可。例如，得到字典dict1中name的值：dict1['name'] （3）看某个值是否在字典中。用in和not in 就行了，返回结果是布尔值，例如： 'name' in dict1 结果是 True 4.5.5.基本字典操作:
4.5.5.1.与序列类似的操作： len(x)返回x中项的数量
x[a]返回键a上的值# 查询某个键对应的值
x[a]=b将值b对应到键a上# 以此可以更改字典中键的值或给字典中加入新项 del x[a]删除键为a的项
键a in x 或者值b in x，检查键是否在字典中，返回布尔值。# 不能检查值是否在 4.5.5.2.与列表不同的操作
（1）键类型：可为任意不可变类型，可以是整型数据、浮点型、字符串、元组。 #这是字典最强大的地方
（2）自动添加：给一个原来不存在的键赋值，自动把这个项加进字典中了。 （3）成员资格：列表中用in查的是值，而字典中查键不查值。
#数据结构规模特别大时，字典中查 键的成员资格比列表中查值的成员资格更高效。 4.5.6.字典的格式化字符串
用字符串将元组格式化见过了，格式化字典也行。
%后加上圆括号括起来的键，再跟上其他说明元素，例如：
>>>dict1={'name': 'earth', 'port': 80} >>>'he is an %(name)s' % dict1 'he is an earth' 4.5.7.字典方法
（1）clear，清空字典所有项，例如，x.clear(),x返回None
（2）fromkeys,创建一个新字典，所有键等于同一个值，例如： 方法一>>> ddict = {}.fromkeys(('x', 'y'), -1) >>> ddict返回结果为{'y': -1, 'x': -1}
方法二>>> ddict = dict.fromkeys(('x', 'y'), -1) >>> ddict返回结果为{'y': -1, 'x': -1} 两种方法结果相同
（3）get用来访问字典 >>>d={}
>>>print d.get('name') 返回结果为None # 如果键不存在返回None,
>>>d.get('name','NA') 返回结果为'NA' # 如果键不存在，也可以令其返回某特定值 >>>d['name']='eric'
>>>d.get('name') 返回结果为'eric' # 键存在时，get用起来跟普通的字典查询一样 （4）items将字典中的项以列表形式返回，列表中每一项为（键，值），无特定顺序。 >>>d={'a':'234f','b':'243d','c':'342g'} >>>d.items()
[('a', '234f'), ('c', '342g'), ('b', '243d')]
（5）keys将字典中的键以列表形式返回，例如，上文中的d: >>>d.keys() ['a', 'c', 'b']
（6）pop以键为参数，先返回这个键的值，再将此键存在的项删除， 例如，上文中的d： >>> d.pop('a') '234f' >>> d
{'c': '342g', 'b': '243d'}
（7）update可用一个字典来更新另一个：
a.update(b) #新字典b中的项将被加到旧字典a中，键相同值不同时，新字典值会覆盖旧的
（8）values以列表形式返回字典中的值，例如，上文中的d: >>>d.values()
['234f', '342g', '243d']
4.6.集合（set）（与列表、字典一样，是可变的/元素无次序/不可重复） set算是list和dict特点的结合：
含有dict的特点——可用{}定义；元素没有顺序；元素不可重复，类似于键 含有list的特点有一种集合可以原处修改 4.6.1.创建集合
集合通过调用集合的构造函数set来创建。 set构造函数至多有1个参数（可迭代参数），若没有参数，set会创建空集
例如：
>>> s1 = set(\"qiwsir\") >>> s1 set(['q', 'i', 's', 'r', 'w'])
>>> s2 = set([123,\"google\>>> s2
set(['facebook', 123, 'google', 'book', 'face']) >>>nullset=set() >>>nulset set([])
4.6.2.set方法：
（1）add向一个集合中加一个元素
对集合a_set增加一个元素：a_set.add('hehe')
（2）update把一个集合合到另一个或添加一个不可变对象 ·加集合 >>> s1
set(['a', 'b']) >>> s2
set(['github', 'qiwsir'])
>>> s1.update(s2) #把s2的元素并入到s1中. >>> s1 #s1的引用对象修改 set(['a', 'qiwsir', 'b', 'github'])
>>> s2 #s2的未变 set(['github', 'qiwsir'])
·加其他不可变对象 >>> s2.update(\"goo\") >>> s2
set(['github', 'o', 'g', 'qiwsir']) >>> s2.update((2,3)) >>> s2
set([2, 3, 'g', 'o', 'github', 'qiwsir'])
（3）pop:从set中任选一个元素删除，并返回该值。pop不能指定元素 （4）remove：删除某指定元素
（5）discard:删除某指定元素，不存在就不删
4.7.对数据结构的几类操作 ·循环（loop），指的是在满足条件的情况下，重复执行同一段代码。比如，while语句。 ·迭代（iterate），指的是按照某种顺序逐个访问列表中的每一项。比如，for语句。 ·递归（recursion），指的是一个函数不断调用自身的行为。比如，以编程方式输出著名的斐波纳契数列。 ·遍历（traversal），指的是按照一定的规则访问树形结构中的每个节点，而且每个节点都只访问一次。
4.7.1.迭代
4.7.1.1.几个概念：
（1）迭代工具：包括for循环、列表解析、in成员关系测试.....等等在内的，用于依次访问可迭代对象（容器）内元素的操作
（2）.迭代器对象：具有__next__()方法的对象。该方法能够自动返回下一个结果，当到达序列结尾时，引发StopIteration异常。
（3）.可迭代对象：具有__iter__()方法的对象。该方法可获取其迭代器对象。e.g.列表、字符串、字典
4.7.1.2.迭代过程： （以for循环为例）
for循环开始：自动调用可迭代对象的__iter__()方法以获取其迭代器对象（含有next方法） for循环：自动调用迭代器对象的__next__()方法获取下一个元素
for循环结束：当__next__()调用引发StopIteration异常时，结束循环。
# 注意 iter()next()迭代结束后，指针会移动到最后一个元素的后面，所以报StopIteration，想要再开始，需要重新再入迭代对象。 4.7.1.3.几点说明： (1)iter()函数：
返回值是一个迭代器对象；
参数需要是一个附和迭代协议的对象或者是一个序列对象； next()配合与之使用
(2)可迭代对象也可以是迭代器对象，如文件对象。此时可迭代对象自己有__next__()方法，而其__iter__()方法返回的就是它自己
(3)对于许多内置对象及其派生对象，如list、dict等，由于需要支持多次打开迭代器，因此自己并非迭代器对象，需要用__iter__()方法返回其迭代器对象，并用迭代器对象来访问其它元素。
4.7.1.4.逐个访问：
在python中，访问对象中每个元素，可以这么做：（例如一个list） 方法一.>>> lst=['q', 'i', 'w'] >>> for i in lst: ... print i, ... q i w
方法二.还可以这样：
>>> lst_iter = iter(lst) #对原来的list实施了一个iter() >>> lst_iter.next() #要不厌其烦地一个一个手动访问 'q'
>>> lst_iter.next() 'i'
>>> lst_iter.next() 'w'
>>> lst_iter.next()
Traceback (most recent call last): File \" 方法三. >>> lst_iter = iter(lst) #那就再写一遍，上面的错误暂且搁置，回头在研究 >>> while True: ... print lst_iter.next() ... q #果然自动化地读取了 i w Traceback (most recent call last): #读取到最后一个之后，报错，停止循环 File \" 五.文件操作 5.1.打开文件,用内置函数open（） (1)假设有个名为‘somefile.txt’的文本文件（大概是用文本编辑器创建的），储存路径为C:\ext 打开方式：f=open(r'C:\ext\\somefile.txt ') (2)标准打开方式 f=open('filename' ,'mode', buffersize) filename：要打开的文件的名字，可以是相对路径也可以是绝对路径 mode ：可选参数，文件打开的模式 buffersize：可选参数，缓冲区的大小（0为无缓冲，1为有缓冲，大于1代表缓冲区大小，小于1代表使用默认缓冲区大小） 文件模式含义 r 以读方式打开（若不写模式，默认为是读） w 以写方式打开，覆盖整个文件，不存在则创建 a 以再文件末尾追加方式打开（从EOF开始），不存在则创建 + 以读写方式打开（可添加到其他模式后面） b 以二进制（可添加到其他模式后面） 模式的组合 r+表示以读写模式打开,不会创建不存在的文件，从顶部开始写，覆盖之前此位置内容 w+ 表示以读写模式打开，若文件存在，则覆盖整个文件；不存在则创建 rb+ 表示以二进制读写模式打开；其他同r+ wb+表示以二进制读写模式打开；其他同w+ rb读取一个二进制文件，这在处理二进制文件，如声音剪辑或图像时很有用。 5.2.读和写 有名为f的类文件对象，可用f.write和f.read方法写入和读取数据。 （1）每次调用f.write(string)时，所提供的参数string会被追加到文件后面，例如： >>>f=open('somefile.txt','w') >>>f.write('hello,') >>>f.write('world!') >>>f.close() # 完成了一个文件操作后调用close （2）读取只要告诉流要读多少字符即可，接着上面的例子： >>>f=open('somefile.txt','r') # 只是读文件，'r'可以省略，因为默认模式是读取 >>>f.read(4) # 指定要读4个字符 'hell' >>>f.read() # 不提供要读取字符数，默认读取剩下的所有 'o,world!' 5.3.csv文件（逗号分隔值文件） 5.3.1.遍历csv文件 import csv fileobj=open('xxx.csv','rU') # 创建文件对象 reader=csv.reader(fileobj) # 调用函数csv.reader创建特殊的csv-reader对象 for line in reader: 六.函数、模块与异常处理 6.1.Python程序的结构 6.2.函数 6.2.1.定义一个函数 你可以定义一个由自己想要功能的函数，以下是简单的规则： (1)函数代码块以def关键词开头，后接函数标识符名称和圆括号()。 (2)任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。 (3)函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。 (4)函数内容以冒号起始，并且缩进。 Return[expression]结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。 6.2.2.如果在函数里用方法/函数修改了参数，那么在调用这个函数的程序里，原始的参数也被改变了。哪怕是形式参数，也可以改变原始参量。因为，所有参数（自变量）在Python里都是按引用传递。但注意，函数里面赋值不会改变全局变量！！！只有方法/函数才能改变！！！ 例如： #!/usr/bin/python # -*- coding: UTF-8 -*- # 可写函数说明 def changeme( mylist ): \"修改传入的列表\" mylist.append([1,2,3,4]); print \"函数内取值: \ return mylist = [10,20,30]; changeme( mylist ); # 调用changeme函数 print \"函数外取值: \ 传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下： 函数内取值: [10, 20, 30, [1, 2, 3, 4]] 函数外取值: [10, 20, 30, [1, 2, 3, 4]] 6.2.3.参数类型：必备参数，命名参数，缺省参数，不定长参数 （1）必备参数， 必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。 （2）命名参数： 命名参数和函数调用关系紧密，调用方用参数的命名确定传入的参数值。你可以跳过不传的参数或者乱序传参，因为Python解释器能够用参数名匹配参数值。 下例能将命名参数顺序不重要展示得更清楚,用命名参数调用printfo()函数： #!/usr/bin/python # -*- coding: UTF-8 -*- #可写函数说明 def printinfo( name, age ): \"打印任何传入的字符串\" print \"Name: \ print \"Age \ return; （3）缺省参数， 调用函数时，缺省参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入： #!/usr/bin/python # -*- coding: UTF-8 -*- #可写函数说明 def printinfo( name, age = 35 ): \"打印任何传入的字符串\" print \"Name: \ print \"Age \ return; printinfo( age=50, name=\"miki\" ); #调用printinfo函数 printinfo( name=\"miki\" ); 以上实例输出结果： Name: miki Age 50 Name: miki Age 35 （4）不定长参数 参数数量不确定。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。 加了星号（*）的变量名会存放所有未命名的变量参数。选择不多传参数也可。比如： #!/usr/bin/python # -*- coding: UTF-8 -*- # 可写函数说明 def printinfo( arg1, *vartuple ): \"打印任何传入的参数\" print \"输出: \" print arg1, for var in vartuple: print var, return; printinfo( '10' ); # 调用printinfo 函数 printinfo( '70', '60',' 50' ); 结果为: 10 结果为: 70 60 50 6.2.4. return语句 return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。例如： #!/usr/bin/python # -*- coding: UTF-8 -*- # 可写函数说明 def sum( arg1, arg2 ): total = arg1 + arg2 # 返回2个参数的和.\" print \"函数内 : \ return total; total = sum( 10, 20 );# 调用sum函数 print \"函数外 : \ 以上实例输出结果： 函数内 : 30 函数外 : 30 6.2.5.变量作用域，全局变量与局部变量： 定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。 局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例： #!/usr/bin/python # -*- coding: UTF-8 -*- total = 0; # 这是一个全局变量 # 可写函数说明 def sum( arg1, arg2 ): #返回2个参数的和.\" total = arg1 + arg2; # total在这里是局部变量. print \"函数内是局部变量 : \ return total; #调用sum函数 sum( 10, 20 ); print \"函数外是全局变量 : \ 以上实例输出结果： 函数内是局部变量 : 30 函数外是全局变量 : 0 3.模块 比如要用地板函数floor或天花板函数ceil，但Python本身并没有，需加上模块math >>>import math >>>math.floor(32.9) 3.1时间模块 ·使用前必须加import datetime >>> a='2015-11-1 17:26:37' >>> a=datetime.datetime.strptime(str(a),'%Y-%m-%d %H:%M:%S') #这是时间标准格式，如果a中年月日用斜线/分隔，时间标准格式变换符中也用/分隔 >>> a datetime.datetime(2015, 11, 1, 17, 26, 37) ·看看如何求出年、月、日、时、分、秒（这些是求值，末尾不用()），日期、时间、周几（这些是函数，末尾要加()）： >>>a.year 2015 >>>a.month 11 >>> a.day 1 >>>a.hour 17 >>>a.minute 26 >>>a.second 37 >>>a.date() datetime.date(2015, 11, 1) >>>a.time() datetime.time(17, 26, 37) >>>a.weekday() 6 ·这些值都是可以比大小的： >>>a.time() >>> x=datetime.datetime.strptime(str(x),'%Y-%m-%d %H:%M:%S') >>> y=datetime.datetime.strptime(str(y),'%Y-%m-%d %H:%M:%S') >>> y-x datetime.timedelta(0, 3600) (y-x).days 结果为0 (y-x).seconds 结果为3600 注意，时间间隔只可以求天数和秒数 七.异常处理 7.1.用try 语句检测异常 7.2.用with open ff as即可便于异常处理 八.面向对象编程 8.1.面向对象编程oop 8.1.1.问题空间，定义： 问题空间是问题解决者对一个问题所达到的全部认识状态，它是由问题解决者利用问题所包含的信息和已贮存的信息主动地构成的。 一个问题一般有下面三个方面来定义： ·初始状态——一开始时的不完全的信息或令人不满意的状况； ·目标状态——你希望获得的信息或状态； ·操作——为了从初始状态迈向目标状态，你可能采取的步骤。 这三个部分加在一起定义了问题空间（problem space）。 对象，定义：属性（是什么）和方法（能做什么）。 8.1.2.面向对象，定义： 传统的程序设计主张将程序看作一系列函数的集合，或者直接就是一系列对电脑下达的指令。 面向对象程序设计中的每一个对象都应该能够接受数据、处理数据并将数据传达给其它对象，因此它们都可以被看作一个小型的“机器”，即对象。 对象指的是类的实例。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性。 8.2.生成器： 把含有yield语句的函数称作生成器 8.2.1.定义、执行与调用yield这个词在汉语中有“生产、出产”之意，在python中，它作为一个关键词（你在变量、函数、类的名称中就不能用这个了），是生成器的标志。 >>> def g(): ... yield 0 ... yield 1 ... yield 2 >>> g >>> ge = g()＃ge = g()：除了返回生成器之外，什么也没有操作 >>> ge.next()＃直到这时候，生成器才开始执行，遇到了第一个yield语句，将值返回，并暂停执行（有的称之为挂起）。 0 >>> ge.next()＃从上次暂停的位置开始，继续向下执行，遇到yield语句，将值返回，又暂停。 1 >>>ge.next() 2 >>> ge.next()＃从上面的挂起位置开始，但是后面没有可执行的了，于是next()发出异常。 Traceback (most recent call last): File \" 8.2.2.生成器用法： 周天元（一个大列表，想对对每一项并且一项一项地使用，直接复制太占用内存，用生成器） >>> list1=[[1,2],[3,4]] >>> def list2(): for line in list1: tmp=line[:] tmp.append(0) yield tmp raise StopIteration＃StopIteration类判断循环是否执行到尾部，如果循环到尾部，则抛出该异常。python会自动引发异常，也可以通过raise显示地引发异常。一旦执行了raise语句，raise后面的语句将不能执行。 >>> for ii in list2(): print ii [1, 2, 0] [3, 4, 0] >>> list2 [[1, 2, 0], [3, 4, 0]] >>> 8.2.2.yield与return的区别 函数遇到return时，将值返回，结束函数。 遇到yield时，返回值并且暂停（挂起），下一次 8.3.类class 定义：类是由某种特定的元数据所组成的内聚的包。它描述了一些对象的行为规则，而这些对象就被称为该类的实例。类有接口和结构。接口描述了如何通过方法与类及其实例互操作，而结构描述了一个实例中数据如何划分为多个属性。类是与某个层的对象的最具体的类型。类还可以有运行时表示形式（元对象），它为操作与类相关的元数据提供了运行时支持。 类的出现，为面向对象编程的三个最重要的特性（封装性，继承性，多态性），提供了实现的手段。 类是对某一群具有同样属性和方法的对象的抽象。 8.3.1.一些类的基础知识 >>> class BB(object): # 定义类 ... pass >>> bb = BB() # 将这个类实例化 >>>bb.__class__ # 查看对象类型 <__main__.BB object at 0xb71efe6c> 8.3.2.定义类 定义方法一: >>> class BB(object): ... pass 定义方法二： >>> __metaclass__ = type >>> class CC: ... pass ... >>> cc = CC() >>> cc.__class__ 8.3.3.创建类（不用交互式，改用编辑界面） # coding=utf-8 __metaclass__ = type # 这意味着下面是新式类 class Person: # 声明创建一个名为\"Person\"的类。类的首字母一般大写，若不止一个单词，则每个单词都大写，例如Class HotPerson，这叫“驼峰命名法”。 def __init__(self, name):# 这是函数，类中的函数叫做“方法”，这也是前文所谓“对象的方法。每个函数必须包括self参数，并且作为默认的第一个参数。 selfname = name def getName(self): return selfname def color(self, color): print \"%s is %s\" % (selfname, color) 底下开始用这个类 girl = Person('canglaoshi') #实例化 name = girl.getName() #用girl.getName()即可调用此实例girl的方法‘def getName(self):’，注意调用时括号比不能少，里面也不要放东西 print \"the person's name is: \ girl.color(\"white\") #在实例化后可以调用方法（函数）'def color(self, color):' print girl.name #实例的属性 保存后，运行得到如下结果： $ python 20701.py the person's name is: canglaoshi canglaoshi is white canglaoshi 上面定义的是一个比较常见的类，一般情况下，都是这样子的。 下面来解释一下上述函数中的一些部分： （1）def __init__叫做初始化函数，两个下划线+init+两个下划线。在类被实例化的时候就执行这个函数，从而将初始化的一些属性可以放到这个函数里面。 （2）def __init__(self, name):在类被实例化的时候，通过name参数传一个值。这个值被一开始就写入了类和实例中，成为了类和实例的一个属性。比如：girl = Person('canglaoshi') girl是一个实例对象，就如同前面所说的一样，它有属性和方法。这里仅说属性吧。当通过上面的方式实例化后，就自动执行了初始化函数，让实例girl就具有了name属性。 print girl.name 执行这句话的结果是打印出canglaoshi。 这就是初始化的功能：通过初始化函数，确定了这个实例（类）的“基本属性”（实例是什么样子的）。比如上面的实例化之后，就确立了实例girl的name是\"canglaoshi\"。 再举个例子：很多时候，并不是每次都要从外面传入数据，有时候会把初始化函数的某些参数设置默认值，如果没有新的数据传入，就应用这些默认值。比如： class Person: def __init__(self, name, lang=\"golang\ self.name = name self.lang = lang self.website = website self.email = \"qiwsir@gmail.com\" laoqi = Person(\"LaoQi\") info = Person(\"qiwsir\ print \"laoqi.name=\laoqi.name＃实例的属性用self定义，用“实例.属性”的形式调用 print \"info.name=\info.name print \"laoqi.lang=\laoqi.lang print \"info.lang=\info.lang print \"laoqi.website=\laoqi.website print \"info.website=\info.website #运行结果 laoqi.name= LaoQi info.name= qiwsir laoqi.lang= golang info.lang= python laoqi.website= www.google.com info.website= qiwsir.github.io 8.3.4.类和实例的关系 “类提供默认行为，是实例的工厂”——类就是那个模子，实例就是具体的产品。所以，实例是程序处理的实际对象。 类是由一些语句组成，但是实例，是通过调用类生成，每次调用一个类，就得到这个类的新的实例。 对于类的：class Person，class是一个可执行的语句。如果执行，就得到了一个类对象，并且将这个类对象赋值给对象名（比如Person）。 8.2.5. self的作用 如上例，在类的外面调用类或者实例的属性，以girl.name的方式，得到\"canglaoshi\"。 在类的内部，想使用实例化传入的数据，用初始化函数的第一个参数self——它接收实例化过程中传入的所有数据。显然，self应该就是一个实例（准确说法是实例的引用变量），因为它所对应的就是具体数据。 例如： class Person: def __init__(self, name): self.name = name 以上红字其实就定义了实例的一个属性，这个属性的值等于初始化函数的参数name所导入的数据。但这个属性‘name’和初始化函数中的name没有任何关系，只是为了省事让他们名字一样罢了。总而言之：类的实例girl对应着self，girl通过self导入实例属性的所有数据。 当然，self的属性数据，也不一定非得是由参数传入的，也可以在构造函数中自己设定。比如： #!/usr/bin/env python #coding:utf-8 __metaclass__ = type class Person: def __init__(self, name): self.name = name self.email = \"qiwsir@gmail.com\" #这个属性不是通过参数传入的 info = Person(\"qiwsir\") #换个字符串和实例化变量 print \"info.name=\ print \"info.email=\ #info通过self建立实例，并导入实例属性数据 因篇幅问题不能全部显示，请点此查看更多更全内容