python笔记
python运行3
py -2运行2
Python2+学习：
一、 简介
l Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
l Python 是交互式语言： 这意味着，您可以在一个Python提示符，直接互动执行写你的程序。
l Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
l Python 是初学者的语言：Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。
Python 是由 Guido van Rossum 在八十年代末和九十年代初，在荷兰国家数学和计算机科学研究所设计出来的。
像 Perl 语言一样，Python 源代码同样遵循 GPL(GNU General Public License)协议。
特点：
1.易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
2.易于阅读：Python代码定义的更清晰。
3.易于维护：Python的成功在于它的源代码是相当容易维护的。
4.一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
5.互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
6.可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
7.可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
8.数据库：Python提供所有主要的商业数据库的接口。
9.GUI编程：Python支持GUI可以创建和移植到许多系统调用。
10.可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。
二、下载与环境配置
Python下载
Python最新源码，二进制文档，新闻资讯等可以在Python的官网查看到：
Python官网：https://www.python.org/
你可以在以下链接中下载 Python 的文档，你可以下载 HTML、PDF 和 PostScript 等格式的文档。
Python文档下载地址：https://www.python.org/doc/
Linux和Unix
以下为在Unix & Linux平台上安装 Python 的简单步骤：
· 打开WEB浏览器访问https://www.python.org/downloads/source/
· 选择适用于Unix/Linux的源码压缩包。
· 下载及解压压缩包。
· 如果你需要自定义一些选项修改Modules/Setup
· 执行 ./configure 脚本
· make
· make install
执行以上操作后，Python会安装在 /usr/local/bin 目录中，Python库安装在/usr/local/lib/pythonXX，XX为你使用的Python的版本号。
Windows：
以下为在 Window 平台上安装 Python 的简单步骤：
· 打开 WEB 浏览器访问https://www.python.org/downloads/windows/
· 在下载列表中选择Window平台安装包，包格式为：python-XYZ.msi 文件， XYZ 为你要安装的版本号。
· 要使用安装程序 python-XYZ.msi, Windows系统必须支持Microsoft Installer 2.0搭配使用。只要保存安装文件到本地计算机，然后运行它，看看你的机器支持MSI。Windows XP和更高版本已经有MSI，很多老机器也可以安装MSI。
· 下载后，双击下载包，进入Python安装向导，安装非常简单，你只需要使用默认的设置一直点击"下一步"直到安装完成即可。
在 Unix/Linux 设置环境变量
· 在 csh shell: 输入
setenv PATH "$PATH:/usr/local/bin/python"
, 按下"Enter"。
· 在 bash shell (Linux): 输入
export PATH="$PATH:/usr/local/bin/python"
，按下"Enter"。
· 在 sh 或者 ksh shell: 输入
PATH="$PATH:/usr/local/bin/python"
, 按下"Enter"。
注意: /usr/local/bin/python 是 Python 的安装目录。
在 Windows 设置环境变量
在环境变量中添加Python目录：
在命令提示框中(cmd) : 输入
path=%path%;C:\Python
按下"Enter"。
注意: C:\Python 是Python的安装目录。
也可以通过以下方式设置：
· 右键点击"计算机"，然后点击"属性"
· 然后点击"高级系统设置"
· 选择"系统变量"窗口下面的"Path",双击即可！
· 然后在"Path"行，添加python安装路径即可(我的D:\Python32)，所以在后面，添加该路径即可。 ps：记住，路径直接用分号"；"隔开！
· 最后设置成功以后，在cmd命令行，输入命令"python"，就可以有相关显示。
Python 环境变量
下面几个重要的环境变量，它应用于Python：
变量名 |
描述 |
PYTHONPATH |
PYTHONPATH是Python搜索路径，默认我们import的模块都会从PYTHONPATH里面寻找。 |
PYTHONSTARTUP |
Python启动后，先寻找PYTHONSTARTUP环境变量，然后执行此变量指定的文件中的代码。 |
PYTHONCASEOK |
加入PYTHONCASEOK的环境变量, 就会使python导入模块的时候不区分大小写. |
PYTHONHOME |
另一种模块搜索路径。它通常内嵌于的PYTHONSTARTUP或PYTHONPATH目录中，使得两个模块库更容易切换。 |
运行：
1、交互式解释器：
以下为Python命令行参数：可以-h查看各个参数基本信息
选项 |
描述 |
-d |
在解析时显示调试信息 |
-O |
生成优化代码 ( .pyo 文件 ) |
-S |
启动时不引入查找Python路径的位置 |
-V |
输出Python版本号 |
-X |
从 1.6版本之后基于内建的异常（仅仅用于字符串）已过时。 |
-c cmd |
执行 Python 脚本，并将运行结果作为 cmd 字符串。 |
file |
在给定的python文件执行python脚本。 |
2、命令行脚本
3、集成开发环境（IDE：IntegratedDevelopment Environment）: PyCharm
PyCharm 下载地址 : https://www.jetbrains.com/pycharm/download/
三、 基础语法
1. Python中默认的编码格式是 ASCII 格式，在没修改编码格式时无法正确打印汉字。在文件开头加入 # -*-coding: UTF-8 -*- 或者 #coding=utf-8。然后在字符串前面加u或者print ‘str’.decode(“utf8”)
2. 标识符：
l 所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头，区分大小写的
l 以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入
l From xxx import *和import xxx有区别！，后者的变量引用还要xxx.kk,前者直接kk
l 以双下划线开头的 __foo 代表类的私有成员；以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识，如 __init__() 代表类的构造函数。
l Python 可以同一行显示多条语句，方法是用分号 ; 分开，普通语句尾部不需要“；”
3. 保留字：所有 Python 的关键字只包含小写字母。
and |
exec |
not |
assert |
finally |
or |
break |
for |
pass |
class |
from |
|
continue |
global |
raise |
def |
if |
return |
del |
import |
try |
elif |
in |
while |
else |
is |
with |
except |
lambda |
yield |
4.缩进与代码块
l 不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。
l 使用的缩进方式要一致，统一是 tab 键缩进或者空格缩进。
l 同一条语句要多行写，可以在行尾用斜杠（ \）
l [], {} 或 () 括号内的就不需要斜杠
5.引号与注释：
l 可以使用引号( ' )、双引号( " )、三引号( ''' 或 """ )来表示字符串，引号的开始与结束必须的相同类型的。
l 三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串。
l 单行注释用#开头，多行用三个单引号(''')或三个双引号(""")
6.空行：规范，便于维护
l 函数之间或类的方法之间用空行分隔，表示一段新的代码的开始
l 类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
7.raw_input
raw_input(“显示提示语：”)
用户输入字符串，按回车，会把字符串输出，\会输出\\
8.print
默认输出是换行结尾的，如果要实现不换行需要在变量末尾加上逗号 ,
9.代码组
l 缩进相同的一组连续语句构成一个代码块，我们称之代码组。
l 像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。
l 我们将首行及后面的代码组称为一个子句(clause)。
10.pass
pass是空语句，是为了保持程序结构的完整性，不做任何事情，一般用做占位语句。
比如C++的if(xxx) {;}差不多
四、变量类型
l 变量赋值不需要类型声明,初始化时根据值类型创建相应内存大小的空间。
l 每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
l 每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
l 多变量赋值：a=b=c=1 a,b,c=1,2.3,”kingson”
l 标准数据类型：Number，String，List，Tuple，Dictionary
l Number
Number存储数值，是不可改变的数据类型，改变数字数据类型会分配一个新的对象。
创建并且初始化变量时，Number对象创建
del删除对象引用，del var1,var2
四种数值类型：int,long,float,complex
long要L或l结尾，复数：a+bj或者complex（a,b）实a虚b都是float
l String
数字、字母、下划线组成，’或”都可以。
索引方式1：从左到右索引默认0开始的，最大范围是字符串长度少1
索引方式2：从右到左索引默认-1开始的，最大范围是字符串开头
[0] [2,5] [2:] [-3,-1] [:6]
Str[0,3]返回一个String对象，包下（左）界不包上界
+连接，*重复。Eg：str*2
l Tuple与list
元组用"()"标识。但是元组不能二次赋值，相当于只读列表。
List用“[]”标识。可二次赋值。
内部元素用逗号隔开，可不同类型共存，索引和string一样，可用*与+
l 字典：
“{}”标识，无序的对象集合，通过键存取，类似C++的map，eg：
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
dict[“2”]的键是’2’，和’2’一样，和2不一样
tinydict = { 'name': 'john','code':6734, 'dept': 'sales'}# 初始化
printtinydict# 输出完整的字典，顺序是存的顺序
printtinydict.keys()# 输出所有键
printtinydict.values()# 输出所有值
l 数据类型转换
函数 |
描述 |
int(x [,base]) |
将x转换为一个整数 |
long(x [,base] ) |
将x转换为一个长整数 |
float(x) |
将x转换到一个浮点数 |
complex(real [,imag]) |
创建一个复数 |
str(x) |
将对象 x 转换为字符串 |
repr(x) |
将对象 x 转换为表达式字符串 |
eval(str) |
用来计算在字符串中的有效Python表达式,并返回一个对象 |
tuple(s) |
将序列 s 转换为一个元组 |
list(s) |
将序列 s 转换为一个列表 |
set(s) |
转换为可变集合 |
dict(d) |
创建一个字典。d 必须是一个序列 (key,value)元组。 |
frozenset(s) |
转换为不可变集合 |
chr(x) |
将一个整数转换为一个字符 |
unichr(x) |
将一个整数转换为Unicode字符 |
ord(x) |
将一个字符转换为它的整数值 |
hex(x) |
将一个整数转换为一个十六进制字符串 |
oct(x) |
将一个整数转换为一个八进制字符串 |
五、运算符
l + - * / %和C++一样，一int一float按float运算
l **：x**y为x的y次方
l //：返回商的整数部分，两个整数相除则效果一样。
l > < != >= <= ==和C++一样， <>和!=一样
l = += -= %= *= /= **= //=
l 按位运算：与& 或| 异或^ 取反~ 移位<< >>
l 逻辑运算：and or not 没有&& || !
l 成员运算符：in notin
l 是否引用同一个存储单元：is isnot注意和==区分
l id(var)返回变量的地址
l 优先级:指数> 一元>乘除模>加减>左右移>&>^ | >比较>(不)等于>赋值系列>is>in>逻辑
六、条件
if判断条件1:
执行语句1……
elif判断条件2:
执行语句2……
elif判断条件3:
执行语句3……
else:
执行语句4……
if(var == 100) : print"变量 var 的值为100" #一句语句
每个条件下的执行语句可以是多条，同缩进即可。
不支持switch
七．循环语句
l while：
while判断条件：
执行语句……
while(flag): print'Given flag is really true!'#简单语句组
l break与continue在语句组中相对缩进一格，eg：
i = 1
whilei < 10:
i += 1
ifi%2 > 0: # 非双数时跳过输出
continue
printi# 输出双数2、4、6、8、10
l while … else:在最后一次条件不成立时执行else的语句，break退出的不执行else
l for
for iterating_var in sequence:
statements(s)
可以用索引：forindexinrange(len(fruits)):
l len()返回长度n，range()返回0-(n-1)的有序数列
l for … else 正常执行完循环才执行else的语句，break这种就不会执行。
l 嵌套循环，注意缩进对齐
foriterating_varinsequence:
foriterating_varinsequence:
statements(s)
statements(s)
八、 Number
Math,cmath模块
l math 模块提供了许多对浮点数的数学运算函数，cmath 模块包含用于复数运算的函数。
l 导入包：import math
l 查看包内容：dir(math)
数学函数：math.f()或cmath.f()
函数 |
返回值 ( 描述 ) |
abs(x) |
返回数字的绝对值，如abs(-10) 返回 10 |
ceil(x) |
返回数字的上入整数，如math.ceil(4.1) 返回 5 |
cmp(x, y) |
如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1 |
exp(x) |
返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 |
fabs(x) |
返回数字的绝对值，如math.fabs(-10) 返回10.0 |
floor(x) |
返回数字的下舍整数，如math.floor(4.9)返回 4 |
log(x) |
如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]) |
返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。 |
sqrt(x) |
返回数字x的平方根 |
随机数
函数 |
描述 |
choice(seq) |
从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。 |
randrange ([start,] stop [,step]) |
从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1 |
random() |
随机生成下一个实数，它在[0,1)范围内。 |
seed([x]) |
改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。 |
shuffle(lst) |
将序列的所有元素随机排序 |
uniform(x, y) |
随机生成下一个实数，它在[x,y]范围内。 |
三角函数
函数 |
描述 |
acos(x) |
返回x的反余弦弧度值。 |
asin(x) |
返回x的反正弦弧度值。 |
atan(x) |
返回x的反正切弧度值。 |
atan2(y, x) |
返回给定的 X 及 Y 坐标值的反正切值。 |
cos(x) |
返回x的弧度的余弦值。 |
hypot(x, y) |
返回欧几里德范数 sqrt(x*x + y*y)。 |
sin(x) |
返回的x弧度的正弦值。 |
tan(x) |
返回x弧度的正切值。 |
degrees(x) |
将弧度转换为角度,如degrees(math.pi/2) ，返回90.0 |
radians(x) |
将角度转换为弧度 |
数学常量
常量 |
描述 |
pi |
数学常量 pi（圆周率，一般以π来表示） |
e |
数学常量 e，e即自然常数（自然常数）。 |
九、 字符串
l 转义字符：\\\ \’ \” \a \b \e \000 \n \v \t \r \f \oyy \xyy \other
l u’str’定义一个Unicode字符串
l R/r:让字符串按字符输出，转义字符不会转化为特定意思。
Eg:print r‘123\n321’ 输出123\n321
l %:有点类似C的printf格式化输出：print ‘kk %s and %d’ % (‘hello’,123)
符 号 |
描述 |
%c |
格式化字符及其ASCII码 |
%s |
格式化字符串 |
%d |
格式化整数 |
%u |
格式化无符号整型 |
%o |
格式化无符号八进制数 |
%x |
格式化无符号十六进制数 |
%X |
格式化无符号十六进制数（大写） |
%f |
格式化浮点数字，可指定小数点后的精度 |
%e |
用科学计数法格式化浮点数 |
%E |
作用同%e，用科学计数法格式化浮点数 |
%g |
%f和%e的简写 |
%G |
%f 和 %E 的简写 |
%p |
用十六进制数格式化变量的地址 |
符号 |
功能 |
* |
定义宽度或者小数点精度 |
- |
用做左对齐 |
+ |
在正数前面显示加号( + ) |
在正数前面显示空格 |
|
# |
在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X') |
0 |
显示的数字前面填充'0'而不是默认的空格 |
% |
'%%'输出一个单一的'%' |
(var) |
映射变量(字典参数) |
m.n. |
m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话) |
%5d,占5个位（包自己），%.3f，小数点3位
l str.format():字符串格式化，用{}代替%
设置指定位置：
eg: "{1} {0} {1}".format("hello", "world")#输出'world hello world'
设置参数：
print("变量1{aa}, 变量2 {xxx}".format(aa="sss", xxx="lll"))#直接设置
site = { "key1": "val1", "key2": "val2"} #通过字典的key
print("var1：{key1}, var2 {key2}".format(**site))
my_list = ['val1', 'val2'] #通过列表
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))# "0" 是必须,代表传入参数
传入一个类也是相似的，print(“{0.value}”).format(classA)#value是classA成员变量
数字 |
格式 |
输出 |
描述 |
3.1415926 |
{:.2f} |
3.14 |
保留小数点后两位 |
3.1415926 |
{:+.2f} |
+3.14 |
带符号保留小数点后两位 |
-1 |
{:+.2f} |
-1.00 |
带符号保留小数点后两位 |
2.71828 |
{:.0f} |
3 |
不带小数 |
5 |
{:0>2d} |
05 |
数字补零 (填充左边, 宽度为2) |
5 |
{:x<4d} |
5xxx |
数字补x (填充右边, 宽度为4) |
10 |
{:x<4d} |
10xx |
数字补x (填充右边, 宽度为4) |
1000000 |
{:,} |
1,000,000 |
以逗号分隔的数字格式 |
0.25 |
{:.2%} |
25.00% |
百分比格式 |
1000000000 |
{:.2e} |
1.00e+09 |
指数记法 |
13 |
{:10d} |
13 |
右对齐 (默认, 宽度为10) |
13 |
{:<10d} |
13 |
左对齐 (宽度为10) |
13 |
{:^10d} |
13 |
中间对齐 (宽度为10) |
11 |
'{:b}'.format(11) '{:d}'.format(11) '{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11) |
1011 11 13 b 0xb 0XB |
进制 |
^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制。{ {}}会显示{}
方法 |
描述 |
string.capitalize() |
把字符串的第一个字符大写 |
string.center(width) |
返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 |
string.count(str, beg=0, end=len(string)) |
返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数 |
string.decode(encoding='UTF-8', errors='strict') |
以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的异常，除非 errors 指定的是 'ignore' 或者'replace' |
string.encode(encoding='UTF-8', errors='strict') |
以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace' |
string.endswith(obj, beg=0, end=len(string)) |
检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. |
string.expandtabs(tabsize=8) |
把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。 |
string.find(str, beg=0, end=len(string)) |
检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1 |
string.format() |
格式化字符串 |
string.index(str, beg=0, end=len(string)) |
跟find()方法一样，只不过如果str不在 string中会报一个异常. |
string.isalnum() |
如果 string 至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回 False |
string.isalpha() |
如果 string 至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False |
string.isdecimal() |
如果 string 只包含十进制数字则返回 True 否则返回 False. |
string.isdigit() |
如果 string 只包含数字则返回 True 否则返回 False. |
string.islower() |
如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
string.isnumeric() |
如果 string 中只包含数字字符，则返回 True，否则返回 False |
string.isspace() |
如果 string 中只包含空格，则返回 True，否则返回 False. |
string.istitle() |
如果 string 是标题化的(见 title())则返回 True，否则返回 False |
string.isupper() |
如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
string.join(seq) |
以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
string.ljust(width) |
返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 |
string.lower() |
转换 string 中所有大写字符为小写. |
string.lstrip() |
截掉 string 左边的空格 |
string.maketrans(intab, outtab]) |
maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
max(str) |
返回字符串 str 中最大的字母。 |
min(str) |
返回字符串 str 中最小的字母。 |
string.partition(str) |
有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把字符串 string 分成一个 3 元素的元组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string. |
string.replace(str1, str2, num=string.count(str1)) |
把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次. |
string.rfind(str, beg=0,end=len(string) ) |
类似于 find()函数，不过是从右边开始查找. |
string.rindex( str, beg=0,end=len(string)) |
类似于 index()，不过是从右边开始. |
string.rjust(width) |
返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 |
string.rpartition(str) |
类似于 partition()函数,不过是从右边开始查找. |
string.rstrip() |
删除 string 字符串末尾的空格. |
string.split(str="", num=string.count(str)) |
以 str 为分隔符切片 string，如果 num有指定值，则仅分隔 num 个子字符串 |
string.splitlines([keepends]) |
按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 |
string.startswith(obj, beg=0,end=len(string)) |
检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查. |
string.strip([obj]) |
在 string 上执行 lstrip()和 rstrip() |
string.swapcase() |
翻转 string 中的大小写 |
string.title() |
返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle()) |
string.translate(str, del="") |
根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 del 参数中 |
string.upper() |
转换 string 中的小写字母为大写 |
string.zfill(width) |
返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0 |
string.isdecimal() |
isdecimal()方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。 |
十、列表（List）
l 数据项不需要具有相同的类型
l 使用下标索引（0开始）来访问列表中的值
l 可以使用方括号的形式截取字符（类似str的索引）
l 创建：list = []，添加：list.append('Google')）删除：del list[1]（后面的补上）
l len(list) ; + ; *; in ; for a in list ; 用法和string一样
l cmp(list1,list2)max(list) min list(seq)把元组转成列表
l list.fun():append(x)count(x) extend(seq)在某位拼接另一个序列 index(x) insert(index,x) pop(x=list[-1])缺省最后一个 remove(x)移除第一个等于x的值 reverse() sort([func])
十一、元组
l 元组中只包含一个元素时，需要在元素后面添加逗号
tup1 =(50,);#不可以（50）
l 元素值是不允许修改的，但我们可以对元组进行连接组合
l 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
l 链表的len* + in等和元组一样
l 任意无符号的对象，以逗号隔开，默认为元组（t=1,2,3）
l 内置函数：cmplen max min tuple
十二、字典
l 键唯一，值不唯一，d = { key1 : value1, key2 : value2 }
l 删除：del dict[key1] del dict dict.clear()
l 键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行
l 内置函数：cmp len str(dict) type(dict)
序号 |
函数及描述 |
1 |
dict.clear() |
2 |
dict.copy() |
3 |
dict.fromkeys(seq[, val]) |
4 |
dict.get(key, default=None) |
5 |
dict.has_key(key) |
6 |
dict.items() |
7 |
dict.keys() |
8 |
dict.setdefault(key, default=None) |
9 |
dict.update(dict2) |
10 |
dict.values() |
11 |
pop(key[,default]) |
12 |
popitem() |
十三、日期和时间
l 模块：time calendar（import），单位秒的时间间隔
l time.time()返回1970/1/1到现在经历的秒（时间戳）
l 时间元组，9个数字的元组表示时间：（time.localtime(time.time())返回时间元组，可不写time.time()参数）
序号 |
属性 |
值 |
0 |
tm_year |
2008 |
1 |
tm_mon |
1 到 12 |
2 |
tm_mday |
1 到 31 |
3 |
tm_hour |
0 到 23 |
4 |
tm_min |
0 到 59 |
5 |
tm_sec |
0 到 61 (60或61 是闰秒) |
6 |
tm_wday |
0到6 (0是周一) |
7 |
tm_yday |
1 到 366(儒略历) |
8 |
tm_isdst |
-1, 0, 1, -1是决定是否为夏令时的旗帜 |
l 一种默认的格式化时间
localtime = time.asctime( time.localtime(time.time()))
输出
ThuApr 710:05:212016
l 也可以自定义格式化：
time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身
l 获取某个月日历：
cal = calendar.month(2016,1)#直接输出print cal
序号 |
函数及描述 |
1 |
time.altzone |
2 |
time.asctime([tupletime]) |
3 |
time.clock( ) |
4 |
time.ctime([secs]) |
5 |
time.gmtime([secs]) |
6 |
time.localtime([secs]) |
7 |
time.mktime(tupletime) |
8 |
time.sleep(secs) |
9 |
time.strftime(fmt[,tupletime]) |
10 |
time.strptime(str,fmt='%a %b %d %H:%M:%S %Y') |
11 |
time.time( ) |
12 |
time.tzset() |
序号 |
属性及描述 |
1 |
time.timezone |
2 |
time.tzname |
Calendar中星期一是默认的每周第一天，星期天是默认的最后一天。更改设置需调用calendar.setfirstweekday()函数
其他模块还有datetime,pytz,dateutil
序号 |
函数及描述 |
1 |
calendar.calendar(year,w=2,l=1,c=6) |
2 |
calendar.firstweekday( ) |
3 |
calendar.isleap(year) |
4 |
calendar.leapdays(y1,y2) |
5 |
calendar.month(year,month,w=2,l=1) |
6 |
calendar.monthcalendar(year,month) |
7 |
calendar.monthrange(year,month) |
8 |
calendar.prcal(year,w=2,l=1,c=6) |
9 |
calendar.prmonth(year,month,w=2,l=1) |
10 |
calendar.setfirstweekday(weekday) |
11 |
calendar.timegm(tupletime) |
12 |
calendar.weekday(year,month,day) |
十四、函数
l 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
l 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
l 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
l 函数内容以冒号起始，并且缩进。
l return [表达式] 结束函数，返回一个值给调用方。不带表达式的return相当于返回 None。
def functionname( parameters ):
"函数_文档字符串"
function_suite
return[expression]
l 在 python 中，类型属于对象，变量是没有类型的，a=[1,2,3]，a只是一个对象的引用。
l strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
l 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。b=a,则只是用新引用b指向a所指的内存，b is a为true，del a，而b仍然等于所指内存的指。类似值传递。GC机制：对象的引用数为0就被回收内存。
l 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。类似引用传递
l 严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
l 调用时可使用的正是参数类型：必备参数，关键字参数，默认参数，不定长参数
l 关键字参数：实参和形参名字一样，允许实参顺序不同。（printme(str=”abc”)）
l 默认参数：缺省，类似C++
l 不定长参数：形参中加了星号（*）的变量名会存放所有未命名的变量参数。Eg:
def printinfo( arg1,*vartuple ):
调用：
printinfo(70,60,50);
l 匿名函数：
lambda的主体是一个表达式，而不是一个代码块。仅仅能在表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
sum =lambda arg1, arg2: arg1 + arg2;
调用：
sum(10,20)
l 全局变量与局部变量
十五、模块
l 模块(Module)，是一个Python文件，以.py结尾，包含了 Python 对象定义和Python语句。
l import导入，引用模块的变量或函数：module.fun()。
l 模一个模块只会被导入一次，不管你执行了多少次import。
l 导入部分（模块内的变量或函数）：from module inport fun1,var1,fun2(用*则全部)
l 导入时搜索顺序：当前目录->shell 变量 PYTHONPATH 下的每个目录->察看默认路径
l 函数中不能直接对全局变量操作！
Var=1
def fun():#在函数中直接作右值使用会出错
#globalVar 这个是使用全局变量
#Var=2 这个是重新声明一个局部变量覆盖全局变量
Var=Var+1
l dir()函数返回一个排好序的字符串列表，内容是一个模块里定义过的名字
l 如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。
如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。
两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。
l 重新导入之前导入过的模块（再执行一次）：reload(module_name)
l 包：
包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。
包就是文件夹，但该文件夹下必须存在 __init__.py文件, 该文件的内容可以为空。__int__.py用于标识当前文件夹是一个包。
包文件夹放在与code.py同级，包pack1内含（__init__.py,module1.py,其他模块或者文件夹子包）
code.py中导入:importpack1.module1(from pack1.module1 import *)
十六、文件IO
l print 用’，’隔开不同表达式。尾部加,则不换行
l 输入：
raw_input([prompt]) 函数从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）
input 可以接收一个Python表达式作为输入，并将运算结果返回。
请输入：[x*5for x in range(2,10,2)]
你输入的内容是: [10,20,30,40]
l 打开和关闭文件
f = open(file_name [, access_mode][, buffering])
· file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。
· access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。“w”
· buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。
二进制格式多用于非文本文件，不存在的则a和w都会新创，r不会，只有a指针在尾
模式 |
描述 |
r |
以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
rb |
以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。 |
r+ |
打开一个文件用于读写。文件指针将会放在文件的开头。 |
rb+ |
以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。 |
w |
打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
wb |
以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 |
w+ |
打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
wb+ |
以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。 |
a |
打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
ab |
以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
a+ |
打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 |
ab+ |
以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |
文件对象的属性
属性 |
描述 |
file.closed |
返回true如果文件已被关闭，否则返回false。 |
file.mode |
返回被打开文件的访问模式。 |
file.name |
返回文件的名称。 |
file.softspace |
如果用print输出后，必须跟一个空格符，则返回false。否则返回true。 |
l f.close():刷新缓冲区里任何还没写入的信息，并关闭该文件，这之后便不能再进行写入。当一个文件对象的引用被重新指定给另一个文件时，Python 会关闭之前的文件。
l f.write()：可将任何字符串写入一个打开的文件，字符串可以是二进制数据，而不是仅仅是文字，不会在字符串的结尾添加换行符('\n')，参数是写入的数据。
l f.read():读取一个字符串，可以是二进制数据，而不是仅仅是文字。参数是要从中读取的字节数，缺省会读到末尾。
l f.tell():返回当前位置，下一次的读写会发生在文件开头这么多字节之后。
l f.seek(offset [,from]):改变当前文件的位置,from默认为0（开头），1则为当前位置，2位文件末尾，文件指针移动到from+offset。
l 重命名：import os os.rename(now_name,new_name);
l 删除：os.remove(file_name)
l 创建文件夹：os.mkdir(“newdir”)
l 显示当前目录：os.getcwd() 设置当前目录：os.chdir(“/a/b/dir”)
l 删除目录：rmdir(“dir_name”)
主要对象：OS与File
File方法
序号 |
方法及描述 |
1 |
file.close() 关闭文件。关闭后文件不能再进行读写操作。 |
2 |
file.flush() 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。 |
3 |
file.fileno() 返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。 |
4 |
file.isatty() 如果文件连接到一个终端设备返回 True，否则返回 False。 |
5 |
file.next() 返回文件下一行。 |
6 |
file.read([size]) 从文件读取指定的字节数，如果未给定或为负则读取所有。 |
7 |
file.readline([size]) 读取整行，包括 "\n" 字符。 |
8 |
file.readlines([sizehint]) 读取所有行并返回列表，若给定sizeint>0，则是设置一次读多少字节，这是为了减轻读取压力。 |
9 |
file.seek(offset[, whence]) 设置文件当前位置 |
10 |
file.tell() 返回文件当前位置。 |
11 |
file.truncate([size]) 截取文件，截取的字节通过size指定，默认为当前文件位置。 |
12 |
file.write(str) 将字符串写入文件，没有返回值。 |
13 |
file.writelines(sequence) 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。 |
十七、异常处理
异常名称 |
描述 |
BaseException |
所有异常的基类 |
SystemExit |
解释器请求退出 |
KeyboardInterrupt |
用户中断执行(通常是输入^C) |
Exception |
常规错误的基类 |
StopIteration |
迭代器没有更多的值 |
GeneratorExit |
生成器(generator)发生异常来通知退出 |
StandardError |
所有的内建标准异常的基类 |
ArithmeticError |
所有数值计算错误的基类 |
FloatingPointError |
浮点计算错误 |
OverflowError |
数值运算超出最大限制 |
ZeroDivisionError |
除(或取模)零 (所有数据类型) |
AssertionError |
断言语句失败 |
AttributeError |
对象没有这个属性 |
EOFError |
没有内建输入,到达EOF 标记 |
EnvironmentError |
操作系统错误的基类 |
IOError |
输入/输出操作失败 |
OSError |
操作系统错误 |
WindowsError |
系统调用失败 |
ImportError |
导入模块/对象失败 |
LookupError |
无效数据查询的基类 |
IndexError |
序列中没有此索引(index) |
KeyError |
映射中没有这个键 |
MemoryError |
内存溢出错误(对于Python 解释器不是致命的) |
NameError |
未声明/初始化对象 (没有属性) |
UnboundLocalError |
访问未初始化的本地变量 |
ReferenceError |
弱引用(Weak reference)试图访问已经垃圾回收了的对象 |
RuntimeError |
一般的运行时错误 |
NotImplementedError |
尚未实现的方法 |
SyntaxError |
Python 语法错误 |
IndentationError |
缩进错误 |
TabError |
Tab 和空格混用 |
SystemError |
一般的解释器系统错误 |
TypeError |
对类型无效的操作 |
ValueError |
传入无效的参数 |
UnicodeError |
Unicode 相关的错误 |
UnicodeDecodeError |
Unicode 解码时的错误 |
UnicodeEncodeError |
Unicode 编码时错误 |
UnicodeTranslateError |
Unicode 转换时错误 |
Warning |
警告的基类 |
DeprecationWarning |
关于被弃用的特征的警告 |
FutureWarning |
关于构造将来语义会有改变的警告 |
OverflowWarning |
旧的关于自动提升为长整型(long)的警告 |
PendingDeprecationWarning |
关于特性将会被废弃的警告 |
RuntimeWarning |
可疑的运行时行为(runtime behavior)的警告 |
SyntaxWarning |
可疑的语法的警告 |
UserWarning |
用户代码生成的警告 |
异常处理：名字就是异常的类型
try:
<语句> #运行别的代码
except<名字>：
<语句> #如果在try部份引发了'name'异常
except<名字>，<数据>:
<语句> #如果引发了'name'异常，获得附加的数据
else:
<语句> #如果没有异常发生
· 如果当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就通过整个try语句（除非在处理异常时又引发新的异常）。
· 如果在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的try，或者到程序的最上层（这样将结束程序，并打印缺省的出错信息）。
· 如果在try子句执行时没有发生异常，python将执行else语句后的语句（如果有else的话），然后控制流通过整个try语句。
l 可以except:不带异常，这样所有异常都执行这个语句块
l 可以except (E1,E2,E3):
try:
<语句>
finally:
<语句> #退出try时总会执行
l 一个异常可以带上参数，可作为输出的异常信息参数
try:
正常的操作
......................
exceptExceptionType,Argument:
你可以在这输出Argument的值...
Eg：
def temp_convert(var):
try:
returnint(var)
exceptValueError,Argument:
print"参数没有包含数字\n",Argument
l 使用raise语句自己触发异常
raiseException("Invalid level!", level)
l 自定义异常类：必须直接或间接继承Exception
classNetworkerror(RuntimeError):
def __init__(self, arg):
self.args = arg
触发：
try:
raiseNetworkerror("Bad hostname")
exceptNetworkerror,e:
print e.args
十八、OS文件/目录方法
序号 |
方法及描述 |
1 |
os.access(path, mode)
|
2 |
os.chdir(path)
|
3 |
os.chflags(path, flags)
|
4 |
os.chmod(path, mode)
|
5 |
os.chown(path, uid, gid)
|
6 |
os.chroot(path)
|
7 |
os.close(fd)
|
8 |
os.closerange(fd_low, fd_high)
|
9 |
os.dup(fd)
|
10 |
os.dup2(fd, fd2)
|
11 |
os.fchdir(fd)
|
12 |
os.fchmod(fd, mode)
|
13 |
os.fchown(fd, uid, gid)
|
14 |
os.fdatasync(fd)
|
15 |
os.fdopen(fd[, mode[, bufsize]])
|
16 |
os.fpathconf(fd, name)
|
17 |
os.fstat(fd)
|
18 |
os.fstatvfs(fd)
|
19 |
os.fsync(fd)
|
20 |
os.ftruncate(fd, length)
|
21 |
os.getcwd()
|
22 |
os.getcwdu()
|
23 |
os.isatty(fd)
|
24 |
os.lchflags(path, flags)
|
25 |
os.lchmod(path, mode)
|
26 |
os.lchown(path, uid, gid)
|
27 |
os.link(src, dst)
|
28 |
os.listdir(path)
|
29 |
os.lseek(fd, pos, how)
|
30 |
os.lstat(path)
|
31 |
os.major(device)
|
32 |
os.makedev(major, minor)
|
33 |
os.makedirs(path[, mode])
|
34 |
os.minor(device)
|
35 |
os.mkdir(path[, mode])
|
36 |
os.mkfifo(path[, mode])
|
37 |
os.mknod(filename[, mode=0600, device]) |
38 |
os.open(file, flags[, mode])
|
39 |
os.openpty()
|
40 |
os.pathconf(path, name)
|
41 |
os.pipe()
|
42 |
os.popen(command[, mode[, bufsize]])
|
43 |
os.read(fd, n)
|
44 |
os.readlink(path)
|
45 |
os.remove(path)
|
46 |
os.removedirs(path)
|
47 |
os.rename(src, dst)
|
48 |
os.renames(old, new)
|
49 |
os.rmdir(path)
|
50 |
os.stat(path)
|
51 |
os.stat_float_times([newvalue]) |
52 |
os.statvfs(path)
|
53 |
os.symlink(src, dst)
|
54 |
os.tcgetpgrp(fd)
|
55 |
os.tcsetpgrp(fd, pg)
|
56 |
os.tempnam([dir[, prefix]])
|
57 |
os.tmpfile()
|
58 |
os.tmpnam()
|
59 |
os.ttyname(fd)
|
60 |
os.unlink(path)
|
61 |
os.utime(path, times)
|
62 |
os.walk(top[, topdown=True[, οnerrοr=None[, followlinks=False]]])
|
63 |
os.write(fd, str)
|
十九、面向对象
l 类、类变量、数据成员、方法重写、实例变量、继承、实例化、方法、对象
l 数据成员=类变量+实例变量
l 创建类
classClassName:
'类的帮助信息' #类文档字符串
class_suite #类体
l 类的帮助信息可以通过ClassName.__doc__查看
classEmployee:#每一个类方法原形的第一个形参都是self（相当*this），调用时忽略
'所有员工的基类'
empCount = 0 #类变量，通过类名.empCount来引用，实例间共用
def__init__(self, name, salary): #构造函数
self.name = name #实例变量
self.salary = salary
Employee.empCount += 1
defdisplayCount(self):
print"Total Employee %d" % Employee.empCount
defdisplayEmployee(self): print"Name : ", self.name, ", Salary: ", self.salary#其他方法也能使用实例变量
#self和runoob等同，self.__class__为自己类名，对于self的拼写没有要求
l 实例化，python没有new，直接调用：
emp1 =Employee("Zara",2000)
l 可以动态添加删除修改成员属性，注意实例变量和类变量的区别
emp1.age =7 # 添加一个 'age' 属性
emp1.age =8 # 修改 'age' 属性
del emp1.age # 删除 'age' 属性
· getattr(obj, name[, default]) : 访问对象的属性。
· hasattr(obj,name) : 检查是否存在一个属性。
· setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
· delattr(obj, name) : 删除属性。
l 内置类属性，ClassName.attr
__dict__ : 类的属性（包含一个字典，由类的数据属性组成）
__doc__ :类的文档字符串
__name__: 类名
__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__等于 mymod）
__bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）
l 垃圾回收
一个内部跟踪变量，称为一个引用计数器。
当对象被创建时，就创建了一个引用计数，当这个对象不再需要时，也就是说，这个对象的引用计数变为0 时，它被垃圾回收。但是回收不是"立即"的，由解释器在适当的时机，将垃圾对象占用的内存空间回收。
垃圾回收机制不仅针对引用计数为0的对象，同样也可以处理循环引用的情况。循环引用指的是，两个对象相互引用，但是没有其他变量引用他们。
l 析构函数：__del__(self)
l 类继承
l 1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。
l 2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别在于类中调用普通函数时并不需要带上self参数
l 3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。
如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。
classSubClassName(ParentClass1[,ParentClass2,...]):
'Optional class documentation string'
class_suite
· issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)
· isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。
l 方法重写：直接定义
l 基础重载方法
序号 |
方法, 描述 & 简单的调用 |
1 |
__init__ ( self [,args...] ) |
2 |
__del__( self ) |
3 |
__repr__( self ) |
4 |
__str__( self ) |
5 |
__cmp__ ( self, x ) |
l 运算符重载
def__str__(self): #用法！！！
return'Vector (%d, %d)' % (self.a, self.b)
def__add__(self,other):
returnVector(self.a + other.a, self.b + other.b)
调用：
v1 = Vector(2,10)
v2 = Vector(5,-2)
printv1 + v2
l 私有属性：
类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
类的方法
在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self,且为第一个参数
类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 self.__private_methods
l 实例不能访问私有变量！！！可以object._className__attrName 访问私有属性
l __foo__: 定义的是特殊方法，一般是系统定义名字，类似 __init__() 之类的。
l _foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
l __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。
二十、正则表达式
re.match(pattern,string, flags=0)
函数参数说明：
参数 |
描述 |
pattern |
匹配的正则表达式 |
string |
要匹配的字符串。 |
flags |
标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等 |
匹配成功re.match方法返回一个匹配的对象，否则返回None。
先import re。
我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
匹配对象方法 |
描述 |
group(num=0) |
匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。 |
groups() |
返回一个包含所有小组字符串的元组，从 1 到所含的小组号。 |
l re.search 扫描整个字符串并返回第一个成功的匹配。
函数语法：
re.search(pattern,string, flags=0)
l 两个都有re.xxx(x,x,x).span() #返回匹配的字符串的起始索引和尾部索引
l re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。
l re,sub
re.sub(pattern, repl,string, count=0, flags=0)
参数：
pattern : 正则中的模式字符串。
repl : 替换的字符串，也可为一个函数。
string : 要被查找替换的原始字符串。
count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
l 正则表达式可用r'#.*$'表示语法。
l Repl参数是一个函数：（注意用法）
importre
# 将匹配的数字乘于 2
defdouble(matched):
value = int(matched.group('value'))
returnstr(value * 2)
s = 'A23G4HFD567'
print(re.sub('(?P
l compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象
re.compile(pattern[, flags])
· pattern : 一个字符串形式的正则表达式
· flags : 可选，表示匹配模式，比如忽略大小写，多行模式等，具体参数为：
1. re.I 忽略大小写
2. re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
3. re.M 多行模式
4. re.S 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）
5. re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
6. re.X 为了增加可读性，忽略空格和 # 后面的注释
用法：
二十一、CGI编程
CGI(Common Gateway Interface),通用网关接口,它是一段程序,运行在服务器上如：HTTP服务器，提供同客户端HTML页面的接口。
get、post方式及处理，传递checkbox数据，radio数据，textarea数据，传递下拉程序，使用cookie（设置与检索），文件下载和上传
二十二、mysql数据库的操作
l 不同的数据库你需要下载不同的DB API模块，例如你需要访问Oracle数据库和Mysql数据，你需要下载Oracle和MySQL数据库模块。
l DB-API 是一个规范. 它定义了一系列必须的对象和数据库存取方式, 以便为各种各样的底层数据库系统和多种多样的数据库接口程序提供一致的访问接口。
l Python的DB-API，为大多数的数据库实现了接口，使用它连接各数据库后，就可以用相同的方式操作各数据库。
l Python DB-API使用流程：
· 引入 API 模块。
· 获取与数据库的连接。
· 执行SQL语句和存储过程。
· 关闭数据库连接。
实际操作一下，在linux安装一下。
二十三、网络编程
Python 提供了两个级别访问的网络服务。：
· 低级别的网络服务支持基本的 Socket，它提供了标准的 BSD Sockets API，可以访问底层操作系统Socket接口的全部方法。
· 高级别的网络服务模块 SocketServer，它提供了服务器中心类，可以简化网络服务器的开发。
socket.socket([family[, type[, proto]]])
参数
· family: 套接字家族可以使AF_UNIX或者AF_INET
· type: 套接字类型可以根据是面向连接的还是非连接分为SOCK_STREAM或SOCK_DGRAM
· protocol: 一般不填默认为0.
二十四、SMTP
二十五、多线程
· 使用线程可以把占据长时间的程序中的任务放到后台去处理。
· 用户界面可以更加吸引人，这样比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度
· 程序的运行速度可能加快
· 在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。在这种情况下我们可以释放一些珍贵的资源如内存占用等等。
Python中使用线程有两种方式：函数或者用类来包装线程对象。
函数式：（import thread）
thread.start_new_thread(function, args[, kwargs])
参数说明:
· function - 线程函数。
· args - 传递给线程函数的参数,他必须是个tuple类型。
· kwargs - 可选参数。
结束：一般依靠线程函数的自然结束；也可以在线程函数中调用thread.exit()，他抛出SystemExit exception
thread提供了低级别的、原始的线程以及一个简单的锁。
threading 模块提供的其他方法：
· threading.currentThread(): 返回当前的线程变量。
· threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
· threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。
除了使用方法外，线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法:
· run(): 用以表示线程活动的方法。
· start():启动线程活动。
· join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。
· isAlive(): 返回线程是否活动的。
· getName(): 返回线程名。
· setName(): 设置线程名。
二十六、XML解析
常见的XML编程接口有DOM和SAX，python有三种
· python 标准库包含SAX解析器，SAX用事件驱动模型，通过在解析XML的过程中触发一个个的事件并调用用户定义的回调函数来处理XML文件。
· 将XML数据在内存中解析成一个树，通过对树的操作来操作XML。
· ElementTree就像一个轻量级的DOM，具有方便友好的API。代码可用性好，速度快，消耗内存少。
因DOM需要将XML数据映射到内存中的树，一是比较慢，二是比较耗内存，而SAX流式读取XML文件，比较快，占用内存少，但需要用户实现回调函数（handler）。
二十七、GUI编程
Tkinter，wxPython，Jython
· 1、导入 Tkinter 模块
· 2、创建控件
· 3、指定这个控件的 master，即这个控件属于哪一个
· 4、告诉 GM(geometry manager) 有一个控件产生了。
二十八、3.0主要变化
（1）Print，只有print()
2.7中：三者一样
print"fish"
print("fish")#注意print后面有个空格
print("fish")#print()不能带有任何其它参数
（2）Unicode
3.0有Unicode(utf-8)字符串，以及一个字节类：byte和bytearrays。
默认使用utf-8编码，可以用中文作为变量名称。
（3）除与整除
2.0:1/2==0,1.0/2.0==0.5，-1//2==-1（//是对正确结果-0.5作floor操作）
3.0:1/2==0.5，-1//2==-1
所以//和/不一样！！！简单舍弃小数应该用math.trunc(-1/2)，floor是下舍操作，5.6->5.0，-5.6->-6
（4）异常
（5）2.0有range和xrange，3.0没有xrange
（6）八进制2.0：0o777或0777,3.0只有0o777,且二进制位都是0b111
（7）3.0只有!=
（8）3.0去掉``，只能用repr函数
（9）改名：
旧的名字 |
新的名字 |
_winreg |
winreg |
ConfigParser |
configparser |
copy_reg |
copyreg |
Queue |
queue |
SocketServer |
socketserver |
repr |
reprlib |
StringIO模块现在被合并到新的io模组内。 new, md5, gopherlib等模块被删除。 Python 2.6已经支援新的io模组。
httplib, BaseHTTPServer, CGIHTTPServer, SimpleHTTPServer,Cookie, cookielib被合并到http包内。
取消了exec语句，只剩下exec()函数。 Python 2.6已经支援exec()函数。
except Exception, e变成except (Exception) as e.
（10）数据类型
1）Py3.X去除了long类型，现在只有一种整型——int，但它的行为就像2.X版本的long
2）新增了bytes类型，对应于2.X版本的八位串，定义一个bytes字面量的方法如下
>>> b = b'china'
>>> type(b)
str对象和bytes对象可以使用.encode()(str -> bytes) or .decode() (bytes -> str)方法相互转化。
3）dict的.keys()、.items 和.values()方法返回迭代器，而之前的iterkeys()等函数都被废弃。同时去掉的还有 dict.has_key()，用 in替代它吧。
二十九、JSON
import json。
函数 |
描述 |
json.dumps |
将 Python 对象编码成 JSON 字符串 |
json.loads |
将已编码的 JSON 字符串解码为 Python 对象 |
json.dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, encoding="utf-8",default=None, sort_keys=False,**kw)
import json
data =[{ 'a':1,'b':2,'c':3,'d':4,'e':5}]
json = json.dumps(data)
print json
Python |
JSON |
dict |
object |
list, tuple |
array |
str, unicode |
string |
int, long, float |
number |
True |
true |
False |
false |
None |
null |
json.loads(s[, encoding[, cls[, object_hook[, parse_float[, parse_int[, parse_constant[, object_pairs_hook[,**kw]]]]]]]])
jsonData ='{"a":1,"b":2,"c":3,"d":4,"e":5}';
text = json.loads(jsonData)
JSON |
Python |
object |
dict |
array |
list |
string |
unicode |
number (int) |
int, long |
number (real) |
float |
true |
True |
false |
False |
null |
None |
Demjson 是 python 的第三方模块库，可用于编码和解码 JSON 数据，包含了JSONLint 的格式化及校验功能。