kernel/kernel_Notes
1
0
Fork 0
mirror of https://github.com/beyondx/Notes.git synced 2026-02-03 10:23:27 +08:00
Code Issues Packages Projects Releases Wiki Activity

updated

Browse Source
This commit is contained in:
geekard
2012-12-30 14:55:16 +08:00
parent 411a288513
commit f8638a5844
58 changed files with 9509 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
Zim/Programme/elf/Introduction_to_PIC.txt Normal file
View File

@@ -0,0 +1,38 @@
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2012-12-23T16:02:09+08:00
====== Introduction to PIC ======
Created Sunday 23 December 2012
http://www.gentoo.org/proj/en/hardened/pic-guide.xml
PIC code radically differs from conventional code in the way it calls functions and operates on data variables.
It will access these functions and data __through an indirection table__, the "Global Offset Table" (GOT), by software convention accessible using the reserved name "**_GLOBAL_OFFSET_TABLE_**".
The exact mechanism used for this is hardware architecture dependent, but usually __a special machine register__ is reserved for setting up the location of the GOT when entering a function.
The rationale behind this indirect addressing is to generate code that can be __independently accessed__ of the actual load address. 例如共享库的目标代码在内存中只加载一次，但是可以映射到多个进程中。
In a true PIC library **without** relocations in the __text segment__, only the symbols exported in the __"Global Offset Table"__ need updating at run-time depending on the current load address of the various shared libraries in the address space of the running process. 使用PIC技术的共享库，在动态链接(映射)到某个进程的地址空间中时，其text section不需要重定位(更改)，只需要对
GOT表中的符号进行重定位即可。而GOT位于.data section中。
Likewise, procedure calls to globally defined functions are redirected through the __"Procedure Linkage Table" (PLT)__ residing in the data segment of the core image. Again, this is done to avoid run-time modifications to the text segment.
其实PLT位于.text section之中，是只读和可执行的，它会使用GOT中的函数符号条目。
The __linker-editor__ allocates the Global Offset Table and Procedure Linkage Table when combining PIC object files into an image suitable for mapping into the process address space. It also collects all symbols that may be needed by the run-time link-editor and stores these along with the image's text and data bits. Another reserved symbol, **_DYNAMIC** is used to indicate the presence of the run-time linker structures. Whenever _DYNAMIC is relocated to 0, there is no need to invoke the run-time link- editor. If this symbol is non-zero, it points at a data structure from which the location of the necessary relocation- and symbol information can be derived. This is most notably used by the start-up module, **crt0, crt1S** and more recently **Scrt1**. The _DYNAMIC structure is conventionally located at the start of the data segment of the image to which it pertains.
On most architectures, when you compile source code to object code, you __need to specify__ whether the object code should be position independent or not. There are occasional architectures which don't make the distinction, usually because all object code is position independent by virtue of the __Application Binary Interface (ABI),__ or less often because the load address of the object is fixed at compile time, which implies that shared libraries are not supported by such a platform. If an object is compiled as position independent code (PIC), then the operating system can load the object __at any address__ in preparation for execution. This involves a time overhead, in replacing direct address references with relative addresses at compile time, and a space overhead, in maintaining information to help the runtime loader fill in the unresolved addresses at runtime.
Consequently, PIC objects are usually slightly larger and slower at runtime than the equivalent non-PIC object. The advantage of sharing library code on disk and in memory outweigh these problems as soon as the PIC object code in shared libraries is reused.
PIC compilation is exactly what is required for objects which will become __part of__ a shared library. Consequently, __libtool__ builds PIC objects for use in shared libraries and non-PIC objects for use in static libraries. Whenever libtool instructs the compiler to generate a PIC object, it also defines the preprocessor symbol, `PIC', so that assembly code can be aware of whether it will reside in a PIC object or not.
Typically, as libtool is compiling sources, it will generate a `.lo' object, as PIC, and a `.o' object, as non-PIC, and then it will use the appropriate one of the pair when linking executables and libraries of various sorts. On architectures where there is no distinction, the `.lo' file is just a soft link to the `.o' file.
In practice, you can link PIC objects into a static archive for a small overhead in execution and load speed, and often you can similarly link non-PIC objects into shared archives.
When you use position-independent code, relocatable references are generated as an indirection that use data in the shared object's data segment. The text segment code remains read-only, and all relocation updates are applied to corresponding entries within the data segment.
If a shared object is built from code that is not position-independent, the text segment will usually require a large number of relocations to be performed at runtime. Although the runtime linker is equipped to handle this, the system overhead this creates can cause serious performance degradation.
You can identify a shared object that requires relocations against its text segment using tools such as 'readelf -d foo' and inspect the output for any TEXTREL entry. The value of the TEXTREL entry is irrelevant. Its presence in a shared object indicates that text relocations exist.

213
Zim/Programme/elf/elf_重定位.txt Normal file
View File

@@ -0,0 +1,213 @@
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2012-12-21T20:33:28+08:00
====== elf 重定位 ======
Created Friday 21 December 2012
Relocation is the process of __associate the symbolic reference with symbolic definition.__ For example, when a program calls a function, the associate all instruction must transfor control to the **proper destination address.** In other words, relocatable files must have information for modifying their section content.
Relocation table entry structer:
{{./0.gif}}
* **r_offset:** Holds the location at which the relocation apply. For a relocable file, the value is the byte offset from the beginning of the section to the storage unit affected by relocation. For an executable file or a share object file, the value is the virtual address of units affected by relocation.
* **r_info:** Holds both the __symbol table index__ with respect to which the relocation must be made, and __the type of relocation__. For example, a call instrution's relocation enry would hold the symbol index of the function. Relocation types are processor-sepcific. The following code shows how to manipulate the values.
#define ELF32_R_SYM(info) ((info)>>8)
#define ELF32_R_TYPE(info) ((info)&ff)
#define ELF32_R_INFO(s,t) (((s)<<8) + ((t)&0xff))
symbol: bits 32–8
type: bits 7–0
**r_addend:** Holds a constand addend used to compute the value to be stored into the relocable field.
===== Relocation Types:(SYSTEM V Architecture) =====
The __link editor__ merge one or more relocable object files to form the output. It first disides how to combine and locate the input files then update the symbol values, and finally preform the relocation. Relocations applied to excutable or shared object files are similar.
link editor(ld)首先合并可重定位目标文件，然后解析其中的符号引用，并将符号的最终实际地址写入到符号表中，最后重定位。
The relocation types specific which bits to change and how to caculate their values（下表真对的是x86而非x86_64）.
{{./1.gif}}
**R_386_32:** Symbol’s value + addend. In the following Fig, thre is a relocation at the **0×7 bytes** offset into **.text** section. The linker alter the address of ‘b’ with S+A, S is symbold b’s new address after reset. A is the endian, here it is zero.
**R_386_32是绝对寻址的重定位。将符号解析后的绝对实际地址填充到关联section的offset处。**
{{./2.gif}}
**R_386_PC32:** Symbol’s **value+Addend-Place**. Because it is __Relative Near CALL__, the operand is the offset from the “next instruction” (EIP) to the called procedure, more infor is here. **VALUE+EIP = Symbol.value, EIP = Place+4. So VALUE = Symbold.value – 4 – Place**. S is ‘Symbol.vale’, ‘-4′ is the Addend. P is the new virtuall address of relocation entry computed by r_offset and other factors.
R_386_PC32是相对寻址的重定位。S是符号表中符号解析后的实际地址，Place是调用该符号的指令地址，所以相对偏移量为 **VALUE = Symbold.value – 4 – Place**
**R_386_GLOB_DAT:** This type is used to __set a global offset table entry__ to the address of the specific symbol. It is used for global or external variable in PIC code . 将解析后的全局或外部符号的实际地址写入到对应的__GOT条目中__。
**R_386_JMP_SLOT:** The linker editor creates this relocation type for dynamic linking. Its offset specify __the GOT entry that contain a PLT entry__. The dynamic linker use it to implement lazy linking.将解析后的外部函数实际入口地址写入到对应的GOT中的PLT条目类型中。
R_386_GLOB_DAT and R_386_JMP_SLOT are only appear in executable file or shared library.
__上面两种类型的重定位是由动态链接器解析符号后完成的，与代码里是否引用该符号无关(因为代码是间接地利用GOT，PLT来引用外部变量和符号的)。而且是对GOT中的符号value进行填充，与代码段无关。__
**R_386_GOTOFF:**引用本文件内使用的static和rodata类型变量时使用的重定位类型。外部static变量和函数内static变量定义在.data section中，对它们的引用不通过GOT条目，而是其符号位置与GOT首地址的偏移量来实现的(同理，字符串字面量由于不能修改，一般保存在.rodata section中，对它们的引用也不是通过GOT条目)，即重定位值= S+A-GOT。示例如下：
//ebx事先保存的是GOT的首地址
movl __globalVarStatic@GOTOFF__(%ebx), %eax __//globalVarStatic@GOTOFF的值为S+A-GOT，再加上GOT的正好为符号globalVarStatic的地址。__
movl (%eax), 4(%esp)
**R_386_GOT32：**代码中引用外部变量时，ld生成的重定位类型。动态链接器将G+A-P的值填充到代码中的重定位位置。所以CPU实际寻址时得到的地址为R_386_GOT32+P-A = G。
**R_386_PLT32：**代码中引用外部函数时，ld生成的重定位类型。动态链接器将L+A-P的值填充到代码中的重定位位置。所以CPU实际寻址时得到的地址为R_386_PLT32+P-A = L。
上面的G和L指的是__相应符号GOT条目距GOT首地址的偏移量。注意GOT32和PLT32一般和GOTPC一起使用，后者将GOT的首地址填充到代码段中的引用位置处。G+GOTPC=相应符号在GOT条目中的实际地址。__
在代码中引用外部变量时，汇编器一般生成如下代码（x86系统，如果是x86_64则直接具有**rip寄存器**）：
call __i686.get_pc_thunk.cx
addl $_GLOBAL_OFFSET_TABLE_, %ecx //_GLOBAL_OFFSET_TABLE符号的值是__GOT表首地址距当前指令的偏移量__，它的重定位类型为R_386_GOTPC。现在ecx寄存器保存的是__GOT表的绝对地址__。
movl var@GOT(%ecx), %eax //var@GOT是__var符号在GOT表中的偏移量__，所以var@GOT(%ecx)会通过GOT中的var条目取得__var符号的实际地址，并将其保存在eax寄存器中__。var@GOT的值是通过R_386_GOT32重定位的。
movl (%eax), %eax //取得var符号引用的内存单元值，保存到eax寄存器中。
__i686.get_pc_thunk.cx: //该函数的目的是获取EIP的值。
mov (%esp),%ecx //此时的esp指向的内存单元保存的值时__函数返回后执行的指令地址，即紧接着call的addl指令地址__。
ret
**R_386_GOTPC:** This type asembles R_386_PC32, except it use __the address of GOT__ in its caculation. The symbol referenced in this relocation normally is **_GLOBAL_OFFSET_TABLE_(见上面的代码示例)** , which additionally instructs linker to build the GOT. It normally used in PIC’s relocable files. See “ELF PIC Dessection“.
Sample:
d.c
int var = 10;
void fun (void){
var++;
int a = var;
}
#gcc -S -o __d.s__ -fPIC d.c //生成汇编代码，这样其中包含有__编译器生成的指导汇编器生成重定位条目的具体信息__。而通过objdump -d d.o看到的反汇编代码已经去掉了这些重定位信息。
#gcc -c -o d.o -fPIC d.c
In d.s, d.c assembled with PIC option, there are instructions to load the GOT address, shown in the following figure.
{{./3.gif}}
There will be a R_386_GOTPC relocation entry in d.o for __update the value of “$_GLOBAL_OFFSET_TABLE”__ to the offset from “addl” to “GOT”(addl指令的地址与GOT表首地址的差值即为_GLOBAL_OFFSET_TABLE符号的值。__该值的计算方法是由重定位类型决定的__), see the following figure（objdump -d的反汇编代码已经看不出原始的重定位信息）. The relocation entry is at 0xd bytes offset from .text section, $_GLOBAL_OFFSET_TABLE resides there. The item’s initial value is ’0×2′. It is the endian A for caculating the address of ‘addl’. During the relocation, the linker caculate the relocation entry’s P (position) by r_offset first. Thus P-2 is the address ‘addl’. why -2? because the opcode of ‘addl’ is 2 bytes long. So $_GLOBAL_OFFSET_TABLE = GOT-P+A.
{{./4.gif}}
**R_386_COPY:** The link editor creates this relocation type for dynamic linking. Its offset member refers to a location in a writable segement. The symbol table index specifies a symbol that should exists __both__ in the current object file and in a shared object. During execution, the dynamic linker __copies the data__ associated with the shared object’s symbol to location specified by the offset.
Sample:
[root@www save]# cat 386copy.c
#include <stdio.h>
extern int a;
int main(void) {
printf(“%d\n”, a);
}
[root@www save]# cat b.c
int a = 10;
#gcc -fPIC -share -o b.so b.c
#gcc -o 386copy 386copy.c ./b.so
{{./5.gif}}
Fig2 shows the variable a’s value from shared object to executable’s .bss section.
===== Notation: =====
S : The value of the symbol whose index resides in the relocation entry’s r_info.
A: The addend used to caculate the value of the relocation field.
P: The place, section offset or address, of the storage unit __being relocated__ (computed useing r_offset).__也就是计算后的值所替换的位置。__
G: The __offset__ into the global offset table at which the address of relocation entry’s symbol will reside during execution.
GOT: The address of the global offset table.
L: The place, section offset or address, of PLT entry for a symbol.
B: The __base address__ at which a shared object file has been loaded into the memory during execution.
===== Relocation section: =====
A relocation section(**而不是重定位条目的属性**) reference other two sections: __a symbol table and a section to modify__. The section header’s sh_info and sh_link, specify these relationships. sh_link is the symbol table index, sh_info is the section link.
Samples Code:
#include <stdio.h>
char a = ‘a’;
int b = 10;
extern char c;
extern void fun();
void pp (void) { }
int main(void) {
printf(“%d\n”, __b__);
int bb = __b__;
char cc = __c__; //b和c都是绝对寻址
**pp**(); //相对寻址
fun();
}
# gcc -c -o test1 test.c //生成的是可重定位的目标对象文件，__没有使用GOT和PLT__，所以和它们相关的重定位类型都没有使用。一般只使用了__R_386_PC32和R_386_32__两种类型。
[geekard@geekard rel]$ readelf -r rel.o
Relocation section '.rel.text' at offset 0x478 contains 7 entries:
Offset Info Type Sym.Value Sym. Name
0000000f 00000a01 __R_386_32__ 00000004 b
0000001a 00000501 R_386_32 00000000 .rodata
0000001f 00000d02 R_386_PC32 00000000 printf
00000024 00000a01 R_386_32 00000004 b
0000002f 00000e01 R_386_32 00000000 c
00000038 00000b02 R_386_PC32 00000000 pp
0000003d 00000f02 __R_386_PC32__ 00000000 fun
Relocation section '.rel.eh_frame' at offset 0x4b0 contains 2 entries:
Offset Info Type Sym.Value Sym. Name
00000020 00000202 R_386_PC32 00000000 .text
00000040 00000202 R_386_PC32 00000000 .text
没有使用PIC技术时，对目标对象文件中全局变量符号引用地址的重定位是直接用实际地址替换(**R_386_32**)，对__内部和外部函数__的调用是相对调转(**R_386_PC32**)。
[geekard@geekard rel]$ readelf -s rel.o
Symbol table '.symtab' contains 16 entries:
Num: Value Size Type Bind Vis Ndx Name
0: 00000000 0 NOTYPE LOCAL DEFAULT UND
1: 00000000 0 FILE LOCAL DEFAULT ABS rel.c
2: 00000000 0 SECTION LOCAL DEFAULT 1
3: 00000000 0 SECTION LOCAL DEFAULT 3
4: 00000000 0 SECTION LOCAL DEFAULT 4
5: 00000000 0 SECTION LOCAL DEFAULT 5
6: 00000000 0 SECTION LOCAL DEFAULT 7
7: 00000000 0 SECTION LOCAL DEFAULT 8
8: 00000000 0 SECTION LOCAL DEFAULT 6
**9: 00000000 1 OBJECT GLOBAL DEFAULT 3 a**
** 10: 00000004 4 OBJECT GLOBAL DEFAULT 3 b**
** 11: 00000000 5 FUNC GLOBAL DEFAULT 1 pp**
** 12: 00000005 62 FUNC GLOBAL DEFAULT 1 main**
** 13: 00000000 0 NOTYPE GLOBAL DEFAULT UND printf**
** 14: 00000000 0 NOTYPE GLOBAL DEFAULT UND c**
** 15: 00000000 0 NOTYPE GLOBAL DEFAULT UND fun**
[geekard@geekard rel]$
[geekard@geekard rel]$ gcc -c __-fPIC__ -o rel.o rel.c #还是可重定位目标类型目标文件，但是符号的引用使用了__位置无关__技术，所以对全局变量和外部函数的引用使用了GOT和PLT。
[geekard@geekard rel]$ readelf -r rel.o
Relocation section '.rel.text' at offset 0x594 contains 9 entries:
Offset Info Type Sym.Value Sym. Name
00000010 00000f02 R_386_PC32 00000000 __x86.get_pc_thunk.bx
00000016 0000100a __R_386_GOTPC__ 00000000 _GLOBAL_OFFSET_TABLE_
0000001c 00000c03 __R_386_GOT32__ 00000004 b
00000028 00000509 R_386_GOTOFF 00000000 .rodata
00000030 00001104 R_386_PLT32 00000000 printf
00000036 00000c03 R_386_GOT32 00000004 b
00000042 00001203 R_386_GOT32 00000000 c
0000004e 00000d04 __R_386_PLT32__ 00000000 pp
00000053 00001304 R_386_PLT32 00000000 fun
Relocation section '.rel.eh_frame' at offset 0x5dc contains 3 entries:
Offset Info Type Sym.Value Sym. Name
00000020 00000202 R_386_PC32 00000000 .text
00000040 00000202 R_386_PC32 00000000 .text
00000064 00000602 R_386_PC32 00000000 .text.__x86.get_pc_thu
[geekard@geekard rel]$
使用了PIC技术后，所有符号的重定位使用__GOT和PLT。__
Here is the details of how REL section associated with symbol table and the section to relocation.
1. Show the ELF sections.
{{./7.gif}}
In fig1, the section ‘.rel.text’ is ‘REL’, the sections it is associated with are the first and the 9th section, ‘.text’ and ‘.symtab’.
2. Show the relocation section entries:
{{./8.gif}}
In fig2, we can see there are two relocation entries for symbol ‘b’ because ‘b’ is referenced two times and the linker has to relocation it two times.
3. What is the raw data of relocation table entry?
{{./9.gif}}
Fig3 shows the content of the first entry of relocation table. r_offset is 0×10, that means the relocation entry is at the 0×10 of test1. the symbol table index is 0×09. we can see the 9th entry of symbol table is ‘b’ through Fig4;
4. b’s offset if 4 byts offset from the start of data section and size is 4 bytes. Then the linercaculate the address of b and modify it’s address in .text section through relocation entry.
{{./10.gif}}
So, we get a simple flow of how linker do the relocation. __first, get all relocation entries, then get all symbols associated with the relocation entries, then caculate the address and modify the unist in the section assosicated with the relocation entries.__ The real relocation is more complex but main flow is like this.
Sunday, September 12th, 2010 at 16:29

