python基础学习笔记

 1 #!/usr/bin/env python
 2 #coding=utf-8
 3 
 4 def login(username):
 5     if username==‘bill‘:
 6         return 1
 7     else:
 8         return 0
 9 
10 def detail(user):
11     print ‘我是%s‘%user
12 
13 if __name__==‘__main__‘:
14     user=raw_input(‘请输入你的名字：‘)
15     if login(user) == 1:
16         print ‘登陆成功‘
17         if raw_input(‘是否显示详细y/n‘) == ‘y‘:
18             detail(user)
19         else:
20             print ‘ok‘
21     else:
22         print ‘登陆失败‘

1 def foo(name,action=‘砍柴‘,where=‘上海‘):
2     print name,‘去‘,action,where
3 
4 if __name__==‘__main__‘:
5     foo(‘zhangsan‘)
6     foo(‘lili‘,‘chipi‘)
7     foo(‘adf‘,where=‘北京‘)

1 def foo(**item):
2     for i in item.items():
3         print i
4 
5 
6 foo(name=‘a‘,age=‘b‘)

1 def foo(**item):
2     for i in item.items():
3         print i
4 
5 a={‘name‘:‘weiwei‘,‘age‘:‘18‘}
6 
7 foo(**a)

1 def foo(*item):
2     for i in item:
3         print i
4 
5 
6 foo(‘a‘,‘b‘,‘23‘)

1 yield的返回值是一个生成器，只有遍历的时候才会返回值
2 def foo():
3     yield 1
4 
5 a=foo()
6 for i in a:
7     print i
8 迭代器和生成器的区别，迭代器会有一个next()方法，一直向下执行，生成器会将数据记录为一个快照，暂时不开辟内存空间，等到有for循环打印出来的时候就需要开辟内存空间了

1 文件的自动关闭
2 with open(‘D:/tmp.txt‘,‘r‘)
3     print ‘xxx‘
4 执行结束之后自动关闭文件

1 三元运算式
2 result=‘ge‘ if 1<3 else ‘it‘
3 print result
4 结果ge
5 
6 num=lambda x,y:x+y#lambda关键字
7 
8 print num(4,10)
9 结果14，三个参数也可以，参数由自己设定

 1 内置函数：
 2 print bool(1)#布尔值
 3 print abs(-9)
 4 print divmod(1,9)#求模
 5 
 6 print max(11,22)
 7 print min(11,22)
 8 print sum([11,22])
 9 print pow(2,10)
10 
11 a=[1]
12 print len(a)
13 #如果a是文字，则此时就是字节的长度，不是字符的长度
14 
15 print all([1,2,3,4,1])
16 print any([2,3,4,1,23])
17 any(iterable)说明：参数iterable：可迭代对象；
18 如果当iterable所有的值都是0、‘‘或False时，那么结果为False，如果所有元素中有一个值非0、‘‘或False，那么结果就为True
19 如果iterable的所有元素不为0、‘‘、False或者iterable为空，all(iterable)返回True，否则返回False；
20 
21 print chr(66)#ASCII对应的数据
22 print ord(‘a‘)#打印对应的95
23 
24 print hex(2)#转换成16进制
25 print bin(2)#转换成2进制
26 print oct(2)#转换成8进制
27 
28 li=[‘手表‘,‘起床‘,‘房‘]#enumerate会将数组或列表组成一个索引序列，2是起始的序号，可随意修改
29 for item in enumerate(li,2):
30     print item[0],item[1]
31 0 one
32 1 two
33 2 three
34 
35 s=‘i am {0} {1}‘
36 print s.format(‘bill‘,‘jj‘)

li=[11,22,33]
print map(lambda arg:arg+100,li)
[111, 122, 133]

 1 li=[11,22,33]
 2 
 3 
 4 def foo(arg):
 5     if arg<22:
 6         return True
 7     else:
 8         return False
 9 
10 tmp=filter(foo,li)
11 print tmp

1 li=[11,22,33]
2 
3 print reduce(lambda x,y:x+y,li)
4 
5 
6 li=[11,22,33]
7 y=[1,2,3]
8 print zip(li,y)
9 [(11, 1), (22, 2), (33, 3)]

1 a=‘8*8‘
2 b=a.split(‘*‘)
3 
4 for i in b:
5     c=int(i)
6     print c,type(c)

 1 temp=‘sys‘
 2 
 3 mode=__import__(temp)
 4 
 5 print mode.path
 6 ------------------------------------------//使用以下方法时需要在同一个目录下，貌似不可以跨越文件夹
 7 temp = ‘12‘#模块的名字
 8 fuc=‘foo‘#函数的名字
 9 model=__import__(temp)
