python学习笔记.docx

python学习笔记.docx

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

python学习笔记

问题

词法

与VB语言通用的关键字

If/ifnot/else/for/while/return

Break/continue

foriinrange（1,3）:

printI#i=1,2

逻辑运算：

Or,and,

函数形参数值传递

与C语言一样，形参的变化不影响实参

数组

[-N]下标表示取倒数第N个键，不能越界

line="1234"

printline[0]+line[1]+line[2]+line[3]

printline[-1]+line[-2]+line[-3]+line[-4]

1234

4321

全局变量

myVariable=1

defaFunction（）:

globalmyVariable

myVariable=myVariable*2

printmyVariable

在函数中使用是要加global关键字

特别的词法

Def函数定义

定义一个用户函数

defreadFile（file,addr）:

它的返回只是通过return的。

也可以没有返回值。

当空行且不在def的缩进之内的代码出现即表示函数结束。

（没有返回值的函数，其实返回的是None ）

defgetFile（addr）:

Try:

finally

异常处理机制。

在try作用域的代码中，如果出现异常，会直接跳到finally处理。

如果没有出现异常，在try结束后也会跑到finally里面

通常finally里面都是一些回退操作，比如文件的close等。

模块import

Python可以引用已经写好的模块或者其它py文件中的函数与变量

只要import就可以了

把全局变量定义在一个单独的模块中：

#gl.py

gl_1='hello'

gl_2='world'

在其它模块中使用

#a.py

importgl

defhello_world（）

  printgl.gl_1,gl.gl_2

自定义模块

把全局变量定义在一个单独的模块中：

#gl.py

gl_1='hello'

gl_2='world'

在其它模块中使用

#a.py

importgl

defhello_world（）

  printgl.gl_1,gl.gl_2

Python文件调用另一文件

execfile（"pythonfilename"）

或者

importos

os.system（"pythonfilename"）//可以传入参数

或者

os.popen（"pythonfilename"）//可以获取输出

系统模块

Os

Sys

字典的使用

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

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

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

它的成员个数是可变的。

创建字典