BIN
Zim/Programme/elf/elf_重定位/0.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 6.1 KiB

BIN
Zim/Programme/elf/elf_重定位/1.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 13 KiB

BIN
Zim/Programme/elf/elf_重定位/10.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 7.4 KiB

BIN
Zim/Programme/elf/elf_重定位/2.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 12 KiB

BIN
Zim/Programme/elf/elf_重定位/3.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.8 KiB

BIN
Zim/Programme/elf/elf_重定位/4.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 12 KiB

BIN
Zim/Programme/elf/elf_重定位/5.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 14 KiB

BIN
Zim/Programme/elf/elf_重定位/6.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 16 KiB

BIN
Zim/Programme/elf/elf_重定位/7.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 8.1 KiB

BIN
Zim/Programme/elf/elf_重定位/8.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 4.5 KiB

BIN
Zim/Programme/elf/elf_重定位/9.gif Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.0 KiB

15
Zim/Programme/elf/elf_重定位/CFI_for_gas.txt Normal file
View File

@@ -0,0 +1,15 @@
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2012-12-23T13:11:25+08:00
====== CFI for gas ======
Created Sunday 23 December 2012
Modern ABIs don't require frame pointers to be used in functions.
Howerver missing FPs bring difficulties when doing a backtrace.
One solutions is to provide Dwarf-2 CFI(call frame information) data
for each such function. This can be easily done for example by GCC in
its output, but isn't that easy to write by hand for pure assembler functions.
With the help of these .cfi_* directives one can ass appropriate unwind info
into his asm source without too much trouble.

198
Zim/Programme/elf/elf_重定位/sample2--可重定位类型.txt Normal file
View File

