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=
升级会员 