dict1={'m1':

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

隔开，用{}定义字典

dict1={'y':

-1,'x':

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

dict1={}.fromkeys（（'m1','m2'）,-1）#创建一个具有两个键的字典，键的初始化值都是-1

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

删除字典

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

字典定义分行写与注释

dict={

'm1':

#sss

'm2'#sss

}

添加一个键

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

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

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

删除一个键

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

clear删除所有键

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

常用的字典方法

dict1={}

dict1['m1']=1

dict1['m2']=2

dict1['m3']='MM3'

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

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

[（'m1',1）,（'m3','MM3'）,（'m2',2）]

printdict1.keys（）#列举全部键

['m1','m3','m2']

printdict1.values（）#列举全部值

[1,'MM3',2]

获取字典键个数

print'ItemNum=%d'%（len（structVal.keys（）））

print'ItemNum=%d'%（len（structVal.values（）））

print'ItemNum=%d'%（len（structVal.items（）））

has_key查找是否有某键

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

dict1.has_key（'m1'）#=True

dict1.has_key（'m4）/#=False

get获取键的值

dict1.get（'m1'）#=1找到，返回其值

dict1.get（'m4'）#找不到返回字符串None

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

setdefault获取键值

printdict1.setdefault（'m1',100）#=1对于已经存在的键，第二个参数没有用

printdict1.setdefault（'m4',100）#=100对于不存在的键，第二个参数则是初始值

update两个字典键值添加

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

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

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

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

Copy两个字典

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

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

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

一键多值字典

不可变键值方式

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

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

引用键的某个值的方法是

dict1['m1'][0]#=-1OK

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

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

数组可变键值方式

dict={'m1':

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

dict['m1'][0]=32

数组字典使用的技巧

dict={

'm1':

（[1,21]）,#sss

'm2':

（[21,22]）#sss

}

forelementindict.items（）:

printelement[1][1]

这里每个element就是

[（'m1',[1,21]）和（'m2',（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]

A[1:

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

切片替换

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

A[1:

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

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

可以不等个数地替换

切片删除

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

A[1:

3]=[]#2replacewithnull,itisadeleteoperation

A=[0,,3,4]

切片生成新数组

line="ABCDE"

line[1:

4][2]#=D

键操作

键排序

A=[3,2,1]

A.sort（）

A=[1,2,3]

键逆序

A=[1,2,3]

A.reverse（）

A=[3,2,1]

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

插入一个键

A=[3,2,1]

A.insert（1,4）

A=[3,4,2,1]

尾部增加一个键

A=[3,2,1]

A.append（4）

A=[3,2,1,4]

多维数组动态添加

L2CodeTable=[]

foriinrange（0,L2CodeTableNum[0]）:

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

删除一个键

A=[3,2,1]

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=open（file,'r'）

datFile.readline（）

1.readline

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

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

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

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

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

2.readlines

a）读取整个文件

Write（‘x’）

datFile=open（file,'r'）

datFile.write（‘x’）

1.把’x’写入文件中

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

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

c）所以是顺序向后写的

2.与readline的处理方式类似

file=open（'testfile.txt','w'）

file.write（'1\n'）

file.write（'12\n'）

file.write（'123\n'）

file.close（）

1

12

123

Writelines

file.writelines（['12','34']）

一次写入多个字符串。

等效与write与+号结合

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

file=open（'aaa.txt','w'）

file.writelines（['12\n','34\n']）

file.writelines（['56\n','78\n']）

file.write（'9a\n'+'bc\n'）

file.close（）

12

34

56

78

9a

bc

文件名修改

importos

os.rename（'bbb.txt','ccc.txt'）#把文件bbb.txt重命名为ccc.txt

文件的行操作

importlinecache

file=open（'3_2.txt','r'）

lines=file.readlines（）

获取行数

linecount=len（lines）#getfilelinenumber

获取某行的内容

linecache.clearcache（）#clearcache

line=linecache.getline（'3_2.txt',5）#getline5[1,MAX-Line]

或者

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

删除某行的内容

lines[x]=''

或者

dellines[x]

替换某行的内容

lines[x]=‘XXXXX\n’

写入所有行到文件

file=open（'aaa.txt','w'）

file.writelines（['12\n','34\n']）

file.writelines（['56\n','78\n']）

file.write（'9a\n'+'bc\n'）

file.close（）

文件copy

file=open（'aaa.txt','r'）

lines=file.readlines（）

file.close（）

file=open（'bbb.txt','w'）

file.write（"".join（lines））

file.close（）

字符串处理函数

常用简单操作

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’,

line="123321"

printline

line=line.replace（'33',''）

printline

123321

1221

ASCII以及进制转换

Test1-uppercasecharacter>bin

>>>converter（'A','bin'）

Bin:

01000001

Test2-lowercasecharacter>bin

>>>converter（'a','bin'）

Bin:

01100001

Test3-number>bin

>>>converter（'2','bin'）

Bin:

00110010

Test4-specialcharacter>bin

>>>converter（'$','bin'）

Bin:

00100100

Test5-specialcharacter>bin

>>>converter（'%','bin'）

Bin:

00100101

Test6-uppercasecharacter>oct

>>>converter（'A','oct'）

Oct:

101

Test7-lowercasecharacter>oct

>>>converter（'a','oct'）

Oct:

141

Test8-number>oct

>>>converter（'2','oct'）

Oct:

062

Test9-specialcharacter>oct

>>>converter（'>','oct'）

Oct:

076

Test10-specialcharacter>oct

>>>converter（'?

','oct'）

Oct:

077

可以直接赋值

赋值即覆盖

line='abcd'

line2='qwerty'

line=line2

printline//qwerty

+相当于cat

newLine=lines[0]

newLine+=lines[1]

newLine+=lines[2]

数组化以及与数组的区别

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

line="1234"

printline[0]

printline[1]

printline[-1]

1

2

4

区别：

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

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

字符串list化

把字符串完成安装list处理

line=[]

line[-1:

-1]='XXXX'

printline

Item=len（line）

FileX=open（'0000.txt','w'）

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','2','3','4','5','6','7','8']

strFF=struct.pack（"B",0xFF）

strx[0]=strFF

strx[1]=strFF

printstrx#['\xff','\xff','3','4','5','6','7','8']

printlen（strx）#8

FileBin=pBinFile.openBinFile（'0000.bin','w'）

foriinrange（0,len（strx））:

FileBin.write（strx[i]）

FileBin.close

FileBin=pBinFile.openBinFile（'0000.bin','r'）

strx=FileBin.readlines（）

printstrx[0]##？

？

345678

printlen（strx[0]）#0

aa=