下面是小编为大家整理的python的几种开发工具介绍，本文共14篇，仅供大家参考借鉴，希望大家喜欢!本文原稿由网友“止损阀”提供。
篇1：Python几种开发工具介绍.net
1 IDLE 1.1 IDLE是python创初人Guido van Rossum使用python and Tkinter来创建的一个集成 开发 环境，要使用IDLE必须安装python and Tkinter。 1.2 特性：自动缩进，彩色编码，命令历史(Alt+p,Alt+n)和单词自动(Alt+/)完成。 1.3 用IDLE执行Tkinter程序，不
1 IDLE
1.1 IDLE是python创初人Guido van Rossum使用python and Tkinter来创建的一个集成开发环境。要使用IDLE必须安装python and Tkinter。
1.2 特性：自动缩进，彩色编码，命令历史(Alt+p,Alt+n)和单词自动(Alt+/)完成。
1.3 用IDLE执行Tkinter程序，不要在程序中包括mainloop。IDLE本身就是Tkinter应用程序，它会自动调用mainloop。再调用一次mainloop会与IDLE的事件循环冲突，造成运行时错误。
2 BlackAdder
2.1 BlackAdder支持windowsandlinux环境。用它创建的程序可在任何一种平台上运行，负责维护它的是TheKompany.com。他们发布了该软件的个人版 ，只提供有限的支持；以及专业版，需要许可，面向商业软件开发者。详情请访问www.thekompany.com/products/blackadder。
3 PythonWorks
3.1 它由SecretLabs公司发布，该公司致力于Python项目的开发与部署提供相应的工具。PythonWorks是一种“快速应用程序开发”（RAD）工具，程序员可借助它快速地创建、调试和发布程序。
3.2 PythonWorks包括一个HTML/XML编辑器、具有完全索引的文档、一个源码管理系统（用于项目分组）、自定义的代码编辑特性以及一个GUI布局编辑器。支持jython。
3.3 允许用户以多种形式对项目进行打包：源码形式、可执行程序形式以及.pyc形式。
3.4 有版权，需购买，详情请访问www.pythonware.com/products/works/
4 Wing IDE
4.1 Wing IDE由Archaeopteryx Software公司开发与支持，适用于windows and linux环境，
它提供一个源码分析器和浏览器、项目管理能力以及文本编辑器和调试器。
4.2 它由python编写，并包含python源码。购买者可自定义源码，以适应自已的要求，但是，不可将修改过的代码用于赢利目的。
4.3 全功能演示版可在archaeopteryx.com/wingide下载。(mypython.net提供wing IDE 1.1.9.1及其license)
5 Pythonwin
5.1 Pythonwin集成开发环境包含在由ActiveState出品的ActivePython中，ActivePython是一个二进制build。其中包括用于XML处理的expat模块，以及一系列windows工具。
5.2 提供的特性有：彩色编码、源代码折叠、单词完成及自动缩进。调试器支持事后诊断功能、标准的单步调试、断点设计及变量监视。
5.3 详情请访问aspn.activestate.com/activepython。
6 Komodo
6.1 ActiveState还为python提供了另一个IDE，名为Komodo，可用它在windows and linux上开发程序。Komodo最大的特点是，它是Perl,PHP,Tcl,HTML,XML AND XSLT的一种集成开发环境。
7 Boa Constructor
7.1 Boa是一个跨平台的python IDE和WxPython GUI。它提供可视化的编程和操作框架，能方便地进行程序的设计。它有一个对象浏览器，并提供有各种资源的视图，有一个html文档生成器，还有一个先进的调试器和完整的帮助系统。Boa还提供对zope的支持，能添加、删除、复制、剪切、导入和导出zope中的对象。能编辑对象属性和进行python脚本的调试。Boa是用python基于WxPython库编写的。 用起来就象vb或delphi一样方便。
7.2 下载地址是：boa-constructor.sourceforge.net/，要安装Boa要先安装合适版本的python和WxPython。
原文转自：www.ltesting.net
篇2：python的几种开发工具介绍
最近更 新
python基础教程之简单入门说明(变量和控制
Python版的文曲星猜数字游戏代码
Python程序设计入门(5)类的使用简介
python计数排序和基数排序算法实例
python应用程序在windows下不出现cmd窗口
python 正则式 概述及常用字符
python中查找excel某一列的重复数据 剔除
Python开发编码规范
Python中条件选择和循环语句使用方法介绍
python实现zencart产品数据导入到magento
热 点 排 行
Python入门教程 超详细1小时学会
python 中文乱码问题深入分析
比较详细Python正则表达式操作指
Python字符串的encode与decode研
Python open读写文件实现脚本
Python enumerate遍历数组示例应
Python 深入理解yield
Python+Django在windows下的开发
python 文件和路径操作函数小结
python 字符串split的用法分享
篇3：Linux下C开发工具介绍
Linux的发行版中包含了很多软件开发工具. 它们中的很多是用于 C 和 C++应用程序开发的. 本文介绍了在 Linux 下能用于 C 应用程序开发和调试的工具. 本文的主旨是介绍如何在 Linux 下使用 C 编译器和其他 C 编程工具, 而非 C 语言编程的教程.
GNU C 编译器
GNU C 编译器(GCC)是一个全功能的 ANSI C 兼容编译器. 如果你熟悉其他操作系统或硬件平台上的一种 C 编译器, 你将能很快地掌握 GCC. 本节将介绍如何使用 GCC 和一些 GCC 编译器最常用的选项.
使用 GCC
通常后跟一些选项和文件名来使用 GCC 编译器. gcc 命令的基本用法如下:
gcc [options] [filenames]
命令行选项指定的操作将在命令行上每个给出的文件上执行. 下一小节将叙述一些你会最常用到的选项.
GCC 选项
GCC 有超过100个的编译选项可用. 这些选项中的许多你可能永远都不会用到, 但一些主要的选项将会频繁用到. 很多的 GCC 选项包括一个以上的字符. 因此你必须为每个选项指定各自的连字符, 并且就象大多数 Linux 命令一样你不能在一个单独的连字符后跟一组选项. 例如, 下面的两个命令是不同的:
gcc -p -g test.c
gcc -pg test.c
第一条命令告诉 GCC 编译 test.c 时为 prof 命令建立剖析(profile)信息并且把调试信息加入到可执行的文件里. 第二条命令只告诉 GCC 为 gprof 命令建立剖析信息.
当你不用任何选项编译一个程序时, GCC 将会建立(假定编译成功)一个名为 a.out 的可执行文件. 例如, 下面的命令将在当前目录下产生一个叫 a.out 的文件:
gcc test.c
你能用 -o 编译选项来为将产生的可执行文件指定一个文件名来代替 a.out. 例如, 将一个叫 count.c 的 C 程序编译为名叫 count 的可执行文件, 你将输入下面的命令:
gcc -o count count.c
--------------------------------------------------------------------------------
注意: 当你使用 -o 选项时, -o 后面必须跟一个文件名.
--------------------------------------------------------------------------------
GCC 同样有指定编译器处理多少的编译选项. -c 选项告诉 GCC 仅把源代码编译为目标代码而跳过汇编和连接的步骤. 这个选项使用的非常频繁因为它使得编译多个 C 程序时速度更快并且更易于管理. 缺省时 GCC 建立的目标代码文件有一个 .o 的扩展名.
-S 编译选项告诉 GCC 在为 C 代码产生了汇编语言文件后停止编译. GCC 产生的汇编语言文件的缺省扩展名是 .s . -E 选项指示编译器仅对输入文件进行预处理. 当这个选项被使用时, 预处理器的输出被送到标准输出而不是储存在文件里.
优 化 选 项
当你用 GCC 编译 C 代码时, 它会试着用最少的时间完成编译并且使编译后的代码易于调试. 易于调试意味着编译后的代码与源代码有同样的执行次序, 编译后的代码没有经过优化. 有很多选项可用于告诉 GCC 在耗费更多编译时间和牺牲易调试性的基础上产生更小更快的可执行文件. 这些选项中最典型的是-O 和 -O2 选项.
-O 选项告诉 GCC 对源代码进行基本优化. 这些优化在大多数情况下都会使程序执行的更快. -O2 选项告诉 GCC 产生尽可能小和尽可能快的代码. -O2 选项将使编译的速度比使用 -O 时慢. 但通常产生的代码执行速度会更快.
除了 -O 和 -O2 优化选项外, 还有一些低级选项用于产生更快的代码. 这些选项非常的特殊, 而且最好只有当你完全理解这些选项将会对编译后的代码产生什么样的效果时再去使用. 这些选项的详细描述, 请参考 GCC 的指南页, 在命令行上键入 man gcc .
调试和剖析选项
GCC 支持数种调试和剖析选项. 在这些选项里你会最常用到的是 -g 和 -pg 选项.
-g 选项告诉 GCC 产生能被 GNU 调试器使用的调试信息以便调试你的程序. GCC 提供了一个很多其他 C 编译器里没有的特性, 在 GCC 里你能使 -g 和 -O (产生优化代码)联用. 这一点非常有用因为你能在与最终产品尽可能相近的情况下调试你的代码. 在你同时使用这两个选项时你必须清楚你所写的某些代码已经在优化时被 GCC 作了改动. 关于调试 C 程序的更多信息请看下一节“用 gdb 调试 C 程序” .
-pg 选项告诉 GCC 在你的程序里加入额外的代码, 执行时, 产生 gprof 用的剖析信息以显示你的程序的耗时情况. 关于 gprof 的更多信息请参考 “gprof” 一节.
用 gdb 调试 GCC 程序
Linux 包含了一个叫 gdb 的 GNU 调试程序. gdb 是一个用来调试 C 和 C++ 程序的强力调试器. 它使你能在程序运行时观察程序的内部结构和内存的使用情况. 以下是 gdb 所提供的一些功能:
它使你能监视你程序中变量的值.
它使你能设置断点以使程序在指定的代码行上停止执行.
它使你能一行行的执行你的代码.
在命令行上键入 gdb 并按回车键就可以运行 gdb 了, 如果一切正常的话, gdb 将被启动并且你将在屏幕上看到类似的内容:
GNU gdb 5.0
Copyright Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type “show copying” to see the conditions.
There is absolutely no warranty for GDB. Type “show warranty” for details.
This GDB was configured as “i386-redhat-linux”.
(gdb)
当你启动 gdb 后, 你能在命令行上指定很多的选项. 你也可以以下面的方式来运行 gdb :
gdb
当你用这种方式运行 gdb , 你能直接指定想要调试的程序. 这将告诉gdb 装入名为 fname 的可执行文件. 你也可以用 gdb 去检查一个因程序异常终止而产生的 core 文件, 或者与一个正在运行的程序相连. 你可以参考 gdb 指南页或在命令行上键入 gdb -h 得到一个有关这些选项的说明的简单列表.
为调试编译代码(Compiling Code for Debugging)
为了使 gdb 正常工作, 你必须使你的程序在编译时包含调试信息. 调试信息包含你程序里的每个变量的类型和在可执行文件里的地址映射以及源代码的行号. gdb 利用这些信息使源代码和机器码相关联.
在编译时用 -g 选项打开调试选项.
gdb 基本命令
gdb 支持很多的命令使你能实现不同的功能. 这些命令从简单的文件装入到允许你检查所调用的堆栈内容的复杂命令, 表27.1列出了你在用 gdb 调试时会用到的一些命令. 想了解 gdb 的详细使用请参考 gdb 的指南页.
基本 gdb 命令.
命 令 描 述
file 装入想要调试的可执行文件.
kill 终止正在调试的程序.
list 列出产生执行文件的源代码的一部分.
next 执行一行源代码但不进入函数内部.
step 执行一行源代码而且进入函数内部.
run 执行当前被调试的程序
quit 终止 gdb
watch 使你能监视一个变量的值而不管它何时被改变.
print 显示表达式的值
break 在代码里设置断点, 这将使程序执行到这里时被挂起.
make 使你能不退出 gdb 就可以重新产生可执行文件.
shell 使你能不离开 gdb 就执行 UNIX shell 命令.
gdb 支持很多与 UNIX shell 程序一样的命令编辑特征. 你能象在 bash 或 tcsh里那样按 Tab 键让 gdb 帮你补齐一个唯一的命令, 如果不唯一的话 gdb 会列出所有匹配的命令. 你也能用光标键上下翻动历史命令.
gdb 应用举例
本节用一个实例教你一步步的用 gdb 调试程序. 被调试的程序相当的简单, 但它展示了 gdb 的典型应用.
下面列出了将被调试的程序. 这个程序被称为 hello , 它显示一个简单的问候, 再用反序将它列出.
#include
static void my_print (char *);
static void my_print2 (char *);
main
{
char my_string[] = “hello world!”;
my_print (my_string);
my_print2 (my_string);
}
void my_print (char *string)
{
printf (“The string is %s ”, string);
}
void my_print2 (char *string)
{
char *string2;
int size, i;
size = strlen (string);
string2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++)
string2[size - i] = string[i];
string2[size+1] = ;
printf (“The string printed backward is %s ”, string2);
}
用下面的命令编译它:
gcc -g -o hello hello.c
这个程序执行时显示如下结果:
./hello
The string is hello world!
The string printed backward is
输出的第一行是正确的, 但第二行打印出的东西并不是我们所期望的. 我们所设想的输出应该是:
The string printed backward is !dlrow olleh
由于某些原因, my_print2 函数没有正常工作. 让我们用 gdb 看看问题究竟出在哪儿, 先键入如下命令:
gdb hello
--------------------------------------------------------------------------------
注意: 记得在编译 hello 程序时把调试选项打开.
--------------------------------------------------------------------------------
如果你在输入命令时忘了把要调试的程序作为参数传给 gdb , 你可以在 gdb 提示符下用 file 命令来载入它:
(gdb) file hello
这个命令将载入 hello 可执行文件就象你在 gdb 命令行里装入它一样.
这时你能用 gdb 的 run 命令来运行 hello 了. 当它在 gdb 里被运行后结果大约会象这样:
(gdb) run
Starting program: /root/hello
The string is hello world!
The string printed backward is
Program exited with code 040
这个输出和在 gdb 外面运行的结果一样. 问题是, 为什么反序打印没有工作? 为了找出症结所在, 我们可以在 my_print2 函数的 for 语句后设一个断点, 具体的做法是在 gdb 提示符下键入 list 命令三次, 列出源代码:
(gdb) list
(gdb) list
(gdb) list
--------------------------------------------------------------------------------
技巧: 在 gdb 提示符下按回车健将重复上一个命令.
--------------------------------------------------------------------------------
第一次键入 list 命令的输出如下:
1 #include
2
3 static void my_print (char *);
4 static void my_print2 (char *);
5
6 main ()
7 {
8 char my_string[] = “hello world!”;
9 my_print (my_string);
10 my_print2 (my_string);
如果按下回车, gdb 将再执行一次 list 命令, 给出下列输出:
11 }
12
13 void my_print (char *string)
14 {
15 printf (“The string is %s ”, string);
16 }
17
18 void my_print2 (char *string)
19 {
20 char *string2;
再按一次回车将列出 hello 程序的剩余部分:
21 int size, i;
22
23 size = strlen (string);
24 string2 = (char *) malloc (size + 1);
25 for (i = 0; i < size; i++)
26 string2[size - i] = string[i];
27 string2[size+1] = ;
28
29 printf (“The string printed backward is %s ”, string2);
30 }
根据列出的源程序, 你能看到要设断点的地方在第26行, 在 gdb 命令行提示符下键入如下命令设置断点:
(gdb) break 26
gdb 将作出如下的响应:
Breakpoint 1 at 0x804857c: file hello.c, line 26.
(gdb)
现在再键入 run 命令, 将产生如下的输出:
Starting program: /root/hello
The string is hello world!
Breakpoint 1, my_print2 (string=0xbffffab0 “hello world!”) at hello.c:26
26 string2[size - i] = string[i];
你能通过设置一个观察 string2[size - i] 变量的值的观察点来看出错误是怎样产生的, 做法是键入:
(gdb) watch string2[size - i]
gdb 将作出如下回应:
Hardware watchpoint 2: string2[size - i]
现在可以用 next 命令来一步步的执行 for 循环了:
(gdb) next
经过第一次循环后, gdb 告诉我们 string2[size - i] 的值是 `h`. gdb 用如下的显示来告诉你这个信息:
Hardware watchpoint 2: string2[size - i]
Old value = 0 0
New value = 104 h
my_print2 (string=0xbffffab0 “hello world!”) at hello.c:25
25 for (i = 0; i < size; i++)
这个值正是期望的. 后来的数次循环的结果都是正确的. 当 i=11 时, 表达式 string2[size - i] 的值等于 `!`, size - i 的值等于 1, 最后一个字符已经拷到新串里了.
如果你再把循环执行下去, 你会看到已经没有值分配给 string2[0] 了, 而它是新串的第一个字符, 因为 malloc 函数在分配内存时把它们初始化为空(null)字符. 所以 string2 的第一个字符是空字符. 这解释了为什么在打印 string2 时没有任何输出了.
现在找出了问题出在哪里, 修正这个错误是很容易的. 你得把代码里写入 string2 的第一个字符的的偏移量改为 size - 1 而不是 size. 这是因为 string2 的大小为 12, 但起始偏移量是 0, 串内的字符从偏移量 0 到 偏移量 10, 偏移量 11 为空字符保留.
改正方法非常简单. 这是这种解决办法的代码:
#include
static void my_print (char *);
static void my_print2 (char *);
main ()
{
char my_string[] = “hello world!”;
my_print (my_string);
my_print2 (my_string);
}
void my_print (char *string)
{
printf (“The string is %s ”, string);
}
void my_print2 (char *string)
{
char *string2;
int size, i;
size = strlen (string);
string2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++)
string2[size -1 - i] = string[i];
string2[size] = ;
printf (“The string printed backward is %s ”, string2);
}
如果程序产生了core文件，可以用gdb hello core命令来查看程序在何处出错，
Linux下C开发工具介绍
，
如在函数my_print2()中，如果忘记了给string2分配内存 string2 = (char *) malloc (size + 1);，很可能就会core dump.
另外的 C 编程工具
xxgdb
xxgdb 是 gdb 的一个基于 X Window 系统的图形界面. xxgdb 包括了命令行版的 gdb 上的所有特性. xxgdb 使你能通过按按钮来执行常用的命令. 设置了断点的地方也用图形来显示.
你能在一个 Xterm 窗口里键入下面的命令来运行它:
xxgdb
你能用 gdb 里任何有效的命令行选项来初始化 xxgdb . 此外 xxgdb 也有一些特有的命令行选项, 表 27.2 列出了这些选项.
表 27.2. xxgdb 命令行选项.
选 项 描 述
db_name 指定所用调试器的名字, 缺省是 gdb.
db_prompt 指定调试器提示符, 缺省为 gdb.
gdbinit 指定初始化 gdb 的命令文件的文件名, 缺省为 .gdbinit.
nx 告诉 xxgdb 不执行 .gdbinit 文件.
bigicon 使用大图标.
calls
你可以在 sunsite.unc.edu FTP 站点用下面的路径:
/pub/Linux/devel/lang/c/calls.tar.Z
来取得 calls , 一些旧版本的 Linux CD-ROM 发行版里也附带有. 因为它是一个有用的工具, 我们在这里也介绍一下. 如果你觉得有用的话, 从 BBS, FTP, 或另一张CD-ROM 上弄一个拷贝. calls 调用 GCC 的预处理器来处理给出的源程序文件, 然后输出这些文件的里的函数调用树图.
注意: 在你的系统上安装 calls , 以超级用户身份登录后执行下面的步骤: 1. 解压和 untar 文件. 2. cd 进入 calls untar 后建立的子目录. 3. 把名叫 calls 的文件移动到 /usr/bin 目录. 4. 把名叫 calls.1 的文件移动到目录 /usr/man/man1 . 5. 删除 /tmp/calls 目录. 这些步骤将把 calls 程序和它的指南页安装载你的系统上.
--------------------------------------------------------------------------------
当 calls 打印出调用跟踪结果时, 它在函数后面用中括号给出了函数所在文件的文件名:
main [hello.c]
如果函数并不是向 calls 给出的文件里的, calls 不知道所调用的函数来自哪里, 则只显示函数的名字:
printf
calls 不对递归和静态函数输出. 递归函数显示成下面的样子:
fact <<< recursive in factorial.c >>>
静态函数象这样显示:
total [static in calculate.c]
作为一个例子, 假设用 calls 处理下面的程序:
#include
static void my_print (char *);
static void my_print2 (char *);
main ()
{
char my_string[] = “hello world!”;
my_print (my_string);
my_print2 (my_string);
my_print (my_string);
}
void count_sum()
{
int i,sum=0;
for(i=0; i<1000000; i++)
sum += i;
}
void my_print (char *string)
{
count_sum();
printf (“The string is %s ”, string);
}
void my_print2 (char *string)
{
char *string2;
int size, i,sum =0;
count_sum();
size = strlen (string);
string2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++) string2[size -1 - i] = string[i];
string2[size] = ;
for(i=0; i<5000000; i++)
sum += i;
printf (“The string printed backward is %s ”, string2);
}
将产生如下的输出:
1 __underflow [hello.c]
2 main
3 my_print [hello.c]
4 count_sum [hello.c]
5 printf
6 my_print2 [hello.c]
7 count_sum
8 strlen
9 malloc
10 printf
calls 有很多命令行选项来设置不同的输出格式, 有关这些选项的更多信息请参考 calls 的指南页. 方法是在命令行上键入 calls -h .
calltree
calltree与calls类似，初了输出函数调用树图外，还有其它详细的信息。
可以从sunsite.unc.edu FTP 站点用下面的路径:/pub/Linux/devel/lang/c/calltree.tar.gz得到calltree.
cproto
cproto 读入 C 源程序文件并自动为每个函数产生原型申明. 用 cproto 可以在写程序时为你节省大量用来定义函数原型的时间.
如果你让 cproto 处理下面的代码(cproto hello.c):
#include
static void my_print (char *);
static void my_print2 (char *);
main ()
{
char my_string[] = “hello world!”;
my_print (my_string);
my_print2 (my_string);
}
void my_print (char *string)
{
printf (“The string is %s ”, string);
}
void my_print2 (char *string)
{
char *string2;
int size, i;
size = strlen (string);
string2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++)
string2[size -1 - i] = string[i];
string2[size] = ;
printf (“The string printed backward is %s ”, string2);
}
你将得到下面的输出:
/* hello.c */
int main(void);
int my_print(char *string);
int my_print2(char *string);
这个输出可以重定向到一个定义函数原型的包含文件里.
indent
indent 实用程序是 Linux 里包含的另一个编程实用工具. 这个工具简单的说就为你的代码产生美观的缩进的格式. indent 也有很多选项来指定如何格式化你的源代码.这些选项的更多信息请看indent 的指南页, 在命令行上键入 indent -h .
下面的例子是 indent 的缺省输出:
运行 indent 以前的 C 代码:
#include
static void my_print (char *);
static void my_print2 (char *);
main ()
{
char my_string[] = “hello world!”;
my_print (my_string);
my_print2 (my_string);
}
void my_print (char *string)
{
printf (“The string is %s ”, string);
}
void my_print2 (char *string)
{
char *string2; int size, i;
size = strlen (string);
string2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++) string2[size -1 - i] = string[i];
string2[size] = ;
printf (“The string printed backward is %s ”, string2);
}
运行 indent 后的 C 代码:
#include
static void my_print (char *);
static void my_print2 (char *);
main ()
{
char my_string[] = “hello world!”;
my_print (my_string);
my_print2 (my_string);
}
void
my_print (char *string)
{
printf (“The string is %s ”, string);
}
void
my_print2 (char *string)
{
char *string2;
int size, i;
size = strlen (string);
string2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++)
string2[size - 1 - i] = string[i];
string2[size] = ;
printf (“The string printed backward is %s ”, string2);
}
indent 并不改变代码的实质内容, 而只是改变代码的外观. 使它变得更可读, 这永远是一件好事.
gprof
gprof 是安装在你的 Linux 系统的 /usr/bin 目录下的一个程序. 它使你能剖析你的程序从而知道程序的哪一个部分在执行时最费时间.
gprof 将告诉你程序里每个函数被调用的次数和每个函数执行时所占时间的百分比. 你如果想提高你的程序性能的话这些信息非常有用.
为了在你的程序上使用 gprof, 你必须在编译程序时加上 -pg 选项. 这将使程序在每次执行时产生一个叫 gmon.out 的文件. gprof 用这个文件产生剖析信息.
在你运行了你的程序并产生了 gmon.out 文件后你能用下面的命令获得剖析信息:
gprof
参数 program_name 是产生 gmon.out 文件的程序的名字.
为了说明问题，在程序中增加了函数count_sum()以消耗CPU时间，程序如下
#include
static void my_print (char *);
static void my_print2 (char *);
main ()
{
char my_string[] = “hello world!”;
my_print (my_string);
my_print2 (my_string);
my_print (my_string);
}
void count_sum()
{
int i,sum=0;
for(i=0; i<1000000; i++)
sum += i;
}
void my_print (char *string)
{
count_sum();
printf (“The string is %s ”, string);
}
void my_print2 (char *string)
{
char *string2;
int size, i,sum =0;
count_sum();
size = strlen (string);
string2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++) string2[size -1 - i] = string[i];
string2[size] = ;
for(i=0; i<5000000; i++)
sum += i;
printf (“The string printed backward is %s ”, string2);
}
$ gcc -pg -o hello hello.c
$ ./hello
$ gprof hello | more
将产生以下的输出
Flat profile:
Each sample counts as 0.01 seconds.
% cumulative self self total
time seconds seconds calls us/call us/call name
69.23 0.09 0.09 1 90000.00 103333.33 my_print2
30.77 0.13 0.04 3 13333.33 13333.33 count_sum
0.00 0.13 0.00 2 0.00 13333.33 my_print
% 执行此函数所占用的时间占程序总
time 执行时间的百分比
cumulative 累计秒数 执行此函数花费的时间
seconds （包括此函数调用其它函数花费的时间）
self 执行此函数花费的时间
seconds （调用其它函数花费的时间不计算在内）
calls 调用次数
self 每此执行此函数花费的微秒时间
us/call
total 每此执行此函数加上它调用其它函数
us/call 花费的微秒时间
name 函数名
由以上数据可以看出，执行my_print()函数本身没花费什么时间，但是它又调用了count_sum()函数，所以累计秒数为0.13.
技巧: gprof 产生的剖析数据很大, 如果你想检查这些数据的话最好把输出重定向到一个文件里.
篇4：右脑开发工具
右脑开发工具
英语类
不学英语(成人)、不学英语(小学)、迪斯尼启蒙英语、英语冠军、英语自然拼读法、精选英语专题、学之源大胡子爷爷讲故事教英语。
早教类
禾玛右脑、星智右脑、引领右脑、亿优才赋、学之源右脑潜能音乐、妈咪语宝宝英语、学伴熊、宝平安、迪斯尼启蒙英语、国学启蒙宝典、全脑识字通、问学堂点读笔、幼儿英语语感操、智能儿童投影机、爱育幼童右脑全脑总动员。
考试类
七田阳光右脑、右脑王英语学习机、2+4快速记忆、不学英语(成人)、不学英语(小学)、英语冠军 、口语宝、作文三步法、学习考试秘籍、童话数学、学之源学习考试秘笈。
数码类
右脑王英语学习机、问学堂点读笔、成长烦恼互动软件、智能儿童投影机、学伴熊、学之源右脑开发宝典。
潜能开发
右脑王英语学习机、2+4快速记忆、音乐本草、环球名曲导读、成功圣经、问学堂贡献、学之源右脑开发训练营。
开发右脑的胎教音乐
*巴洛克音乐集锦
*彼德和狼
*图画展览会
*动物狂欢节
*小狗圆舞曲
*小提琴协奏曲(门德尔松)
*花之歌(门德尔松)
*皮尔金组曲―清晨(葛里格)
*月光曲(德彪西)
*海(德彪西)
开发右脑的12个小办法
1.听音乐
心理学家发现：音乐可以开发右脑，尤其古典音乐对孩子右脑的开发有很大影响。听钢琴曲时让孩子用左手模仿按琴健的姿势、听小提琴曲时让孩子模仿压琴弦的样子。此外，还可以在孩子从事其它活动时，创造一个音乐背景。
2.培养绘画感觉能力
右脑具有绘画感觉能力。让孩子练习绘画，能培养其观察能力。尽情欣赏绘画作品、自然风景，陶醉其中。带孩子参观花展、盆景展，直观整体地欣赏作品。涂鸦也是一种综合训练，包括视觉感受、动手能力、听觉描述、语言理解等能力，对右脑刺激也是多方面的。
3.干力所能及的家务
家长先有意把房间弄乱，然后同孩子一起清理房间。开始时孩子可能会做不好，分不清垃圾的种类、不知怎样用抹布擦桌子等，家长要耐心地指导，教几遍后孩子就会做好。
4.体育运动
右脑在运动中对形象的感知及细胞的激发比静止状态更快更强。每天跳半小时的迪斯科健身操、打乒乓球、羽毛球等，在打拳或做操时有意识地让左手多重复几个动作，以刺激右脑。
5.童话故事
童话故事是右脑形象思维能力开发的最佳方法。童话富于幻想，听童话故事，孩子会不由自主地随着情节的发展想象故事中的人物、场面和情景，这对右脑的图形思维能力有很好的促进。睡前给孩子讲讲故事，这时右脑呈现最佳状态，开发孩子想像力的效果比白天紧张时要好得多。
6.训练空间识别能力
经常变化孩子的环境，送孩子上幼儿园时不妨有意改变路线;玩玩捉迷藏游戏;只给孩子看小动物身体的某一部分，让他想象整个小动物是什么样子;将一幅画的一部分遮起来，让他猜其他部分是什么样的;放一堆糖果在桌上，训练他用目测法判断糖果的数量;下棋也会对孩子的右脑产生很好的刺激。
7.带孩子逛商场
带孩子一同去商场是开发孩子右脑的另一种有效途径，能够培养孩子综合各种知识及判断的能力。可以教孩子独自挑选自己感兴趣的东西，也可以教孩子如何根据价格来挑选面包或水果等。
8.手指训练
左手剪东西、抓玩具、玩石子，玩豆豆等，可以锻炼孩子手的神经反射，促进大脑的发育;闭上眼扣扣，练习写字绘画，可以增强手指的柔韧性;摆弄智力玩具、拍球投篮、学打算盘、做手指操等活动，可以锻炼手指的灵活性，玩积木、橡皮泥有利于动手能力的培养;经常让孩子交替使用左、右手，可以更好地开发大脑两半球的智力。
9.爬行和梳头
平时多用梳子或以手指代梳给孩子梳理头发，特别是多梳右侧头发，强化对右侧头皮的刺激，加快头皮血液循环。从小训练爬行，对孩子的平衡感及运动细胞都有帮助。
10.益智玩具
益智玩具是开发右脑的最佳工具。主要以拼插、组装、游戏等活动形式为主。电脑游戏机也是锻炼孩子右脑的好工具，要为孩子选择一个以图形为主的游戏，如想象游戏、猜图游戏等。买新玩具后，父母没有必要按说明书告诉孩子应该怎么玩，放手让他们去摸索。
11.学外语(课程)
右脑开发专家研究发现，儿童学会两三种语言跟学会一种语言一样容易，因为当孩子只学会一种语言时，仅需大脑左半球，如果培养同时学习几种语言，就会“启用”大脑右半球。
12.观看体育比赛
观看体育比赛能够锻炼孩子右脑，提高形象思维能力。每一次惊险的镜头，都会给右脑带来一连串的富于魅力的想像，启发孩子根据场上的变化不断推想可能出现的情况。
篇5：Python模块学习datetime介绍
最近更 新
Python2.5/2.6实用教程 入门基础篇
python抓取京东商城手机列表url实例代码
python 实现文件的递归拷贝实现代码
Python time模块详解（常用函数实例讲解,
使用go和python递归删除.ds store文件的方
Python 解析XML文件
python获取糗百图片代码实例
浅析python 内置字符串处理函数的使用方法
Python中使用动态变量名的方法
Python3.x和Python2.x的区别介绍
热 点 排 行
Python入门教程 超详细1小时学会
python 中文乱码问题深入分析
比较详细Python正则表达式操作指
Python字符串的encode与decode研
Python open读写文件实现脚本
Python enumerate遍历数组示例应
Python 深入理解yield
Python+Django在windows下的开发
python 文件和路径操作函数小结
python 字符串split的用法分享
篇6：Python isinstance函数介绍
这篇文章主要介绍了Python isinstance函数介绍,本文用实例讲解了判断变量是否是某个指定类型,需要的朋友可以参考下
isinstance(object, classinfo)
判断实例是否是这个类或者object
object是变量
classinfo 是类型(tuple,dict,int,float)
判断变量是否是这个类型
代码如下:
class objA:
pass
A = objA
B = ‘a‘,‘v‘
C = ‘a string‘
print isinstance(A, objA)
print isinstance(B, tuple)
print isinstance(C, basestring)
输出结果：
代码如下:
True
True
True
不仅如此，还可以利用isinstance函数，来判断一个对象是否是一个已知的类型，
Python isinstance函数介绍
，
isinstance说明如下:
代码如下:
isinstance(object, class-or-type-or-tuple) ->bool
Return whether an object is an instance of a class or of a subclass thereof.
With a type as second argument, return whether that is the object‘s type.
The form. using a tuple, isinstance(x, (A, B, ...)), is a shortcut for
isinstance(x, A) or isinstance(x, B) or ... (etc.).
其第一个参数为对象，第二个为类型名或类型名的一个列表。其返回值为布尔型。若对象的类型与参数二的类型相同则返回True。若参数二为一个元组，则若对象类型与元组中类型名之一相同即返回True。
代码如下:
>>>isinstance(lst, list)
True
>>>isinstance(lst, (int, str, list) )
True
另外:Python可以得到一个对象的类型 ，利用type函数：>>>lst = [1, 2, 3]>>>type(lst)
篇7：HTML学习方法以及开发工具
HTML学习步骤一：看HTML代码
HTML学习步骤二：练HTML代码
我们在记忆了很多HTML代码之后就要学会利用这些代码，我们可以在网上搜索HTML在线编辑工具，也可以下载一款免费的HTML编辑软件，下载完成之后先打开一个小网站，将网站的网页与网站先看一下，最后我们就要开始一步一步的练习了，企业建议可以采取对比练习法，即是一行一行的练习HTML代码，写完了标题的代码，就可以与网站的源代码进行对比，如果有不对的地方就修改，时间长了HTML代码写法水平也会不断的提高。
HTML学习步骤三：记HTML代码
光学会看与练并不行，那样的东西最终还是别人的，学习HTML代码最重要的一个过程就是记，首先我们要记HTML代码最基本的网页组成部分，比如说颜色如何表示、结构排序如何表示、超链接如何表示、关键词与标题等等如何表示，而这些东西我们都必须将之记忆在大脑之中，通过记忆这个过程要让自己的头脑中有丰富的HTML代码可以随时利用。
当然，设计完美网站对于新手设计师来说，不但需要掌握以上三个好方法，还需要掌握专业的网站设计知识和美工知识。蒙特网站设计小编希望大家学活这些方法，快速设计完美画面。
HTML5开发工具
一、Adobe Edge
目前还处于预览阶段的Adobe Edge是用HTML5、CSS、JavaScript开发动态互动内容的设计工具。内容可以同时兼容移动设备和桌面电脑。Edge的一个重要功能是Web工具包界面，方便确保页面在不同浏览器中的架构一致性，此外Edge还将整合TypeKit这样的字体服务。
二、Adobe Dreamweaver CS6
Adobe Dreamweaver CS6作为一个Web设计软件，提供了对HTML网站和移动程序的可视化编辑界面。其Fluid Grid排版系统整合CSS样式表功能，提供自适应版面的跨平台兼容性。开发者可以完全实现Web设计的可视化操作
三、Adobe ColdFusion 10
ColdFusion是用来开发企业Web程序的服务器端技术，通过Websockets、互动表单、视频和地理标签等HTML5技术创建富媒体用户体验。，无需为代码所困。
四、Sencha Architect 2
在开发移动和桌面应用的工具中，Sencha的定位是HTML5可视化应用开发。开发团队可以在一个单一集成的环境中完成应用的设计、开发和部署。开发者还可以开发Sencha Touch2和Ext JS4 JavaScript应用，并实时预览。
五、Sencha Touch 2
Sencha Touch2是移动应用框架，也被看作是Sencha的HTML5平台。开发者可以用它开发面向iOS、Android和Blackberry、Kindle Fire等多种平台的移动应用。
六、Dojo Foundation Maqetta
来自于IBM的一个项目，Dojo Foundation Maqetta是为桌面和移动设备开发HTML5应用的开源工具，支持在浏览器中查看HTML5界面。用户体验设计师可以通过拖放组装UI样板
七、微软Visual Studio ServicePack 1
虽然一开始并不支持HTML5，但微软在三月发布的Visual Studio 2010 SP1中提供了IntelliSense，追加了针对HTML5的一些元素。
八、JetBrains WebStorm 4.0
作为拥有HTML编辑器的JavaScript集成开发环境，WebStorm4.0提供了开发web应用的HTML5样板。开发者可以在创建HTML文档时可获得对HTML5文件的支持。例如砍伐者键入。开发者还可以在chrome浏览器中实时预览HTML文档。
九、Google Web Toolkit
该开发工具用于开发浏览器应用，但库中支持很多HTML5功能。包括对客户端或web存储的支持。其他HTML5功能还包括支持Canvas可视化，以及音频和视频widget。
篇8：怎么选择智力开发工具
首先来看看你的宝宝属于哪一种吧!在生活中，最常见的有两种宝宝，第一种是视觉型宝宝，观察力敏锐，对图形很敏感，喜欢画画和拼图，比较安静不爱说话，动手能力强。第二种是听觉型宝宝，语言表达能力强，喜欢听故事或讲故事，喜欢音乐、戏剧及有表现力的活动，听觉灵敏，容 易分散注意力。
区分清楚了宝宝的学习类型后，父母在挑选产品的时候就可以做到心中有数了，对于视觉型宝宝，要选择一些色彩鲜艳，插图比较多的幼儿书籍，这样可以使宝宝从色彩中获取信息，丰富宝宝的生活视野。对于听觉型宝宝，可以通过讲故事、学儿歌等方式来刺激宝宝听觉，让宝宝更敏捷掌握知识。但随着社会的发展，一个优秀的人才不仅要有一技之长，更重要的还是要全面发展，所以在开发宝宝的智力时，并不是说宝宝光用视觉、听觉单一途径进行学习，而是要充分发挥他们的长处。在发挥他们长处的同时，我们还要取长补短，让孩子永不落后，全面发展。其实市场上有很多这样的产品，比如各种有声图书、点读笔都是家长
不二的选择。而在这些产品中，天线宝宝点读笔和学之源智慧宝系列产品是其中佼佼者，它正是从宝宝的视觉和听觉特点出发，完美把两者结合起来，不管是视觉型宝宝还是听觉型的宝宝，都可以在发挥宝宝的优势时，还能开发宝宝的潜在素质，取长补短，让宝宝智力全面发展!
目前有个培养孩子动手动脑的开发智力的网站 贪猫网，里面有很多孩子喜欢的课程，一套器材，一节视频，在线培养孩子动手动脑，对孩子的发展提高很有帮助。
篇9：介绍Python中的future模块
作者：廖雪峰 字体：[增加 减小] 类型：
这篇文章主要介绍了介绍Python中的__future__模块,__future__模块使得在Python2.x的版本下能够兼容更多的Python3.x的特性,需要的朋友可以参考下
Python的每个新版本都会增加一些新的功能，或者对原来的功能作一些改动，有些改动是不兼容旧版本的，也就是在当前版本运行正常的代码，到下一个版本运行就可能不正常了。
从Python 2.7到Python 3.x就有不兼容的一些改动，比如2.x里的字符串用‘xxx‘表示str，Unicode字符串用u‘xxx‘表示unicode，而在3.x中，所有字符串都被视为unicode，因此，写u‘xxx‘和‘xxx‘是完全一致的，而在2.x中以‘xxx‘表示的str就必须写成b‘xxx‘，以此表示“二进制字符串”。
要直接把代码升级到3.x是比较冒进的，因为有大量的改动需要测试。相反，可以在2.7版本中先在一部分代码中测试一些3.x的特性，如果没有问题，再移植到3.x不迟。
Python提供了__future__模块，把下一个新版本的特性导入到当前版本，于是我们就可以在当前版本中测试一些新版本的特性。举例说明如下：
为了适应Python 3.x的新的字符串的表示方法，在2.7版本的代码中，可以通过unicode_literals来使用Python 3.x的新的语法：
# still running on Python 2.7from __future__ import unicode_literalsprint ‘\\‘xxx\\‘ is unicode?‘, isinstance(‘xxx‘, unicode)print ‘u\\‘xxx\\‘ is unicode?‘, isinstance(u‘xxx‘, unicode)print ‘\\‘xxx\\‘ is str?‘, isinstance(‘xxx‘, str)print ‘b\\‘xxx\\‘ is str?‘, isinstance(b‘xxx‘, str)
注意到上面的代码仍然在Python 2.7下运行，但结果显示去掉前缀u的‘a string‘仍是一个unicode，而加上前缀b的b‘a string‘才变成了str：
$ python task.py‘xxx‘ is unicode? Trueu‘xxx‘ is unicode? True‘xxx‘ is str? Falseb‘xxx‘ is str? True
类似的情况还有除法运算，
在Python 2.x中，对于除法有两种情况，如果是整数相除，结果仍是整数，余数会被扔掉，这种除法叫“地板除”：
>>>10 / 33
要做精确除法，必须把其中一个数变成浮点数：
>>>10.0 / 33.3333333333333335
而在Python 3.x中，所有的除法都是精确除法，地板除用//表示：
$ python3Python 3.3.2 (default, Jan 22 , 09:54:40) [GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.2.79)] on darwinType “help”, “copyright”, “credits” or “license” for more information.>>>10 / 33.3333333333333335>>>10 // 33
如果你想在Python 2.7的代码中直接使用Python 3.x的除法，可以通过__future__模块的division实现：
from __future__ import divisionprint ‘10 / 3 =‘, 10 / 3print ‘10.0 / 3 =‘, 10.0 / 3print ‘10 // 3 =‘, 10 // 3
结果如下：
10 / 3 = 3.3333333333310.0 / 3 = 3.3333333333310 // 3 = 3
小结
由于Python是由社区推动的开源并且免费的开发语言，不受商业公司控制，因此，Python的改进往往比较激进，不兼容的情况时有发生。Python为了确保你能顺利过渡到新版本，特别提供了__future__模块，让你在旧的版本中试验新版本的一些特性。
篇10：Python构造函数及解构函数介绍
这篇文章主要介绍了Python构造函数及解构函数介绍,本文只是讲解构造及解构函数的简单知识,需要的朋友可以参考下
python 有一个相应的特殊解构器（destructor）方法名为__del__，然而，由于python具有垃圾对象回收机制（靠引用计数），这个函数要直到该实例对象所有的引用都被清除掉后才会被执行。python中的解构器是在实例释放前提供特殊处理功能方法，它们通常没有被实现，因为实例很少被显式释放。
在下面的例子中，我们分别创建（并覆盖） __init__()和__del__()构造器及解构函数，然后，初始化类并给同样的对象很多别名。id()内建函数可用来确定引用同一对象的三个别名。最后一步是使用del语句清除所有的别名，显示何时调用了多少次解构器。
代码如下:
#!/usr/bin/env python
#coding=utf-8
class P():
def __del__(self):
pass
class C(P):
def __init__(self):
print ‘initialized‘
def __del__(self):
P.__del__(self)
print ‘deleted‘
c1 = C()
c2 = c1
c3 = c1
print id(c1), id(c2), id(c3)
del c1
del c2
del c3
python没有提供任何内部机制来跟跟踪一个类有多少个实例被创建了，或者记录这些实例是什么东西，
如果需要这些功能，可以显式加入一些代码到类定义或者__init__()和__del__()中去。最好的方式是使用一个静态成员来记录实例的个数。靠保存它们的引用来跟踪实例对象是很危险的，因为你必须合理管理这些引用，不然你的引用可能没办法释放（因为还有其他的引用）！看下面的例子：
代码如下:
class InstCt(object):
count = 0
def __init__(self):
InstCt.count += 1
def __del__(self):
InstCt.count -= 1
def howMany(self):
return InstCt.count
a = InstCt()
b = InstCt()
print b.howMany()
print a.howMany()
del b
print a.howMany()
del a
print InstCt.count
所有输出：
代码如下:
initialized
4372150104 4372150104 4372150104
deleted
********************
2
2
1
0
篇11：Python基本数据类型详细介绍
最近更 新
python代码检查工具pylint 让你的python更
python操作数据库之sqlite3打开数据库、删
python网络编程学习笔记(六)：Web客户端访
python中使用sys模板和logging模块获取行
python利用elaphe制作二维条形码实现代码
Python 学习笔记
9种python web 程序的部署方式小结
Python实现类继承实例
Python中条件选择和循环语句使用方法介绍
Python实现的几个常用排序算法实例
热 点 排 行
Python入门教程 超详细1小时学会
python 中文乱码问题深入分析
比较详细Python正则表达式操作指
Python字符串的encode与decode研
Python open读写文件实现脚本
Python enumerate遍历数组示例应
Python 深入理解yield
Python+Django在windows下的开发
python 文件和路径操作函数小结
python 字符串split的用法分享
篇12：Python迭代器和生成器介绍
这篇文章主要介绍了Python迭代器和生成器介绍,本文分别用代码实例讲解了Python的迭代器和生成器,需要的朋友可以参考下
迭代器
迭代器是一个实现了迭代器协议的对象，Python中的迭代器协议就是有next方法的对象会前进到下一结果，而在一系列结果的末尾是，则会引发StopIteration，
在for循环中，Python将自动调用工厂函数iter获得迭代器，自动调用next()获取元素，还完成了检查StopIteration异常的工作。
常用的几个内建数据结构tuple、list、set、dict都支持迭代器，字符串也可以使用迭代操作。
你也可以自己实现一个迭代器，如上所述，只需要在类的__iter__方法中返回一个对象，这个对象拥有一个next()方法，这个方法能在恰当的时候抛出StopIteration异常即可。但是需要自己实现迭代器的时候不多，即使需要，使用生成器会更轻松。
代码如下:
#!/usr/bin/env python
# coding=utf-8
class test:
def __init__(self, input_list):
self.list = input_list
self.i = 0
def __iter__(self):
return self
def next(self):
if self.i == len(self.list):
self.i = 0
raise StopIteration
self.i += 1
return self.list[self.i - 1]
使用迭代器一个显而易见的好处就是：每次只从对象中读取一条数据，不会造成内存的过大开销。
例如：
代码如下:
/* 把文件一次加载到内存中，然后逐行打印。当文件很大时，这个方法的内存开销就很大了 */
for line in open(“test.txt”).readlines():
print line
/* 这是最简单也是运行速度最快的写法，他并没显式的读取文件，而是利用迭代器每次读取下一行 */
for line in open(“test.txt”): #use file iterators
print line
生成器
生成器的编写方法和函数定义类似，只是在return的地方改为yield，
生成器中可以有多个yield。当生成器遇到一个yield时，会暂停运行生成器，返回yield后面的值。当再次调用生成器的时候，会从刚才暂停的地方继续运行，直到下一个yield。
生成器自身又构成一个迭代器，每次迭代时使用一个yield返回的值。
需要注意的是，生成器中不需要return语句，不需要指定返回值，在生成器中已经存在默认的返回语句
生成器表达式
代码如下:
(i for i in range(5))
// 返回迭代器
列表解析，返回list
代码如下:
[i for i in range(5)]
// 返回list
[0, 1, 2, 3, 4]
在这里存在一个问题，那就是range(5)会返回一个长度为5的数据，如果是range(1000)那么就会占用一个1000大小的数组空间；如果我们采用`生成器`，在需要的时候产生一个数字，那么空间的占用情况就会降低，这里我们可以使用xrange()函数来实现。
代码如下:
‘‘‘
xrange
函数说明：用法与range完全相同，所不同的是生成的不是一个数组，而是一个生成器。
xrange示例:
‘‘‘
>>>xrange(5)
xrange(5)
>>>list(xrange(5))
[0, 1, 2, 3, 4]
>>>xrange(1,5)
xrange(1, 5)
>>>list(xrange(1,5))
[1, 2, 3, 4]
>>>xrange(0,6,2)
xrange(0, 6, 2)
>>>list(xrange(0,6,2))
[0, 2, 4]
所以xrange做循环的性能比range好，尤其是返回很大的时候，尽量用xrange吧，除非你是要返回一个列表。
篇13：Python常用模块
Python模块
模块是Python最高级别的程序组织单元，他将程序代码和数据封装起来以便重用，
实际来看模块往往对应Python程序文件。本质就是用一些代码实现某些功能的集合
这个集合可以是一个.py文件，也可以是一个包（一个文件夹中，有一个.py入口文件）
一、导入模块
import module
from module.xx import xx
from module.xx import xx as rename
from module.xx import *
导入一个py文件，解释器解释该文件
导入一个包
导入模块根据路径 sys.path如果有该路径，就可直接导入
如果sys.path么有想要的路径，通过sys.path.append('路径')
二、开源模块
下载安装
1、yum、pip、apt-get
2、源码编译安装：Python setup.py build Python setup install
三、常用模块
1、os模块#用作系统级别的工作
os.popen('id').read() # 执行系统命令得到返回结果
os.system() # 得到返回状态 返回无法截取
os.name # 返回系统平台 Linux/Unix用户是'posix'
os.getenv() # 读取环境变量
os.putenv() # 设置环境变量
os.getcwd() # 当前工作路径
os.chdir() # 改变当前工作目录
os.walk('/root/') # 递归路径
文件处理
mkfifo()/mknod() # 创建命名管道/创建文件系统节点
remove()/unlink() # 删除文件
rename()/renames() # 重命名文件
*stat() # 返回文件信息
symlink() # 创建符号链接
utime() # 更新时间戳
tmpfile() # 创建并打开('w+b')一个新的临时文件
walk() # 遍历目录树下的所有文件名
目录/文件夹
chdir()/fchdir() # 改变当前工作目录/通过一个文件描述符改变当前工作目录
chroot() # 改变当前进程的根目录
listdir() # 列出指定目录的文件
getcwd()/getcwdu() # 返回当前工作目录/功能相同,但返回一个unicode对象
mkdir()/makedirs() # 创建目录/创建多层目录
rmdir()/removedirs() # 删除目录/删除多层目录
访问/权限
saccess() # 检验权限模式
chmod() # 改变权限模式
chown()/lchown() # 改变owner和groupID功能相同,但不会跟踪链接
umask() # 设置默认权限模式
文件描述符操作
open() # 底层的操作系统open(对于稳健,使用标准的内建open()函数)
read()/write() # 根据文件描述符读取/写入数据 按大小读取文件部分内容
dup()/dup2() # 复制文件描述符号/功能相同,但是复制到另一个文件描述符
设备号
makedev() # 从major和minor设备号创建一个原始设备号
major()/minor() # 从原始设备号获得major/minor设备号
os.path模块
os.path.expanduser('~/.ssh/key') # 家目录下文件的全路径
分隔
os.path.basename() # 去掉目录路径,返回文件名
os.path.dirname() # 去掉文件名,返回目录路径
os.path.join() # 将分离的各部分组合成一个路径名
os.path.spllt() # 返回(dirname(),basename())元组
os.path.splitdrive() # 返回(drivename,pathname)元组
os.path.splitext() # 返回(filename,extension)元组
信息
os.path.getatime() # 返回最近访问时间
os.path.getctime() # 返回文件创建时间
os.path.getmtime() # 返回最近文件修改时间
os.path.getsize() # 返回文件大小(字节)
查询
os.path.exists() # 指定路径(文件或目录)是否存在
os.path.isabs() # 指定路径是否为绝对路径
os.path.isdir() # 指定路径是否存在且为一个目录
os.path.isfile() # 指定路径是否存在且为一个文件
os.path.islink() # 指定路径是否存在且为一个符号链接
os.path.ismount() # 指定路径是否存在且为一个挂载点
os.path.samefile() # 两个路径名是否指向同一个文件
2、sys模块#提供解释器相关操作
sys.argv # 命令行参数List，第一个元素是程序本身路径
sys.exit(2) # 退出脚本返回状态 会被try截取
sys.exc_info() # 获取当前正在处理的异常类
sys.version # 获取Python解释程序的版本信息
sys.maxint # 最大的Int值 9223372036854775807
sys.maxunicode # 最大的Unicode值
sys.modules # 返回系统导入的模块字段，key是模块名，value是模块
sys.path # 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform # 返回操作系统平台名称
sys.stdout # 标准输出
sys.stdin # 标准输入
sys.stderr # 错误输出
sys.exec_prefix # 返回平立的python文件安装的位置
sys.stdin.readline() # 从标准输入读一行
sys.stdout.write(“a”) # 屏幕输出a
3、hashlib模块# 用于加密相关的操作
常规加密
import hashlib
hash_md5 = hashlib.md5()
hash_md5.update('admin')
print(hash_md5.hexdigest())
hash = hashlib.sha512()
hash.update('admin')
print hash.hexdigest()
#以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。
添加自定义key做加密
import hashlib
hash = hashlib.md5('898oaFs09f')
hash.update('admin')
print hash.hexdigest()
超 加密-对我们创建的key和内容继续加密
import hmac
h = hmac.new('wueiqi')
h.update('hellowo')
print h.hexdigest()
4、json和pickle模块 #用于序列化数据
json，#json解决简单数据类型的序列换
pickle，#能存储python的复杂数据类型
Json模块提供了四个功能：dumps、dump、loads、load
pickle模块提供了四个功能：dumps、dump、loads、load
name_tra=json.dumps('[1,2,3,4,5]') #dunmps将序列化的数据放到内存
with open('json_tra','wb') as f_json:
f_json.write(name_tra)
with open('json_tra1','wb') as f_json:#dump直接将内存中序列化的数据写入文件
json.dump(a,f_json)
time_now=datetime.datetime.now()
pickle_mem=p.dumps(time_now)
pickle_load=p.loads(pickle_mem)
5、subprocess模块
subprocess包来fork一个子进程，并运行一个外部的程序，
subprocess包中定义有数个创建子进程的函数。subprocess还提供了一些管理标准流(standard stream)和管道(pipe)的工具，从而在进程间使用文本通信。
subprocess.call()
父进程等待子进程完成
返回退出信息(returncode，相当于Linux exit code)
b=subprocess.call(['ls','-l'])
b=subprocess.call(“ls -l”,shell=True)
shell=True,允许shell命令是字符串形式。
subprocess.check_call()
父进程等待子进程完成
返回0
检查退出信息，如果returncode不为0，则举出错误subprocess.CalledProcessError，该对象包含有returncode属性，可用try…except…来检查
subprocess.check_call([“ls”, “-l”])
subprocess.check_call(“exit 1”, shell=True)
subprocess.check_output()
父进程等待子进程完成
返回子进程向标准输出的输出结果
检查退出信息，如果returncode不为0，则举出错误subprocess.CalledProcessError，该对象包含有returncode属性和output属性，output属性为标准输出的输出结果，可用try…except…来检查
6、shuit模块 #文件的复制移动
shutil.copyfile('data.db', 'archive.db') # 拷贝文件
shutil.move('/build/executables', 'installdir') # 移动文件或目录
7、logging模块#格式化记录日志
#通过logging.basicConfig函数对日志的输出格式及方式做相关配置,日志将被写入文件
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s [line:%(lineno)d] %(levelname)s %(message)s',
datefmt='%Y/%m/%d %H:%M:%S',
filename='myapp.log',
filemode='a')
logging.debug('This is debug message')
logging.info('This is info message')
logging.warning('This is warning message')
#logging.basicConfig函数各参数:
#datefmt: 指定时间格式，同time.strftime()
#filename: 指定日志文件名
#filemode: 和file函数意义相同，指定日志文件的打开模式，'w'或'a'
#level: 设置日志级别，默认为logging.WARNING
#format: 指定输出的格式和内容，format可以输出很多有用信息，如上例所示:
# %(asctime)s: 打印日志的时间
# %(levelname)s: 打印日志级别名称
# %(message)s: 打印日志信息
# %(levelno)s: 打印日志级别的数值
# %(lineno)d: 打印日志的当前行号
# %(pathname)s: 打印当前执行程序的路径，其实就是sys.argv[0]
# %(filename)s: 打印当前执行程序名
# %(funcName)s: 打印日志的当前函数
# %(thread)d: 打印线程ID
# %(threadName)s: 打印线程名称
# %(process)d: 打印进程ID
#将日志同时写入文件，并打印到屏幕
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
datefmt='%Y/%m%d %H:%M:%S',
filename='myapp.log',
filemode='w')
#打印到屏幕
console = logging.StreamHandler()
console.setLevel(logging.WARNING)
formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
console.setFormatter(formatter)
logging.getLogger().addHandler(console)
8、random模块 用于取随机数
random.choice(['apple', 'pear', 'banana']) # 随机取列表一个参数
random.sample(xrange(100), 10) # 不重复抽取10个
random.randrange(3,7) #随机抽取整数范围不包括7
random.random() # 随机浮点数
9、time datetime模块时间模块
时间戳 #1970年1月1日之后的秒，即：time.time()
格式化的字符串 # -11-11 11:11， 即：time.strftime('%Y-%m-%d')
结构化时间 # 元组包含了：年、日、星期等... time.struct_time 即：time.localtime()
import time
time.time() # 时间戳[浮点]
time.localtime()[1] - 1 # 上个月
int(time.time()) # 时间戳[整s]
time.strftime('%Y-%m-%d %X') #格式化输出时间
import datetime
datetime.datetime.datetime.now() #现在的时间
datetime.datetime.now() - datetime.timedelta(days=5,hours=3,seconds=3,minutes=2) #减时间
10、re模块 正则匹配
#Pattern对象是一个编译好的正则表达式，通过Pattern提供的一系列方法可以对文本进行匹配查找。
pattern=re.compile(strPattern[, flag]):
flag是匹配模式，re.I|re.M表示同时生效。
re.I(re.IGNORECASE): 忽略大小写
M(MULTILINE): 多行模式，改变'^'和'$'的行为
match(string[, pos[, endpos]]) | re.match(pattern, string[, flags]): #结果匹配一次
#match(string[, pos[, endpos]])从string的pos下标处起尝试匹配pattern；如果pattern结束时仍可匹配，则返回一个Match对象；
pos和endpos的默认值分别为0和len(string)；re.match()flags用于编译pattern时指定匹配模式。
#re.match(pattern, string[, flags])不能指定pos和endpos值。所以匹配的是在开头进行匹配。
search(string[, pos[, endpos]]) | re.search(pattern, string[, flags]): #结果匹配一次
#search(string[, pos[, endpos]])从string的pos下标处起尝试匹配pattern，如果pattern结束时仍可匹配，则返回一个Match对象；
若无法匹配，则将pos加1后重新尝试匹配；直到pos=endpos时仍无法匹配则返回None。
#re.search(pattern, string[, flags]) ，用于匹配任意开始位
a='321.423.432.432 33.43.5.42 1.2.443.34 255.52.53.255 2.2.2.2 3.3.3.3'
pattern=re.compile(r'([12]?\\d{1,2}\\.){3}([12]?\\d{1,2})')
print pattern.search(a).group()
split(string[, maxsplit]) | re.split(pattern, string[, maxsplit]):
按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数，不指定将全部分割。
#a='qwe123dsa43** ***2*342rew'
#print re.split('[\\d* ]+',a)
findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags]):
搜索string，以列表形式返回全部能匹配的子串。
p = re.compile(r'\\d+')
print p.findall('one1two2three3four4')
sub(repl, string[, count]) | re.sub(pattern, repl, string[, count]):
使用repl替换string中每一个匹配的子串后返回替换后的字符串。
count用于指定最多替换次数，不指定时全部替换。
a='321.423.432.432 33.43.5.42 1.2.443.34 255.52.53.255 2.2.2.2 3.3.3.3'
pattern=re.compile(r'([12]?\\d{1,2}\\.){3}([12]?\\d{1,2})')
print pattern.sub('bibi',a)
finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags]):
搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。
a='321.423.432.432 33.43.5.42 1.2.443.34 255.52.53.255 2.2.2.2 3.3.3.3'
pattern=re.compile(r'([12]?\\d{1,2}\\.){3}([12]?\\d{1,2})')
for i in pattern.finditer(a):
print(i.group())
篇14：Python Tkinter GUI编程入门介绍
这篇文章主要介绍了Python Tkinter GUI编程入门介绍,本文讲解了Tkinter介绍、Tkinter的使用、Tkinter的几何管理器等内容,并给出了一个完整示例,需要的朋友可以参考下
一、Tkinter介绍
Tkinter是一个python模块，是一个调用Tcl/Tk的接口，它是一个跨平台的脚本图形界面接口，Tkinter不是唯一的python图形编程接口，但是是其中比较流行的一个。最大的特点是跨平台，缺点是性能不太好，执行速度慢。
一般使用Tkinter的方法是：
From Tkinter import *
或者： import Tkinter 两者的区别我们前面讲模块的时候已经说过了。
二、Tkinter的使用
先看一下GUI程序的开发，熟悉MFC的朋友应该不会陌生。在GUI程序中，我们会有一个顶层窗口，在这个顶层窗口上可以包括所有的小窗口对象，像标签，按钮，列表框等等，也就是说顶层窗口时我们放置其他窗口或者控件的地方。我们用下面的语句可以创建一个顶层窗口，或者叫根窗口：
代码如下:
Import Tkinter
top = Tkinter.Tk()
（如果前面是用的from Tkinter import * ，那么Tk()就够了）
然后我们就可以在这个根窗口上设置“组件”了。通常这些组件会有一些相应的行为，比如鼠标点击，按下等等，这些称为事件，而程序会根据这些时间采取相应的反应，称为回调。这个过程成为事件驱动。
所有的创建和放置完毕后，就立刻进入主循环，代码如下：
代码如下:
Tkinter.mainloop( )
Tk的组件有很多，不可能一一介绍，通过一个小例子看看其中一个标签的使用吧。
代码如下:
>>>import Tkinter
>>>top = Tkinter.Tk()
>>>label = Tkinter.Label(top,text=‘Hello World‘)
>>>label.pack()
>>>Tkinter.mainloop()
运行结果就是
下面解释一下：
第一行，是导入模块。
第二行，创建主窗口。
第三行，创建label标签，它是有Tkinter的一个方法Label来实现的，关于Label的帮助可以help一下。
第四行，pack（）是用来管理和显示组件的，它的参数我们以后再说。
第五行，mainloop（）进入主循环。剩下的事就系统的了。
下面看看组件的配置。Tk中的每一个组件都有很多option，通过改变这些option可以改变组件的外观，比如显示的内容，颜色，大小，位置，事件处理函数等。
比如： w=label(root,text=‘hello‘,fg=‘red‘)
创建一个w，第一个参数时他的master widget，是root，所有参数都有默认的，
我们可以用默认的来创建，w.cget(option)得到一个option的值。同样可以用w.config(option=‘‘)来设置某个参数的值。
三、Tkinter的几何管理器
熟悉GUI编程的人知道，放好每个组件的是很繁琐的，不仅要调整自身大小，还要
整和其他组件的相对位置。Tk提供了三个管理器来帮助我们：Pack Grid Place
1、pack
Pack使用很简单，就是w.pack(option)。常用的option有：
Side 表示把组件放到哪一边，TOP（上），BOTTOM（下），LEFT，RIGHT
Padx和pady 表示parcel的每一个边和组件的预留空间。
Ipadx和ipady，表示组件的每一个边和他包含的内容之间的预留空间。
Anchor表示在parcel放置组件的方式，缺省时CENTER。
2、grid
使用方法和pack类似。
3、place
精确的摆放一个组件的位置，一般不太用。
关于这个三个的详细使用和算法可以参考相关资料。
下面看最后一个例子：
先看一下结果。
通过拖动进度条而改变文字大小
看一下代码：
代码如下:
from Tkinter import * #引入模块
#resize函数是用来改变文字大小的，当进度条改变时调用
def resize(ev=None):
label.config(font=‘Helvetica -%d bold‘ % scale.get())
#config函数就是通过设置组件的参数来改变组件的，这里改变的是font字体大小
top=Tk() #主窗口
top.geometry(‘600x400‘) #设置了主窗口的初始大小600x400
label=Label(top,text=‘Hello world!‘,font=‘Helvetica -12 bold‘) #设置标签字体的初始大小
label.pack(fill=Y,expand=1)
#scale创建进度条，设置
scale=Scale(top,from_=10,to=40,orient=HORIZONTAL,command=resize)
scale.set(12) #设置起始位置
scale.pack(fill=X,expand=1)
quit = Button(top,text=‘QUIT‘,command=top.quit,activeforeground=‘white‘,
activebackground=‘red‘)
quit.pack()
mainloop()
- 如何快速学会Python2023-06-18
- python 时间模块小结2022-12-11
- Python编码问题详解2022-12-11
- python简单实现基数排序算法2024-06-25
- Python读写unicode文件的方法2023-01-25
- Python SQLite3数据库操作类2023-06-04
- python使用xmlrpc实例讲解2024-05-23
- python学习数据结构实例代码2023-01-07
- Python编写屏幕截图程序方法2022-12-11
- python 中的列表解析和生成表达式2023-08-05