python学习笔记Word文件下载.docx

python学习笔记Word文件下载.docx

《python学习笔记Word文件下载.docx》由会员分享，可在线阅读，更多相关《python学习笔记Word文件下载.docx（19页珍藏版）》请在冰豆网上搜索。

#a.py

importgl

defhello_world（）

printgl.gl_1,gl.gl_2

自定义模块

Python文件调用另一文件

execfile（"

pythonfilename"

）

或者

importos

os.system（"

）//可以传入参数

os.popen（"

）//可以获取输出

系统模块

Os

Sys

字典的使用

字典就是有N个键的一个集合，类似与结构，但是成员没有类型只说。

一个键可以在字符型、字符串、数据型之间来回切换。

但是一个时刻只有一种值型（被赋值的类型）

它的成员个数是可变的。

创建字典

dict1={'

m1'

:

'

m2'

}#创建一个具有两个键的字典，键之间使用:

隔开，用{}定义字典

y'

:

-1,'

x'

-1}#创建一个具有两个键的字典，键的初始化值都是-1（这里分开的是,）

dict1={}.fromkeys（（'

'

）,-1）#创建一个具有两个键的字典，键的初始化值都是-1

dict1={}#创建一个空字典，键后续可以随意添加

删除字典

deldict1#之后dict1就不可以再用了，并须重新定义

字典定义分行写与注释

dict={

#sss

}

添加一个键

dict1['

m3'

]=3#如果原来没有m3键，则m3键会被添加且赋值

dict1.setdefault（'

m3’,2）#使用setdefault函数增加一个键并赋值

上面两种方法本质上都是给键设值

删除一个键

deldict1['

]#之后键m3就不可以再用了，并须重新添加

clear删除所有键

dict1.clear（）#所有的键都被清除，并须重新添加

常用的字典方法

dict1={}

]=1

]=2

]='

MM3'

列举字典的所有键以及其值

printdict1.items（）#列举全部键及值

[（'

1）,（'

）,（'

2）]

printdict1.keys（）#列举全部键

['

]

printdict1.values（）#列举全部值

[1,'

2]

获取字典键个数

print'

ItemNum=%d'

%（len（structVal.keys（）））

%（len（structVal.values（）））

%（len（structVal.items（）））

has_key查找是否有某键

有的话返回True，否则返回False

dict1.has_key（'

）#=True

m4）/#=False

get获取键的值

dict1.get（'

）#=1找到，返回其值

m4'

）#找不到返回字符串None

get与dict1[‘x’]的区别是，如果没有x，后一种方法会异常终止脚步，前一种方法只是返回None

setdefault获取键值

printdict1.setdefault（'

100）#=1对于已经存在的键，第二个参数没有用

100）#=100对于不存在的键，第二个参数则是初始值

update两个字典键值添加

dict1.update（dict2）#badict2中的键值全部添加到dict1中

如果是dict1中没有的，则添加

如果是dict1中有的，则覆盖（值为dict2中的值）

如果是dict2中没有的，则不变

Copy两个字典

dict1=dict2.copy（）#badict2中的键值全部copy到dict1中

dict1中的键与值都变为dict2一样的

如果是dict2中没有的，则会被删除掉

一键多值字典

不可变键值方式

）,（-1,2））#创建一个两键字典，每个键一个列表，列表中的元素不可单个变，只可以作为整体编号

上面的各种字典方法也一样可用

引用键的某个值的方法是

][0]#=-1OK

dict1[‘m1’][0]=10#ERR不可单独变

dict1[‘m1’]=10#OK，但是m1变为单值了

数组可变键值方式

dict={'

（[31,21]）,'

（[21,22]）}#每个键都是一个数组，使用（[]）方式，数组每个元素可变

dict['

][0]=32

数组字典使用的技巧

（[1,21]）,#sss

（[21,22]）#sss

forelementindict.items（）:

printelement[1][1]

这里每个element就是

[1,21]）和（'

（21,22））]

所以element[0]是键名

Element[1]是键值

Element[1][x]就是数组键值的第x个元素

这样可以读取也可以赋值

数组字典

dict1={}.fromkeys（range（5）,'

NONE'

）#创建一个数组字典，有5个元素0,1,2,3,4，初始值都是NONE

printdict[0]#NONE

注：

数组字典的下标不能是负数

数组的使用

初始化

A=[1,2,3]

