寒木

python总结

import py_compile

py_compile.compile(1.py)

以上在python交互界面输入

引用库模块，进行编译。编译完成后当前文件下产生1.pyc

运行时同样python 1.pyc

Python -O –m py_compile 1.py 产生1.pyo 在linux的shell中输入，次为优化编译。运行也是python 1.pyo

在python交互下变量名只是缓存。退出python后变量名消失，在脚本中也是，脚本执行完则变量消失。

type(a) 显示变量类型

id(a) 查看a在内存中的位置

当数据相同时，变量指向一个内存位置，变量只是标签。

9/2 显示4

9.0/2 显示4.5

9.0//2 得 4，取整

9%2 得1 ，取余

2**3 为2的3次方

1>2 返回False

1<2 返回True

x=1>2 x为False

== 判断是否相等

= 赋值

x = 1+2 and 2-2 x为False,非0为True，0为False

x = 9 x为整型

x =9L x为长整型

‘a\nb’ 打印时a与b间有回车。但内存中存储是a\nb

在python中‘’与“”没有任何区别

“”” a ds ””” 保存格式如回车与 ‘’’ a ds ’’’相同

Hello / 另一行输入world 其中/为续行符号，打印后同行输出

当命令写入一行是用；分号连接

print x，a 这里x和a都是变量这里用“，”而不能用空格

print ‘x’,’a’ 这里打印结果是 x a

print ‘x’ ‘a’ 这里打印结果是 xa 只有字符串在直接打印时可以用空格也可以不用空格。但结果没有空格

9．

name = raw_input () 注意此函数接受的都是字符或字符串

a = input() a只能为int

a=100 str(a)此函数返回为字符，但a仍为int

10.

print 2,3 结果 2 3

print （2,3）结果（2,3）

11.

pow( 2,3) 为2的3次方

round() 四舍五入运算

abs(-2) 返回绝对值

coerce(num1,num2) 将num1与num2转化为同一数据类型

divmod(num1,num2) 返回num1//num2后的整数和余数

第二天

str1 = ‘hello’

str1[0] 索引都是从0开始

str1[0]+str1[1] 拼接结果 he

str1[-3:-1] 结果为 ll 默认都是从左往右切

str1[2:0:-1] 结果为le

str1[3:5] 注意此时5已超出索引，但仍然可以切割

tom=[25,’male’] tom[0]=20 则tom=[20,male] 且数据id不变

tom.append(‘tom’) 往列表中增加，往后加

tom.remove(‘tom’) 删除列表中的tom

del a[2] 删除列表中的标号为2第三个元素

增加删除元素的上述函数只能对列表操作

当元组中只有一个字符串，则返回为字符串类型，若要返回仍为元组则要在后面加逗号

tom=(‘male’) tom为字符串

tom=(‘male’,) tom为元组

tom=() tom为元组

a+b 序列连接无空格，在列表中有逗号

tom*5 ‘#’*10 重复序列内容

25 in tom 判断元素是否在序列中（可以是字符串）返回True

20 not in tom 不在返回True

在字典中是判断key key in dic 判断value不行

dic={‘age’: 25 , ’gender’: ’male’ , ‘tel’: 124354}

索引就是dic[‘age’]

list(123) 不能将int型转化为序列

list(‘123’) 结果为 [‘1’, ‘2’ ,’3’] 序列间可以转化

注意将list转化为str 结果是整个列表做为一个字符串包括中括号 str(a) 结果为 ‘[ ‘1’,‘2’, ’3’]’ 序列间转化id都变

help(max) 帮助

help(list.append)

0和0.0都是False 字符串空为False 返回值None也为False

10.

if ~ :

elif ~ : pass

else :

11.

range(100) 产生0到99的列表

range(1,10,2)产生10内奇数

12.

from _ _ future_ _ import division 除法模块

#coding:utf8 可中文输入

Import random

x =random.randint(1,100) 随机产生100内整数

13.

bool() 转化为布尔值。如bool(None)

第三天

for x in range(5):

print ‘a’ ,

加逗号,水平打印

想输竖直打印时直接 print

range(10) 产生0到9的列表

range (1,10,-1) 产生9到1的倒序列表

while 和for 循环中跳出用break ，但只跳出循环。跳出程序用 exit()

在循环中continue 跳过以下代码，执行下一个循环。

x[len(x)-1]与x[-1]都是最后一个

for i in x 为遍历

for i in range(len(x)) 将x中的索引取出

print ‘做个’+x+’元’ 此时x与字无空格

def maxFun(x,y=’a’) :

两个单词以上第二个要大写

默认值必须要从右到左有

赋值给第二个或第三个要

maxFun(y=3) 写出形式参数名

一旦出现return则函数马上终止

每一个函数都有返回值，默认为None

局部变量永远不能在外边用，即函数内的变量不可全局调用

a =’test’

def fg():

a = ‘new’

fg()

print a 输出为test 此处a与函数内局部变量a没关系

a =’test’

def fg():

globala 此处不能global a=‘new’

a = ‘new’

fg()

print a 输出为new

如果函数不被调用，即使里面定义了全局变量，也不能用

10.

将元组的数据传入函数中

a = (2,3)

pow(*a)

在实际参数前加个*

11.

a = [i+1 for i in range(5)]

将range(5)的元素分别赋给前面的变量x，然后产生一个新列表

12.

chr() 将ASCII码转为字符

13.

字符 ’a’ <’b’ 返回True

比较是按ASCII值返回True和False

第四天

isintance(a,int) 用于检测变量类型，返回True或False

range(10) 直接产生列表，速度快

xrange(10) 需要一个生成一个，节省内存

filter( 函数() , [ ….. ] ) 将参数交给前面的函数，只要返回True则参数将保留下来，产生新序列。如果返回None，则保留所有元素。

a =[‘a’ , ‘b’, ‘c’] b = [1, 2 ,3]

map(None,a,b) 返回[ (‘a’,1), (‘b’,2), (‘c’,3) ]

def fun(x):

return x+5