@@ -0,0 +1,198 @@
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2012-12-22T10:50:43+08:00
====== sample2--可重定位类型 ======
Created Saturday 22 December 2012
[geekard@geekard rel]$ cat -n rel.c **#测试文件**
1 #include <stdio.h>
2 int globalVar = 1;
3 int globalVarUninit;
4 static int globalVarStatic = 3;
5 extern externVar;
6
7 extern void externFun(void);
8 void Fun(void) {}
9
10 int main(void) {
11 int autoVar = globalVar;
12 static int staticVar = 2;
13 globalVarUninit = externVar;
14 printf("%d\n",globalVarStatic);
15 externFun();
16 Fun();
17 }
[geekard@geekard rel]$ **gcc -c rel.c #编译，生成可重定位类型的目标对象文件**
[geekard@geekard rel]$ readelf **-r** rel.o **#查看可重定位条目**
Relocation section '.rel.text' at offset 0x4e0 contains 8 entries:
Offset Info Type Sym.Value Sym. Name
0000000f 00000b01 R_386_32 00000000 globalVar __#对文件中的第11行变量引用进行重定位__
00000018 00000f01 R_386_32 00000000 externVar **#13**
0000001d 00000c01 R_386_32 00000004 globalVarUninit **#13**
00000022 00000301 R_386_32 00000000 .data
0000002d 00000601 R_386_32 00000000 .rodata
00000032 00001002 R_386_PC32 00000000 printf **#14**
00000037 00001102 R_386_PC32 00000000 externFun **#15**
0000003c 00000d02 R_386_PC32 00000000 Fun **#16**
Relocation section '.rel.eh_frame' at offset 0x520 contains 2 entries:
Offset Info Type Sym.Value Sym. Name
00000020 00000202 R_386_PC32 00000000 .text
00000040 00000202 R_386_PC32 00000000 .text
由于在编译时没有指定PIC，所以重定位条目没有使用GOT或PLT。对全局变量使用的时R_386_32的绝对地址重定位，对函数使用的是
R_386_PC32相对寻址重定位。
[geekard@geekard rel]$ **objdump -t rel.o #查看符号表**
rel.o: file format elf32-i386
SYMBOL TABLE:
00000000 l df *ABS* 00000000 rel.c
00000000 l d .text 00000000 .text
00000000 l d .data 00000000 .data
00000000 l d .bss 00000000 .bss
00000004 l O __.data__ 00000004 globalVarStatic
00000000 l d .rodata 00000000 .rodata
00000008 l O __.data__ 00000004 staticVar.1828
00000000 l d .note.GNU-stack 00000000 .note.GNU-stack
00000000 l d .eh_frame 00000000 .eh_frame
00000000 l d .comment 00000000 .comment
00000000 g O __.data__ 00000004 globalVar
00000004 O __*COM*__ 00000004 globalVarUninit
00000000 g F .text 00000005 Fun
00000005 g F .text 0000003d main
00000000 *UND* 00000000 externVar
00000000 *UND* 00000000 printf
00000000 *UND* 00000000 externFun
[geekard@geekard rel]$
全局静态变量、全局已初始化变量、静态自动变量都位于.data section中。但是全局未初始化变量位于COMMON(named after Fortran 77's "common blocks") section中，而且对外不可见。file-scope and local-scope uninitiated global variables 保存在bss（"Block Started by Symbol"）段中。如果想让globalVarUninit保存在.bss section中，可以在编译时使用-fno-common选项，则是建议的用法。
geekard@ubuntu:~/Code$ cat bar.c
double globalVar;
int main() {}
geekard@ubuntu:~/Code$ cat bar.c
double globalVar;
int main() {}
geekard@ubuntu:~/Code$
geekard@ubuntu:~/Code$ gcc foo.c bar.c
编译并链接上面两个文件时，编译器并没有提示符号重复定义的错误，但是如果启用-fno-common选项，则会提示错误。
geekard@ubuntu:~/Code$ gcc foo.c bar.c **-fno-common**
/tmp/cceNAIis.o:(.bss+0x0): multiple definition of `globalVar'
/tmp/ccWmFhZG.o:(.bss+0x0): first defined here
/usr/bin/ld: Warning: size of symbol `globalVar' changed from 4 in /tmp/ccWmFhZG.o to 8 in /tmp/cceNAIis.o
collect2: ld 返回 1
geekard@ubuntu:~/Code$
则是由于foo.oh和bar.o中的globalVar都放在.bss section中，而且都是global bind，所以会冲突。注意，放在COMMON section中时
没有bind属性，默认是外界不可见的：
geekard@ubuntu:~/Code$ objdump -t bar.o |grep globalVar //未启用-fno-common，无绑定信息，外界不可见
0000000000000008 __O *COM*__ 0000000000000008 globalVar
geekard@ubuntu:~/Code$ objdump -t bar.o |grep globalVar //启用-fno-common后
0000000000000000 __g__ O __.bss__ 0000000000000008 globalVar
kkkn
[geekard@geekard rel]$ __gcc -S rel.c #编译__
[geekard@geekard rel]$ cat rel.s #查看编译生成的汇编代码，代码中含有指示链接器ld生成各section和重定位的指令。
.file "rel.c"
.globl globalVar **#符号全局可见**
.data **#data section开始**
.align 4
.type globalVar, @object **#符号类型**
.size globalVar, 4 **#符号对象大小**
globalVar:
.long 1 **#符号的值**
__.comm__ globalVarUninit,4,4 **#COMMON section**
.align 4
.type globalVarStatic, @object
.size globalVarStatic, 4
globalVarStatic:
.long 3
.text **#代码段开始**
.globl Fun
.type Fun, @function
Fun:
.LFB0:
.cfi_startproc
pushl %ebp
.cfi_def_cfa_offset 8
.cfi_offset 5, -8
movl %esp, %ebp
.cfi_def_cfa_register 5
popl %ebp
.cfi_restore 5
.cfi_def_cfa 4, 4
ret
.cfi_endproc
.LFE0:
.size Fun, .-Fun #函数对象的大小
.section .rodata **#rodata section的开始**
.LC0:
.string "%d\n"
.text
.globl main
.type main, @function
main:
.LFB1:
.cfi_startproc
pushl %ebp
.cfi_def_cfa_offset 8
.cfi_offset 5, -8
movl %esp, %ebp
.cfi_def_cfa_register 5
andl $-16, %esp
subl $32, %esp
movl __globalVar,__ %eax __#对全局变量的引用是绝对寻址，没有使用GOT。汇编时as会生成R_386_32类型的重定位条目__
movl %eax, 28(%esp)
movl __externVar__, %eax
movl %eax, __globalVarUninit__
movl __globalVarStatic__, %eax
movl %eax, 4(%esp)
movl $.LC0, (%esp)
call __printf #对外部或全局函数的引用，使用的是相对寻址，没有使用PLT。汇编时as会生成R_386_PC32类型的重定位条目__
call __externFun__
call __Fun __
leave
.cfi_restore 5
.cfi_def_cfa 4, 4
ret
.cfi_endproc
.LFE1:
.size main, .-main
.data
.align 4
.type __staticVar.1828__, @object
.size staticVar.1828, 4
staticVar.1828:
.long 2
.ident "GCC: (GNU) 4.7.2"
.section .note.GNU-stack,"",@progbits
[geekard@geekard rel]$
[geekard@geekard rel]$ objdump -d rel.o
rel.o: file format elf32-i386
Disassembly of section .text:
00000000 <Fun>:
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 5d pop %ebp
4: c3 ret
00000005 <main>:
5: 55 push %ebp
6: 89 e5 mov %esp,%ebp
8: 83 e4 f0 and $0xfffffff0,%esp
b: 83 ec 20 sub $0x20,%esp
e: a1 00 00 00 00 mov 0x0,%eax
13: 89 44 24 1c mov %eax,0x1c(%esp)
17: a1 00 00 00 00 mov 0x0,%eax
1c: a3 00 00 00 00 mov %eax,0x0
21: a1 04 00 00 00 mov 0x4,%eax
26: 89 44 24 04 mov %eax,0x4(%esp)
2a: c7 04 24 00 00 00 00 movl $0x0,(%esp)
31: e8 fc ff ff ff call 32 <main+0x2d>
36: e8 fc ff ff ff call 37 <main+0x32>
3b: e8 fc ff ff ff call 3c <main+0x37>
40: c9 leave
41: c3 ret
[geekard@geekard rel]$

236
Zim/Programme/elf/elf_重定位/sample3--PIC可重定位类型.txt Normal file
View File

@@ -0,0 +1,236 @@
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2012-12-22T22:55:46+08:00
====== sample3--PIC可重定位类型 ======
Created Saturday 22 December 2012
[geekard@geekard rel]$ cat rel.c
#include <stdio.h>
int globalVar = 1;
int globalVarUninit;
static int globalVarStatic = 3;
extern externVar;
extern void externFun(int);
void Fun(void) {}
int main(void) {
int autoVar = globalVar;
static int staticVar = 2;
globalVarUninit = externVar;
printf("%d\n",globalVarStatic);
externFun(staticVar);
Fun();
}
[geekard@geekard rel]$ gcc -c __-fPIC__ rel.c
[geekard@geekard rel]$ readelf -r rel.o
Relocation section '**.rel.text**' at offset 0x600 contains 10 entries: **//对text section中的符号引用重定位**
Offset Info Type Sym.Value Sym. Name
00000010 00001102 R_386_PC32 00000000 __x86.get_pc_thunk.bx //相对寻址重定位，这里没有使用PLT是因为该函数是文件内部定义的。
00000016 0000120a R_386___GOTPC__ 00000000 _GLOBAL_OFFSET_TABLE_ //用IP与GOT首地址的偏移量重定位代码中的值。
0000001c 00000d03 R_386___GOT32__ 00000000 globalVar //用var条目在GOT中的偏移量重定位代码中的值。
00000028 00001303 R_386_GOT32 00000000 externVar
00000030 00000e03 R_386_GOT32 00000004 globalVarUninit
00000038 00000309 R_386___GOTOFF__ 00000000 .data //用__static符号的地址与GOT的偏移量__来重定位代码段中的值。
00000042 00000609 R_386_GOTOFF 00000000 .rodata //.rodata section中保存的是**字符串字面量**。
0000004a 00001404 R_386___PLT32__ 00000000 printf //用printf条目在GOT PLT中的偏移量重定位代码中的值。
00000050 00000309 R_386_GOTOFF 00000000 .data
0000004f 00001504 R_386_PLT32 00000000 externFun
00000054 00000f04 R_386_PLT32 00000000 Fun
Relocation section '.rel.eh_frame' at offset 0x650 contains 3 entries:
Offset Info Type Sym.Value Sym. Name
00000020 00000202 R_386_PC32 00000000 .text
00000040 00000202 R_386_PC32 00000000 .text
00000064 00000802 R_386_PC32 00000000 .text.__x86.get_pc_thu
[geekard@geekard rel]$ objdump -t rel.o
rel.o: file format elf32-i386
SYMBOL TABLE:
00000000 l df *ABS* 00000000 rel.c
00000000 l d .text 00000000 .text //.text section定义
00000000 g F __.text__ 00000005 Fun //.text section中的第一个函数(偏移量为0)，本文件内定义
00000005 g F .text 00000058 main //.text section中的第二个函数
00000000 g F .text.x86.get_pc_thunk.bx 00000000 .hidden x86.get_pc_thunk.bx
00000000 l d .text.x86.get_pc_thunk.bx 00000000 .text.x86.get_pc_thunk.bx
00000000 l d .data 00000000 .data //.data section定义
00000000 g O .data 00000004 globalVar
00000004 l O .data 00000004 globalVarStatic
00000008 l O .data 00000004 __staticVar.1828__
00000000 l d .rodata 00000000 .rodata
00000000 l d .bss 00000000 .bss
00000004 O __*COM*__ 00000004 globalVarUninit
00000000 l d .note.GNU-stack 00000000 .note.GNU-stack
00000000 l d .eh_frame 00000000 .eh_frame
00000000 l d .comment 00000000 .comment
00000000 l d .group 00000000 .group
00000000 __*UND*__ 00000000 _GLOBAL_OFFSET_TABLE_
00000000 *UND* 00000000 externVar
00000000 *UND* 00000000 printf
00000000 *UND* 00000000 externFun
[geekard@geekard rel]$ gcc -S __-fPIC__ rel.c
[geekard@geekard rel]$ cat rel.s
.file "rel.c"
.globl globalVar
.data
.align 4
.type globalVar, @object
.size globalVar, 4
globalVar:
.long 1
.comm globalVarUninit,4,4
.align 4
.type globalVarStatic, @object
.size globalVarStatic, 4
globalVarStatic:
.long 3
.text
.globl Fun
.type Fun, @function
Fun:
.LFB0: **//.LFB是Dwarf使用的一个标号，与.LFE相匹配。**
.cfi_startproc //[[../CFI_for_gas.txt|cfi(call frame information)]]
pushl %ebp
.cfi_def_cfa_offset 8
.cfi_offset 5, -8
movl %esp, %ebp
.cfi_def_cfa_register 5
popl %ebp
.cfi_restore 5
.cfi_def_cfa 4, 4
ret
.cfi_endproc
.LFE0:
.size Fun, .-Fun
.section __.rodata__
__.LC0: //该标号没有使用.globl限定，所以符号表中没有包含。只在本文件内有效。__
.string "%d\n"
.text
.globl main
.type main, @function
main:
.LFB1: //前面使用的是.LFB0, 所以这里是.LFB1
.cfi_startproc
pushl %ebp
.cfi_def_cfa_offset 8
.cfi_offset 5, -8
movl %esp, %ebp
.cfi_def_cfa_register 5
pushl %ebx
andl $-16, %esp
subl $32, %esp
.cfi_offset 3, -12
call ____x86.get_pc_thunk.bx __**//获得IP的值，保存在ebx寄存器中**
addl $___GLOBAL_OFFSET_TABLE___, %ebx **//通过GOTPC重定位，获得GOT与当前IP的偏移量。最终获得GOT的首地址**
movl __globalVar@GOT__(%ebx), %eax **//通过GOT32重定位，获得var@GOT的值，即var所在的GOT条目相对GOT的偏移量。**
movl (%eax), %eax **//eax寄存器的值为var符号的实际地址，这样间接引用获得其实际值。**
movl %eax, 28(%esp)
movl externVar@GOT(%ebx), %eax
movl (%eax), %edx
movl globalVarUninit@GOT(%ebx), %eax
movl %edx, (%eax)
movl __globalVarStatic@GOTOFF__(%ebx), %eax __//GOTOFF类型的重定位__
movl %eax, 4(%esp)
leal __.LC0@GOTOFF__(%ebx), %eax
movl %eax, (%esp)
call __printf@PLT__
movl __staticVar.1828@GOTOFF__(%ebx), %eax
movl %eax, (%esp)
call externFun@PLT
call Fun@PLT
movl -4(%ebp), %ebx
leave
.cfi_restore 5
.cfi_restore 3
.cfi_def_cfa 4, 4
ret
.cfi_endproc
.LFE1:
.size main, .-main
.data
.align 4
.type staticVar.1828, @object
.size staticVar.1828, 4
staticVar.1828:
.long 2
.section .text.x86.get_pc_thunk.bx,"axG",@progbits,x86.get_pc_thunk.bx,comdat
.globl __x86.get_pc_thunk.bx
.hidden __x86.get_pc_thunk.bx
.type __x86.get_pc_thunk.bx, @function
__x86.get_pc_thunk.bx:
.LFB2:
.cfi_startproc
movl (%esp), %ebx
ret
.cfi_endproc
.LFE2:
.ident "GCC: (GNU) 4.7.2"
.section .note.GNU-stack,"",@progbits
[geekard@geekard rel]$
[geekard@geekard rel]$ objdump -d rel.o
rel.o: file format elf32-i386
Disassembly of section .text:
00000000 <Fun>:
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 5d pop %ebp
4: c3 ret
00000005 <main>:
5: 55 push %ebp
6: 89 e5 mov %esp,%ebp
8: 53 push %ebx
9: 83 e4 f0 and $0xfffffff0,%esp
c: 83 ec 20 sub $0x20,%esp
f: e8 __fc ff ff ff__ call 10 <main+0xb>
14: 81 c3 __02 00 00 00__ add $0x2,%ebx //objdump反汇编后的代码中已经__看不到原始的重定位信息__。所以需要和重定位条目一起查看。
1a: 8b 83 __00 00 00 00__ mov 0x0(%ebx),%eax
20: 8b 00 mov (%eax),%eax
22: 89 44 24 1c mov %eax,0x1c(%esp)
26: 8b 83 __00 00 00 00__ mov 0x0(%ebx),%eax
2c: 8b 10 mov (%eax),%edx
2e: 8b 83 __00 00 00 00__ mov 0x0(%ebx),%eax
34: 89 10 mov %edx,(%eax)
36: 8b 83 __04 00 00 00__ mov 0x4(%ebx),%eax
3c: 89 44 24 04 mov %eax,0x4(%esp)
40: 8d 83 __00 00 00 00__ lea 0x0(%ebx),%eax
46: 89 04 24 mov %eax,(%esp)
49: e8 __fc ff ff ff__ call 4a <main+0x45>
4e: 8b 83 __08 00 00 00__ mov 0x8(%ebx),%eax
54: 89 04 24 mov %eax,(%esp)
57: e8 __fc ff ff ff__ call 58 <main+0x53>
5c: e8 __fc ff ff ff__ call 5d <main+0x58>
61: 8b 5d fc mov -0x4(%ebp),%ebx
64: c9 leave
65: c3 ret
#上面黄色标记的位置需要链接器对其重定位。
Disassembly of section .text.__x86.get_pc_thunk.bx:
00000000 <__x86.get_pc_thunk.bx>:
0: 8b 1c 24 mov (%esp),%ebx
3: c3 ret
[geekard@geekard rel]$

125
Zim/Programme/elf/ld-linux调试信息.txt Normal file
View File

@@ -0,0 +1,125 @@
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2012-12-16T17:34:49+08:00
====== ld-linux调试信息 ======
Created Sunday 16 December 2012
启用动态连接器调试信息输出的方法是定义变量LD_DEBUG=all
**[geekard@geekard hello]$ cat hello.c**
#include <stdio.h>
#include <stdlib.h>
int glb_init = 1;
int glb_uninit;
int main(void)
{
char *str = "Just a test string!";
printf("The test string is:\"%s\"\n", str);
printf("glb_init:%d, glb_uninit:%d\n", glb_init, glb_uninit);
pause(); **//暂停进程，这样可以查看其内存映射情况。**
exit(0);
}
[geekard@geekard hello]$ __strace -e trace=mmap2,mprotect,munmap,open,close -ELD_DEBUG=all ./hello &>log__
^Z
[1]+ Stopped strace -e trace=mmap2,mprotect,munmap,open,close -ELD_DEBUG=all ./hello &>log
#上面的log文件中包含有strace的输出和hello的ld-linux.so的DEBUG信息。
**#4727为hello的进程号，下面命令从log中提取ld-linux.so的DEBUG信息**
**[geekard@geekard hello]$ cat log|grep 4727>log.ld **
#**下面命令从log中提取hello的系统调用信息**
**[geekard@geekard hello]$ cat log |sed '/4727/d' >log.strace**
MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb77b8000
**[geekard@geekard hello]$ readelf -l /lib/libc.so.6**
Elf file type is DYN (Shared object file)
Entry point __0x19760__
There are __10__ program headers, starting at offset 52
Program Headers:
Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align
PHDR 0x000034 0x00000034 0x00000034 0x00140 0x00140 R E 0x4
INTERP 0x16b7e8 0x0016b7e8 0x0016b7e8 0x00017 0x00017 R 0x1
[Requesting program interpreter: [[/usr/lib/ld-linux.so.2]]]
#第一个LOAD为RE，其大小为1718236B(0x1a37dc)，需要4KB对齐，所以实际需要空间1720320B，这会传给mmap2函数。
**LOAD** __0x000000__ 0x00000000 0x00000000 __0x1a37dc__ 0x1a37dc R E 0x1000
**LOAD** 0x1a41dc 0x001a41dc 0x001a41dc 0x02ce0 __0x058e8__ RW 0x1000
DYNAMIC __0x1a5d9c__ 0x001a5d9c 0x001a5d9c 0x000f8 0x000f8 RW 0x4
NOTE 0x000174 0x00000174 0x00000174 0x00044 0x00044 R 0x4
TLS 0x1a41dc 0x001a41dc 0x001a41dc 0x00008 0x00040 R 0x4
GNU_EH_FRAME 0x16b800 0x0016b800 0x0016b800 0x07454 0x07454 R 0x4
GNU_STACK 0x000000 0x00000000 0x00000000 0x00000 0x00000 RW 0x4
**GNU_RELRO** 0x1a41dc 0x001a41dc 0x001a41dc 0x01e24 0x01e24 R 0x1
Section to Segment mapping:
Segment Sections...
00
01 .interp
02 .note.gnu.build-id .note.ABI-tag .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_d .gnu.version_r .rel.dyn .rel.plt .plt .text __libc_freeres_fn __libc_thread_freeres_fn .rodata .interp .eh_frame_hdr .eh_frame .gcc_except_table .hash
03 .tdata .init_array __libc_subfreeres __libc_atexit __libc_thread_subfreeres .data.rel.ro .dynamic .got .got.plt .data .bss
04 .dynamic
05 .note.gnu.build-id .note.ABI-tag
06 .tdata .tbss
07 .eh_frame_hdr
08
09 .tdata .init_array __libc_subfreeres __libc_atexit __libc_thread_subfreeres .data.rel.ro .dynamic .got
可以看出libc.so.6中的__虚拟地址从0开始__。
**[geekard@geekard hello]$ pmap $(pgrep hello) |nl #查看hello进程的地址映射情况**
1 4727: ./hello
2 08048000 4K r-x-- /home/geekard/Code/hello/hello
3 08049000 4K rw--- /home/geekard/Code/hello/hello
4 __b75eb000__ 4K rw--- [ anon ] //libc的保护区域
//0xb75ec000为ld-linux.so映射libc到a.out进程地址空间时的__随机base地址(见后文log文件)__。
5 __b75ec000__ 1680K r-x-- /usr/lib/libc-2.16.so
6 __b7790000__ 8K r---- /usr/lib/libc-2.16.so
7 b7792000 4K rw--- /usr/lib/libc-2.16.so
8 __b7793000__ 12K rw--- [ anon ]
9 b77b8000 **8K** rw--- [ anon ] //包含有第一次调用mmap2()分配的匿名内存块。
10 b77ba000 4K r-x-- [ anon ] //ld的保护区域
11 b77bb000 128K r-x-- /usr/lib/ld-2.16.so
12 b77db000 4K r---- /usr/lib/ld-2.16.so
13 b77dc000 4K rw--- /usr/lib/ld-2.16.so
14 __bff8b000__ 132K rw--- [ stack ]
15 total 1996K
**[geekard@geekard hello]$ cat log //查看strace打印出的系统调用和ld-linux.so打印的DEBUG信息。**
//匿名映射，mmap2的第一个参数为NULL，所以内核会随机地选择一个地址，这里为 **0xb77b9000。**
//匿名映射的虚拟地址空间为**0xb77b9000～0xb77ba000。包含在pmap打印的第9行中。**
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|**MAP_ANONYMOUS**, -1, 0) = **0xb77b9000**
open("/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
//文件映射，内核随机选择一个起始地址，这里为**0xb7796000**
mmap2(**NULL**, 139868, PROT_READ, MAP_PRIVATE, 3, 0) = **0xb7796000**
4727:
4727: file=libc.so.6 [0]; needed by ./hello [0]
4727: find library=libc.so.6 [0]; searching
4727: search cache=/etc/ld.so.cache
//关闭了ld.so.cache，所以**其映射的内存区域将删除**。
close(3) = 0
4727: trying file=/usr/lib/libc.so.6
open("/usr/lib/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
//文件映射，内核随机选择一个起始地址，这里为 __0xb75ec000。这里映射的是第一个LOAD segment__
mmap2(**NULL**, 1743556, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = __0xb75ec000__
//这里映射的是第二个LOAD segment
mmap2(**0xb7790000,** 12288, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, **0x1a4**) = 0xb7790000
mmap2(**0xb7793000**, 10948, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|**MAP_ANONYMOUS**, -1, 0) = 0xb7793000
close(3) = 0
4727:
4727: file=libc.so.6 [0]; generating link map
4727: dynamic: __0xb7791d9c__ base: __0xb75ec000__ size: 0x001a9ac4
4727: entry: 0xb7605760 phdr: 0xb75ec034 phnum: 10
4727:
4727: checking for version `GLIBC_2.0' in file /usr/lib/libc.so.6 [0] required by file ./hello [0]
4727: checking for version `GLIBC_2.3' in file /lib/ld-linux.so.2 [0] required by file /usr/lib/libc.so.6 [0]
4727: checking for version `GLIBC_PRIVATE' in file /lib/ld-linux.so.2 [0] required by file /usr/lib/libc.so.6 [0]
4727: checking for version `GLIBC_2.1' in file /lib/ld-linux.so.2 [0] required by file /usr/lib/libc.so.6 [0]
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = **0xb75eb000**
mprotect(0xb7790000, 8192, PROT_READ) = 0
mprotect(0xb77db000, 4096, PROT_READ) = 0
munmap(0xb7796000, 139868) = 0
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = **0xb77b8000**

7
Zim/Programme/goagent.txt Normal file
View File

@@ -0,0 +1,7 @@
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2012-12-29T11:19:39+08:00
====== goagent ======
Created Saturday 29 December 2012

380
Zim/Programme/python/The-Python-Standard-Library.txt Normal file
View File

@@ -0,0 +1,380 @@
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2012-11-29T14:30:56+08:00
====== The-Python-Standard-Library ======
Created Thursday 29 November 2012
http://docs.python.org/2/library/index.html
While **The Python Language Reference** describes the exact syntax and semantics of the Python language, this library reference manual describes the standard library that is distributed with Python. It also describes some of the optional components that are commonly included in Python distributions.
Python’s standard library is very extensive, offering a wide range of facilities as indicated by the long table of contents listed below.
The library contains __built-in modules__ (written in C) that provide access to system functionality such as file I/O that would otherwise be inaccessible to Python programmers, as well as modules written in Python that provide __standardized solutions__ for many problems that occur in everyday programming. Some of these modules are explicitly designed to encourage and enhance the portability of Python programs by abstracting away platform-specifics into platform-neutral APIs.
The Python installers for the Windows platform usually includes the entire standard library and often also include many additional components. For Unix-like operating systems Python is normally provided as **a collection of packages**, so it may be necessary to use the packaging tools provided with the operating system to obtain some or all of the optional components.
In addition to the standard library, there is a growing collection of several thousand components (from individual programs and modules to packages and entire application development frameworks), available from the Python Package Index.
1. Introduction
2. Built-in Functions
3. Non-essential Built-in Functions
4. Built-in Constants
4.1. Constants added by the site module
5. Built-in Types
5.1. Truth Value Testing
5.2. Boolean Operations — and, or, not
5.3. Comparisons
5.4. Numeric Types — int, float, long, complex
5.5. Iterator Types
5.6. Sequence Types — str, unicode, list, tuple, bytearray, buffer, xrange
5.7. Set Types — set, frozenset
5.8. Mapping Types — dict
5.9. File Objects
5.10. memoryview type
5.11. Context Manager Types
5.12. Other Built-in Types
5.13. Special Attributes
6. Built-in Exceptions
6.1. Exception hierarchy
7. String Services
7.1. string — Common string operations
7.2. re — Regular expression operations
7.3. struct — Interpret strings as packed binary data
7.4. difflib — Helpers for computing deltas
7.5. StringIO — Read and write strings as files
7.6. cStringIO — Faster version of StringIO
7.7. textwrap — Text wrapping and filling
7.8. codecs — Codec registry and base classes
7.9. unicodedata — Unicode Database
7.10. stringprep — Internet String Preparation
7.11. fpformat — Floating point conversions
8. Data Types
8.1. datetime — Basic date and time types
8.2. calendar — General calendar-related functions
8.3. collections — High-performance container datatypes
8.4. heapq — Heap queue algorithm
8.5. bisect — Array bisection algorithm
8.6. array — Efficient arrays of numeric values
8.7. sets — Unordered collections of unique elements
8.8. sched — Event scheduler
8.9. mutex — Mutual exclusion support
8.10. Queue — A synchronized queue class
8.11. weakref — Weak references
8.12. UserDict — Class wrapper for dictionary objects
8.13. UserList — Class wrapper for list objects
8.14. UserString — Class wrapper for string objects
8.15. types — Names for built-in types
8.16. new — Creation of runtime internal objects
8.17. copy — Shallow and deep copy operations
8.18. pprint — Data pretty printer
8.19. repr — Alternate repr() implementation
9. Numeric and Mathematical Modules
9.1. numbers — Numeric abstract base classes
9.2. math — Mathematical functions
9.3. cmath — Mathematical functions for complex numbers
9.4. decimal — Decimal fixed point and floating point arithmetic
9.5. fractions — Rational numbers
9.6. random — Generate pseudo-random numbers
9.7. itertools — Functions creating iterators for efficient looping
9.8. functools — Higher-order functions and operations on callable objects
9.9. operator — Standard operators as functions
10. File and Directory Access
10.1. os.path — Common pathname manipulations
10.2. fileinput — Iterate over lines from multiple input streams
10.3. stat — Interpreting stat() results
10.4. statvfs — Constants used with os.statvfs()
10.5. filecmp — File and Directory Comparisons
10.6. tempfile — Generate temporary files and directories
10.7. glob — Unix style pathname pattern expansion
10.8. fnmatch — Unix filename pattern matching
10.9. linecache — Random access to text lines
10.10. shutil — High-level file operations
10.11. dircache — Cached directory listings
10.12. macpath — Mac OS 9 path manipulation functions
11. Data Persistence
11.1. pickle — Python object serialization
11.2. cPickle — A faster pickle
11.3. copy_reg — Register pickle support functions
11.4. shelve — Python object persistence
11.5. marshal — Internal Python object serialization
11.6. anydbm — Generic access to DBM-style databases
11.7. whichdb — Guess which DBM module created a database
11.8. dbm — Simple “database” interface
11.9. gdbm — GNU’s reinterpretation of dbm
11.10. dbhash — DBM-style interface to the BSD database library
11.11. bsddb — Interface to Berkeley DB library
11.12. dumbdbm — Portable DBM implementation
11.13. sqlite3 — DB-API 2.0 interface for SQLite databases
12. Data Compression and Archiving
12.1. zlib — Compression compatible with gzip
12.2. gzip — Support for gzip files
12.3. bz2 — Compression compatible with bzip2
12.4. zipfile — Work with ZIP archives
12.5. tarfile — Read and write tar archive files
13. File Formats
13.1. csv — CSV File Reading and Writing
13.2. ConfigParser — Configuration file parser
13.3. robotparser — Parser for robots.txt
13.4. netrc — netrc file processing
13.5. xdrlib — Encode and decode XDR data
13.6. plistlib — Generate and parse Mac OS X .plist files
14. Cryptographic Services
14.1. hashlib — Secure hashes and message digests
14.2. hmac — Keyed-Hashing for Message Authentication
14.3. md5 — MD5 message digest algorithm
14.4. sha — SHA-1 message digest algorithm
15. Generic Operating System Services
15.1. os — Miscellaneous operating system interfaces
15.2. io — Core tools for working with streams
15.3. time — Time access and conversions
15.4. argparse — Parser for command-line options, arguments and sub-commands
15.5. optparse — Parser for command line options
15.6. getopt — C-style parser for command line options
15.7. logging — Logging facility for Python
15.8. logging.config — Logging configuration
15.9. logging.handlers — Logging handlers
15.10. getpass — Portable password input
15.11. curses — Terminal handling for character-cell displays
15.12. curses.textpad — Text input widget for curses programs
15.13. curses.ascii — Utilities for ASCII characters
15.14. curses.panel — A panel stack extension for curses
15.15. platform — Access to underlying platform’s identifying data
15.16. errno — Standard errno system symbols
15.17. ctypes — A foreign function library for Python
16. Optional Operating System Services
16.1. select — Waiting for I/O completion
16.2. threading — Higher-level threading interface
16.3. thread — Multiple threads of control
16.4. dummy_threading — Drop-in replacement for the threading module
16.5. dummy_thread — Drop-in replacement for the thread module
16.6. multiprocessing — Process-based “threading” interface
16.7. mmap — Memory-mapped file support
16.8. readline — GNU readline interface
16.9. rlcompleter — Completion function for GNU readline
17. Interprocess Communication and Networking
17.1. subprocess — Subprocess management
17.2. socket — Low-level networking interface
17.3. ssl — TLS/SSL wrapper for socket objects
17.4. signal — Set handlers for asynchronous events
17.5. popen2 — Subprocesses with accessible I/O streams
17.6. asyncore — Asynchronous socket handler
17.7. asynchat — Asynchronous socket command/response handler
18. Internet Data Handling
18.1. email — An email and MIME handling package
18.2. json — JSON encoder and decoder
18.3. mailcap — Mailcap file handling
18.4. mailbox — Manipulate mailboxes in various formats
18.5. mhlib — Access to MH mailboxes
18.6. mimetools — Tools for parsing MIME messages
18.7. mimetypes — Map filenames to MIME types
18.8. MimeWriter — Generic MIME file writer
18.9. mimify — MIME processing of mail messages
18.10. multifile — Support for files containing distinct parts
18.11. rfc822 — Parse RFC 2822 mail headers
18.12. base64 — RFC 3548: Base16, Base32, Base64 Data Encodings
18.13. binhex — Encode and decode binhex4 files
18.14. binascii — Convert between binary and ASCII
18.15. quopri — Encode and decode MIME quoted-printable data
18.16. uu — Encode and decode uuencode files
19. Structured Markup Processing Tools
19.1. HTMLParser — Simple HTML and XHTML parser
19.2. sgmllib — Simple SGML parser
19.3. htmllib — A parser for HTML documents
19.4. htmlentitydefs — Definitions of HTML general entities
19.5. xml.etree.ElementTree — The ElementTree XML API
19.6. xml.dom — The Document Object Model API
19.7. xml.dom.minidom — Lightweight DOM implementation
19.8. xml.dom.pulldom — Support for building partial DOM trees
19.9. xml.sax — Support for SAX2 parsers
19.10. xml.sax.handler — Base classes for SAX handlers
19.11. xml.sax.saxutils — SAX Utilities
19.12. xml.sax.xmlreader — Interface for XML parsers
19.13. xml.parsers.expat — Fast XML parsing using Expat
20. Internet Protocols and Support
20.1. webbrowser — Convenient Web-browser controller
20.2. cgi — Common Gateway Interface support
20.3. cgitb — Traceback manager for CGI scripts
20.4. wsgiref — WSGI Utilities and Reference Implementation
20.5. urllib — Open arbitrary resources by URL
20.6. urllib2 — extensible library for opening URLs
20.7. httplib — HTTP protocol client
20.8. ftplib — FTP protocol client
20.9. poplib — POP3 protocol client
20.10. imaplib — IMAP4 protocol client
20.11. nntplib — NNTP protocol client
20.12. smtplib — SMTP protocol client
20.13. smtpd — SMTP Server
20.14. telnetlib — Telnet client
20.15. uuid — UUID objects according to RFC 4122
20.16. urlparse — Parse URLs into components
20.17. SocketServer — A framework for network servers
20.18. BaseHTTPServer — Basic HTTP server
20.19. SimpleHTTPServer — Simple HTTP request handler
20.20. CGIHTTPServer — CGI-capable HTTP request handler
20.21. cookielib — Cookie handling for HTTP clients
20.22. Cookie — HTTP state management
20.23. xmlrpclib — XML-RPC client access
20.24. SimpleXMLRPCServer — Basic XML-RPC server
20.25. DocXMLRPCServer — Self-documenting XML-RPC server
21. Multimedia Services
21.1. audioop — Manipulate raw audio data
21.2. imageop — Manipulate raw image data
21.3. aifc — Read and write AIFF and AIFC files
21.4. sunau — Read and write Sun AU files
21.5. wave — Read and write WAV files
21.6. chunk — Read IFF chunked data
21.7. colorsys — Conversions between color systems
21.8. imghdr — Determine the type of an image
21.9. sndhdr — Determine type of sound file
21.10. ossaudiodev — Access to OSS-compatible audio devices
22. Internationalization
22.1. gettext — Multilingual internationalization services
22.2. locale — Internationalization services
23. Program Frameworks
23.1. cmd — Support for line-oriented command interpreters
23.2. shlex — Simple lexical analysis
24. Graphical User Interfaces with Tk
24.1. Tkinter — Python interface to Tcl/Tk
24.2. ttk — Tk themed widgets
24.3. Tix — Extension widgets for Tk
24.4. ScrolledText — Scrolled Text Widget
24.5. turtle — Turtle graphics for Tk
24.6. IDLE
24.7. Other Graphical User Interface Packages
25. Development Tools
25.1. pydoc — Documentation generator and online help system
25.2. doctest — Test interactive Python examples
25.3. unittest — Unit testing framework
25.4. 2to3 - Automated Python 2 to 3 code translation
25.5. test — Regression tests package for Python
25.6. test.test_support — Utility functions for tests
26. Debugging and Profiling
26.1. bdb — Debugger framework
26.2. pdb — The Python Debugger
26.3. Debugger Commands
26.4. The Python Profilers
26.5. hotshot — High performance logging profiler
26.6. timeit — Measure execution time of small code snippets
26.7. trace — Trace or track Python statement execution
27. Python Runtime Services
27.1. sys — System-specific parameters and functions
27.2. sysconfig — Provide access to Python’s configuration information
27.3. __builtin__ — Built-in objects
27.4. future_builtins — Python 3 builtins
27.5. __main__ — Top-level script environment
27.6. warnings — Warning control
27.7. contextlib — Utilities for with-statement contexts
27.8. abc — Abstract Base Classes
27.9. atexit — Exit handlers
27.10. traceback — Print or retrieve a stack traceback
27.11. __future__ — Future statement definitions
27.12. gc — Garbage Collector interface
27.13. inspect — Inspect live objects
27.14. site — Site-specific configuration hook
27.15. user — User-specific configuration hook
27.16. fpectl — Floating point exception control
27.17. distutils — Building and installing Python modules
28. Custom Python Interpreters
28.1. code — Interpreter base classes
28.2. codeop — Compile Python code
29. Restricted Execution
29.1. rexec — Restricted execution framework
29.2. Bastion — Restricting access to objects
30. Importing Modules
30.1. imp — Access the import internals
30.2. importlib – Convenience wrappers for __import__()
30.3. imputil — Import utilities
30.4. zipimport — Import modules from Zip archives
30.5. pkgutil — Package extension utility
30.6. modulefinder — Find modules used by a script
30.7. runpy — Locating and executing Python modules
31. Python Language Services
31.1. parser — Access Python parse trees
31.2. ast — Abstract Syntax Trees
31.3. symtable — Access to the compiler’s symbol tables
31.4. symbol — Constants used with Python parse trees
31.5. token — Constants used with Python parse trees
31.6. keyword — Testing for Python keywords
31.7. tokenize — Tokenizer for Python source
31.8. tabnanny — Detection of ambiguous indentation
31.9. pyclbr — Python class browser support
31.10. py_compile — Compile Python source files
31.11. compileall — Byte-compile Python libraries
31.12. dis — Disassembler for Python bytecode
31.13. pickletools — Tools for pickle developers
32. Python compiler package
32.1. The basic interface
32.2. Limitations
32.3. Python Abstract Syntax
32.4. Using Visitors to Walk ASTs
32.5. Bytecode Generation
33. Miscellaneous Services
33.1. formatter — Generic output formatting
34. MS Windows Specific Services
34.1. msilib — Read and write Microsoft Installer files
34.2. msvcrt – Useful routines from the MS VC++ runtime
34.3. _winreg – Windows registry access
34.4. winsound — Sound-playing interface for Windows
35. Unix Specific Services
35.1. posix — The most common POSIX system calls
35.2. pwd — The password database
35.3. spwd — The shadow password database
35.4. grp — The group database
35.5. crypt — Function to check Unix passwords
35.6. dl — Call C functions in shared objects
35.7. termios — POSIX style tty control
35.8. tty — Terminal control functions
35.9. pty — Pseudo-terminal utilities
35.10. fcntl — The fcntl() and ioctl() system calls
35.11. pipes — Interface to shell pipelines
35.12. posixfile — File-like objects with locking support
35.13. resource — Resource usage information
35.14. nis — Interface to Sun’s NIS (Yellow Pages)
35.15. syslog — Unix syslog library routines
35.16. commands — Utilities for running commands
36. Mac OS X specific services
36.1. ic — Access to the Mac OS X Internet Config
36.2. MacOS — Access to Mac OS interpreter features
36.3. macostools — Convenience routines for file manipulation
36.4. findertools — The finder‘s Apple Events interface
36.5. EasyDialogs — Basic Macintosh dialogs
36.6. FrameWork — Interactive application framework
36.7. autoGIL — Global Interpreter Lock handling in event loops
36.8. Mac OS Toolbox Modules
36.9. ColorPicker — Color selection dialog
37. MacPython OSA Modules
37.1. gensuitemodule — Generate OSA stub packages
37.2. aetools — OSA client support
37.3. aepack — Conversion between Python variables and AppleEvent data containers
37.4. aetypes — AppleEvent objects
37.5. MiniAEFrame — Open Scripting Architecture server support
38. SGI IRIX Specific Services
38.1. al — Audio functions on the SGI
38.2. AL — Constants used with the al module
38.3. cd — CD-ROM access on SGI systems
38.4. fl — FORMS library for graphical user interfaces
38.5. FL — Constants used with the fl module
38.6. flp — Functions for loading stored FORMS designs
38.7. fm — Font Manager interface
38.8. gl — Graphics Library interface
38.9. DEVICE — Constants used with the gl module
38.10. GL — Constants used with the gl module
38.11. imgfile — Support for SGI imglib files
38.12. jpeg — Read and write JPEG files
39. SunOS Specific Services
39.1. sunaudiodev — Access to Sun audio hardware
39.2. SUNAUDIODEV — Constants used with sunaudiodev
40. Undocumented Modules
40.1. Miscellaneous useful utilities
40.2. Platform specific modules
40.3. Multimedia
40.4. Undocumented Mac OS modules
40.5. Obsolete
40.6. SGI-specific Extension modules
»
indexmodules |next |previous | Python » Documentation »
© Copyright 1990-2012, Python Software Foundation.
The Python Software Foundation is a non-profit corporation. Please donate.
Last updated on Dec 01, 2012. Found a bug?
Created using Sphinx 1.0.7.

22
Zim/Programme/python/The-Python-Standard-Library/1._Introduction.txt Normal file
View File

@@ -0,0 +1,22 @@
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2012-12-02T16:34:03+08:00
====== 1. Introduction ======
Created Sunday 02 December 2012
===== 1. Introduction =====
The “Python library” contains several different kinds of components.
It contains __data types__ that would normally be considered part of the “core” of a language, such as **numbers and lists**. For these types, the Python language core defines the form of **literals** and places some constraints on their semantics, but does **not fully define** the semantics. (On the other hand, the language core does define syntactic properties like the spelling and priorities of operators.)
The library also contains __built-in functions and exceptions__ — objects that can be used by all Python code //without the need of an import statement//. Some of these are defined by the core language, but many are not essential for the core semantics and are only described here.
The bulk of the __library__, however, consists of a collection of modules. There are many ways to dissect this collection. Some modules are written in C and __built in__** to the Python interpreter**; others are written in Python and imported in source form.
Some modules provide interfaces that are highly specific to Python, like printing a stack trace; some provide interfaces that are specific to particular operating systems, such as access to specific hardware; others provide interfaces that are specific to a particular application domain, like the World Wide Web. Some modules are available in all versions and ports of Python; others are only available when the underlying system supports or requires them; yet others are available only when a particular configuration option was chosen at the time when Python was compiled and installed.
This manual is organized **“from the inside out:”** it first describes the built-in data types, then the built-in functions and exceptions, and finally the modules, grouped in chapters of related modules. The ordering of the chapters as well as the ordering of the modules within each chapter is roughly from most relevant to least important.
Let the show begin!

892
Zim/Programme/python/The-Python-Standard-Library/2._Built-in_Functions.txt Normal file
View File

@@ -0,0 +1,892 @@
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2012-12-02T16:37:06+08:00
====== 2. Built-in Functions ======
Created Sunday 02 December 2012
The Python interpreter has a number of functions built into it that are __always available__. They are listed here in alphabetical order.
abs() divmod() input() open() staticmethod()
all() enumerate() int() ord() str()
any() eval() isinstance() pow() sum()
basestring() execfile() issubclass() print() super()
bin() file() iter() property() tuple()
bool() filter() len() range() type()
bytearray() float() list() raw_input() unichr()
callable() format() locals() reduce() unicode()
chr() frozenset() long() reload() vars()
classmethod() getattr() map() repr() xrange()
cmp() globals() max() reversed() zip()
compile() hasattr() memoryview() round() __import__()
complex() hash() min() set() apply()
delattr() help() next() setattr() buffer()
dict() hex() object() slice() coerce()
dir() id() oct() sorted() intern()
===== abs(x) =====
Return the absolute value of **a number**. The argument may be a plain or long integer or a floating point number. If the argument is a complex number, its magnitude is returned.
===== all(iterable) =====
Return True if **all elements** of the iterable are true (or if the iterable is empty). Equivalent to:
def all(iterable):
for element in iterable:
if not element:
return False
return True
New in version 2.5.
===== any(iterable) =====
Return True if **any element** of the iterable is true. If the iterable is empty, return False. Equivalent to:
def any(iterable):
for element in iterable:
if element:
return True
return False
New in version 2.5.
===== basestring() =====
__This abstract type is the superclass for str and unicode. It cannot be called or instantiated__, but it can be used to test whether an object is an instance of str or unicode. **isinstance(obj, basestring)** is equivalent to isinstance(obj, (str, unicode)).
basestring其实是一个抽象类，它是str和unicode的基类，不能被实例化。
New in version 2.3.
===== bin(x) =====
x需要为int或long类型，否则需要定义__index__()方法。
Convert an __integer number__ to a binary string. The result is a valid Python expression. If x is not a Python int object, it has to define an **__index__()** method that returns an integer.
=== 实例： ===
**>>> bin(123.22)**
**Traceback (most recent call last):**
** File "<stdin>", line 1, in <module>**
**TypeError: 'float' object cannot be interpreted as an index**
**>>>**
New in version 2.6.
===== bool([x]) =====
Convert a value to a Boolean, using the standard truth testing procedure. If x is false or omitted, this returns **False**; otherwise it returns True. __bool is also a class__, which is a subclass of int. Class bool cannot be subclassed further. Its only instances are False and True.
__False和True时class bool的实例。__
New in version 2.2.1.
Changed in version 2.3: If no argument is given, this function returns False.
===== bytearray([source[, encoding[, errors]]]) =====
Return a new array of bytes. The bytearray type __is a mutable sequence of integers in the range 0 <= x < 256__. It has most of the usual methods of mutable sequences, described in Mutable Sequence Types, as well as most methods that the str type has, see String Methods.
The optional source parameter can be used to initialize the array in a few different ways:
* If it is a **string**, you must also give the encoding (and optionally, errors) parameters; bytearray() then converts the string to bytes using str.encode().
* If it is an **integer**, __the array will have that size__ and will be initialized with null bytes.
* If it is an **object** conforming to the buffer interface, a read-only buffer of the object will be used to initialize the bytes array.
* If it is an **iterable**, it must be an iterable of integers in the range 0 <= x < 256, which are used as the initial contents of the array.
Without an argument, an array of **size 0** is created.
New in version 2.6.
===== callable(object) =====
Return True if the object argument appears callable, False if not. If this returns true, it is still possible that a call fails, but if it is false, calling object will never succeed. Note that **classes are callable** (calling a class returns a new instance); class instances are callable if they have a __call__() method.
===== chr(i) =====
Return **a string of one character** whose ASCII code is the integer i. For example, chr(97) returns the string 'a'. This is the inverse of **ord()**. The argument must be in the range [0..255], inclusive; ValueError will be raised if i is outside that range. See also unichr().
===== classmethod(function) =====
Return a class method for function.
A class method receives the class as __implicit first argument__, just like an instance method receives the instance. To declare a class method, use this idiom:
class C:
**@classmethod //不可少，否则调用时解释器不会自动将class传给f函数。**
def f(cls, arg1, arg2, ...): ...
The @classmethod form is a function **decorator** – see the description of function definitions in Function definitions for details.
It can be called either on the **class (such as C.f()) or on an instance (such as C().f())**. The instance is **ignored** except for its class. If a class method is called for a derived class, the derived **class object** is passed as the implied first argument.
__classmethod修饰器，用来修饰一个class method。可以通过class或实例来调用该class method，解释器会将class或instance所属的class默认传给class method。__
Class methods are different than C++ or Java static methods. If you want those, see **staticmethod()** in this section.
For more information on class methods, consult the documentation on the standard type hierarchy in The standard type hierarchy.
New in version 2.2.
Changed in version 2.4: Function decorator syntax added.
===== cmp(x, y) =====
Compare the two objects x and y and __return an integer__ according to the outcome. The return value is negative if x < y, zero if x == y and strictly positive if x > y.
===== compile(source, filename, mode[, flags[, dont_inherit]]) =====
Compile the source into **a code object or AST object**. Code objects can be executed by an __exec__ statement or evaluated by a call to __eval().__ source can either be a string or an AST object. Refer to the ast module documentation for information on how to work with AST objects.
The filename argument should give the file from which the code was read; pass some recognizable value if it wasn’t read from a file ('<string>' is commonly used).
The mode argument specifies **what kind of code** must be compiled; it can be __'exec'__ if source consists of a sequence of statements, __'eval'__ if it consists of a single expression, or __'single'__ if it consists of a single interactive statement (in the latter case, expression statements that evaluate to something other than None will be printed).
The optional arguments flags and dont_inherit control which future statements (see PEP 236) affect the compilation of source. If neither is present (or both are zero) the code is compiled with those future statements that are in effect in the code that is calling compile. If the flags argument is given and dont_inherit is not (or is zero) then the future statements specified by the flags argument are used in addition to those that would be used anyway. If dont_inherit is a non-zero integer then the flags argument is it – the future statements in effect around the call to compile are ignored.
Future statements are specified by bits which can be bitwise ORed together to specify multiple statements. The bitfield required to specify a given feature can be found as the compiler_flag attribute on the _Feature instance in the __future__ module.
This function raises SyntaxError if the compiled source is invalid, and TypeError if the source contains null bytes.
Note When compiling **a string with multi-line code** in 'single' or 'eval' mode, input must be terminated by at least one newline character. This is to facilitate detection of incomplete and complete statements in the code module.
Changed in version 2.3: The flags and dont_inherit arguments were added.
Changed in version 2.6: Support for compiling AST objects.
Changed in version 2.7: Allowed use of Windows and Mac newlines. Also input in 'exec' mode does not have to end in a newline anymore.
===== complex([real[, imag]]) =====
Create a complex number with the value real + imag*j or convert a string or number to a complex number. If the first parameter is a string, it will be interpreted as a complex number and the function must be called without a second parameter. The second parameter can never be a string. Each argument may be any numeric type (including complex). If imag is omitted, it defaults to zero and the function serves as a numeric conversion function like int(), long() and float(). If both arguments are omitted, returns 0j.
Note When converting from a string, the string must not contain whitespace around the central + or - operator. For example, complex('1+2j') is fine, but complex('1 + 2j') raises ValueError.
The complex type is described in Numeric Types — int, float, long, complex.
===== delattr(object, name) =====
This is a relative of setattr(). The arguments are an object and a string. The string must be the name of one of the object’s attributes. The function deletes the named attribute, provided the object allows it. For example, **delattr(x, 'foobar')** is equivalent to **del x.foobar**.
===== dict(**kwarg) =====
===== dict(mapping, **kwarg) =====
===== dict(iterable, **kwarg) =====
Create a new dictionary. The dict object is the dictionary class. See dict and Mapping Types — dict for documentation about this class.
For other containers see the built-in list, set, and tuple classes, as well as the collections module.
===== dir([object]) =====
Without arguments, return the list of names in the current local scope. With an argument, attempt to return a list of valid attributes for that object.
If the object has a method named __dir__(), this method will be called and must return the list of attributes. This allows objects that implement a custom __getattr__() or __getattribute__() function to customize the way dir() reports their attributes.
If the object does not provide __dir__(), the function tries its best to gather information from the object’s __dict__ attribute, if defined, and from its type object. The resulting list is not necessarily complete, and may be inaccurate when the object has a custom __getattr__().
The default dir() mechanism behaves differently with different types of objects, as it attempts to produce the most relevant, rather than complete, information:
* If the object is a module object, the list contains the names of the module’s attributes.
* If the object is a type or class object, the list contains the names of its attributes, and recursively of the attributes of its bases.
* Otherwise, the list contains the object’s attributes’ names, the names of its class’s attributes, and recursively of the attributes of its class’s base classes.
The resulting list is sorted alphabetically. For example:
>>>
>>> import struct
>>> dir() # show the names in the module namespace
['__builtins__', '__doc__', '__name__', 'struct']
>>> dir(struct) # show the names in the struct module
['Struct', '__builtins__', '__doc__', '__file__', '__name__',
'__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
'unpack', 'unpack_from']
>>> class Shape(object):
def __dir__(self):
return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'perimeter', 'location']
Note Because dir() is supplied primarily as a convenience for use at an interactive prompt, it tries to supply an interesting set of names more than it tries to supply a rigorously or consistently defined set of names, and its detailed behavior may change across releases. For example, metaclass attributes are not in the result list when the argument is a class.
===== divmod(a, b) =====
Take two (non complex) numbers as arguments and return a pair of numbers consisting of their quotient and remainder when using long division. With mixed operand types, the rules for binary arithmetic operators apply. For plain and long integers, the result is the same as (a // b, a % b). For floating point numbers the result is (q, a % b), where q is usually math.floor(a / b) but may be 1 less than that. In any case q * b + a % b is very close to a, if a % b is non-zero it has the same sign as b, and 0 <= abs(a % b) < abs(b).
Changed in version 2.3: Using divmod() with complex numbers is deprecated.
===== enumerate(sequence, start=0) =====
Return an enumerate object. sequence must be a sequence, an iterator, or some other object which supports iteration. The next() method of the iterator returned by enumerate() returns a tuple containing a count (from start which defaults to 0) and the values obtained from iterating over sequence:
>>>
>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
Equivalent to:
def enumerate(sequence, start=0):
n = start
for elem in sequence:
**yield n, elem**
n += 1
New in version 2.3.
Changed in version 2.6: The start parameter was added.
===== eval(expression[, globals[, locals]]) =====
The arguments are a string and optional globals and locals. If provided, globals must be a dictionary. If provided, locals can be any mapping object.
Changed in version 2.4: formerly locals was required to be a dictionary.
The expression argument is parsed and evaluated as a Python expression (technically speaking, a condition list) using the globals and locals dictionaries as global and local namespace. If the globals dictionary is present and lacks ‘__builtins__’, the current globals are copied into globals before expression is parsed. This means that expression normally has full access to the standard __builtin__ module and restricted environments are propagated. If the locals dictionary is omitted it defaults to the globals dictionary. If both dictionaries are omitted, the expression is executed in the environment where eval() is called. The return value is the result of the evaluated expression. Syntax errors are reported as exceptions. Example:
>>>
>>> x = 1
>>> print eval('x+1')
2
This function can also be used to execute arbitrary code objects (such as those created by compile()). In this case pass a code object instead of a string. If the code object has been compiled with 'exec' as the mode argument, eval()‘s return value will be None.
Hints: dynamic execution of statements is supported by the exec statement. Execution of statements from a file is supported by the execfile() function. The globals() and locals() functions returns the current global and local dictionary, respectively, which may be useful to pass around for use by eval() or execfile().
See ast.literal_eval() for a function that can safely evaluate strings with expressions containing only literals.
===== execfile(filename[, globals[, locals]]) =====
This function is similar to __the exec statement__, but parses a file instead of a string. It is different from the import statement in that it does not use the module administration — it reads the file unconditionally and does not create a new module. [1]
The arguments are a file name and two optional dictionaries. The file is parsed and evaluated as a sequence of Python statements (similarly to a module) using the globals and locals dictionaries as global and local namespace. If provided, locals can be any mapping object. Remember that **at module level, globals and locals are the same dictionary**. If two separate objects are passed as globals and locals, the code will be executed as if it were embedded in a class definition.
Changed in version 2.4: formerly locals was required to be a dictionary.
__If the locals dictionary is omitted it defaults to the globals dictionary. If both dictionaries are omitted, the expression is executed in the environment where execfile() is called.__ The return value is None.
Note The default locals act as described for function locals() below: modifications to the default locals dictionary should not be attempted. Pass an explicit locals dictionary if you need to see effects of the code on locals after function execfile() returns. execfile() cannot be used reliably to modify a function’s locals.
===== file(name[, mode[, buffering]]) =====
file其实时class file的构造函数。
Constructor function for the **file type**, described further in section File Objects. The constructor’s arguments are the same as those of the open() built-in function described below.
When opening a file, it’s preferable to use open() instead of invoking this constructor directly. file is more suited to type testing (for example, writing isinstance(f, file)).
New in version 2.2.
===== filter(function, iterable) =====
Construct a list from those elements of iterable __for which function returns true__. iterable may be either a sequence, a container which supports iteration, or an iterator.
**If iterable is a string or a tuple, the result also has that type; otherwise it is always a list.**
If function is None, the identity function is assumed, that is, all elements of iterable that are false are removed.
**如果可迭代对象是字符串或tuple，则结果也为字符串或tuple，其它的都为list。**
**如果function为None，则结果为iterable中去掉判断为False的元素。**
Note that **filter(function, iterable) is equivalent to [item for item in iterable if function(item)]** if function is not None and [item for item in iterable if item] if function is None.
See **itertools.ifilter() and itertools.ifilterfalse() f**or iterator versions of this function, including a variation that filters for elements where the function returns false.
===== float([x]) =====
Convert a string or a number to floating point.
If the argument is a string, it must contain a possibly signed decimal or floating point number, __possibly embedded in whitespace（空格, \t, \r, \n, \v, \f）__.
__如果x为string，则x只能为十进制整型和浮点型字符串（则是因为float函数不像int函数那样含有可选的base参数，__
__可以猜测或指定数字的进制类型），同时可以包含空字符。__The argument may also be **[+|-]nan or [+|-]inf**.
Otherwise, the argument may be **a plain** or long integer or a floating point number, and a floating point number with the same value (within Python’s floating point precision) is returned. If no argument is given, returns 0.0.
Note When passing in a string, values for **NaN** and **Infinity** may be returned, depending on the underlying C library. Float accepts the strings **nan, inf and -inf** for **NaN** and **positive or negative infinity**. The case and a leading + are ignored as well as a leading - is ignored for NaN. Float always represents NaN and infinity as nan, inf or -inf.
The float type is described in Numeric Types — int, float, long, complex.
>>> float(__0xff__)
255.0
>>> float(__'0xff'__)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for float(): 0xff
>>>
>>> float('__+inf'__)
inf
>>> float('+nan')
nan
>>>
>>> float(__'123'__)
123.0
>>> float(__'123\n\r\v'__)
123.0
>>>
>>> float(__+nan__)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name **'nan' is not defined**
>>>
===== format(value[, format_spec]) =====
Convert a value to a “formatted” representation, as controlled by **format_spec**. The interpretation of format_spec will depend on the type of the value argument, however there is a standard formatting syntax that is used by most built-in types: Format Specification Mini-Language.
Note format(value, format_spec) merely calls **value.__format__(format_spec)**.
New in version 2.6.
===== frozenset([iterable]) =====
Return a new frozenset object, optionally with elements taken from iterable. frozenset is a built-in class. See frozenset and Set Types — set, frozenset for documentation about this class.
For other containers see the built-in set, list, tuple, and dict classes, as well as the __collections__ module.
New in version 2.4.
===== getattr(object, name[, default]) =====
Return the value of the named attribute of object. **name must be a string**. If the string is the name of one of the object’s attributes, the result is the value of that attribute. For example, getattr(x, 'foobar') is equivalent to x.foobar. If the named attribute does not exist, default is returned if provided, otherwise AttributeError is raised.
===== globals() =====
Return a dictionary representing __the current global symbol table__. This is always the dictionary of the current module (inside a function or method, this is the module where it is **defined**, not the module from which it is called).
===== hasattr(object, name) =====
The arguments are an object and a string. The result is True if the string is the name of one of the object’s attributes, False if not. (This is implemented by calling getattr(object, name) and seeing whether it raises an exception or not.)
===== hash(object) =====
Return the hash value of the object (if it has one). **Hash values are integers**. They are used to quickly compare dictionary keys during a dictionary lookup. Numeric values that compare equal have the same hash value (even if they are of different types, as is the case for 1 and 1.0).
===== help([object]) =====
Invoke the built-in help system. (This function is intended for interactive use.) If no argument is given, the interactive help system starts on the interpreter console. If the argument is a string, then the string is looked up as the name of a module, function, class, method, keyword, or documentation topic, and a help page is printed on the console. If the argument is any other kind of object, a help page on the object is generated.
This function is added to the built-in namespace by the site module.
New in version 2.2.
===== hex(x) =====
Convert an integer number (of any size) to a hexadecimal string. The result is a valid Python expression.
Note To obtain a hexadecimal string representation for a float, use the __float.hex()__ method.
Changed in version 2.4: Formerly only returned an unsigned literal.
===== id(object) =====
Return the “identity” of an object. This is an integer (or long integer) which is guaranteed to be unique and constant for this object during its lifetime. Two objects with non-overlapping lifetimes may have the same id() value.
CPython implementation detail: This is **the address of the object in memory**.
===== input([prompt]) =====
Equivalent to **eval(raw_input(prompt))**.
This function does not catch user errors. If the input is not syntactically valid, a SyntaxError will be raised. Other exceptions may be raised if there is an error during evaluation.
If the __readline__ module was loaded, then input() will use it to provide elaborate line editing and history features.
Consider using the **raw_input()** function for general input from users.
===== int(x=0) =====
===== int(x, base=10) =====
Convert a number or string x to an integer, or return 0 if no arguments are given. If x is a number, it can be a plain integer, a long integer, or a floating point number. If x is floating point, the conversion __truncates towards zero__. If the argument is outside the integer range, the function returns a long object instead.
__如果x为number，则不需要为其指定base参数，因为int函数会根据x的前缀如0b, 0x等正确判断。如果x为float number则其必须为十进制。__
If x is not a number or if base is given, then x must be a string or Unicode object __representing an integer literal in radix base__.
__如果x为string，则其必须为整型数字字符串，不能为各种进制的小数字符串。__
Optionally, the literal can be preceded by + or - (with no space in between) and __surrounded by whitespace__. A base-n literal consists of the digits 0 to n-1, with **a to z (or A to Z)** having values __10 to 35__. The default base is 10. The allowed values are 0 and 2-36.
Base-2, -8, and -16 literals can be optionally **prefixed with 0b/0B, 0o/0O/0, or 0x/0X**, as with integer literals in code. __Base 0__ means to interpret the string exactly as an integer literal, so that the actual base is 2, 8, 10, or 16.
The integer type is described in Numeric Types — int, float, long, complex.
>>> int("0xfff") **//默认为Base 10, 所以解码错误。**
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with __base 10__: '0xfff'
>>> int("0xfff", 16)
4095
>>> int(0xfff.ff) __//如果x为float number，则其必须为十进制。__
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute 'ff'
>>> int(111.22)
111
>>> int(0b111.11)
File "<stdin>", line 1
int(0b111.11)
^
SyntaxError: invalid syntax
>>>
>>> int("**0xfff.ff"**, 16)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 16: '0xfff.ff'
>>>
>>> int('22.33') __//如果x为string，则必须为整型数字字符串。__
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '22.33'
===== isinstance(object, classinfo) =====
Return true if the object argument is an instance of the classinfo argument, or of a (direct, indirect or virtual) subclass thereof. Also return true if classinfo is a type object (new-style class) and object is an object of that type or of a (direct, indirect or virtual) subclass thereof. If object is not a class instance or an object of the given type, the function always returns false. If classinfo is neither a class object nor a type object, it may be a tuple of class or type objects, or may recursively contain other such tuples (other sequence types are not accepted). If classinfo is not a class, type, or tuple of classes, types, and such tuples, a TypeError exception is raised.
Changed in version 2.2: Support for a tuple of type information was added.
===== issubclass(class, classinfo) =====
Return true if class is a subclass (direct, indirect or virtual) of classinfo. A class is considered a subclass of itself. classinfo may be a tuple of class objects, in which case every entry in classinfo will be checked. In any other case, a TypeError exception is raised.
Changed in version 2.3: Support for a tuple of type information was added.
===== iter(o[, sentinel]) =====
Return an iterator object. The first argument is interpreted very differently depending on the presence of the second argument. Without a second argument, o must be __a collection object__ which supports th**e iteration protocol** (the __iter__() method), or it must support **the sequence protocol** (the __getitem__() method with integer arguments starting at 0). If it does not support either of those protocols, TypeError is raised. If the second argument, sentinel, is given, then o must be __a callable object__. The iterator created in this case will **call o with no arguments for each call** to its next() method; if the value returned is __equal to sentinel__, StopIteration will be raised, otherwise the value will be returned.
如果没有使用第二个参数，则o必须为容器对象。否则，o必须为可调用对象。
One useful application of the second form of iter() is to read lines of a file until a certain line is reached. The following example reads a file until the readline() method returns an empty string:
with open('mydata.txt') as fp:
for line in iter(fp.readline, ''):
process_line(line)
New in version 2.2.
===== len(s) =====
Return the length (the number of items) of an object. The argument may be a sequence (string, tuple or list) or a mapping (dictionary).
===== list([iterable]) =====
Return a list whose items are the same and in the same order as iterable‘s items. iterable may be either a sequence, a container that supports iteration, or an iterator object. If iterable is already a list, **a copy is made** and returned, similar to iterable[:]. For instance, list('abc') returns ['a', 'b', 'c'] and list( (1, 2, 3) ) returns [1, 2, 3]. If no argument is given, returns a new empty list, [].
list is a mutable sequence type, as documented in Sequence Types — str, unicode, list, tuple, bytearray, buffer, xrange. For other containers see the built in dict, set, and tuple classes, and the collections module.
===== locals() =====
Update and return a dictionary representing the **current local symbol table**. Free variables are returned by locals() when it is called in function blocks, but not in class blocks.
Note The contents of this dictionary should not be modified; changes may not affect the values of local and free variables used by the interpreter.
===== long(x=0) =====
===== long(x, base=10) =====
Convert a string or number to a long integer. If the argument is a string, it must contain a possibly signed number of arbitrary size, possibly embedded in whitespace. The base argument is interpreted in the same way as for int(), and may only be given when x is a string. Otherwise, the argument may be a plain or long integer or a floating point number, and a long integer with the same value is returned. Conversion of floating point numbers to integers truncates (towards zero). If no arguments are given, returns 0L.
The long type is described in Numeric Types — int, float, long, complex.
===== map(function, iterable, ...) =====
Apply function to **every item of iterable** and return a list of the results. If additional iterable arguments are passed, function must take that many arguments and is applied to the items from all iterables in parallel. If one iterable is shorter than another it is assumed to be __extended with None items__. If function is None, the identity function is assumed; if there are multiple arguments, map() returns a list consisting of tuples containing the corresponding items from all iterables (a kind of transpose operation). The iterable arguments may be a sequence or any iterable object; the result is __always a list__.
===== max(iterable[, key]) =====
===== max(arg1, arg2, *args[, key]) =====
Return the largest item in an iterable or the largest of two or more arguments.
If one positional argument is provided, iterable must be a non-empty iterable (such as a non-empty string, tuple or list). The largest item in the iterable is returned. If two or more positional arguments are provided, the largest of the positional arguments is returned.
The optional key argument specifies **a one-argument ordering function** like that used for list.sort(). The key argument, if supplied, must be __in keyword form__ (for example, max(a,b,c,key=func)).
Changed in version 2.5: Added support for the optional key argument.
===== memoryview(obj) =====
Return a “memory view” object created from the given argument. See memoryview type for more information.
===== min(iterable[, key]) =====
===== min(arg1, arg2, *args[, key]) =====
Return the smallest item in an iterable or the smallest of two or more arguments.
If one positional argument is provided, iterable must be a non-empty iterable (such as a non-empty string, tuple or list). The smallest item in the iterable is returned. If two or more positional arguments are provided, the smallest of the positional arguments is returned.
The optional key argument specifies a one-argument ordering function like that used for list.sort(). The key argument, if supplied, __must be in keyword form (__for example, min(a,b,c,key=func)).
Changed in version 2.5: Added support for the optional key argument.
===== next(iterator[, default]) =====
Retrieve the next item from the iterator by calling its next() method. If default is given, it is returned if the iterator is exhausted, otherwise StopIteration is raised.
New in version 2.6.
===== object() =====
Return a new featureless object. object is a base for all new style classes. It has the methods that are common to all instances of new style classes.
New in version 2.2.
Changed in version 2.3: This function does not accept any arguments. Formerly, it accepted arguments but ignored them.
===== oct(x) =====
Convert an integer number (of any size) to an octal string. The result is a valid Python expression.
Changed in version 2.4: Formerly only returned an unsigned literal.
===== open(name[, mode[, buffering]]) =====
Open a file, returning an object of the **file type** described in section File Objects. If the file cannot be opened, __IOError__ is raised. When opening a file, it’s preferable to use open() instead of invoking the file constructor directly.
The first two arguments are the same as for stdio‘s fopen(): name is the file name to be opened, and mode is a string indicating how the file is to be opened.
The most commonly-used values of mode are __'r'__ for reading, __'w'__ for writing (**truncating the file** if it already exists), and __'a'__ for appending (which on some Unix systems means that all writes append to the end of the file regardless of the current seek position). If mode is omitted, __it defaults to 'r'__. The default is to use __text mode__, which may convert '\n' characters to a platform-specific representation on writing and back on reading. Thus, when opening a binary file, you should append __'b'__ to the mode value to open the file in binary mode, which will improve portability. (Appending 'b' is useful even on systems that don’t treat binary and text files differently, where it serves as documentation.) See below for more possible values of mode.
The optional buffering argument specifies the file’s desired buffer size: __0 means unbuffered, 1 means line buffered, any other positive value means use a buffer of (approximately) that size.__ A negative buffering means to use **the system default**, which is usually line buffered for tty devices and fully buffered for other files. If omitted, the system default is used. [2]
Modes **'r+', 'w+' and 'a+'** open the file for updating (note that __'w+' truncates the file__). Append 'b' to the mode to open the file in binary mode, on systems that differentiate between binary and text files; on systems that don’t have this distinction, adding the 'b' has no effect.
In addition to the standard **fopen()** values mode may be 'U' or 'rU'. Python is usually built with universal newlines support; supplying 'U' opens the file as a text file, but lines may be terminated by any of the following: the Unix end-of-line convention '\n', the Macintosh convention '\r', or the Windows convention '\r\n'. All of these external representations are seen as '\n' by the Python program. If Python is built without universal newlines support a mode with 'U' is the same as normal text mode. Note that file objects so opened also have an attribute called newlines which has a value of None (if no newlines have yet been seen), '\n', '\r', '\r\n', or a tuple containing all the newline types seen.
Python enforces that the mode, after stripping 'U', begins with 'r', 'w' or 'a'.
Python provides many file handling modules including __fileinput, os, os.path, tempfile, and shutil__.
Changed in version 2.5: Restriction on first letter of mode string introduced.
===== ord(c) =====
Given a string of length one, return an integer representing the Unicode code point of the character when the argument is a unicode object, or the value of the byte when the argument is an 8-bit string. For example, ord('a') returns the integer 97, ord(u'\u2020') returns 8224. This is the inverse of chr() for 8-bit strings and of unichr() for unicode objects. If a unicode argument is given and Python was built with UCS2 Unicode, then the character’s code point must be in the range [0..65535] inclusive; otherwise the string length is two, and a TypeError will be raised.
===== pow(x, y[, z]) =====
Return x to the power y; if z is present, return **x to the power y, modulo z** (computed more efficiently than pow(x, y) % z). The two-argument form pow(x, y) is equivalent to using the power operator: **x**y**.
The arguments must have numeric types. With mixed operand types, the coercion rules for binary arithmetic operators apply. For int and long int operands, the result has the same type as the operands (after coercion) unless the second argument is negative; in that case, all arguments are converted to float and a float result is delivered. For example, 10**2 returns 100, but 10**-2 returns 0.01. (This last feature was added in Python 2.2. In Python 2.1 and before, if both arguments were of integer types and the second argument was negative, an exception was raised.) If the second argument is negative, the third argument must be omitted. If z is present, x and y must be of integer types, and y must be non-negative. (This restriction was added in Python 2.2. In Python 2.1 and before, floating 3-argument pow() returned platform-dependent results depending on floating-point rounding accidents.)
===== print(*objects, sep=' ', end='\n', file=sys.stdout) =====
Print objects to the stream file, separated by sep and followed by end. sep, end and file, if present, must be given as keyword arguments.
All non-keyword arguments are converted to strings like **str()** does and written to the stream, separated by sep and followed by end. Both sep and end must be strings; they can also be None, which means to use the default values. If no objects are given, print() will just write end.
The file argument must be an object with a write(string) method; if it is not present or None, sys.stdout will be used. Output buffering is determined by file. Use **file.flush()** to ensure, for instance, immediate appearance on a screen.
Note This function is **not normally available as a built-in** since the name print is recognized as the **print statement**.
该函数一般不能直接使用，因为pythn2中的print是一个statement。
To disable the statement and use the print() function, use this future statement at the top of your module:
__from __future__ import print_function__
New in version 2.6.
===== property([fget[, fset[, fdel[, doc]]]]) =====
Return a property attribute for new-style classes (classes that derive from object).
fget is a function for getting an attribute value, likewise fset is a function for setting, and fdel a function for del’ing, an attribute. Typical use is to define a managed attribute x:
class C(object):
def __init__(self):
self._x = None
def getx(self):
return self._x
def setx(self, value):
self._x = value
def delx(self):
del self._x
__x = property(getx, setx, delx, "I'm the 'x' property.")__
If then c is an instance of C, **c.x will invoke the getter, c.x = value will invoke the setter and del c.x the deleter**.
If given, doc will be the docstring of the property attribute（例如上面的最后一行字符串）. Otherwise, the property will copy fget‘s docstring (if it exists). This makes it possible to create **read-only properties** easily using property() as a decorator:
class Parrot(object):
def __init__(self):
self._voltage = 100000
__@property //生成一个read-only properity。__
def voltage(self):
"""Get the current voltage."""
return self._voltage
turns the voltage() method into a “getter” for a read-only attribute with the same name.
A property object has __getter, setter, and deleter__ methods usable as decorators that create a copy of the property with the corresponding accessor function set to the decorated function. This is best explained with an example:
class C(object):
def __init__(self):
self._x = None
@property //property装饰器使修饰的函数x变为property object，默认生成一个read-only properity。
def x(self):
"""I'm the 'x' property."""
return self._x
__@x__.setter //调用property object的setter方法。
__def x__(self, value):
self._x = value
@x.deleter
def x(self): //注意没有参数，x就暗示了属性的类型。
del self._x
This code is exactly equivalent to the first example. Be sure to give the additional functions **the same name as the original** property (x in this case.)
The returned property also has the attributes fget, fset, and fdel corresponding to the constructor arguments.
New in version 2.2.
Changed in version 2.5: Use fget‘s docstring if no doc given.
Changed in version 2.6: The getter, setter, and deleter attributes were added.
===== range(stop) =====
===== range(start, stop[, step]) =====
This is a versatile function to create lists containing arithmetic progressions. It is most often used in __for loops__. The arguments must be plain integers. If the step argument is omitted, it defaults to 1. If the start argument is omitted, it defaults to 0. The full form returns a list of plain integers [start, start + step, start + 2 * step, ...]. If step is positive, the last element is the largest start + i * step less than stop; if step is negative, the last element is the smallest start + i * step greater than stop. step must not be zero (or else ValueError is raised). Example:
>>>
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> range(0, -10, -1)
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]
===== raw_input([prompt]) =====
If the prompt argument is present, it is written to standard output __without a trailing newline__. The function then reads a line from input, __converts it to a string (stripping a trailing newline)__, and returns that. When EOF is read, EOFError is raised. Example:
>>>
>>> s = raw_input('--> ')
--> Monty Python's Flying Circus
>>> s
"Monty Python's Flying Circus"
If the readline module was loaded, then raw_input() will use it to provide elaborate line editing and history features.
===== reduce(function, iterable[, initializer]) =====
Apply function of __two arguments__ cumulatively to the items of iterable, from left to right, so as to reduce the iterable to a single value. For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates ((((1+2)+3)+4)+5). **The left argument, x, is the **__accumulated value__** and the right argument, y, is the update value from the iterable**. If the optional initializer is present, it is placed before the items of the iterable in the calculation, and serves as a default when the iterable is empty. If initializer is not given and iterable contains only one item, the first item is returned. Roughly equivalent to:
def reduce(function, iterable, initializer=None):
it = iter(iterable)
if initializer is None:
try:
initializer = next(it)
except StopIteration:
raise TypeError('reduce() of empty sequence with no initial value')
**accum_value** = initializer
for x in it:
accum_value = function(accum_value, x)
return accum_value
===== reload(module) =====
Reload a previously imported module. The argument must be **a module object**, so it must have been successfully imported before. This is useful if you have **edited the module source file** using an external editor and want to try out the new version without leaving the Python interpreter. The return value is the module object (the same as the module argument).
When reload(module) is executed:
Python modules’ code is recompiled and the module-level code reexecuted, defining a new set of objects which are bound to names in the module’s dictionary. The init function of extension modules is not called a second time.
As with all other objects in Python the old objects are only reclaimed after their reference counts drop to zero.
The names in the module namespace are updated to point to any new or changed objects.
Other references to the old objects (such as names external to the module) are not rebound to refer to the new objects and must be updated in each namespace where they occur if that is desired.
There are a number of other caveats:
If a module is syntactically correct but its initialization fails, the first import statement for it does not bind its name locally, but does store a (partially initialized) module object in sys.modules. To reload the module you must first import it again (this will bind the name to the partially initialized module object) before you can reload() it.
When a module is reloaded, its dictionary (containing the module’s global variables) is retained. Redefinitions of names will override the old definitions, so this is generally not a problem. If the new version of a module does not define a name that was defined by the old version, the old definition remains. This feature can be used to the module’s advantage if it maintains a global table or cache of objects — with a try statement it can test for the table’s presence and skip its initialization if desired:
try:
cache
except NameError:
cache = {}
It is legal though generally not very useful to reload built-in or dynamically loaded modules, except for sys, __main__ and __builtin__. In many cases, however, extension modules are not designed to be initialized more than once, and may fail in arbitrary ways when reloaded.
If a module imports objects from another module using from ... import ..., calling reload() for the other module does not redefine the objects imported from it — one way around this is to re-execute the from statement, another is to use import and qualified names (module.*name*) instead.
If a module instantiates instances of a class, reloading the module that defines the class does not affect the method definitions of the instances — they continue to use the old class definition. The same is true for derived classes.
===== repr(object) =====
Return a string containing **a printable representation of an object**. This is the same value yielded by conversions (reverse quotes). It is sometimes useful to be able to access this operation as an ordinary function. For many types, this function makes an attempt to return a string that would yield an object with the same value when passed to eval(), otherwise the representation is a string enclosed in angle brackets that contains the name of the type of the object together with additional information often including the name and address of the object. A class can control what this function returns for its instances by defining a __repr__() method.
===== reversed(seq) =====
__Return a reverse iterator.__ seq must be an object which has a __reversed__() method or supports **the sequence protocol** (the __len__() method and the __getitem__() method with integer arguments starting at 0).
New in version 2.4.
Changed in version 2.6: Added the possibility to write a custom __reversed__() method.
===== round(number[, ndigits]) =====
Return the floating point value number rounded to **ndigits digits after the decimal point.** If ndigits is omitted, it defaults to zero. The result is a floating point number. Values are rounded to the closest multiple of 10 to the power minus ndigits; if two multiples are equally close, rounding is done away from 0 (so. for example, round(0.5) is 1.0 and round(-0.5) is -1.0).
Note The behavior of round() for floats can be surprising: for example, round(2.675, 2) gives 2.67 instead of the expected 2.68. This is not a bug: it’s a result of the fact that most decimal fractions can’t be represented exactly as a float. See Floating Point Arithmetic: Issues and Limitations for more information.
===== set([iterable]) =====
Return a new set object, optionally with elements taken from iterable. set is a built-in class. See set and Set Types — set, frozenset for documentation about this class.
For other containers see the built-in frozenset, list, tuple, and dict classes, as well as the collections module.
New in version 2.4.
===== setattr(object, name, value) =====
This is the counterpart of getattr(). The arguments are an object, a string and an arbitrary value. The string may name an existing attribute or a new attribute. The function assigns the value to the attribute, provided the object allows it. For example, setattr(x, 'foobar', 123) is equivalent to x.foobar = 123.
===== slice(stop) =====
===== slice(start, stop[, step]) =====
Return a slice object representing the set of indices specified by **range(start, stop, step)**. The start and step arguments default to None. Slice objects have read-only data attributes start, stop and step which merely return the argument values (or their default). They have no other explicit functionality; however they are used by Numerical Python and other third party extensions. Slice objects are also generated when extended indexing syntax is used. For example: a[start:stop:step] or a[start:stop, i]. See itertools.islice() for an alternate version that returns an iterator.
===== sorted(iterable[, cmp[, key[, reverse]]]) =====
Return __a new sorted list__ from the items in iterable.
The optional arguments **cmp, key, and reverse** have the same meaning as those for the list.sort() method (described in section Mutable Sequence Types).
cmp specifies __a custom comparison function of two arguments__ (iterable elements) which should __return a negative, zero or positive number__ depending on whether the first argument is considered smaller than, equal to, or larger than the second argument: cmp=lambda x,y: cmp(x.lower(), y.lower()). The default value is None.
key specifies a function of one argument that is used to **extract a comparison key from each list element**: key=str.lower. The default value is None (compare the elements directly).
reverse is a boolean value. If set to True, then the list elements are sorted as if each comparison were reversed.
In general, the key and reverse conversion processes are much faster than specifying an equivalent cmp function. This is because cmp is called multiple times for each list element while key and reverse touch each element only once. Use **functools.cmp_to_key()** to convert an old-style cmp function to a key function.
For sorting examples and a brief sorting tutorial, see Sorting HowTo.
New in version 2.4.
===== staticmethod(function) =====
Return a static method for function.
A static method does not receive an implicit first argument. To declare a static method, use this idiom:
class C:
@staticmethod
def f(arg1, arg2, ...): ...
The @staticmethod form is a function decorator – see the description of function definitions in Function definitions for details.
It can be called either on the class (such as C.f()) or on an instance (such as C().f()). The instance is ignored except for its class.
Static methods in Python are similar to those found in Java or C++. Also see classmethod() for a variant that is useful for creating alternate class constructors.
For more information on static methods, consult the documentation on the standard type hierarchy in The standard type hierarchy.
New in version 2.2.
Changed in version 2.4: Function decorator syntax added.
===== str(object='') =====
Return a string containing a nicely printable representation of an object. For strings, this returns the string itself. The difference with repr(object) is that str(object) does not always attempt to return a string that is acceptable to eval(); its goal is to return a printable string. If no argument is given, returns the empty string, ''.
For more information on strings see Sequence Types — str, unicode, list, tuple, bytearray, buffer, xrange which describes sequence functionality (strings are sequences), and also the string-specific methods described in the String Methods section. To output formatted strings use template strings or the % operator described in the String Formatting Operations section. In addition see the String Services section. See also unicode().
===== sum(iterable[, start]) =====
Sums start and the items of an iterable from left to right and returns the total. start defaults to 0. The iterable‘s items are normally numbers, and the start value is not allowed to be a string.
For some use cases, there are good alternatives to sum(). The preferred, fast way to concatenate a sequence of strings is by calling __''.join(sequence)__. To add floating point values with extended precision, see math.fsum(). To concatenate a series of iterables, consider using itertools.chain().
New in version 2.3.
===== super(type[, object-or-type]) =====
Return a proxy object that delegates method calls to a parent or sibling class of type. This is useful for accessing inherited methods that have been overridden in a class. The search order is same as that used by getattr() except that the type itself is skipped.
The ____mro____ attribute of the type lists **the method resolution search order** used by both getattr() and super(). The attribute is dynamic and can change whenever the inheritance hierarchy is updated.
If the second argument is omitted, the super object returned is unbound. If the second argument is an object, isinstance(obj, type) must be true. If the second argument is a type, issubclass(type2, type) must be true (this is useful for classmethods).
Note super() only works for new-style classes.
There are two typical use cases for super. In a class hierarchy with single inheritance, **super can be used to refer to parent classes **__without naming them explicitly__, thus making the code more maintainable. This use closely parallels the use of super in other programming languages.
The second use case is to support __cooperative multiple inheritance in a dynamic execution environment__. This use case is unique to Python and is not found in statically compiled languages or languages that only support single inheritance. This makes it possible to implement “diamond diagrams” where multiple base classes implement the same method. Good design dictates that this method have the same calling signature in every case (because the order of calls is determined at runtime, because that order adapts to changes in the class hierarchy, and because that order can include sibling classes that are unknown prior to runtime).
For both use cases, a typical superclass call looks like this:
class C(B):
def method(self, arg):
super(C, self).method(arg)
Note that super() is implemented as part of the binding process for explicit dotted attribute lookups such as super().__getitem__(name). It does so by implementing its own __getattribute__() method for searching classes in a predictable order that supports cooperative multiple inheritance. Accordingly, super() is undefined for implicit lookups using statements or operators such as super()[name].
Also note that super() is not limited to use inside methods. The two argument form specifies the arguments exactly and makes the appropriate references.
For practical suggestions on how to design cooperative classes using super(), see guide to using super().
New in version 2.2.
===== tuple([iterable]) =====
Return a tuple whose items are the same and in the same order as iterable‘s items. iterable may be a sequence, a container that supports iteration, or an iterator object. If iterable is already a tuple, it is returned unchanged. For instance, tuple('abc') returns ('a', 'b', 'c') and tuple([1, 2, 3]) returns (1, 2, 3). If no argument is given, returns a new empty tuple, ().
tuple is an immutable sequence type, as documented in Sequence Types — str, unicode, list, tuple, bytearray, buffer, xrange. For other containers see the built in dict, list, and set classes, and the collections module.
===== type(object) =====
===== type(name, bases, dict) =====
With one argument, return the type of an object. The return value is a type object. The isinstance() built-in function is recommended for testing the type of an object.
With three arguments, return a new type object. This is essentially a dynamic form of the class statement. The name string is the class name and becomes the __name__ attribute; the bases tuple itemizes the base classes and becomes the __bases__ attribute; and the dict dictionary is the namespace containing definitions for class body and becomes the __dict__ attribute. For example, the following two statements create identical type objects:
>>>
>>> class X(object):
... a = 1
...
>>> X = type('X', (object,), dict(a=1))
New in version 2.2.
===== unichr(i) =====
Return the Unicode string of one character whose Unicode code is the integer i. For example, unichr(97) returns the string u'a'. This is the inverse of ord() for Unicode strings. The valid range for the argument depends how Python was configured – it may be either UCS2 [0..0xFFFF] or UCS4 [0..0x10FFFF]. ValueError is raised otherwise. For ASCII and 8-bit strings see chr().
New in version 2.0.
===== unicode(object='') =====
===== unicode(object[, encoding[, errors]]) =====
Return the Unicode string version of object using one of the following modes:
If encoding and/or errors are given, unicode() will decode the object which can either be an 8-bit string or a character buffer using the codec for encoding. The encoding parameter is a string giving the name of an encoding; if the encoding is not known, LookupError is raised. Error handling is done according to errors; this specifies the treatment of characters which are invalid in the input encoding. If errors is 'strict' (the default), a ValueError is raised on errors, while a value of 'ignore' causes errors to be silently ignored, and a value of 'replace' causes the official Unicode replacement character, U+FFFD, to be used to replace input characters which cannot be decoded. See also the codecs module.
If no optional parameters are given, unicode() will mimic the behaviour of str() except that it returns Unicode strings instead of 8-bit strings. More precisely, if object is a Unicode string or subclass it will return that Unicode string without any additional decoding applied.
For objects which provide a __unicode__() method, it will call this method without arguments to create a Unicode string. For all other objects, the 8-bit string version or representation is requested and then converted to a Unicode string using the codec for the default encoding in 'strict' mode.
For more information on Unicode strings see Sequence Types — str, unicode, list, tuple, bytearray, buffer, xrange which describes sequence functionality (Unicode strings are sequences), and also the string-specific methods described in the String Methods section. To output formatted strings use template strings or the % operator described in the String Formatting Operations section. In addition see the String Services section. See also str().
New in version 2.0.
Changed in version 2.2: Support for __unicode__() added.
===== vars([object]) =====
Return the __dict__ attribute for a module, class, instance, or any other object with a __dict__ attribute.
Objects such as modules and instances have an updateable __dict__ attribute; however, other objects may have write restrictions on their __dict__ attributes (for example, new-style classes use a dictproxy to prevent direct dictionary updates).
Without an argument, vars() acts like locals(). Note, the locals dictionary is only useful for reads since updates to the locals dictionary are ignored.
===== xrange(stop) =====
===== xrange(start, stop[, step]) =====
This function is very similar to range(), but returns an xrange object instead of a list. This is an opaque sequence type which yields the same values as the corresponding list, without actually storing them all simultaneously. The advantage of xrange() over range() is minimal (since xrange() still has to create the values when asked for them) except when a very large range is used on a memory-starved machine or when all of the range’s elements are never used (such as when the loop is usually terminated with break). For more information on xrange objects, see XRange Type and Sequence Types — str, unicode, list, tuple, bytearray, buffer, xrange.
CPython implementation detail: xrange() is intended to be simple and fast. Implementations may impose restrictions to achieve this. The C implementation of Python restricts all arguments to native C longs (“short” Python integers), and also requires that the number of elements fit in a native C long. If a larger range is needed, an alternate version can be crafted using the itertools module: islice(count(start, step), (stop-start+step-1+2*(step<0))//step).
===== zip([iterable, ...]) =====
This function returns a list of tuples, where the i-th tuple contains the i-th element from each of the argument sequences or iterables. The returned list is truncated in length to the length of the shortest argument sequence. When there are multiple arguments which are all of the same length, zip() is similar to map() with an initial argument of None. With a single sequence argument, it returns a list of 1-tuples. With no arguments, it returns an empty list.
The left-to-right evaluation order of the iterables is guaranteed. This makes possible an idiom for clustering a data series into n-length groups using zip(*[iter(s)]*n).
zip() in conjunction with the * operator can be used to unzip a list:
>>>
>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> zipped
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zipped)
>>> x == list(x2) and y == list(y2)
True
New in version 2.0.
Changed in version 2.4: Formerly, zip() required at least one argument and zip() raised a TypeError instead of returning an empty list.
===== __import__(name[, globals[, locals[, fromlist[, level]]]]) =====
Note This is an advanced function that is not needed in everyday Python programming, unlike importlib.import_module().
This function is invoked by the import statement. It can be replaced (by importing the __builtin__ module and assigning to __builtin__.__import__) in order to change semantics of the import statement, but nowadays it is usually simpler to use import hooks (see PEP 302). Direct use of __import__() is rare, except in cases where you want to import a module whose name is only known at runtime.
The function imports the module name, potentially using the given globals and locals to determine how to interpret the name in a package context. The fromlist gives the names of objects or submodules that should be imported from the module given by name. The standard implementation does not use its locals argument at all, and uses its globals only to determine the package context of the import statement.
level specifies whether to use absolute or relative imports. The default is -1 which indicates both absolute and relative imports will be attempted. 0 means only perform absolute imports. Positive values for level indicate the number of parent directories to search relative to the directory of the module calling __import__().
When the name variable is of the form package.module, normally, the top-level package (the name up till the first dot) is returned, not the module named by name. However, when a non-empty fromlist argument is given, the module named by name is returned.
For example, the statement import spam results in bytecode resembling the following code:
spam = __import__('spam', globals(), locals(), [], -1)
The statement import spam.ham results in this call:
spam = __import__('spam.ham', globals(), locals(), [], -1)
Note how __import__() returns the toplevel module here because this is the object that is bound to a name by the import statement.
On the other hand, the statement from spam.ham import eggs, sausage as saus results in
_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], -1)
eggs = _temp.eggs
saus = _temp.sausage
Here, the spam.ham module is returned from __import__(). From this object, the names to import are retrieved and assigned to their respective names.
If you simply want to import a module (potentially within a package) by name, use importlib.import_module().
Changed in version 2.5: The level parameter was added.
Changed in version 2.5: Keyword support for parameters was added.
===== 3. Non-essential Built-in Functions =====
There are several built-in functions that are no longer essential to learn, know or use in modern Python programming. They have been kept here to maintain backwards compatibility with programs written for older versions of Python.
Python programmers, trainers, students and book writers should feel free to bypass these functions without concerns about missing something important.
apply(function, args[, keywords])
The function argument must be a callable object (a user-defined or built-in function or method, or a class object) and the args argument must be a sequence. The function is called with args as the argument list; the number of arguments is the length of the tuple. If the optional keywords argument is present, it must be a dictionary whose keys are strings. It specifies keyword arguments to be added to the end of the argument list. Calling apply() is different from just calling function(args), since in that case there is always exactly one argument. The use of apply() is equivalent to function(*args, **keywords).
Deprecated since version 2.3: Use function(*args, **keywords) instead of apply(function, args, keywords) (see Unpacking Argument Lists).
buffer(object[, offset[, size]])
The object argument must be an object that supports the buffer call interface (such as strings, arrays, and buffers). A new buffer object will be created which references the object argument. The buffer object will be a slice from the beginning of object (or from the specified offset). The slice will extend to the end of object (or will have a length given by the size argument).
coerce(x, y)
Return a tuple consisting of the two numeric arguments converted to a common type, using the same rules as used by arithmetic operations. If coercion is not possible, raise TypeError.
intern(string)
Enter string in the table of “interned” strings and return the interned string – which is string itself or a copy. Interning strings is useful to gain a little performance on dictionary lookup – if the keys in a dictionary are interned, and the lookup key is interned, the key comparisons (after hashing) can be done by a pointer compare instead of a string compare. Normally, the names used in Python programs are automatically interned, and the dictionaries used to hold module, class or instance attributes have interned keys.
Changed in version 2.3: Interned strings are not immortal (like they used to be in Python 2.2 and before); you must keep a reference to the return value of intern() around to benefit from it.
Footnotes
[1] It is used relatively rarely so does not warrant being made into a statement.
[2] Specifying a buffer size currently has no effect on systems that don’t have setvbuf(). The interface to specify the buffer size is not done using a method that calls setvbuf(), because that may dump core when called after any I/O has been performed, and there’s no reliable way to determine whether this is the case.
[3] In the current implementation, local variable bindings cannot normally be affected this way, but variables retrieved from other scopes (such as modules) can be. This may change.
»
indexmodules |next |previous | Python » Documentation » The Python Standard Library »
© Copyright 1990-2012, Python Software Foundation.
The Python Software Foundation is a non-profit corporation. Please donate.
Last updated on Dec 01, 2012. Found a bug?
Created using Sphinx 1.0.7.