10 
11 a=getattr(model,fuc)#查找该模块中是否有这个函数，函数部分不可以直接写foo
12 print a()#获取的是函数，所以需要使用对象

 1 import random
 2 #print random.random()#生成0-1之间的随机数
 3 #print random.randint(1,5)#生成1-5之间的随机数
 4 print random.randrange(1,3)#1<=x<3
 5 
 6 print chr(random.randint(65,90))#获取随机字母
 7 
 8 
 9 生成一个随机的验证码
10 import random
11 array=[]
12 for i in range(6):
13     if i==random.randint(1,5):
14         array.append(str(i))
15     else:
16         array.append(chr(random.randint(65,90)))
17 
18 print ‘‘.join(array)#Python的格式化操作，拼接字符串，并且用这种方法效率高拼接字符串，并且用这种方法效率高

1 MD5加密
2 import hashlib
3 hash=hashlib.md5()
4 hash.update(‘admin‘)
5 print hash.hexdigest()

 1 #为什么要序列化？两个python程序内存之间的交互，保存到硬盘上
 2 
 3 import pickle#python与python之间的文件的传输，可以共享文件，相互读
 4 li=[‘nima‘,1,2,3,‘2432‘,123,4,‘1‘]
 5 dumpsed=pickle.dumps(li)#dumps将所传入的变量的值序列化为一个bytes，然后，就可以将这个bytes写入磁盘或者进行传输。
 6 print dumpsed
 7 print type(dumpsed)
 8 
 9 loadsed=pickle.loads(dumpsed)#loads当我们要把对象从磁盘读到内存时，可以先把内容读到一个bytes，然后用loads方法反序列化出对象，也可以直接用load方法直接反序列化一个文件。
10 print loadsed
11 print type(loadsed)
12 
13 pickle.dump(li,open(‘D:/nima.pk‘,‘w‘))#dump则更加一步到位，在dump中可以传入两个参数，一个为需要序列化的变量，另一个为需要写入的文件。
14 
15 result=pickle.load(open(‘D:/nima.pk‘,‘r‘))
16 print result

#pickle与python的区别,json只能序列化常规的数据类型，字典、列表，集合，序列化之后可读
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，
比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，
可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。
JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

 1 正则表达式
 2 re模块用于对python的正则表达式的操作。
 3 
 4 字符：
 5 
 6 　　. 匹配除换行符以外的任意字符
 7 　　\w    匹配字母或数字或下划线或汉字
 8 　　\s    匹配任意的空白符
 9 　　\d    匹配数字
10 　　\b    匹配单词的开始或结束
11 　　^    匹配字符串的开始
12 　　$    匹配字符串的结束
13 
14 次数：
15 
16 　　* 重复零次或更多次
17 　　+    重复一次或更多次
18 　　?    重复零次或一次
19 　　{n}    重复n次
20 　　{n,}    重复n次或更多次
21 　　{n,m}    重复n到m次
22 
23 import re
24 
25 hh1=re.match(‘\d+‘,‘123ajfdiosaj12321j4lklnljj432ojoij‘)#该函数是匹配开头，如果在开头的位置找到就返回找到的值，反之就返回None
26 if hh1:
27     print hh1.group()
28 else:
29     print ‘nothing‘
30 
31 
32 hh2=re.search(‘\d+‘,‘ajfdiosaj12321j4lklnljj432ojoij‘)#该函数是开头开始找，但是它是一直向后找，直到找到了，才返回值
33 if hh2:
34     print hh2.group()
35     
36 ---------------------------------------------------------------------有多少数字取多少数字
37 
38 import re
39 hh3=re.findall(‘\d+‘,‘aodijfjoj1324joijoij12joi‘)
40 print hh3
41 
42 [‘1324‘, ‘12‘]    
43 ---------------------------------------------------------------------先编译，再执行
44 import re
45 
46 com=re.compile(‘\d+‘)
47 print com.findall(‘adfoiqe213324joijoij234‘)

1 ---------------------------------------------------------------------group与groups
2 import re
3 
4 result=re.search(‘(\d+)ojoijlo(\d+)‘,‘oijoij24324ojoijlo643‘)
5 print result.group()
6 print result.groups()
7 
8 24324ojoijlo643
9 (‘24324‘, ‘643‘)

1 import time
2 
3 #print time.time()
4 #print time.strftime(‘%Y-%m-%d %H:%M:%S‘)
5 #print time.strptime(‘2014-11-11‘, ‘%Y-%m-%d‘)
6 print time.mktime(time.localtime())
7 print time.localtime()

 1 反射器的各种应用
 2 #!/usr/bin/env python
 3 #coding:utf-8
 4 
 5 data=raw_input(‘Please input your address:‘)
 6 array=data.split(‘/‘)
 7 
 8 username=__import__(‘backend.‘+array[0])#可以实现不同页面之间的跳转，节约代码量
 9 
10 model=getattr(username,array[0])#将其理解成先进入文件夹
11 func=getattr(model,array[1])#然后进入模块调用相应的方法
12 func()