map(fun #此处不用加函数的括号 ,b) 返回列表[6,7,8]

zip(a,b) 返回[ (‘a’,1), (‘b’,2), (‘c’,3) ] zip中不能加函数

5．

def fun(n):

if(n>1):

n=n*fun(n-1) 阶乘

return n n的阶乘递归调用函数本身,递归调用必须让形参本身与得到递归值

def fun (x,y):

returnx*y

reduce(fun, range(1,6)) reduce 取前两值进行运算，结果再取下一值进行运算 5的阶乘5！

reduce(fun ,[….], 2 #作为运算的第一个值)

str中用的方法

一种直接调用 h.capitalize()

另一种引入模块 import string string.capitalize(hw)

hw=’hello’

hw.capitalize() 得字符串首字母大写

h.replace(‘h’,’g’，1 #换几个) 注意h本身不变，产生新字符串 string.replace(hw, ’h’, ’g’)

替换字符串中的字符

ip = ‘192.168.0.1’

ip.split(‘.’) 以‘ . ’分割字符串产生新列表，且新列表中不包含分割用的字符串

l=[‘192’,’168’,’0’,’1’]

‘ . ’.join(l) 将列表（列表用法）每个元素以‘ . ’分割，返回字符串注意此时要分割的列表在括号中，而用分割的字符串在前面, 注意与js中数组的join的用法区别，数组中分割的字符串在括号中。

s=’abcd’

s[::-1] 翻转字符串（列表也可以用，并且还可以用l.reverse()）

s.find(‘c’) 找‘c’的索引

s.rfind(‘c’) 从右往左找索引

a[4][1][4]三次元的索引

a,b=1,2 既a=1，b=2

a,b=(1,2)

t=(1,2)

a,b=t 元组解包

t=(a,b) 元组打包

for x in range(len(t))

print x 找出索引

for x in t

print x 找出元素

10.

l.insert(1,’test’) 在索引1前插入元素’test’ 列表特有

l.remove(‘test’) 删除指定元素

l.append(‘test’) 依次往后增加元素，堆栈

l.pop(1) 根据索引将元素弹出列表且返回改元素，默认弹出最右边的既出栈 pop可以根据key弹出字典中指定元素，但没有默认弹出项，因字典无序

l.pop(0) 先出第一个既队列

l.index(‘test’) 查出元素的索引，列表特有

l.index(‘a’,2) 从索引第2开始往后寻找，包含第二

l.index(‘a’, (l.index(‘a’)+1) ) 往下查找

l.sort() 将列表正排序

l.sort(reverse = True) 列表倒排序

l.reverse() 翻转列表

11.

字典不属于序列，字典里元素无序

dic[‘a’]=’abc’ 字典中没有‘a’为key时往字典里添加元素

del dic[‘a’] 删除字典中以‘a’为key的元素，列表也可用

字符串貌似没有删除单个字符函数

del( dic[‘a’]) 同上

dic.pop (‘a’) 弹出字典中‘a’为key的元素并返回

dic.clear() 清空字典

for x in dic:

print x 取出的是key

print dic[x] 取出的是元素

dic=dic.items() 先将将字典转化为元组的列表并返回列表

for x,y in dic: 然后再取出key与value

print x,y

dic.keys() 取key，并返回由key组成的列表

dic.values() 取value，并返回由value组成的列表

dic[‘fd’] key索引取值时若无此key则报错

dic.get(‘fd’, ‘no this key’) 此时取key若无报错，且返回后边编写的内容

dic.update (dic1) dic从dic1中升级，没有的增加，有的重新赋值

sorted(dic) 强制排序，按keys的顺序

12.

def fun()

def fun1()

v1={‘1’: fun,‘2’:fun1}[x]()

减少判断时间，缩短if语句运行时间。[x] 为key用来选择调用哪个函数，后的（）为形参，v1为函数的返回值，没有则为none

也可写dic[x]()同样也可直接写{…}[x]()

注意字典的函数不用加()

字典中不可以有命令如：print，所以此种用法，一定要将每个if语句写成函数再调用

if dic.get(‘存在的key’):

此时除非此value为False，否则执行if下的命令。

if dic.get(‘不存在的key’)：

此时if下的命令不执行。

这里dic.get()用来判断字典中是否有查的元素

#最好用 if‘key’ in dic：

13.

a = ‘abc%sd%def’

a%(‘a’,2) %s 格式化为字符串经验证此时写入int也可以 %d 格式化为整形数值

print a%(‘a’,2) 若要字符串输出%如5% 只需 5%%实验后发现5%一个%也可，若无传入值则所有%s都原样输出

14.

‘\n’ 换行 ‘\t’缩进空格可能是8个

‘\a’报警

a. strip()

s = ‘\nabc\n’

s.strip() 可去除两边的’\n’返回’abc’无参数时只对反斜杠特殊符号有意义。

s = ‘123abc456’

s.strip(‘123456’)返回’abc’

lstrip() 从左边开始匹配

rstrip() 从右边开始匹配

15.

import time 一定要引入时间模块

time.ctime() 显示时间

time.time() 显示时间戳

time.sleep(2) 休眠延时2秒

time.strftime(‘%y-%m-%d-%H-%M-%S’)

设定时间格式 %j 一年中第几天

datetime.datetime.now().strftime(%y-%m-%d-%H-%M-%S)

16.

字典的key也以是中文。

在vim编辑器中若‘’中的字符串为黑色，则是由于‘’为中文格式切换为’’

17.

while 1:

a= raw_input()

if a:

dic[a]()

按回车继续不退出

第五天

def fun(x,y)：

print x,y

a={‘x’:’a’,’y’:’b’}

fun(**a) 写一个*传递元组，写两个*传递字典，而且字典key必须对应变量，必须是变量的形参既‘x’ ‘y’

b=(x,y)

apply(fun,b) apply作用既向函数传元组和字典

apply(fun,(),a) 传字典一定要在前加个空元组

def test(x,*t )

print x

test(2,4,5) 形参前加* ，则传递时多余的参数作为元组存储起来，且可print t 查看

test(x=’1’,y=’2’,z=’3’) 此时多余的实参不能作为元组存储应在定义函数时 def test(x,*t,**d) 则多余的元素作为字典保存可print d 查看

这样在dic做if选择时可以解决了不同函数形参数不同的问题 {。。。}.get(z)(x,*t,**d)

Python默认库是/usr/lib64/python2.6/

‘’’ ‘’’ 还可以用于注释

import相当于将代码全部写入当前文件中

import m 引入m.py写有函数的模块注意不必写.py

m.maxFun() 调用m.py中的函数maxFun()

引入自定义模块，模块一定要与当前文件在同一目录下

Python默认找模块先在当前找，再去自带库中找，再找库目录下site-packages中，再没有则报错

模块在包中，目录中如有__init__.py则表示当前文件为包，此文件可以使空文件

函数存放在模块中，模块存放在包中

from m import testFun,test

从模块中导入testFun和test函数，导入后直接用既

testFun()而不用m.testFun() 且m模块中其它函数不能调用即使m.fun()也不行

在模块中内置属性有__name__

若模块内程序运行则__name__== ’__main__’ (注意为字符串要加引号)

而在模块被调用时__name__=’__m__’既模块文件名，其自动变为了文件名。

此可作为当模块中有程序，但在import此模块后不想让程序运行可以用来作if判断。在模块中

if __name__== ‘__main__’：

程序代码

内置属性__doc__既为程序中被’’’ ‘’’注释掉的内容，可以作为帮助说明些在模块中

在引入模块后在新程序汇总可以

print m.__doc__ 必须在m.py中的最顶端可以在#注释之下，否则返回None

print m.maxFun.__doc__在显示函数中的注释,注释也必须在函数的最顶端。

def fun():

pass

def test():

fun() 函数的调用嵌套

def test():

pass

def test1():

pass 定义嵌套只能在函数内使用，不能在主程序中使用

def fun(x):

if x<4:

print ‘hello’

fun(x+1) 递归调用

print x 当递归调用下还有代码时，在递归执行到最底层时，程序会依次往回执行各自的下一行代码，看上去就像一层层往上返

匿名函数lambada x,y : x+y 相当于def fun(x,y):return x+y分号前为函数的形参，分号后为函数的返回值，没有的话要加上None。优势在于一些用的少得小函数就不必再另外定义了

reduce(lambada x,y:x+y , [1,2,3])

def fun(x):

for i in xrange(x):

yield i 可以多次返回而return只返回一次,且返回值为生成器

g = fun(x)

print g.next()

print g,next() 一次生成数据，generator生成器

Iteration 迭代

def fun():

print ‘one’

yield 1

print ‘two’

yield 2

print ‘three’

yield 3

g=fun() 此时g为生成器

g.next()

生成器以堆栈形式生成，一次产生不能跨越

10.

中文在列表中存储时打印时不能作为列表打印只能作为单一元素打印出来

a = [‘张’，‘男’,’石家庄’]

print a，a[1:] 打印出的皆是在内存中的存储形式而不是汉字

print a[0] 张此时可以显示中文

第六天

正则表达式是一种小型的高度专业化的编程语言，它内嵌在python中，并通过re模块实现。

正则表达式模式被编译成一系列的字节码，然后由用c编写的匹配引擎执行。

[ ] 常用来指定一个字符集：[abc]其中为或的关系。元字符在字符集中不起作用：[ak$] 但^在字符集中表示排除[^abc] 排除a bc

^t 必须以t开头

p$ 必须以p为结尾

\ 转义将特殊符号变普通

\d 匹配任何十进制数：相当于[0-9]

\D 匹配任何非数字字符：相当于[^0-9]

\s 匹配任何空白字符：它相当于[\t\n\r\f\v]

\S 匹配任何非空白字符：它相当于[^\t\n\r\f\v]

\w 匹配任何字母数字字符下划线：它相当于[a-zA-Z0-9_]

\W 匹配任何非字母数字字符：它相当于[^a-zA-Z0-9_]

*指定前一个字符可以被匹配0次或更多次。

‘t*?’匹配符合的最短模式不加‘？’则是默认贪婪模式，加上？后只取符合的最短字符串。注意是 ’ *? ’合用应该也可与+合用

‘t+’ 表示匹配一次或更多次，和*的区别就是必须出现至少一次

t？ t匹配一次或零次：可以用于标识某事物是可选的

‘t{m,n}’ 该限定符的意思是至少有m个重复，之多到n个重复。{0，} 等同于*，{1，}等同于+，而{0,1}则与？相同

4．

编译正则表达式

import re

p=re.compile(‘ab*’)

p=re.compile(‘ab*’,re.I) 可以接受可选的标志参数，常用来实现不同的特殊功能语法变更。都是在编译时加入

要加‘ re . ‘

S 使匹配包括换行在内的所有字符

I 使匹配忽视大小写

L 做本地化识别匹配如法语等

M 多行匹配影响^和$

X 能够使用’’’ ‘’’格式，正则表达式更清晰易懂

当正则表达式只用一次时不用编译：

re.findall( t[io]p , 字符串)

‘\n’ 要匹配的字符串

‘\\n’ 为re.compile 取消反斜杠的特殊意义

‘\\\\n’ 为’\\n’的字符串实值取消反斜杠的特殊意义

此时只要在在字符串前加’r’反斜杠就不会被任何特殊方式处理 r’\\n’

在未编译时直接：

a=re.findall(r ‘\$’ ,’hello$’) 找匹配为$符号此时只用一个\ r是取消特殊符号意义，注意 ’ \n \t’与 ’ . ^ $ ’相同整体为一个特殊符号。

match() 决定re是否在字符串刚开始的位置匹配，返回对象

search() 扫描字符串在文中的位置，但仅找匹配到的第一个，返回对象。

a=’toptipfas

b=’t[oi]p’ 正则表达式

x=re.compile(b) 编译正则表达式

y=x.match(a) 匹配产生对象x.search()同理。不匹配返回None，且不看到。但y可作为if语句的判断条件，

if y: print ‘match find’

z=y.group() 匹配后查看匹配项只能用y.group()

z=y.start() 返回匹配后首字符索引

z=y.stop() 返回匹配后最后一个字符后面一个字符索引

z=y.span() 返回匹配起止索引，注意止索引为后一个字符的

y.findall(a) 匹配后返回所有匹配值，生成正则列表

x=y.finditer(a) 匹配后返回迭代器对象

z=x.next()

z.group() 才能查看匹配列表

a = ‘a[io][io]c’ 找两个字符

a=’^abc’ 找以abc开头的 ‘fd$’以fd结尾的

a=’^$’ 空字符，经试验无效

a=’a[^abc]d’ 找a与d间没有a b c 的

查看是否是邮件地址

mailer=r’\w{1,12}@[a-zA-Z0-9]+\.(com|cn)’

findall在有（）分组时，只返回（）中的内容，即使匹配有时会不返回值

注意在用 ‘|’时如 ‘com | cn’ 要分组，成 ‘ ( com|cn)’ 否则前面的整体将于cn来或，注意运算等级。

‘ . ‘ 代表一个任意符号

10.

s=’topfsdfatip’

e=r’t[io]p’

re.sub(e , ‘abc ’, s) 在字符串中查找并替换为abc

re.subn(e, ’ abc’ , s) 查找并替换后返回元组

(‘新字符串’，替换了几次)

str.replace(‘a’,’n’,1)无后参数时默认只替换一次，参数控制替换几个。

ip=’192.168+1+1’

re.split(r’[.+]’,ip) 切割字符串并返回列表，其中‘ . +’或集，元字符变为普通符号。

ip.split(‘ . ’) 效果相同，如果没有找到’ . ’则不替换但返回只包含本身字符串的列表

11.

打开网站所有内容为

import urllib

page = urllib.urlopen(网址) 打开网页所有内容

html = page.read() 将网页所有内容作为字符串读取出来

page.close() 打开后也要关闭

urllib.urlretrieve(图片地址，重命名) 下载地址内容到本地。

第七天

p= file(‘/etc/passwd’, ‘r’) 打开文件返回一个对象，注意前后参数都有引号

str=p.read() 读取文件内容，且返回文件内容。

回车保存方式为一个字符’ \n’

p.close() 关闭打开的文件

file(name,mode[.buffering]) buffering:设置缓冲，0表示不缓冲，>1表示缓冲区的大小（字节单位B）

mode有 r 只读。无文件时不能创建

r+ 读写。写入时看指针默认在文件开头写入，并替换原指针处字符。

w 写入，先删除原文件，再重新写入，如果文件没有则创建文件

w+ 同上但可以写入输出

a 写入。在文件末尾追加新内容，文件不存在则创建。

a+ 读写

b 打开二进制的文件，与r，w，a，+结合使用。如rb ， rb+。往图片末尾加字符串可能不影响图片。图片文件不用b的话，可能会丢失一些数据。

U 支持所有换行符（不同系统中）如’\r’

‘\n’, ’\r\n’

f.close() 文件打开后要关闭，才能看到写入内容，

或者在关闭之前f.flush() 刷新则不关闭也以写入内容。

g =f.read([size]) 读出文件所有内容，并作为整体字符串返回，此时赋给g。 size参数读出文件前size个字符，并输出给字符串，此时文件的指针指向size处

wordline =f.readline([size]) 每次读取文件一行，作为字符串返回，此时赋给wordline。size为每次每行读取size个字符，直到行的末尾

？？？？？？？？？？？？？？？？？？

list =f.readlines([size]) 多行读，返回一个列表，此时列表赋给list 。size，每次按全文size个字节，然后继续按size读字节，而不是每次读入行的size个字节。

？？？？？？？？？？？？？？？？？？

wordline = f.next() 返回当前行内容赋给wordline，并将文件指针到下一行，作用同f.readline()相同

f.write(‘abc’)写入时清空当前指针的字符，再写入

f.writelines([‘abc’,’def’]) 多行写，可以写入列表，效率比write高，速度更快

f.seek(0,0)前一个为移动量，字符为单位。后一个为0表示文件开头位置。

f.seek(1,1)表示当前位置后移一位。

f.seek(-4,1)表示当前位置向前移动四位。

f.seek(-1,2)倒数第一位。

Import os 需要调用os模块

os.mkdir(‘a’) 创建a目录

os.rmdir(‘a’) 删除目录a

os.makedirs(‘a/b/c’) 创建递归目录a/b/c

os.removedirs(‘a/b/c’) 可以删除递归目录a/b/c包括a和b

而如果是os.rmdir(‘a/b/c’)则只能删’c’

os.remove(‘1.txt’) 删除文件

os.listdir(‘./’) 当前目录中内容，做为列表返回，每个文件名是个字符串

os.getcwd() 当前绝对路径，作为字符串返回。

os.chdir(‘/’) 切换当前路径到根下

path =os.getcwd()

filepath =os.path.join(‘path’,’filename’) 给文件名加上路径

os.path.isfile(‘1.py’) 判断是否为文件，是则返回True不是则返回False

os.path.isdir(‘a’) 判断是否为目录，是则返回True不是则返回False

import shutil

shutil.copy(test.py , 1.py)引入shutil模块，复制test.py到1.py

g =os.walk(‘/home’) 返回生成器对象

f =g.next() 返回一个元组，（‘当前路径’，[子目录的列表]，[当前目录中文件的列表]）

g.next() 继续以子目录为参数向下产生元组。

g.next() 不断遍历，结果就是遍历了’/home’中的所有文件

for p,d,f in g: 此为便利g中的内容。注意在这下面如果有 g.next()则是遍历第二层目录了。

类：是对事物的抽象。对象：是类的一个实例。

变量：类中定义的变量称为‘成员变量’。也是类的属性

函数：类中的函数成为‘成员函数’。只有classmethod和staticmethod后才是类方法

类里面包含了变量和方法，这种包含也称值为‘封装’

类的名字首字母要大写。类里面包含了变量和方法，这种包含也称之为封装

var = ‘类的属性’ 直接定义在类中

私有方法：不能被外部的类和方法调用,私有方法的定义和私有属性的定义都是一样的，在方法的前面加上“_ _”双下划线就可以了

类的方法：

People.fun()为类直接调用类方法，既不必加’()’

需要使用classmethod（）把方法定义为类的方法

@classmethod

def fun(self):

或者fc = classmethod(fun)

@staticmethod

def fun(): 此处不必加self参数

或者fc = staticmethod(fun)

静态方法：可以被类直接调用，被所有实例化对象共享的函数，类似于‘全局变量’，可以称之为‘全局函数’

静态方法加载时将所有参数全加载到内存上，包括类变量，所以运行快，但占内存，而动态的类属性是用时再调用。

第八天

类中参数的用要加self如 self.name

类中方法的互相调用间用要 self.fun()

def set( self , x): 往类方法中传参数。

self.name= x 调用时直接写 a.set( ‘new’ ) 即可将类变量name变为new，重新赋值。

class Fun(): 类中有变量，函数，还可以有命令。其中命令在类实例化的时候执行

name =‘zhang’

printname

def f():

pass

a =Fun 将a直接看做Fun可这样用 e = a() 同e = Fun() 效果相同。但a并没有成为句柄，加括号才算实例化。此处为动态函数特性

b =Fun() 实例化 Fun为b，但不可以e = b()

内部类，类的内部定义的类，主要目的是为了更好的抽象现实世界

class Father:

class Son:

pass a = Father.Son() 实例化

x=Father() a=x.Son() 实例化第二种方法

构造函数：用于初始化类的内部状态：_ _init_ _()

a = ‘name’

def _ _init_ _(self ，a):

print ‘初始化 ’

self.a= ‘newname’ 此时实例化类时，首先自动运行，并将类变量a重新赋值为‘newname’以实现初始化。若开始无a则增加了a为变量（其实在方法函数中也可self.new建立新的变量）（此时创建的并不是类属性，而是对象的属性）

class Father():

name =‘ ’

def _ _init_ _(self, a): 注意当在init中有第二个变量时实例化时一定要给类一个参数，如 a = Father(‘123’)

self.name= a 通过_ _init_ _()可以实现直接对类的传值，此处可以x=Father(‘123’) 此处将‘123’赋给了name

注意方法函数中的self均不可省。

析构函数:用于释放对象占用的资源。

def _ _del_ _(): 主程序执行最后，自动运行。

f.close()

def _ _str_ _(): 返回为字符串，

return ‘gogo!’ print a 时才运行与_ _doc_ _类似

内置属性_ _dict_ _

class F():

a = ‘111’

def _ _init_ _(self):

self.b= ‘222’

x = F()

print x.__dict_ _ 显示{‘b’:’222’} 此时输出实例化对象的属性。b为有self来操作的，并不是类属性。

print F.__dict_ _ 显示{‘a’:’111’, ’_ _module_ _’:’_ _main_ _’,

‘_ _doc_ _’:None, ’_ _init_ _’:<对象>} 显示类属性。注意b不是类属性。

定义的函数间互相调用，可以不分上下，但在程序中调用函数，被调用的函数一定要在程序上方。与js不同，js中程序也由上到下执行，但函数可以在任何地方

继承 class F：

name= ‘zhang’

def drive(self):

print ‘I can drive’

class S(F):

pass

以“_ _”双下划线开始的成员变量就是私有属性，否则是公有属性

表示S子类继承自F父类，可用F父类中除私有内容外的所有内容，有同名变量和函数时用子类中的。子类中用父类中的变量要： class S(F): a=F.var def fun(self): print F.var即可方法中不能用self.F.var

多次继承 class S(F,U): pass 如果F与U中有同名属性和方法，则按现按先继承的算，后继承的不重新赋值。

子类用父类的初始化时可用：

def _ _init_ _(self):

F.__init_ _(self) 即可运行父类的初始化。

多态：就是用参数的形式来选择类的使用，这样使得程序可以控制类的调用，为复杂高效的解决实际问题提供了可能。

第九天

class Fun():

def test():

pass

@classmethod

def newTest():

pass

a = Fun()

a.test() 实例化的对象可以调用任意方法

a.newTest()

Fun.newTest() 只有类方法才可被类直接调用。而test()不行。

如果不是object新兴类，则staticmethod静态方法无用

面向对象编程三大特点：封装，继承，多态。

对象的三个特点：句柄，属性，方法。

__getattr__(类名，属性名) 调用类属性时自动运行

def get(self):

return __var 获取私有属性

_ _new__(cls,*args,**kwd) 实例的生成，在_ _init_ _()之前执行。是在实例化时执行。

单例模式：只能实例化一个对象。

注意次函数的参数是cls,不是self，此处cls指的是定义的类本身如下cls代表的就是类Ｓ

class S(object): 一定要写object，否则__new__方法不执行

_ _ a=None

def _ _new_ _(cls): 重写内置方法

if not cls.__a:

cls.__a= object.__new__(cls) #每次新型类实例化return cls.__a 都是 object.__new__(cls)

来执行的

a = s()

b = s()

print id(a),id(b) 此时a与b指向相同内存地址，可以实例化但，只生成一个对象

运算的魔术方法要重新写否则无效。

class c():

num =0

def__add__(self,other):

return self.num+other.num

def__gt__(self,other):

return self.num>other.num

a = c()

b =c()

a. num=20

b. num=10

print a+b

if a>b:

print ‘ok’

__lt__(self,other) 判断self对象是否小于other对象

__ge__(self,other) 判断self对象是否大于或等于other对象

__le__(self,other) 判断self对象是否小于或等于other对象

__eq__(self,other) 判断self对象是否等于other对象

class F():

def testFun(x):注意此外函数一定要有一个用作self的形参

F.fun = testFun 则将外函数变成类的成员函数，动态函数

a = F()

a. fun()注意此时fun()只是成员函数并不是类函数，类不能直接调用。

接收错误。

filename= raw_input()

try:

p= file(filename , ’r’)

p.close()

except IOError, msg:

print ‘您输入的文件%s不存在。’%filename

except NameError,msg: 在一个try中的错误，可以用多个except接受，但遇到第一个错误，try中以下代码不执行，不会接收下面其他错误。

passs

finally: 即使前面报错，仍然要执行的命令

pass

在实例化类时，如果错误发生在类的内部，则

try： a =Class()此时接受不到错误。在函数互相调用时，即可以加在调用函数那一步，也可以加在被调用函数内。最好用在被调用的函数内，因一旦报错，则函数内下面的其他代码不执行了

x = raw_input()

if t == ‘x’:

raise NameError(‘您输入了x名字错误’) raise主动抛出异常。

注意此时抛出的异常必须是已有的异常名，不能随便写。

with as 文件操作

第十天

如果启动mysql失败可能是安装问题只安装了客户端应该

yum install mysql mysql-server mysql-libs

chkconfig mysqld on 开机自动运行mysql

或者在ntsysv图形界面用空格选择用tab建选择确定。

show databases; 显示库

use test; 使用库

show tables; 查看库中的表

select * from listname 看表格中存储的内容。

百度MySQL手册

show creat database python;查看创建过程

drop database python;删除

create database python default character set utf8:

创建可存中文的表。

alter database python default character set latin1; 修改

creat table info(id int(2), name char(10))

前为列名，后为列类型，之间用空格。注意此时id和name相当于变量，不需要引号

id int(2) not null(不能为空) primary key(主键约束不能重复) auto_increment(自增长)

name char(10) not null,注意此时不能把notnull写在char(10)前，否则报错

age tinyint unsigned 0~255无符号小整形

gender enum(‘s’, ‘m’, ’f’) 枚举只能是括号中的三个之一。

show create table info;显示创建信息

desc info; 查看表的结构和信息

drop table info 删除表

insert into info value(1,’tom’,24,’m’);向表中传值。

insert into info(name,age) value(‘rose’,23) 向表中传指定值。

若果id设置了自增长，不能为空，则在传值时，可以不写每一项，而在后面给个null值

insert into info value(null，‘rose’,23)

update info set name=’wang’,age=24 where id =3;

修改在id为3时的name 和age之间用逗号注意此时无table

delete from info where age=3

删除在age=3时的那一整行。

第十一天

登陆客户端

mysql -h + IP -u+用户名 -p+密码

不能创建空表，即至少有一列。

desc info; 产看表的结构。

name varchar(10) 灵活存储最多10个字节

id int(2) zerofill 填充空位结果为 01 02

set(‘a’,’b’,’c’) 枚举多选注意传值时value(‘ a,b ’)

enum(‘a’,’b’,’c’) 枚举单选

alter table gender default character set latin1;

???????????????????????????????????

alter table info add tel char(2) [after name]

[在name]后增加列 tel

alter table info add id char(2) first;

在最前面增加一列，注意first后面没有参数。

alter table info drop tel;

删除tel列。

更改列的类型，但名字不变

alter table info modify gender enum(‘男’, ’女’);

更改列名称类型：

alter table info change oldname newname enum(‘男’, ’女 ’);

7．

insert into info(name,age,gender) values(‘tom’,20,’m’),(‘jack’,21,’f’)

注意此处第一项id并没有传值，但id由于前面设置，默认从1开始递增。在value后加s可传多行值。实验后发现value不加s也可传入多值。

select name,gender from info where id=2;

select * from info where age>=25 and age<=30;

age between 25 and 30;

select * from info where age is NULL; 年龄为空此时用is

注意只有判断为NULL时才可用is（可以是is not），而在某些不能为空的not null指定后，不符合NULL，搜索不出来。

where name like ‘zhang%’ %表示任意多个字符。

where name like ‘zhang_’ _表示一个字符,_ _两个，几个表示几个。

select distinct gender from info; 去除重复项，用来看总共有几种。

select * from info order by age; 按年龄升序排列查找，注意此时并没有对原数据进行修改。

order by age desc;倒序

select * frominfo order by age desc limit 3；

倒序排列取前三。limit 1,3 往下移动一位，再取相对前三。

select 1+2;

select 1*2;

select 1/2;

可直接进行运算。

10.

select sum(age) from info; 查年龄的总和

select max(age) from info; 查年龄的最大值

注意sum max等函数只有在select中发生作用，并且不能用到where条件中。

11.

select count(*) from info; 查看总共多少行。

select count(*) , gender from info group by gender

按gender分组后显示各个类型包含的数量。

12.

select info.name, score.yuwen ,score.shuxue from info , score where info.id = score.id;

查看两表相关联内容。

select name as ‘名字’，age as ‘年龄’ from info as i 为查找出的那列命名别名，注意表名不能命名为中文

13.

主表，从表（附属表）。外键约束，当主表不存在记录时，从表无法添加。但从表的自己的id仍然会往加上，只是不显示。再加入一个在主表的数据则，会看到从表的id已经跳过一个继续增加。

只有引擎为InnoDB的才支持外键。所以要将主从均改为此引擎。

alter table info engine=InnoDB; 更改主表引擎。

create table score(

id int(2) notnull primary key auto_increment ,

uid int(2),

yuwen tinyint ,

shuxue tinyint ,

foreign key (uid) references info (id) 注意此也在括号内

) engine=InnoDB;

select name, yuwen , shuxue from info , score where info.id =score.uid; 此时不必加info.name 的info.和score.yuwen中的score. 但是仍然要加where info.id = score.uid

14.

name char 不写几个时，默认是一个字符。即a

经试验每个汉字最小显示的字符为3即

name char(3);

15.

mysqladmin -uroot password ‘123456’ 设置密码

mysql -uroot -p 回车这样输入密码不显示

mysql -uroot -p123456 登陆

忘记密码时（必须同时是linux和服务器管理员）

a. 停mysql服务

b. 在系统终端输入mysqld _safe -- skip- grant-tables &此为无密码验证模式(最好启动后加&，否则会一直占用终端)

c. 在另一个终端中进入mysql,在mysql库中，表User

select Host,User,Password from user;

upadate userset password=’’ where Host=’localhost’

and User=’root’; 将密码删除。

d. 关闭mysqld服务，开启。注意此时不能用重启。

16.

备份数据库

cd /var/lib 中保存数据库文件。

mysqldump -A > all.sql 备份所有。Vim打开后看到全是库的创建命令。在当前路径下创建文件。

mysqldump -A < all.sql 恢复文件。

mysqldump -B python > python.sql 备份库

最好用mysqldump -uroot < python.sql 恢复文件

可在mysql交互模式下输入source python.sql;

第十二天

python 控制数据库要装MySQL-python包

import MySQLdb 要引入模块

selecet age + 10 from info;

运算查询，原数据不变。

{ 。。。。}.get(x,exit)() 效果为按任意键退出。

while 1:

a =raw_input()

if a:

{ }.get(a,exit)() 效果为按回车继续但其它键退出

注意此时数据库的引擎最好不要是InnoDB的, 使用InnoDB之类的存储引擎管理表的时候需要手动提交事务，否则所有的更改都变得无效

如果是InnoDB引擎的话有两种办法解决：

一在关闭数据库连接之前执行 conn.commit()

二在初始化数据库连接的时候即下面这条指令下面加

conn.autocommit(True)

不是InnoDB的加上也不影响

conn=MySQLdb.connect(

user=’root’,

host=’127.0.0.1’,

passwd=’’，

db=’n8test’, 也可在连接时直接选择库名，省下面的选择库指令

)

连接数据库返回对象。括号中为默认值，不写也行

curs=conn.cursor() 创建游标对象，句柄用来发送指令，返回游标对象。

curs.execute() 用来发送执行的命令。

curs.execute(‘create database python’)创建库python

conn.select_db(‘n8test’) 选择库

curs.execute(‘create table test(id int,name char(20))’) 创建表test

curs.execute(‘insert into info value(%s,%s)’,(2,’lisi’)) 这个函数还可以往指令里传值，但注意后面是以元组方式传入，且原样传入，即连lisi的’ ’ 也传入。因value的值即为表中的值，本身就有引号。

curs.executemany( sqli ,[ (1,2,3), (1,2,3), (1,2,3) ] )

传入多值注意后面参数用列表中的元组表示。

查找 i = curs.execute(‘select * from test’) 返回为查找到的符合要求的行数。

注意i = curs.execute()的返回值永远是：操作指令影响了几行数据，如用curs.excutemany(‘insert into …’,[ (),(),() ] )插入多条数据，则返回值为插入了几行数据。 i = curs.execute(‘select * from test’)此时指令显示几行，则返回几。

curs.fetchone() 迭代产生每行内容以元组形式返回。

curs.fetchone() 继续向下返回行的元组，超出为None并不报错。

curs.scroll(0,’absolute’) 相当于控制指针，使回到开头位置再curs.fetchone()返回行内容，但之前一定要执行curs.fetchone()指令。

curs.fetchmany() 也是迭代，无参数时和curs.fethone()功能相同

curs.fetchall() 结果也返回大元组，结果与fetchmany(i)有参数的效果相同，几个由前面的execute指定决定

select name，age from info 后则在fetchall中每个小元组中就没有了其它前面没有列出的项

curs.fetchmany( i ) 返回结果为一个大元组，每行一个元组作为一个元素。

显示可用：

for my in curs.fetchmany(i): my为每行的元组。

print ‘id:’,my[0],’name：’,my[1]

最后要关闭游标 cursor.close()

关闭连接 conn.close()

curs.execute(comd,(x,y) ) 此函数只能传表格内容的值value内的，都是在命令中加引号的。不可以穿列表项如id name这样的值，因它们在命令中无引号，而在此函数中不加引号又会当做是变量，故此类传值应该在comd本身完成,

comd = ‘insert into test( ‘ , x , ‘ ) value(%s)’

注意x左右两边的空格要加到字符串上，不要漏了，在写查询时一定注意 ‘where ‘ +x+ ‘ like’ 变量前后的空格

curs.execute(comd, y ) y是value的值此时可以双参数传入

或者直接在comd全部传入：

comd = ‘insert into test( %s ) value(%s) ’ %(x, ‘ ” zhangsan ” ’) 此时后面value的值只能传确定值，不能是变量，且用两层引号，因传入后value后的值本身就有引号。

电话有11位。故不能用 tel int(11) 因int最多到21亿，最多为10位，最好也不用float(11) 因很可能显示为科学计数法1.234567e10。所以电话存储要用字符串: tel char(11)

模糊查询

comd = ‘where name like %s”%%”’ 在字符串中双百分号可实现单半分号输出。且由于在值中，本身有 ’ ’ 所以要再加双引号。

第十三天

数字，字符串，元组在内存中的地址不可变。

列表和字典改值时在内存中地址不变。

import copy

a=[1,2,[‘a’,’b’]]

b=a

c=copy.copy(a) 浅拷贝，只拷贝父对象

d=copy.deepcopy(a) 深拷贝，拷贝所有数据

列表相当于标签的集合。

a. append(3)

b=[1,2,[‘a’,’b’],3] 此时因对列表数据段本身操作，故标签b的内容也会变

c=[1,2,[‘a’,’b’]] 此时c为拷贝列表中标签无变化，故数据不变。

d=[1,2,[‘a’,’b’]] d当然也不变，深拷贝后无论原数据怎变都和它没有关系。

a[2].append(‘c’)

注意此时c也会跟着变c=[1,2,[‘a’,’b’,’c’] ] 因对于a[2]这个标签的数据，c[2] 也指向同一处数据，即浅拷贝，不能拷贝子对象数据的标签。

id(a) 与id(c)不同，整形地址不变即id(a[0]), id(c[0])

id(d[0]) 相同。列表地址id(a[2])与id(c[2]) 相同

但id(d[2])与它们不同。

a = [‘a’ , ’b’]

b = a

c = a[:]

a[0] = ‘l’

则b和a一起变成 [‘l’ , ’ b’ ] 而c不变仍为[‘a’ , ’b’]

位图有像素，矢量图无像素。PIL不支持矢量图。

先安装python-imaging 包

import Image

img1= Image.open(‘1.jpg’) 先打开文件。

img1.show() 显示图片

img1.save(‘2.png’) 另存为，此时注意图片格式真的变了。

img1.size 显示像素大小

img1.format 显示图片格式

img1.mode 模式

img2 = img1 resize( (100,100) )传元组改变像素大小

注意不保存img2.save( ‘3.jpg’ )则不会保存改变后的图片

img1.thumbnail( (200,200) ) 变为缩略图，按比例缩小，以最长边为准。不保存不会改变

newi = img1.rotate(-45) 顺势转45度，返回对象

newi.show() 查看

GNU图像处理软件。将图片拖到软件中。

p =Image.open(‘1.jpg’) 将图片剪切一部分贴到另一个图片上。

在GNU中查看像素

pc =p.crop( (618,63,817,183) )左上角和右下角像素

pc.show()

pcopy = pc.copy()

h =Image.open(‘0.jpg’)

h.show()

h.paste(pcopy ,(786,258) ) 只需目标图片的左上角像素

h.show() 此时可看到效果。

h =Image.open(‘0.jpg’)

p =Image.open(‘1.jpg’)

ld =Image.blend( h ,p ,0.5) 注意图片像素必须一致，第三个参数越小前图像越明显，越大后图片越明显。

第十四天

wxPython 安装要通过rpm官方下载安装，不能yum安装光盘也没有。

wxPython 一般包含两个对象：应用程序对象和根窗口

应用程序对象通过实例化wx.App实现

根窗口通过wx.Frame实现

应用程序对象：wx.APP

wx的必要部分，完成wx的总体框架

完成事件的循环处理，完成窗口事件。

父窗口对象：wx.Frame

作用：完成图形的基本容器

import wx

app = wx.App() 创建应用程序对象注意以下结皆为首字母大写

win = wx.Frame(None,title= ‘记事本’,size = (600,400) )

生成窗口的对象。可以设置标题。size设置窗口像素大小。

win.Show() 显示窗口

app.MainLoop() 进入应用程序管理，循环，实例化循环，并不使程序循环。

btn = wx.Button(win， label=’Open’, pos =(10,5), size=(80,25) )

在win窗口中添加按钮,且按钮名为’open’ ，位置pos为左上角像素，大小为size。(只加一个,不指定大小时为整个大窗口为一个按钮)

filepath = wx.TextCtrl(win,pos = (5,5),size = (300,25 ))

添加文本框。

contents = wx.TextCtrl(win,pos = (5,35),size = (300,400 ),style =wx.TE_MULTILINE|wx.HSCROLL)

wx.TE_MULTILINE 文本可多行输入

wx.HSCROLL 一行不按回车不换行，加水平条。

style 多个值时用 ‘ | ’ 隔开

尺寸器：sizer wx.BoxSizer 管理添加在其中的组件布局位置。

wx.GridSizer：一个固定的二维网格，其中的每个元素都有相同的尺寸。当创建一个

grid sizer时，你要么固定行的数量，要么固定列的数量。项目被从左到右的添加，

直到一行被填满，然后从下一行开始。

如计算器的多个按钮可以用

Xbox =wx.GridSizer(4, 4, 4, 4)

buttons = [‘1’,’2’,’3’……]

for x in buttons:

button= wx.button(panel, label=x)

xbox.Add(button,proportion=1,flag=wx.WXPAND, border=5)

button.Bind(wx.EVT_BUTTON,onclick) onclick在下

则获取连续的按键值可如下

def onclick(event):

b= event.GetEventObject() 先生成事件对象

label= b.GetLabel() 再调用方法得到按钮上的值

nums= [‘1’,’2’,……]

if x in nums:

lcd.AppendText(x ) 在TextCtrl文本框内从尾部添加文本。

还有lcd.Clear() 重置文本框为””空值。

bkg = wx.Panel(win) 首先把窗口变成画板，可以用尺寸器管理。

以下win全用bkg代替

hbox = wx.BoxSizer( wx.HORIZONAL wx.VERTICAL) 前一个是水平管理，后一个是竖直管理。不写参数默认是水平管理。

filepath = wx.TextCtrl(bkg) 大小和位置不用写

btn = wx.Button(bkg， label=’Open’) 大小和位置不用写

hbox.Add(filepath,proportion=1,flag=wx.EXPAND) 从左往右增加内容，这里先加文本框，proportion比例与其它本列的内容相比为0时，拉拽不延长，若三个值为 1 ，1 ，1则各个占三分之一。2 ，1 ，1 第一个占二分之一，后两个占四分之一。

wx.EXPAND为当拉伸时填充所有有效空间，当只需文本框水平拉伸，竖直不变时此参数不用给出。

hbox.Add(btn,proportion=0,flag= wx.LEFT,border=5)

继续向后添加，wx.LEFT 代表左侧距前一个元素有border=5 五个像素

vbox= wx.BoxSizer(wx.VERTICAL) 纵向管理

vbox.Add(hbox, ,proportion=0,flag=wx.EXPAND| wx.ALL,border=5)

将第一个管理器做为一项管理，wx.ALL距离四周距离5像素

vbox.Add(contents,,proportion=0,

flag=wx.EXPAND |wx.LEFT | wx.BOTTOM | wx.RIGHT ,border=5)

将下面的大文本框加入，且左右下距边框为5像素，且自动填充有效区域。此时不用wx.ALL因上面的hbox已经用了向下5像素，若此时也用wx.ALL则上下间距会变成10

bkg.SetSizer(vbox) 执行布局管理器，注意此时执行大的布局管理。

对于图形要经分析，分上下或左右进行管理，可将一部分作为一个小的布局管理器，大的再管理小的。

事件处理：组件，发生事件，对应事件行为（事件处理函数）

btn = wx.Button(bkg， label=’Open’) 创建键对象

btn.Bind(wx.EVT_BUTTON, fun) 函数名不用加括号。将事件与函数连接起来。注意定义时 def fun(evt):要加默认参数，因事件发生时要有值传入。其实对函数本身无意义。

filepath.GetValue() 将文本框中的值取出来，并返回

contents.SetValue(写入数据) 写入数据到文本框中。

contents.SetValue(‘’)清空要写空字符串，不可什么都不写。

注意最后显示图像一直都是win.Show()而不是bkg.Show()

wxPython 编程的常规思路：

class Frame(wx.Frame): 子类化框架

def __init__(self):

wx.Frame.__init__(self,None,title = ‘title’ ….)记得写self

panel = wx.Pane(self) 建立画板句柄，用来增加元素

button = wx.Button(panel,label = ‘open’…..) 增加元素

self.Bind(wx.EVT_BUTTON, self.fun, button) 绑定按键事件也写在此处 AAAA下用

def fun(self, evt): 此处两个变量都不可少

passs

class App(wx.App) 子类化应用程序

def OnInit(self): 重载此函数

win = Frame() 实例化自己定义的框架类

win.Show()

return True 此函数必须返回True

def fun(): 此函数用于盛放需要的运算命令代码

pass

test = App()

test.fun() 调用程序，可省

test.MainLoop()

？？？？？？

注意当需要重载子类App的__init__时。要记得调用父类的

wx.App.__init__(self)且要写在__init__的最后一行。因此父类初始化一旦调用，则它下面的代码不执行。

？？？？？经再次实验发现，放在前面，下面的代码也执行。

注意：在多窗口时，如果一个窗口时用类写的，且其中调用了另外一个窗口函数，如AAAA处调用了fun这个窗口函数，则在关闭窗口时会发现，即使关掉所有窗口终端进程也退不出来。所以在遇到多窗口时第一个窗口不要用类写。函数调用也时，即在循环内调用循环，则进程无法结束。

第十五天

程序是为实现特定目标或解决特定问题而用计算机语言编写的命令序列的集合。特征：静态，保存在存储介质上。

进程：一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程是基本的分配单元，也是基本的执行单元。

程序：静态，保存于存储介质。一个程序可以对应多个进程。

进程：动态，程序的动态执行，对应于一个程序。

线程：是进程中某个单一顺序的控制流。在单个程序中同时运行多个线程完成不同的工作，称为多线程。

任意时刻只能有一个线程在执行。

import thread 使用线程模块

def fun1():

def fun2():-

thread.start_new_thread(fun1,()) 产生新的线程fun1 ,后面传参数以元组的形式。

线程在进程中产生，线程时间不可以比进程长。

线程近乎同时执行。各线程顺序不是固定的。

def fun(var):

for x in xrange(5):

print ‘ test ’

time.sleep(1)

lock.release() 释放锁对象

lock =thread.allocate_lock() 创建锁对象

lock.acquire() 加锁

thread.start_new_thread( fun , (lock,) ) 将锁对象作为变量传入函数中，在作为线程的函数中释放锁。

while lock.locked() or lock1.locked : pass

主程序等待所有线程结束后再结束进程。

lock.locked()在加锁状态返回True，释放后返回False

import threading threading此模块完善同步机制，提供守护进程功能。

th1 =threading.Thread( target = fun1,args = () ) 创建进程对象，第一个参数时函数名，第二个参数是函数需要的值，要以元组形式

th2 =threading.Thread(target = fun2, args = ())

注意此时程序并不运行。

th1.start() th2.start() 使用此方法来实现线程的启动，且同时启动多个线程，并在线程结束后，主程序才会停止。

th1.run()

th2.run() 两个线程运行，但当上一个线程运行完之后，才运行下一个于start()的区别。

th1.join() 阻塞进程直到线程执行完毕，然后才执行后面的代码。通用的做法是我们启动一批线程，最后join这些线程结束。要与th1.start()连用否则会报错。

当th1.join()在两个线程之间时，则执行完上面的线程然后再执行下一个线程。

th1.isAlive() 判断th1线程的状态，工作时为True.不工作时为False

th1.getName() 查看进程名字。

th1.setName(‘name’) 设置进程的名字。

接口使两个计算机连接时找到相应的服务。

协议信息传输的标准

TCP 传输控制协议

UDP用户数据报协议

socket 通常也称作‘套接字’，用于描述IP地址和端口，是一个通信链的句柄。

每种服务都打开一个Socket,并绑定到一个端口上，不同的端口对应不同的服务。应用程序通过‘套接字’向网络发出请求或者应答网络请求。

服务器监听：是服务器端口套接字并不定位具体的客户端套接字，而是出于等待连接的状态，实时监控网络状态。

import socket

s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

第一个参数时ipv4 第二个参数tcp。生成实例化对象注意此参数无引号。

s.bind ( (‘127.0.0.1’,5200) ) 传入一个元组，第一个服务器ip地址，第二个为端口绑定ip与端口地址。元组第二个值是整形。

s.listen(10) 服务器处于监听模式下。

conn,addr =s.accept() 接收登陆者连接。并返回一个元组，第一个参数，是连接后的对象，第二个参数时登陆者的ip

conn.send(‘welcome’) 服务器发送到客户端。

data = conn.recv(1024) 获取客户端传来的数据，大小不超过1024kb

while True:

print conn.recv(1024)

newdata = raw_input(‘input:’)

conn.send(newdata) 客户端实现与服务端对话

conn.close() 关闭连接

客户端

c = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

c.connect( (‘ 192,168,4,112’, 9004)) 要连接的服务器的ip和端口参数为元组

where True:

print c.recv(1024)

newdata = raw_input()

c.send(newdata)

第十六天

不同电脑间连接有防火墙要关闭

service iptables top 关闭防火墙

setenforce 0 这个可以不写

端口号0—65535 自定义时用1024以上的

recv(1024) 单位为B既1KB最大只接收1KB的信息

telnet + IP + 端口地址

客户端软件。

if newdata: 输入的信息

clientobj.send(newdata)

else:

conn.close() 实现按回车退出连接

break

addr 接收为元组，（IP，端口号）

print addr[0] 显示客户端ip

子类继承父类时若子类没有重新定义 __init__(self) 则会自动运行父类的初始化

class S(F): 子类继承父类

a = S() 实例化子类为a。注意此时也相当于实例化了父类。

a. fun() 对象可直接调用父类方法不必加父类名。

在子类内访问父类变量要加父类名 F.var

在wx中写自定义类App (wx.App)类时

将图形构造重载于OnInit()

class App(wx.App):

def OnInit(self):

win =wx.Frame(None) 图形框架写在此函数中

win.show()

return True 此函数一定要返回True

def Chengxu(self): pass 盛放需要程序的方法

a = App() 实例化自定义的wx.App的子类

a. MainLoop()

相应的程序在自定义类内另外自定义一个方法即可

“”” “”” 三引号注释，两个三引号要注意缩进，与上下缩进一致，注释内容不必

Bad filedescriptor 错误。只需要将conn.close()删除即可。

10.

源码包安装后import wx 可用在安装编译时指定库路径

./configure -- with – python =/库路径最好放到set-package

11.

在用wx图形化传输时可能遇到传输不了中文。在程序前加入以下代码

import sys

reload (sys)

sys.setdefaultencoding(‘utf- 8’) 注意要加‘—’ utf-8

12.

在类中类属性和__init__(self,var): 中设定的变量，只要加着self. 则在类中就相当于全局变量。

13.

写的服务器和客户端如果没有退出键的话，直接关闭终端的方式关闭连接时，先关客户端，再关服务器，则可避免每次退出后就要改端口的问题。

14.

在循环中，只有print命令而没有其它中断命令如raw_input 时

如print ‘test’ , 后面加逗号，则在全部循环终止时，才会在一行中显示所有’test’。循环不终止，一个也不显示

15.

双线程时，只需将一个以线程方式开启，另一个直接是主程序即可，没必要开启两个双线程。

16．

字符串和整形不能print ‘test’ +11 错

应该 print ‘test’ , print 11 结果为 test 11

17.

对象的空值为None

18.

创建线程的命令的执行也是按照从上到下的顺序，并不是程序一开始不管线程在哪里创建，就执行线程，而是按从上到下的顺序执行到那一命令时线程才开始创建。

a=raw_input()

thread.start_new_thread( fun,() ) 此时在输入a之前线程不会执行。

19.

将某些会影响程序连续性的中断命令放入线程中，由主程序来控制程序的连续性。如服务器的多次连接时，服务器发送数据的命令会产生中断。将send放入线程中，可实现服务器的多次accept连接。

20.

线程中的exit()不能使程序结束，只能结束当前线程。除非此线程为最后执行完。（并不等价于在最后一行）

21.

conn.send(data) 不受data大小限制

conn.recv(1024) 每次最多接受1024B即1KB，循环此函数，则可继续往下接受，直到接受完成为止。

上传时若需要将上传内容让服务器分两部分接收，则需要连接两次。c = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

c.connect( (‘127.0.0.1’, 9004) ) 参数为一个元组

c.send(part1) 上传第一部分如文件名

c = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

c.connect( (‘ 127.0.0.1’, 9004) )

c.send(part2) 上传第二部分，如文件内容。

22.

产生0到9的字符串列表

Numlist = [str(i) for i in xrange(10) ] 列表解析

[‘0’,’1’,……….’9’]

[ I for I in xrange(3) if I> 1]

结果[2]

编外篇

在程序中and or not逻辑运算符可用

但& | ^ ~皆为运算符只是对整形或字符串进行操作

在vim中tab与空格不等价，同逻辑级别必须相同

f = file(‘1.txt’,’r+’)

f.write(‘zhang’)

f = file(‘1.txt’,’w’)

f.close()

注意在这操作结束后，原1.txt中内容丢失，但‘zhang’仍然会写入‘1.txt’。若要连‘zhang’都没写入，则要在f = file(‘1.txt’,’w’)前加f.close()

网络yum源查找

将yum.repo.d中文件只让一个可用，即将一个改为enable = 1

最好将gpgcheck = 0此为检测，关闭最好。

baseurl=http://mirrors.163.com/centos/6.3/os/x86_64

此源的查找可用，在百度搜索centos yum 源。找网页上的配置文件，将到centos那一部分复制到浏览器，选最新版，一般是6.3（旧的一般是空的）选os选x86_64(64位系统)，将此时的地址做为yum源

类的继承时，要从上到下定义，下面的类只能继承上面的类。

而调用则不需要有顺序，定义的函数间调用也不需要有顺序。

实现按1,2选择函数，按0返回上一级：

while 1:

try：

a = input(‘1: ,2: ,3: ,0:返回上一级：’) 只接受整形

if a: 只有在为整形0时才为False 。字符串’0’是True，字符串在只有空才是False。

{1: ,2: ,3: }[a]()

else:

break

except NameError,msg: 当a接收为字母时出此错误

print ‘请按要求输入’

except KeyError,msg: 当a为key外时出此错误

print ‘请按要求输入’

def __init__(self,a):

self.a= a 注意不能往类内传入变量，只能传入值，或者定义变量

判断输入的字符串是字母汉字还是数字。

x =raw_input()

if x> ’999999999999’:

print ‘x为字母或汉字 ’

else：

print ‘ x为数字字符串’

可用于判断输入的是name还是id，在数据库控制时可实现对name和id的查询判断。

类中的成员函数内部的定义的函数不用写self参数。

10.

定义类方法时要注意。

A．类方法中用到的变量及某些调用模块等操作必须定义为类属性，不能用_ _init_ _添加。

B．类方法调用函数时，被调用的函数也必须是类方法。

11.

在写函数内的__doc__时’’’ ‘’’ 三引号一定要缩进，但里面写的字符串最好顶头写，不必缩进

12.

bs 模式，浏览器服务器模式，所有数据都在服务器上运行

cs 模式，大量数据处理在客户端上处理

13.

类中类的方法可以被调用，但类中方法内的函数不可被调用

14.

在wxpython遇到信息传输时，有时会传不了中文。在程序前加代码

import sys

reload(sys)

sys.setdefaultencoding(‘utf-8’) 记得加‘-’

15.

在类中类属性和__init__(self)中传入的self.bianliang 在类中相当于全局变量。

16.

a=b= c=d =’’

让变量递变，可用列表遍历

for var in [a,b,c,d]:

var =1

可以以元组形式如

for x,y in [(a, 1) , (b, 2)]:

x= y 这样可实现某种情况下，节省代码

注意此变量x可以用a的属性如a.relpace(….) 可以在for循环中用x.replace(…..)相同效果

在用之前记得先给列表中的变量赋初值。

经研究，发现，以上不对，因变量只是标签，不可遍历，

18.

若在mysql与wxPython遇到编码错误可到库目录下

site-packages/MySQLdb/connections.py

301行将最后self.unicode_........ = charset 改为 = ‘utf-8’

19.

被调用的父类的方法，也要加self参数。

注意：如果是类内方法间的调用不必加self参数:

class F():

def fun(self):

print ‘test’

def fun1(self):

self.fun() 此时不必传入(self)

21.

a = ‘test’

def f():

print a

此时因为a没有在函数内重新定义，故a为全局变量。

a = ‘test’

def f():

a = ‘new’

print a

此时为打印a为 ’new ’.

函数内没有声明为global的。定义的变量为局部变量。

直接用的如在函数内用，而没有定义的 b.Clear() 都是全局变量

22.

当数据库与图形界面传输仍出现编码错误时，当读取一条数据可以，读取多行不行时，只需将数据库中的所有数据全删除，然后重新输入即可，可能是由于原来输入时用不同的编码输入导致的结果。

23.

vim ~/.vimrc 加上set nu 可永久显示行号

set ts=4 等号两边无空格，改tab

24.

在用eval求值时对于异常的接收可用

eval( x, {‘__builtins_ _’:None}, {}) 这样在输入异常不是正确的数时，也不会报错。

25.

括号内的’=’两边不加空格，其它加空格，逗号后加空格。

python总结

你可能感兴趣的:(python,python)