A=[0forIinRange（0,100）]//100个0的数组

A=[IforIinrange（0,100）]//100个键分别是0,1,2,….,99

A=[f（i）forIinrange（X,Y）]//Y-X个键，值是i在[X,Y）中取值为作为f（i）的输入的输出

切片操作

切片获取

A[N:

M]=[A[N],…,A[M-1]

A=[1,2,3,4]

A[1:

3]=[2,3]

A[0:

1]=[1]

切片插入

A=[0,1,2,3,4]

1]=[5,6,7]#insert3elementsatposition1

A=[0,5,6,7,1,2,3,4]

aa=[[1,1]]

aa[0:

0]=[[2,2]]

printaa//=[[2,2],[1,1]]

切片尾追加元素

A[-1:

-1]=[5,6,7]

A=[0,1,2,3,4,5,6,7]#insert3elementsatend

切片替换

3]=[5,6,7]#3replace2atbeginpointof1

A=[0,5,6,7,3,4]

可以不等个数地替换

切片删除

3]=[]#2replacewithnull,itisadeleteoperation

A=[0,,3,4]

切片生成新数组

ABCDE"

line[1:

4][2]#=D

键操作

键排序

A=[3,2,1]

A.sort（）

键逆序

A.reverse（）

所以sort与reverse操作可以实现大小排序

插入一个键

A.insert（1,4）

A=[3,4,2,1]

尾部增加一个键

A.append（4）

A=[3,2,1,4]

多维数组动态添加

L2CodeTable=[]

foriinrange（0,L2CodeTableNum[0]）:

L2CodeTable.append（[0,0,0]）#动态创建了多维数组

DelA[1]

A=[3,1]

函数

Filefunctions

文件格式

importmsvcrt

文本格式os.O_TEXT,

二进制格式os.O_BINARY

msvcrt.setmode改变一个文件描述符的模式

主要解释一下Windows系统中text模式和binary模式的区别（Unix系统无此差别）：

text模式读取时，会将’\r\n’中的回车符去掉，变为’\n’,输出时会将’\n’变为’\r\n’。

而binary模式不做转换，和Unix中表现一样。

二进制文件读取

Unpack

msvcrt.setmode（0,os.O_BINARY）

outFile=open（coreName,'

rb'

strings=outFile.readline（）

aa=struct.unpack（"

l"

strings[0:

4]）#读取二进制数据，这里必须通过unpack进行解压获取

print"

aa=%x"

%（aa）

pack

a=20 

b=400 

str=struct.pack（"

ii"

a,b） 

#转换后的str虽然是字符串类型，但相当于其他语言中的字节

第一个参数：

格式序列

第2到第N+1个参数，为要压缩的参数。

如果后面有N个参数，则前面格式序列字符窜中就要有N个格式关键字

把a,b两个数字压缩为intint格式的字符流

因为两个数字都压缩为int了，都为4B，所以一共为8B

Pack/unpack格式关键字

注，下面数字返回的是一个具有一个元素的数组

下面是字符和unpack出来的数据类型的关系。

xpadbytenovalue

ccharstringoflength1

bsignedcharinteger

Bunsignedcharinteger

?

_Boolbool

（1）

hshortinteger

Hunsignedshortinteger

iintinteger

Iunsignedintintegerorlong

llonginteger

Lunsignedlonglong

qlonglonglong

（2）

Qunsignedlonglonglong

（2）

ffloatfloat

ddoublefloat

schar[]string

pchar[]string

Pvoid*long

Open&

close

datFile=open（file,'

r'

datFile.close（）

readline&

readlines

datFile.readline（）

1.readline

a）第一次读取时是从文件的头开始的

b）读取文件一行，读取的最后一个字符是\n（所以直接打印出来会自动换行）

i.读到’\n’则会返回读取的字符串

c）读取后，会记录下次读取的起始位置

i.所以读取是顺序向后读取的

2.readlines

a）读取整个文件

Write（‘x’）

datFile.write（‘x’）

1.把’x’写入文件中

a）第一次写时，是从文件的头开始的

b）写完后会记录下次写的位置

c）所以是顺序向后写的

2.与readline的处理方式类似

file=open（'

testfile.txt'

w'

file.write（'

1\n'

12\n'

123\n'

file.close（）

1

12

123

Writelines

file.writelines（['

12'

'

34'

]）

一次写入多个字符串。

等效与write与+号结合