57
Zim/Programme/python/The-Python-Standard-Library/4._Built-in_Constants.txt Normal file
View File

@@ -0,0 +1,57 @@
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2012-12-02T20:49:44+08:00
====== 4. Built-in Constants ======
Created Sunday 02 December 2012
A small number of constants live in the built-in namespace. They are:
===== False =====
The false value of the bool type.
New in version 2.3.
===== True =====
The true value of the bool type.
New in version 2.3.
===== None =====
The sole value of types.NoneType. None is frequently used to represent the absence of a value, as when default arguments are not passed to a function.
Changed in version 2.4: Assignments to None are illegal and raise a SyntaxError.
===== NotImplemented =====
Special value which can be returned by the “rich comparison” special methods (__eq__(), __lt__(), and friends), to indicate that the comparison is not implemented with respect to the other type.
===== Ellipsis =====
Special value used in conjunction with extended slicing syntax.
===== __debug__ =====
This constant is true if Python was __not started with an -O option__. See also the assert statement.
Note The names None and __debug__ cannot be reassigned (assignments to them, even as an attribute name, raise SyntaxError), so they can be considered “true” constants.
Changed in version 2.7: Assignments to __debug__ as an attribute became illegal.
===== 4.1. Constants added by the site module =====
The site module (which is __imported automatically during startup__, except if the -S command-line option is given) adds several constants to the built-in namespace. They are useful for the interactive interpreter shell and should not be used in programs.
===== quit([code=None]) =====
===== exit([code=None]) =====
Objects that when printed, print a message like “Use quit() or Ctrl-D (i.e. EOF) to exit”, and when called, raise SystemExit with the specified exit code.
==== copyright ====
==== license ====
==== credits ====
Objects that when printed, print a message like “Type license() to see the full license text”, and when called, display the corresponding text in a pager-like fashion (one screen at a time).
»
indexmodules |next |previous | Python » Documentation » The Python Standard Library »
© Copyright 1990-2012, Python Software Foundation.
The Python Software Foundation is a non-profit corporation. Please donate.
Last updated on Dec 02, 2012. Found a bug?
Created using Sphinx 1.0.7.