它与write函数是串行顺序写入的，即也是接着彼此的写指针往后写的

file=open（'

aaa.txt'

34\n'

56\n'

78\n'

9a\n'

+'

bc\n'

34

56

78

9a

bc

文件名修改

os.rename（'

bbb.txt'

ccc.txt'

）#把文件bbb.txt重命名为ccc.txt

文件的行操作

importlinecache

3_2.txt'

lines=file.readlines（）

获取行数

linecount=len（lines）#getfilelinenumber

获取某行的内容

linecache.clearcache（）#clearcache

line=linecache.getline（'

5）#getline5[1,MAX-Line]

Line=lines[i]#i=[0,MAX-Line-1]

删除某行的内容

lines[x]='

'

dellines[x]

替换某行的内容

lines[x]=‘XXXXX\n’

写入所有行到文件

文件copy

file.write（"

"

.join（lines））

字符串处理函数

常用简单操作

linex.split（‘x’）分割

1.以指定的字符或者字符串为分割符，把字符串分成N个段，变为一个数组列

2.如果不指定分割符，则默认通过空格分割

a）不指定分割符时，则是以1个或者N个连续的空格为分割符。

空格个数是动态的。

b）如果指定分割，即使指定的是空格，则按照指定的空格个数严格匹配

c）所以，不指定分割符，对于空格分割更有通用性

line='

11211121111'

elements=line.split（'

2'

printelements[0]

printelements[1]

printlen（elements）

elementsx=linex.split（）#getitselements

beginAddr=long（'

0x'

+elementsx[2],16）

11

111

3

linex.replace（‘x’,‘y’）替换

把字符或者字符串’x’替换为字符或字符串’y’，产生并返回此新的字符串

如果’y’为空则表示删除字符串中的’x’,

123321"

printline

line=line.replace（'

33'

123321

1221

ASCII以及进制转换

Test1-uppercasecharacter>

bin

>

converter（'

A'

bin'

Bin:

01000001

Test2-lowercasecharacter>

a'

01100001

Test3-number>

00110010

Test4-specialcharacter>

$'

00100100

Test5-specialcharacter>

%'

00100101

Test6-uppercasecharacter>

oct

oct'

Oct:

101

Test7-lowercasecharacter>

141

Test8-number>

062

Test9-specialcharacter>

076

Test10-specialcharacter>

077

可以直接赋值

赋值即覆盖

abcd'

line2='

qwerty'

line=line2

printline//qwerty

+相当于cat

newLine=lines[0]

newLine+=lines[1]

newLine+=lines[2]

数组化以及与数组的区别

字符串可以作为字符数组使用

printline[0]

printline[1]

printline[-1]

2

4

区别：

可以切片，但是不可以对切边赋值

也不可以对单个元素赋值修改

字符串list化

把字符串完成安装list处理

line=[]

line[-1:

-1]='

XXXX'

Item=len（line）

FileX=open（'

0000.txt'

foriinrange（0,Item）:

FileX.write（line[i]）

FileX.close（）

优点

可以对单个字符进行任意操作，也可以添加，替换某个或某段字符

缺点

打印和保存到文件中是，必须一个一个字符进行写入。

因为它本质不是字符串

Sring组件使用

importstring

可以有很多特别的定义

hexdigits=string.hexdigits#16进制数字的字符序列

ifxnotinhexdigits:

如果x不是16进制的字符序列

digits=string.digits#10进制数字的字符序列

string.join#连接字符串

还有大写字符，小写字符等功能

UserString组件使用

定义一个可变字符串

out_str=UserString.MutableString（）

out_str+='

XXX'

out_str[0]=‘’C

printout_str//=CXX

一般的字符串是不可以这样去修改某一个字符的。

缺点：

不能写成文件.不如数组化处理

可变字符串数组处理

strx=[]#空数组

strx+="

12345678"

#则为字符串数组

printstrx#['

1'

3'

4'

5'

6'

7'

8'

strFF=struct.pack（"

B"

0xFF）

strx[0]=strFF

strx[1]=strFF

printstrx#['

\xff'

printlen（strx）#8

FileBin=pBinFile.openBinFile（'

0000.bin'

foriinrange（0,len（strx））:

FileBin.write（strx[i]）

FileBin.close

strx=FileBin.readlines（）

printstrx[0]##？

？

345678

printlen（strx[0]）#0

aa=