1403
Zim/Programme/python/The-Python-Standard-Library/5._Built-in_Types.txt Normal file
View File

File diff suppressed because it is too large Load Diff

38
Zim/Programme/python/The-Python-Standard-Library/int.txt Normal file
View File

@@ -0,0 +1,38 @@
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2012-12-02T10:31:10+08:00
====== int ======
Created Sunday 02 December 2012
In [12]: lst = '123\n' //如果字符串中包含__空字符(如空格, \t, \v, \f, \n, \r)等__，int(), float()等函数仍然有效。
In [13]: lst
Out[13]: '123\n'
__In [14]: int(lst)__
__Out[14]: 123__
In [15]: lst = '123\n\t'
In [16]: lst
Out[16]: '123\n\t'
In [18]: int(lst)
Out[18]: 123
In [19]: lst = '123\nstr' //字符串中包含除了数字外的非空字符，转换时提示错误。
In [20]: lst
Out[20]: '123\nstr'
In [21]: int(lst)
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-21-7fdf78d62dad> in <module>()
----> 1 int(lst)
__ValueError:__ invalid literal for int() with **base 10**: '123\nstr'
In [22]:

74
Zim/Programme/python/The-Python-Standard-Library/list.txt Normal file
View File

@@ -0,0 +1,74 @@
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2012-12-02T09:40:06+08:00
====== list ======
Created Sunday 02 December 2012
~ $ ipython2
Python 2.7.3 (default, Apr 24 2012, 00:06:13)
Type "copyright", "credits" or "license" for more information.
In [1]: lst = ['sdfds', 'dsfsd', 1, 3, [123, 22, 33, 'dsfds']]
__In [2]: lst[0]=[1, 2, 3] //为列表的某个成员赋值时，python不会对右边的值进行迭代。__
In [3]: lst
Out[3]: 1, 2, 3], 'dsfsd', 1, 3, [123, 22, 33, 'dsfds'
__In [8]: lst[0:0] = 'dffds' //为列表的成员列表赋值时，python会对右边的值进行迭代。__
In [9]: lst
Out[9]: [__'d', 'f', 'f', 'd', 's',__ 'dffds', 2, 3, 'dsfsd', 1, 3, [123, 22, 33, 'dsfds']] //可见，python对等式右边序列进行了迭代。
In [4]: lst[0:1] = [1, 2, 3]
In [5]: lst
Out[5]: [1, 2, 3, 'dsfsd', 1, 3, [123, 22, 33, 'dsfds']] //同上
In [10]:
__In [10]: lst[0:0] = ['dffds'] //将字符序列外加[和]就可以阻止迭代(因为这时字符串时列表的唯一成员)__
In [11]: lst
Out[11]:
['dffds',
'd',
'f',
'f',
'd',
's',
'dffds',
2,
3,
'dsfsd',
1,
3,
[123, 22, 33, 'dsfds']]
In [12]:
In [24]: lst
Out[24]: '123\nstr'
In [25]: lst = [1, 2, 3]
In [26]: lst = lst + [4, 5, 6] //列表相+时，python会对第二个列表进行__迭代__。
In [27]: lst
Out[27]: [1, 2, 3, **4, 5, 6]**
__In [28]: lst = lst + 'fdf' //只能list间相加__
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-28-0818686a3a7d> in <module>()
----> 1 lst = lst + 'fdf'
TypeError: **can only concatenate list** (not "str") to list
In [29]: lst = lst + list('fdf')
In [30]: lst
Out[30]: [1, 2, 3, 4, 5, 6, 'f', 'd', 'f']
In [31]:

20
Zim/Programme/python/library/pexpect.txt → Zim/Programme/python/The-Python-Standard-Library/pexpect.txt
View File

@@ -6,10 +6,6 @@ Creation-Date: 2012-01-05T15:16:44+08:00
Created Thursday 05 January 2012
http://www.noah.org/wiki/Pexpect
pexpect
(Redirected from Pexpect)
Contents
1 Pexpect version 2.3
@@ -59,22 +55,12 @@ Download the current version here from the SourceForge site here: pexpect curren
===== Description of Pexpect =====
Pexpect is a **pure Python module** that makes Python a better tool for__ controlling and automating other programs__. Pexpect is similar to the Don Libes `Expect` system, but Pexpect as a different interface that is easier to understand.
Pexpect is__ basically a pattern matching system__. It runs programs and watches output. When output matches a given pattern Pexpect can **respond** as if a human were typing responses. Pexpect can be used for** automation, testing, and screen scraping**.
Pexpect can be used for__ automating interactive console applications __such as ssh, ftp, passwd, telnet, etc.
It can also be used to__ control web applications__ via `lynx`, `w3m`, or some other **text-based **web browser. Pexpect is pure Python. Unlike other Expect-like modules for Python Pexpect does not require TCL or Expect nor does it require C extensions to be compiled. It should work on any platform that supports the standard Python pty module.
Pexpect can be used for__ automating interactive console applications __such as ssh, ftp, passwd, telnet, etc. It can also be used to__ control web applications__ via `lynx`, `w3m`, or some other **text-based **web browser. Pexpect is pure Python. Unlike other Expect-like modules for Python Pexpect does not require TCL or Expect nor does it require C extensions to be compiled. It should work on any platform that supports the standard Python __pty__ module.
Send questions to: noah@noah.org Put 'pexpect' in the subject.
License
MIT style -- Free, open source, and all that good stuff.
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Pexpect Copyright (c) 2010 Noah Spurrier
===== Download and Installation =====

1045
Zim/Programme/python/The-Python-Standard-Library/re.txt Normal file
View File

File diff suppressed because it is too large Load Diff

92
Zim/Programme/python/The-Python-Standard-Library/string的操作函数.txt Normal file
View File

@@ -0,0 +1,92 @@
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2012-11-30T20:55:38+08:00
====== string的操作函数 ======
Created Friday 30 November 2012
转自:http://www.91linux.com/html/article/program/python/20090804/17759.htm
在python有各种各样的string操作函数。在历史上string类在python中经历了一段轮回的历史。在最开始的时候，python有**一个专门的string的module**，要使用string的方法要先import，但后来由于众多的python使用者的建议，从python2.0开始，string方法改为用S.method()的形式调用，只要S是一个字符串对象就可以这样使用，而不用import。同时__为了保持向后兼容__，现在的python中仍然保留了一个string的module，其中定义的方法与S.method()是相同的，这些方法都**最后都指向了**用S.method()调用的函数。要注意，S.method()能调用的方法比string的module中的多，比如isdigit()、istitle()等就只能用S.method()的方式调用。
对一个字符串对象，首先想到的操作可能就是计算它有多少个字符组成，很容易想到用S.len()，但这是错的，应该是__len(S)__。因为len()是内置函数，包括在__builtin__模块中。python不把len()包含在string类型中，乍看起来好像有点不可理解，其实一切有其合理的逻辑在里头。len()不仅可以计算字符串中的字符数，还可以计算list的成员数，tuple的成员数等等，因此**单单把len()算在string里是不合适**，因此一是可以__把len()作为通用函数__，用重载实现对不同类型的操作，还有就是可以在每种有len()运算的类型中都要包含一个len()函数。python选择的是第一种解决办法。类似的还有str(arg)函数，它把arg用string类型表示出来。
===== 字符串中字符大小写的变换： =====
S.lower() #小写
S.upper() #大写
S.swapcase() #大小写互换
S.capitalize() #首字母大写
String.capwords(S)
#这是模块中的方法。它把S用split()函数分开，然后用capitalize()把首字母变成大写，最后用join()合并到一起
S.title() #只有首字母大写，其余为小写，模块中没有这个方法
===== 字符串在输出时的对齐： =====
S.ljust(width,[fillchar])
#输出width个字符，S左对齐，不足部分用fillchar填充，默认的为空格。
S.rjust(width,[fillchar]) #右对齐
S.center(width, [fillchar]) #中间对齐
S.zfill(width) #把S变成width长，并在右对齐，不足部分用0补足
===== 字符串中的搜索和替换： =====
S.find(substr, [start, [end]])
#返回S中出现substr的第一个字母的标号，如果S中没有substr则返回-1。start和end作用就相当于在S[start:end]中搜索
S.index(substr, [start, [end]])
#与find()相同，只是在S中没有substr时，会返回一个运行时错误
S.rfind(substr, [start, [end]])
#返回S中最后出现的substr的第一个字母的标号，如果S中没有substr则返回-1，也就是说从右边算起的第一次出现的substr的首字母标号
S.rindex(substr, [start, [end]])
S.count(substr, [start, [end]]) #计算substr在S中出现的次数
S.replace(oldstr, newstr, [count])
#把S中的oldstar替换为newstr，count为替换次数。这是替换的通用形式，还有一些函数进行特殊字符的替换
S.strip([chars])
#把S中前后chars中有的字符全部去掉，可以理解为把S前后chars替换为None
S.lstrip([chars])
S.rstrip([chars])
S.expandtabs([tabsize])
#把S中的tab字符替换没空格，每个tab替换为tabsize个空格，默认是8个
===== 字符串的分割和组合： =====
S.split([sep, [maxsplit]])
#以sep为分隔符，把S分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符
S.rsplit([sep, [maxsplit]])
S.splitlines([keepends])
#把S按照行分割符分为一个list，keepends是一个bool值，如果为真每行后而会保留行分割符。
S.join(seq) #把seq代表的序列──字符串序列，用S连接起来
===== 字符串的mapping，这一功能包含两个函数： =====
String.maketrans(from, to)
#返回一个256个字符组成的翻译表，其中from中的字符被一一对应地转换成to，所以from和to必须是等长的。
S.translate(table[,deletechars])
#使用上面的函数产后的翻译表，把S进行翻译，并把deletechars中有的字符删掉。需要注意的是，如果S为unicode字符串，那么就不支持deletechars参数，可以使用把某个字符翻译为None的方式实现相同的功能。此外还可以使用codecs模块的功能来创建更加功能强大的翻译表。
===== 字符串还有一对编码和解码的函数： =====
S.encode([encoding,[errors]])
#其中encoding可以有多种值，比如gb2312 gbk gb18030 bz2 zlib big5 bzse64等都支持。errors默认值为"strict"，意思是UnicodeError。可能的值还有'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 和所有的通过codecs.register_error注册的值。这一部分内容涉及codecs模块，不是特明白
S.decode([encoding,[errors]])
===== 字符串的测试函数，这一类函数在string模块中没有，这些函数返回的都是bool值： =====
S.startwith(prefix[,start[,end]])
#是否以prefix开头
S.endwith(suffix[,start[,end]])
#以suffix结尾
S.isalnum()
#是否全是字母和数字，并至少有一个字符
S.isalpha() #是否全是字母，并至少有一个字符
S.isdigit() #是否全是数字，并至少有一个字符
S.isspace() #是否全是空白字符，并至少有一个字符
S.islower() #S中的字母是否全是小写
S.isupper() #S中的字母是否便是大写
S.istitle() #S是否是首字母大写的
===== 字符串类型转换函数，这几个函数只在string模块中有： =====
**string.atoi(s[,base])**
#base默认为10，如果为0,那么s就可以是012或0x23这种形式的字符串，如果是16那么s就只能是0x23或0X12这种形式的字符串
string.atol(s[,base]) #转成long
string.atof(s[,base]) #转成float
这里再强调一次，字符串对象是不可改变的，也就是说在python创建一个字符串后，你不能把这个字符中的某一部分改变。任何上面的函数改变了字符串后，都会返回一个__新的字符串__，原字串并没有变。其实这也是有变通的办法的，__可以用S=list(S)这个函数把S变为由单个字符为成员的list，这样的话就可以使用S[3]='a'的方式改变值，然后再使用S=" ".join(S)还原成字符串__

76
Zim/Programme/python/library/subprocess.txt → Zim/Programme/python/The-Python-Standard-Library/subprocess.txt
View File

@@ -39,13 +39,13 @@ __subprocess.STDOUT__
[*] subprocess.__call__(**args**, *, stdin=None, stdout=None, stderr=None, shell=False)
Run the command described by __args__. __Wait __for command to complete, then return the **returncode** attribute.
适合非交互式进程，执行args指定的程序直到其结束，返回退出码，即使命令执行失败，也不产生异常。stdin,stdout,stderr一般不使用PIPE，因为调用进程一般不读这种非交互式进程的输出。stdin为None表示子进程的stdin将__继承__调用进程的描述符。
适合非交互式进程，执行args指定的程序直到其结束，返回退出码，即使命令执行失败，也不产生异常。stdin,stdout,stderr一般不使用PIPE，因为调用进程一般不读这种非交互式进程的输出。stdin为None表示子进程的stdin将__继承__调用进程的描述符。
The arguments shown above are merely the most common ones, described below in Frequently Used Arguments (hence the slightly odd notation in the abbreviated signature). The full function signature is the same as that of the __Popen__ constructor - this functions passes all supplied arguments directly through to that interface.
Examples:
>>>
__#如果shell=False(默认)，则python调用os.execlp()来执行args，因此，如果args是字符串，则只能包含命令名；如果是序列，则可以包含命令参数(参数不支持shell的特性如文件名扩展等。)，而且每个元素一般包括一个参数(否则调用程序可能会产生解析错误)。__
__#如果shell=False(默认)，则python调用os.exelp()来执行args，因此，如果args是字符串，则只能包含命令名；如果是序列，则可以包含命令参数(参数不支持shell的特性如文件名扩展等。)。__
>>> subprocess.call(__["ls", "-l"]__)
0
__#如果shell=True，则python调用system shell来执行args，调用形式为: execlp("/bin/sh", '-c', 'arg1', 'arg2', ....)因此，如果args是字符串，则其中可以包含命令参数，而且支持各种shell特性如文件名扩展、命令扩展等；如果args是序列，则其第一个元素为命令名，其它元素为被当作shell本身的参数。__
@@ -53,14 +53,14 @@ __#如果shell=True，则python调用system shell来执行args，调用形式为
>>> subprocess.call("exit 1", shell=True)
1
__总的来说__**：**如果shell=False, python使用os.execvp(...)来执行args，因此，如果args是一个string，则该string只能是命令名称, 如果要为命令附加参数，则只能使用序列类型; 如果shell=True，则python使用shell来执行行args，因此，args最好是一个string，该string可以包含命令名及其参数，如果使用序列，则从第二个元素开始作为shell本身的参数(而非命令的参数。)。
__总的来说__**：**如果shell=False, python使用os.execvp(...)来执行args，因此，如果args是一个string，则该string__只能是__命令名称, 如果要为命令附加参数，则只能使用序列类型; 如果shell=True，则python使用shell来执行行args，因此，args最好是一个string，该string可以包含命令名及其参数，如果使用序列，则从第二个元素开始作为shell本身的参数(而非命令的参数。)。
Invoking the system shell with shell=True can be **a security hazard** if combined with untrusted input. See the warning under Frequently Used Arguments for details.
__Do not use stdout=PIPE or stderr=PIPE with this function__. As the pipes are not being read in the current process, the child process may block if it generates enough output to a pipe to fill up the OS pipe buffer.
当使用stdout=PIPE时，如果子进程填满了管道而调用进程没有读该管道时__子进程就会被阻塞__。因此使用上面三个函数时一般不使用这个参数。
The standard input and output channels for the process started by call() are__ bound to the parent’s input and output__. That means the calling programm cannot capture the output of the command. Use check_output() to capture the output for later processing.
The standard input and output channels for the process started by call() are__ bound to the parent’s input and output__. That means the calling programm __cannot capture the output__ of the command. Use check_output() to capture the output for later processing.
[*] subprocess.**check_call**(args, *, stdin=None, stdout=None, stderr=None, shell=False)
和call类似，但是对返回值进行检查，如果非0则引发异常。
@@ -152,9 +152,10 @@ __class subprocess.Popen__(args, bufsize=0, **executable**=None, stdin=None, std
Arguments are:
* args should be a string, or a sequence of program arguments. The program to execute is normally the **first item** in the args sequence or the string if a string is given, but can be **explicitly set **by using the __executable__ argument. When executable is given, the first item in the args sequence is still treated by most programs as the** command name**, which can then be different from the actual executable name. On Unix, it becomes the** display name** for the executing program in utilities such as ps.
* args should be a string, or a sequence of program arguments. The program to execute is normally the **first item** in the args sequence or the string(string作为命令名，不能有参数) if a string is given, but can be **explicitly set **by using the __executable__ argument. When executable is given, the first item in the args sequence is still treated by most programs as the** command name**, which can then be different from the actual executable name. On Unix, it becomes the** display name** for the executing program in utilities such as ps. 如果ecutable被设置，则其值将作为__实际执行__的命令名。args的第一个元素将作为命令的显示名称。
On Unix, with shell=False (default): In this case, the __Popen class uses os.execvp()__ to execute the child program. args should **normally be a sequence.** If a string is specified for args, it will be used as the **name or path of the program **to execute; this will only work if the program is being given __no__ arguments.
默认情况下shell=False，这样args通常为sequence，其第一个元素为待执行的命令，其它元素为命令参数。如果args为string，则其**只能为命令名或命令路径，不能带任何参数**。这时因为python使用os.execvp()来执行这个string。
Note
@@ -172,22 +173,22 @@ __class subprocess.Popen__(args, bufsize=0, **executable**=None, stdin=None, std
Note in particular that options (such as -input) and arguments (such as eggs.txt) that are separated by whitespace in the shell go in **separate list elements**, while arguments that need quoting or backslash escaping when used in the shell (such as filenames containing spaces or the echo command shown above) are single list elements.
On Unix, with shell=True: __If args is a string, it specifies the command string to execute through the shell.__ This means that the string must be formatted exactly as it would be when typed at the shell prompt. This includes, for example, quoting or backslash escaping filenames with spaces in them. If args is a sequence, the first item specifies the command string, and any additional items will be treated as additional arguments __to the shell itself__. That is to say, Popen does the equivalent of:
在shell=True的情况下，args最好是一个字符串。如果是序列，则从第二个元素开始是__作为shell本身的参数__，而非命令的参数。
在shell=True的情况下，args**最好是一个字符串**。如果是序列，则从第二个元素开始是__作为shell本身的参数__，而非命令的参数。
__ Popen(['/bin/sh', '-c', args[0], args[1], ...])__
On Windows: the Popen class uses CreateProcess() to execute the child child program, which __operates on strings.__ If args is a sequence, it will be converted to a string in a manner described in Converting an argument sequence to a string on Windows.
**总的来说：如果shell=False, python使用os.execvp(...)来执行args，因此，如果args是一个string，则该string只能是命令名称, 如果要为命令执行参数，则只能使用序列类型; 如果shell=True，则python使用shell来执行行args，因此，args最好是一个string，该string可以包含命令名及其参数，如果使用序列，则从第二个元素开始作为**__shell本身__**的参数(而非命令的参数。)。**
* bufsize, if given, has the same meaning as the corresponding argument to the built-in open() function: **0 means **__unbuffered__**, 1 means**__ line buffered__**, any other positive value means use a buffer of (approximately) that size**. A negative bufsize means to use the system **default**, which usually means__ fully__ buffered. The** default value for bufsize is 0** (unbuffered).
控制打开文件的缓冲方式。
* bufsize, if given, has the same meaning as the corresponding argument to the built-in open() function: **0 means **__unbuffered__**, 1 means**__ line buffered__**, any other positive value means use a buffer of (approximately) that size**. A negative bufsize means to use the system **default**, which usually means__ fully__ buffered. The** default value for bufsize is 0** __(unbuffered)__.
控制打开文件的缓冲方式，默认为unbuffered。
Note
If you experience performance issues, it is recommended that you try to enable buffering by setting bufsize to either -1 or a large enough positive value (such as 4096).
* The executable argument **specifies the program** to execute. It is very seldom needed: Usually, the program to execute is defined by the **args** argument. If shell=True, the executable argument specifies __which shell to use__. On Unix, the default shell is /bin/sh. On Windows, the default shell is specified by the COMSPEC environment variable. The only reason you would need to specify shell=True on Windows is where the command you wish to execute is actually built in to the shell, eg dir, copy. You don’t need shell=True to run a batch file, nor to run a console-based executable.
* The executable argument **specifies the program** to execute. It is very seldom needed: Usually, the program to execute is defined by the **args** argument. If shell=True, the executable argument specifies __which shell to use__. On Unix, the default shell is **/bin/sh**. On Windows, the default shell is specified by the COMSPEC environment variable. The only reason you would need to specify shell=True on Windows is where the command you wish to execute is actually built in to the shell, eg dir, copy. You don’t need shell=True to run a batch file, nor to run a console-based executable.
* stdin, stdout and stderr specify the __executed program’s __standard input, standard output and standard error file handles, respectively. Valid values are __PIPE, an existing file descriptor (a positive integer), an existing file object, and None__. PIPE indicates that a new pipe to the child should be created. With the **default settings of None**, no redirection will occur; the child’s file handles will be inherited from the parent. Additionally, stderr can be STDOUT, which indicates that the stderr data from the child process should be captured into the same file handle as for stdout.
* stdin, stdout and stderr specify the __executed program’s __standard input, standard output and standard error file handles, respectively. Valid values are __PIPE, an existing file descriptor (a positive integer), an existing file object, and None__. PIPE indicates that a new pipe to the child should be created. With the **default settings of None**, no redirection will occur; the child’s file handles will be **inherited from the parent**. Additionally, stderr can be STDOUT, which indicates that the stderr data from the child process should be captured into the same file handle as for stdout.
* If__ preexec_fn__ is set to a callable object, this object will be called in the child process just **before** the child is executed. (Unix only)
@@ -210,7 +211,8 @@ __class subprocess.Popen__(args, bufsize=0, **executable**=None, stdin=None, std
Note
This feature is only available if Python is built with universal newline support (the default). Also, the newlines attribute of the file objects stdout, stdin and stderr are not updated by the communicate() method.
* If given, startupinfo will be a STARTUPINFO object, which is passed to the underlying __CreateProcess __function. creationflags, if given, can be CREATE_NEW_CONSOLE or CREATE_NEW_PROCESS_GROUP. (Windows only)
* If given, startupinfo will be a STARTUPINFO object, which is passed to the underlying __CreateProcess __function.
* creationflags, if given, can be CREATE_NEW_CONSOLE or CREATE_NEW_PROCESS_GROUP. (Windows only)？
==== 17.1.1.3. Exceptions ====
@@ -232,11 +234,11 @@ Popen()函数返回一个__Popen对象__。
Instances of the Popen class have the following methods:
**Popen.poll()**
Check if child process __has terminated__. Set and return returncode attribute.
Check if child process __has terminated__. Set and return **returncode** attribute.
**Popen.wait()**
Wait for child process to terminate. Set and return returncode attribute.
Wait for child process to terminate. Set and return **returncode** attribute.
Warning
This will deadlock when using stdout=PIPE and/or stderr=PIPE and the child process generates enough output to a pipe such that it blocks waiting for the OS pipe buffer to accept more data. Use communicate() to avoid that.
@@ -247,7 +249,7 @@ __Popen.communicate__(input=None)
communicate() returns __a tuple__ (stdoutdata, stderrdata).
Note that if you want to send data to the process’s stdin, you need to create the Popen object with__ stdin=PIPE__. Similarly, to get anything other than None in the result tuple, you need to give__ stdout=PIPE__ and/or stderr=PIPE too.
Note that if you want to send data to the process’s stdin, you need to create the Popen object with__ stdin=PIPE__. Similarly, to get anything other than None in the result tuple, you need to give__ stdout=PIPE__ and/or __stderr=PIPE__ too.
Note
The data read is buffered in memory, so do not use this method if the data size is large or unlimited.
@@ -262,7 +264,7 @@ __Popen.communicate__(input=None)
**Popen.terminate()**
Stop the child. On Posix OSs the method sends SIGTERM to the child. On Windows the Win32 API function TerminateProcess() is called to stop the child.
Stop the child. On Posix OSs the method sends __SIGTERM__ to the child. On Windows the Win32 API function TerminateProcess() is called to stop the child.
**Popen.kill()**
@@ -271,7 +273,7 @@ __Popen.communicate__(input=None)
===== The following attributes are also available: =====
**Popen对象**具有下列属性：
Warning
Use communicate() rather than .stdin.write, .stdout.read or .stderr.read to avoid deadlocks due to any of the other OS pipe buffers filling up and blocking the child process.
Use communicate() rather than //.stdin.write, .stdout.read or .stderr.read// to avoid deadlocks due to any of the other OS pipe buffers filling up and blocking the child process.
Popen.stdin #对Popen调用stdin属性，将返回一个**写打开的文件对象**。
If the stdin argument was PIPE, this attribute is **a file object** that provides input to the child process. Otherwise, it is__ None__.
@@ -287,7 +289,7 @@ Popen.__pid__
Popen.__returncode__
The child return code, **set by poll() and wait()** (and indirectly by communicate()). A __None__ value indicates that the process hasn’t terminated yet. A negative value -N indicates that the child was **terminated by signal N** (Unix only).
The child return code, **set by poll() and wait()** (and indirectly by communicate()). A __None__ value indicates that the process hasn’t terminated yet. A negative value __-N__ indicates that the child was **terminated by signal N** (Unix only).
===== 17.1.3.1. Constants =====
@@ -314,7 +316,7 @@ subprocess.STARTF_USESHOWWINDOW
subprocess.CREATE_NEW_CONSOLE
The new process ha**s a new console**, instead of inheriting its parent’s console (the default).
The new process ha**s a new console**, instead of inheriting its parent’s console __(the default)__.
This flag is always set when Popen is created with shell=True.
subprocess.CREATE_NEW_PROCESS_GROUP
@@ -345,12 +347,20 @@ output=`dmesg | grep hda`
# becomes
p1 = Popen(["dmesg"], __stdout=PIPE__)
p2 = Popen(["grep", "hda"], stdin=__p1.stdout__, stdout=PIPE) #p1是Popen对象，其stdout返回一个读打开的文件对象（因为p1的stdout为PIPE）。
__p1.stdout__.close() # Allow p1 to receive a SIGPIPE if p2 exits.
__p1.stdout__.close() # Allow p1 to receive a SIGPIPE if p2 exits，**关键！！！**
output = __p2.communicate()__[0] #communicate()返回一个__元组__，这里只取出第一个元素即子进程的标准输出。
The p1.stdout.close() call after starting the p2 is __important in order__ for p1 to receive a SIGPIPE if p2 exits before p1.
具体解释如下：stackoverflow.com/q/7391689
From Wikipedia, SIGPIPE is the signal sent to a process when it attempts to **write** to a pipe without a process connected to the other end.
When you first create p1 using **stdout=PIPE**, there is one process connected to the pipe, which is __your Python process__, and you can read the output using p1.stdout.
最开始Popen()时，python解释器会连接到p1.stdout管道，这样在p2没有创建前，p1的cmd就可以执行了，输出将临时地放入管道中。
When you create p2 using stdin=p1.stdout there are now __two processes__ connected to the pipe p1.stdout.
Generally when you are running processes in a pipeline you want **all processes** to end when any of the processes end. For this to happen automatically __you need to close p1.stdout so p2.stdin is the only process attached to that pipe__, this way if p2 ends and p1 writes additional data to stdout, it will receive a SIGPIPE since there are no longer any processes attached to that pipe.
Alternatively, for trusted input, the shell’s own pipeline support may still be used directly:
Alternatively, for **trusted input**, the shell’s own pipeline support may still be used directly:
output=`dmesg | grep hda` # becomes output=__check_output__(“dmesg | grep hda”,__ shell=True__)
@@ -432,7 +442,7 @@ p = Popen("cmd", shell=True, bufsize=bufsize,
stdin=PIPE, stdout=PIPE, __stderr=STDOUT__, close_fds=True) #STDOUT标示，子进程的标准出错和__它的__标准输出__重定向到同一个__文件。
(child_stdin, child_stdout_and_stderr) = (p.stdin, p.stdout)
On Unix, os.popen2, os.popen3 and os.popen4 also accept __a sequence__ as the command to execute, in which case arguments will be passed directly to the program without shell intervention. This usage can be replaced as follows:
On Unix, os.popen2, os.popen3 and os.popen4 also accept __a sequence__ as the command to execute, in which case arguments will be passed **directly to the program** without shell intervention. This usage can be replaced as follows:
(child_stdin, child_stdout) = os.popen2(["/bin/ls", "-l"], mode,
bufsize)
@@ -444,13 +454,13 @@ Return code handling translates as follows:
pipe = os.popen("cmd", 'w')
...
rc = pipe.close()
if rc is not None and rc >> 8:
rc = pipe.close() //"cmd"进程读管道时收到EOF，程序一般将终止。
if rc is not None and rc **>> 8**:
print "There were some errors"
==>
process = Popen("cmd", 'w', shell=True, stdin=PIPE)
...
process.stdin.close()
process.stdin.close() //**同样使'cmd'读到EOF**，而自动终止。
if **process.wait()** != 0:
print "There were some errors"
@@ -473,19 +483,19 @@ p = Popen(["mycmd", "myarg"], bufsize=bufsize,
popen2.Popen3 and popen2.Popen4 basically work as subprocess.Popen, except that:
Popen raises an exception if the execution fails.
the capturestderr argument is replaced with the stderr argument.
stdin=PIPE and stdout=PIPE must be specified.
popen2 closes all file descriptors by default, but you have to specify close_fds=True with Popen.
* Popen raises an exception if the execution fails.
* the capturestderr argument is replaced with the stderr argument.
* stdin=PIPE and stdout=PIPE must be specified.
* popen2 closes all file descriptors by default, but you have to specify close_fds=True with Popen.
===== 17.1.5. Notes =====
17.1.5.1. Converting an argument sequence to a string on Windows
On Windows, an args sequence is converted to a string that can be parsed using the following rules (which correspond to the rules used by the MS C runtime):
Arguments are delimited by white space, which is either a space or a tab.
A string surrounded by double quotation marks is interpreted as a single argument, regardless of white space contained within. A quoted string can be embedded in an argument.
A double quotation mark preceded by a backslash is interpreted as a literal double quotation mark.
Backslashes are interpreted literally, unless they immediately precede a double quotation mark.
If backslashes immediately precede a double quotation mark, every pair of backslashes is interpreted as a literal backslash. If the number of backslashes is odd, the last backslash escapes the next double quotation mark as described in rule 3.
* Arguments are delimited by white space, which is either a space or a tab.
* A string surrounded by double quotation marks is interpreted as a single argument, regardless of white space contained within. A quoted string can be embedded in an argument.
* A double quotation mark preceded by a backslash is interpreted as a literal double quotation mark.
* Backslashes are interpreted literally, unless they immediately precede a double quotation mark.
* If backslashes immediately precede a double quotation mark, every pair of backslashes is interpreted as a literal backslash. If the number of backslashes is odd, the last backslash escapes the next double quotation mark as described in rule 3.

0
Zim/Programme/python/library/Python_Subprocess_Module_Examples.txt → Zim/Programme/python/The-Python-Standard-Library/subprocess/Python_Subprocess_Module_Examples.txt
View File

0
Zim/Programme/python/library/subprocess/subprocess_-_New_process_module.txt → Zim/Programme/python/The-Python-Standard-Library/subprocess/subprocess_-_New_process_module.txt
View File

0
Zim/Programme/python/library/subprocess_–_Work_with_additional_processes.txt → Zim/Programme/python/The-Python-Standard-Library/subprocess/subprocess_–_Work_with_additional_processes.txt
View File

0
Zim/Programme/python/library/virtualenvwrapper.txt → Zim/Programme/python/The-Python-Standard-Library/virtualenvwrapper.txt
View File

0
Zim/Programme/python/library/virtualenvwrapper/1.jpg → Zim/Programme/python/The-Python-Standard-Library/virtualenvwrapper/1.jpg
View File

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 17 KiB

After

Width:  |  Height:  |  Size: 17 KiB

0
Zim/Programme/python/library/virtualenvwrapper/2.jpg → Zim/Programme/python/The-Python-Standard-Library/virtualenvwrapper/2.jpg
View File

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 22 KiB

After

Width:  |  Height:  |  Size: 22 KiB

2
Zim/Programme/python/The_Python_Tutorial/3._An_Informal_Introduction_to_Python.txt
View File

@@ -38,7 +38,7 @@ The interpreter acts as a simple calculator: you can type an expression at it an
>>> #__ Integer division returns the floor__:
... 7/3
2
>>> 7/-3
>>> 7/-3 //对于整型出发，结果也是整数，而且结果总是rounded towards minus infinity。也就是说__结果总是取小于小数的最大整数值。__例如7/-3= -2.25...，而小于-2.25的最大整数为-3.
-3
The equal sign ('=') is used to assign a value to a variable. Afterwards, no result is displayed before the next interactive prompt:

7
Zim/Programme/python/library.txt
View File

@@ -1,7 +0,0 @@
Content-Type: text/x-zim-wiki
Wiki-Format: zim 0.4
Creation-Date: 2012-01-05T15:16:40+08:00
====== library ======
Created Thursday 05 January 2012

2
Zim/Programme/python/python笔记/dict.txt
View File

@@ -13,7 +13,7 @@ class dict(object)
| (key, value) pairs
| dict(iterable) -> new dictionary initialized as if via:
| d = {}
| for **k, v** in iterable: #迭代器对象每次返回的元素必须是一个容器类型，__容器中元素的个数为2__.**如[a,b], "ab",(a,b)**
| for **k, v** in iterable: #迭代器对象每次返回的元素必须是一个容器类型，__容器中元素的个数为2__.**如[a,b], **~~"ab"~~**,(a,b)**
| d[k] = v
| dict(__**kwargs)__ -> new dictionary initialized with the name=value pairs
| in the keyword argument list. For example: dict(one=1, two=2)

36
Zim/Programme/python/python笔记/unpack.txt
View File

@@ -36,3 +36,39 @@ unpack一个顺序容器类型时，左边变量的数目必须要与容器中
>>> print k,v
d f
>>>
In [9]: for k,v in 'dfdf': //对于字符串的迭代，迭代其每次只返回__一个字符__，所以赋值给k,v时出错
...: print k,v
...:
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-9-5ba17a6181e2> in <module>()
----> 1 for k,v in 'dfdf':
2 print k,v
3
ValueError: need more than 1 value to unpack
In [10]: k,v='ff' __//对于可迭代对象，展开后的元素个数必须与等式左边的相等。__
In [11]: print k,v
**f f**
In [13]: k,v='fff'
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-13-0aecd2a10b05> in <module>()
----> 1 k,v='fff'
ValueError: too many values to unpack
In [14]:
In [12]:
In [12]: for k,v in ['df',[1,2],(3,4)]: __//每次迭代器返回列表中的一个元素，每个元素都可以展开为2个变量。__
print k,v
....:
d f
1 2
3 4
In [13]: